v1.77 Update ci-contracts-upload-binaries.yml

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,9 @@
+# Description
+
+Closes: #XXXX
+
+<!-- If appropriate, insert relevant description here -->
+
+# Checklist:
+
+- [ ] added a changelog entry to `CHANGELOG.md`

.github/workflows/cd-docs.yml

@@ -9,11 +9,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git python3 && sudo apt-get update --fix-missing
-      - name: Install pip3
-        run: sudo apt install -y python3-pip  
-      - name: Install Python3 modules
-        run: sudo pip3 install pandas tabulate
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git
       - name: Install rsync
         run: sudo apt-get install rsync
       - uses: rlespinasse/github-slug-action@v3.x
@@ -41,8 +37,8 @@ jobs:
 # This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
       - name: Save current branch to ~/current_branch
         run: git rev-parse --abbrev-ref HEAD > ~/current_branch
-      - name: Git pull, reset & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
-        run: git pull && git reset --hard && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
       - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
         run: cd documentation && ./build_all_to_dist.sh
 

.github/workflows/ci-build-upload-binaries.yml

@@ -104,9 +104,12 @@ jobs:
           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
             target/release/nymvisor
             target/release/nym-node
@@ -121,9 +124,12 @@ jobs:
           OUTPUT_DIR: ci-builds/${{ github.ref_name }}
         run: |
           cp target/release/nym-client $OUTPUT_DIR
+          cp target/release/nym-gateway $OUTPUT_DIR
+          cp target/release/nym-mixnode $OUTPUT_DIR
           cp target/release/nym-socks5-client $OUTPUT_DIR
           cp target/release/nym-api $OUTPUT_DIR
           cp target/release/nym-network-requester $OUTPUT_DIR
+          cp target/release/nym-network-statistics $OUTPUT_DIR
           cp target/release/nymvisor $OUTPUT_DIR
           cp target/release/nym-node $OUTPUT_DIR
           cp target/release/nym-cli $OUTPUT_DIR

.github/workflows/ci-build.yml

@@ -6,6 +6,7 @@ on:
       - 'clients/**'
       - 'common/**'
       - 'explorer-api/**'
+      - 'ephemera/**'
       - 'gateway/**'
       - 'integrations/**'
       - 'mixnode/**'
@@ -23,6 +24,7 @@ on:
       - 'clients/**'
       - 'common/**'
       - 'explorer-api/**'
+      - 'ephemera/**'
       - 'gateway/**'
       - 'integrations/**'
       - 'mixnode/**'

.github/workflows/ci-contracts-upload-binaries.yml

@@ -58,6 +58,9 @@ jobs:
           cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_dkg.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_service_provider_directory.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_name_service.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_ecash.wasm $OUTPUT_DIR
 
       - name: Deploy branch to CI www
         continue-on-error: true

.github/workflows/ci-docs.yml

@@ -13,11 +13,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git python3 && sudo apt-get update --fix-missing
-      - name: Install pip3
-        run: sudo apt install -y python3-pip  
-      - name: Install Python3 modules
-        run: sudo pip3 install pandas tabulate
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git
       - name: Install rsync
         run: sudo apt-get install rsync
       - uses: rlespinasse/github-slug-action@v3.x
@@ -46,8 +42,8 @@ jobs:
 # This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
       - name: Save current branch to ~/current_branch
         run: git rev-parse --abbrev-ref HEAD > ~/current_branch
-      - name: Git pull, reset & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
-        run: git pull && git reset --hard && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
+        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
       - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
         run: cd documentation && ./build_all_to_dist.sh
 

.github/workflows/ci-nym-connect-desktop-rust.yml

@@ -0,0 +1,65 @@
+name: ci-nym-connect-desktop-rust
+
+on:
+  pull_request:
+    paths:
+      - "nym-connect/desktop/src-tauri/**"
+      - "nym-connect/desktop/src-tauri/Cargo.toml"
+      - "clients/client-core/**"
+      - "clients/socks5/**"
+      - "common/**"
+      - "gateway/gateway-requests/**"
+      - "contracts/vesting/**"
+      - "nym-api/nym-api-requests/**"
+
+jobs:
+  build:
+    runs-on: [self-hosted, custom-linux]
+    env:
+      CARGO_TERM_COLOR: always
+    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: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path nym-connect/desktop/Cargo.toml --all -- --check
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        continue-on-error: true
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace --all-features
+
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --manifest-path nym-connect/desktop/Cargo.toml --workspace --all-features -- -D warnings

.github/workflows/ci-nym-connect-desktop.yml

@@ -0,0 +1,72 @@
+name: ci-nym-connect-desktop
+
+on:
+  pull_request:
+    paths:
+      - 'nym-connect/desktop/**'
+
+defaults:
+  run:
+    working-directory: nym-connect/desktop
+
+jobs:
+  build:
+    runs-on: custom-linux
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install rsync
+      run: sudo apt-get install rsync
+      continue-on-error: true
+    - uses: rlespinasse/github-slug-action@v3.x
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 18
+    - name: Install Yarn
+      run: npm install -g yarn
+    - name: Install Rust stable
+      uses: actions-rs/toolchain@v1
+      with:
+        toolchain: stable
+    - name: Install wasm-pack
+      run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+    - name: Install project dependencies
+      run: cd ../.. && yarn --network-timeout 100000
+      
+    - name: Install app dependencies
+      run: yarn
+      continue-on-error: true
+      
+    - name: Set environment from the example
+      run: cp .env.sample .env
+    - run: yarn storybook:build
+    - name: Deploy branch to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "nym-connect/desktop/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/nym-connect-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: Matrix - Node Install
+      run: npm install
+      working-directory: .github/workflows/support-files
+    - name: Matrix - Send Notification
+      env:
+        NYM_NOTIFICATION_KIND: nym-connect
+        NYM_PROJECT_NAME: "nym-connect"
+        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+        NYM_CI_WWW_LOCATION: "nym-connect-${{ env.GITHUB_REF_SLUG }}"
+        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+        GIT_BRANCH: "${GITHUB_REF##*/}"
+        IS_SUCCESS: "${{ job.status == 'success' }}"
+        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
+        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/ci-sdk-docs-typescript.yml

@@ -17,7 +17,7 @@ jobs:
       - uses: rlespinasse/github-slug-action@v3.x
       - uses: actions/setup-node@v3
         with:
-          node-version: 18.17
+          node-version: 18
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:

.github/workflows/nightly-nym-connect-desktop-build.yml

@@ -0,0 +1,92 @@
+name: nightly-nym-connect-desktop-build
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '14 1 * * *'
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-20.04, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    env:
+      CARGO_TERM_COLOR: always
+      MANIFEST_PATH: --manifest-path nym-connect/desktop/Cargo.toml
+    continue-on-error: true
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v3
+
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        if: matrix.os == 'ubuntu-20.04'
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: ${{ env.MANIFEST_PATH }} --all -- --check
+
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: ${{ env.MANIFEST_PATH }} --release --workspace
+
+      - name: Unit tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: ${{ env.MANIFEST_PATH }} --workspace
+
+      - name: Clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: ${{ env.MANIFEST_PATH }} --workspace --all-targets -- -D warnings
+
+  notification:
+    needs: build
+    runs-on: custom-linux
+    steps:
+      - name: Collect jobs status
+        uses: technote-space/workflow-conclusion-action@v2
+      - name: Check out repository code
+        uses: actions/checkout@v3
+      - name: install npm
+        uses: actions/setup-node@v3
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        with:
+          node-version: 18
+      - name: Matrix - Node Install
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Matrix - Send Notification
+        if: env.WORKFLOW_CONCLUSION == 'failure'
+        env:
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "nym-connect-desktop-nightly-build"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
+          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_NIGHTLY }}"
+          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/pr-validation.yml

@@ -1,27 +0,0 @@
-name: pr-validation
-
-on:
-  pull_request:
-    branches:
-      - develop
-      - 'release/**'
-    types:
-      - labeled
-      - unlabeled
-      - opened
-      - reopened
-      - synchronize
-      - edited
-      - milestoned
-      - demilestoned
-
-env:
-  LABELS: ${{ join( github.event.pull_request.labels.*.name, ' ' ) }}
-
-jobs:
-  check-milestone:
-    name: Check Milestone
-    runs-on: ubuntu-latest
-    steps:
-      - if: github.event.pull_request.milestone == null && contains( env.LABELS, 'no-milestone' ) == false
-        run: exit 1

.github/workflows/publish-nym-binaries.yml

@@ -27,17 +27,23 @@ jobs:
       release_id: ${{ steps.create-release.outputs.id }}
       release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
       client_hash: ${{ steps.binary-hashes.outputs.client_hash }}
+      mixnode_hash: ${{ steps.binary-hashes.outputs.mixnode_hash }}
+      gateway_hash: ${{ steps.binary-hashes.outputs.gateway_hash }}
       nymvisor_hash: ${{ steps.binary-hashes.outputs.nymvisor_hash }}
       nymnode_hash: ${{ steps.binary-hashes.outputs.nymnode_hash }}
       socks5_hash: ${{ steps.binary-hashes.outputs.socks5_hash }}
       netreq_hash: ${{ steps.binary-hashes.outputs.netreq_hash }}
       cli_hash: ${{ steps.binary-hashes.outputs.cli_hash }}
+      netstat_hash: ${{ steps.binary-hashes.outputs.netstat_hash }}
       client_version: ${{ steps.binary-versions.outputs.client_version }}
+      mixnode_version: ${{ steps.binary-versions.outputs.mixnode_version }}
+      gateway_version: ${{ steps.binary-versions.outputs.gateway_version }}
       nymvisor_version: ${{ steps.binary-versions.outputs.nymvisor_version }}
       nymnode_version: ${{ steps.binary-versions.outputs.nymnode_version }}
       socks5_version: ${{ steps.binary-versions.outputs.socks5_version }}
       netreq_version: ${{ steps.binary-versions.outputs.netreq_version }}
       cli_version: ${{ steps.binary-versions.outputs.cli_version }}
+      netstat_version: ${{ steps.binary-versions.outputs.netstat_version }}
 
     steps:
       - uses: actions/checkout@v3
@@ -69,9 +75,12 @@ jobs:
           path: |
             target/release/explorer-api
             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
             target/release/nymvisor
             target/release/nym-node
@@ -85,9 +94,12 @@ jobs:
           files: |
             target/release/explorer-api
             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
             target/release/nymvisor
             target/release/nym-node

.github/workflows/publish-nym-connect-macos.yml

@@ -0,0 +1,122 @@
+name: publish-nym-connect-macos
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-connect/desktop
+
+jobs:
+  publish-tauri:
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-12-large]
+    runs-on: ${{ matrix.platform }}
+
+    outputs:
+      release_id: ${{ steps.create-release.outputs.id }}
+      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
+      version: ${{ steps.release-info.outputs.version }}
+      filename: ${{ steps.release-info.outputs.filename }}
+      file_hash: ${{ steps.release-info.outputs.file_hash }}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: wasm32-unknown-unknown
+
+      - name: Install wasm-pack
+        run: |
+          export WASM_PACK_VERSION="v0.12.1" 
+          curl -LO https://github.com/rustwasm/wasm-pack/releases/download/${WASM_PACK_VERSION}/wasm-pack-${WASM_PACK_VERSION}-x86_64-apple-darwin.tar.gz
+          tar xvzf wasm-pack-${WASM_PACK_VERSION}-x86_64-apple-darwin.tar.gz -C $HOME/.cargo/bin --strip-components=1
+          rm wasm-pack-${WASM_PACK_VERSION}-x86_64-apple-darwin.tar.gz
+
+      - name: Install the Apple developer certificate for code signing
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: |
+          # create variables
+          CERTIFICATE_PATH=$RUNNER_TEMP/build_certificate.p12
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+
+          # import certificate and provisioning profile from secrets
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output $CERTIFICATE_PATH
+
+          # create temporary keychain
+          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+
+          # import certificate to keychain
+          security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
+          security list-keychain -d user -s $KEYCHAIN_PATH
+
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
+      - name: Install project dependencies
+        shell: bash
+        run: cd .. && yarn --network-timeout 100000
+
+      - name: Install app dependencies and build it
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          SENTRY_DSN_RUST: ${{ secrets.SENTRY_DSN_RUST }}
+          SENTRY_DSN_JS: ${{ secrets.SENTRY_DSN_JS }}
+        run: yarn && yarn build
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-connect_1.0.0_x64.dmg
+          path: nym-connect/desktop/target/release/bundle/dmg/nym-connect_1*_x64.dmg
+          retention-days: 30
+
+      - name: Clean up keychain
+        if: ${{ always() }}
+        run: |
+          security delete-keychain $RUNNER_TEMP/app-signing.keychain-db
+
+      - id: create-release
+        name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            nym-connect/desktop/target/release/bundle/dmg/*.dmg
+            nym-connect/desktop/target/release/bundle/macos/*.app.tar.gz*
+
+  push-release-data:
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    uses: ./.github/workflows/release-calculate-hash.yml
+    needs: publish-tauri
+    with:
+      release_tag: ${{ github.ref_name }}
+    secrets: inherit

.github/workflows/publish-nym-connect-ubuntu.yml

@@ -0,0 +1,89 @@
+name: publish-nym-connect-ubuntu
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-connect/desktop
+
+jobs:
+  publish-tauri:
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [custom-ubuntu-20.04]
+    runs-on: ${{ matrix.platform }}
+
+    outputs:
+      release_id: ${{ steps.create-release.outputs.id }}
+      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
+      version: ${{ steps.release-info.outputs.version }}
+      filename: ${{ steps.release-info.outputs.filename }}
+      file_hash: ${{ steps.release-info.outputs.file_hash }}
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Tauri dependencies
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y webkit2gtk-4.0 libayatana-appindicator3-dev
+        continue-on-error: true
+
+      - name: Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Install project dependencies
+        shell: bash
+        run: cd .. && yarn --network-timeout 100000
+
+      - name: Install app dependencies
+        run: yarn
+
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
+      - name: Build app
+        run: yarn build
+        env:
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          SENTRY_DSN_RUST: ${{ secrets.SENTRY_DSN_RUST }}
+          SENTRY_DSN_JS: ${{ secrets.SENTRY_DSN_JS }}
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-connect.AppImage.tar.gz
+          path: nym-connect/desktop/target/release/bundle/appimage/nym-connect_1*_amd64.AppImage
+          retention-days: 30
+
+      - id: create-release
+        name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            nym-connect/desktop/target/release/bundle/appimage/*.AppImage
+            nym-connect/desktop/target/release/bundle/appimage/*.AppImage.tar.gz*
+
+  push-release-data:
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    uses: ./.github/workflows/release-calculate-hash.yml
+    needs: publish-tauri
+    with:
+      release_tag: ${{ github.ref_name }}
+    secrets: inherit

.github/workflows/publish-nym-connect-win10.yml

@@ -0,0 +1,108 @@
+name: publish-nym-connect-win10
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-connect/desktop
+
+jobs:
+  publish-tauri:
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [windows10]
+    runs-on: ${{ matrix.platform }}
+
+    outputs:
+      release_id: ${{ steps.create-release.outputs.id }}
+      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
+      version: ${{ steps.release-info.outputs.version }}
+      filename: ${{ steps.release-info.outputs.filename }}
+      file_hash: ${{ steps.release-info.outputs.file_hash }}
+
+    steps:
+      - name: Clean up first
+        continue-on-error: true
+        working-directory: .
+        run: |
+          cd ..
+          del /s /q /A:H nym
+          rmdir /s /q nym
+
+      - uses: actions/checkout@v3
+
+      - name: Import signing certificate
+        env:
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+        run: |
+          New-Item -ItemType directory -Path certificate
+          Set-Content -Path certificate/tempCert.txt -Value $env:WINDOWS_CERTIFICATE
+          certutil -decode certificate/tempCert.txt certificate/certificate.pfx
+          Remove-Item -path certificate -include tempCert.txt
+          Import-PfxCertificate -FilePath certificate/certificate.pfx -CertStoreLocation Cert:\CurrentUser\My -Password (ConvertTo-SecureString -String $env:WINDOWS_CERTIFICATE_PASSWORD -Force -AsPlainText)
+
+      - name: Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
+      - name: Install project dependencies
+        shell: bash
+        run: cd .. && yarn --network-timeout 100000
+
+      - name: Install app dependencies
+        shell: bash
+        run: yarn --network-timeout 100000
+
+      - name: Build and sign it
+        shell: bash
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          SENTRY_DSN_RUST: ${{ secrets.SENTRY_DSN_RUST }}
+          SENTRY_DSN_JS: ${{ secrets.SENTRY_DSN_JS }}
+        run: yarn build
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-connect_1.0.0_x64_en-US.msi
+          path: nym-connect/desktop/target/release/bundle/msi/nym-connect_1*_x64_en-US.msi
+          retention-days: 30
+
+      - id: create-release
+        name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            nym-connect/desktop/target/release/bundle/msi/*.msi
+            nym-connect/desktop/target/release/bundle/msi/*.msi.zip*
+
+  push-release-data:
+    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    uses: ./.github/workflows/release-calculate-hash.yml
+    needs: publish-tauri
+    with:
+      release_tag: ${{ github.ref_name }}
+    secrets: inherit

.github/workflows/support-files/nym-connect/index.js

@@ -0,0 +1,29 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.NYM_CI_WWW_LOCATION) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
+  }
+  if (!context.env.NYM_CI_WWW_BASE) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.IS_SUCCESS === 'true'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+  return template(context);
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};

.github/workflows/support-files/nym-connect/templates/failure

@@ -0,0 +1,16 @@
+🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+>
+> 🔴 **FAILURE** :cry:
+>
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+>
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+>
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+>
+
+Commit message:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```

.github/workflows/support-files/nym-connect/templates/success

@@ -0,0 +1,16 @@
+🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
+> :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View storybook:** https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}/
+>
+> ✅ **SUCCESS**
+>
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+>
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+>
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+>
+
+Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```

CHANGELOG.md

@@ -4,95 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
-## [2024.6-chomp] (2024-06-25)
-
-- Remove additional code as part of Ephemera Purge and SP and contracts ([#4650])
-- bugfix: make sure nym-api can handle non-cw2 (or without detailed build info) compliant contracts ([#4648])
-- introduced a flag to accept toc and exposed it via self-described API ([#4647])
-- bugfix: make sure to return an error on invalid public ip ([#4646])
-- Add ci check for PR having an assigned milestone ([#4644])
-- Removed ephemera code ([#4642])
-- Remove stale peers ([#4640])
-- Add generic wg private network routing ([#4636])
-- Feature/new node endpoints ([#4635])
-- standarised ContractBuildInformation and added it to all contracts ([#4631])
-- validate nym-node public ips on startup ([#4630])
-- Bump defguard wg ([#4625])
-- Fix cargo warnings ([#4624])
-- Update kernel peers on peer modification ([#4622])
-- Handle v6 and v7 requests in the IPR, but reply with v6 ([#4620])
-- fix typo ([#4619])
-- Update crypto and rand crates ([#4607])
-- Purge name service and service provider directory contracts ([#4603])
-
-[#4650]: https://github.com/nymtech/nym/pull/4650
-[#4648]: https://github.com/nymtech/nym/pull/4648
-[#4647]: https://github.com/nymtech/nym/pull/4647
-[#4646]: https://github.com/nymtech/nym/pull/4646
-[#4644]: https://github.com/nymtech/nym/pull/4644
-[#4642]: https://github.com/nymtech/nym/pull/4642
-[#4640]: https://github.com/nymtech/nym/pull/4640
-[#4636]: https://github.com/nymtech/nym/pull/4636
-[#4635]: https://github.com/nymtech/nym/pull/4635
-[#4631]: https://github.com/nymtech/nym/pull/4631
-[#4630]: https://github.com/nymtech/nym/pull/4630
-[#4625]: https://github.com/nymtech/nym/pull/4625
-[#4624]: https://github.com/nymtech/nym/pull/4624
-[#4622]: https://github.com/nymtech/nym/pull/4622
-[#4620]: https://github.com/nymtech/nym/pull/4620
-[#4619]: https://github.com/nymtech/nym/pull/4619
-[#4607]: https://github.com/nymtech/nym/pull/4607
-[#4603]: https://github.com/nymtech/nym/pull/4603
-
-## [2024.5-ragusa] (2024-05-22)
-
-- Feature/nym node api location ([#4605])
-- Add optional signature to IPR request/response ([#4604])
-- Feature/unstable tested nodes endpoint ([#4601])
-- nym-api: make report/avg_uptime endpoints ignore blacklist ([#4599])
-- removed blocking for coconut in the final epoch state ([#4598])
-- allow using explicit admin address for issuing freepasses ([#4595])
-- Use rfc3339 for last_polled in described nym-api endpoint ([#4591])
-- Explicitly handle constraint unique violation when importing credential ([#4588])
-- [bugfix] noop flag for nym-api for nymvisor compatibility ([#4586])
-- Chore/additional helpers ([#4585])
-- Feature/wasm coconut ([#4584])
-- upgraded axum and related deps to the most recent version ([#4573])
-- Feature/nyxd scraper pruning ([#4564])
-- Run cargo autoinherit on the main workspace ([#4553])
-- Add rustls-tls to reqwest in validator-client ([#4552])
-- Feature/rewarder voucher issuance ([#4548])
-- make sure 'OffsetDateTimeJsonSchemaWrapper' is serialised with legacy format  ([#4613])
-
-
-[#4613]: https://github.com/nymtech/nym/pull/4613
-[#4605]: https://github.com/nymtech/nym/pull/4605
-[#4604]: https://github.com/nymtech/nym/pull/4604
-[#4601]: https://github.com/nymtech/nym/pull/4601
-[#4599]: https://github.com/nymtech/nym/pull/4599
-[#4598]: https://github.com/nymtech/nym/pull/4598
-[#4595]: https://github.com/nymtech/nym/pull/4595
-[#4591]: https://github.com/nymtech/nym/pull/4591
-[#4588]: https://github.com/nymtech/nym/pull/4588
-[#4586]: https://github.com/nymtech/nym/pull/4586
-[#4585]: https://github.com/nymtech/nym/pull/4585
-[#4584]: https://github.com/nymtech/nym/pull/4584
-[#4573]: https://github.com/nymtech/nym/pull/4573
-[#4564]: https://github.com/nymtech/nym/pull/4564
-[#4553]: https://github.com/nymtech/nym/pull/4553
-[#4552]: https://github.com/nymtech/nym/pull/4552
-[#4548]: https://github.com/nymtech/nym/pull/4548
-
-## [2024.4-nutella] (2024-05-08)
-
-- [fix] apply disable_poisson_rate from internal NR/IPR cfgs ([#4579])
-- updating sign commands to include nym-node ([#4578])
-- changed nym-node redirects from 308 'Permanent Redirect' to 303: 'See Other' ([#4572])
-
-[#4579]: https://github.com/nymtech/nym/pull/4579
-[#4578]: https://github.com/nymtech/nym/pull/4578
-[#4572]: https://github.com/nymtech/nym/pull/4572
-
 ## [2024.3-eclipse] (2024-04-22)
 
 - Initial release of the first iteration of the Nym Node

Cargo.toml

@@ -33,11 +33,15 @@ members = [
     "common/commands",
     "common/config",
     "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
+    "common/cosmwasm-smart-contracts/ecash-contract",
     "common/cosmwasm-smart-contracts/coconut-dkg",
     "common/cosmwasm-smart-contracts/contracts-common",
+    #    "common/cosmwasm-smart-contracts/ephemera",
     "common/cosmwasm-smart-contracts/group-contract",
     "common/cosmwasm-smart-contracts/mixnet-contract",
     "common/cosmwasm-smart-contracts/multisig-contract",
+    "common/cosmwasm-smart-contracts/name-service",
+    "common/cosmwasm-smart-contracts/service-provider-directory",
     "common/cosmwasm-smart-contracts/vesting-contract",
     "common/country-group",
     "common/credential-storage",
@@ -58,6 +62,7 @@ members = [
     "common/node-tester-utils",
     "common/nonexhaustive-delayqueue",
     "common/nymcoconut",
+    "common/nym_offline_compact_ecash",
     "common/nym-id",
     "common/nym-metrics",
     "common/nymsphinx",
@@ -76,6 +81,7 @@ members = [
     "common/socks5-client-core",
     "common/socks5/proxy-helpers",
     "common/socks5/requests",
+    "common/statistics",
     "common/store-cipher",
     "common/task",
     "common/topology",
@@ -98,6 +104,7 @@ members = [
     "service-providers/common",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
+    "service-providers/network-statistics",
     "nym-api",
     "nym-browser-extension/storage",
     "nym-api/nym-api-requests",
@@ -114,10 +121,9 @@ members = [
     "tools/nymvisor",
     "tools/ts-rs-cli",
     "wasm/client",
-    # "wasm/full-nym-wasm",  # If we uncomment this again, remember to also uncomment the profile settings below
+    #    "wasm/full-nym-wasm",
     "wasm/mix-fetch",
     "wasm/node-tester",
-    "wasm/zknym-lib",
 ]
 
 default-members = [
@@ -125,6 +131,7 @@ default-members = [
     "clients/socks5",
     "gateway",
     "service-providers/network-requester",
+    "service-providers/network-statistics",
     "mixnode",
     "nym-api",
     "tools/nymvisor",
@@ -137,6 +144,9 @@ exclude = [
     "explorer",
     "contracts",
     "nym-wallet",
+    "nym-connect/mobile/src-tauri",
+    "nym-connect/desktop",
+    "nym-vpn/ui/src-tauri",
     "cpu-cycles",
     "sdk/ffi/cpp",
 ]
@@ -150,152 +160,44 @@ edition = "2021"
 license = "Apache-2.0"
 
 [workspace.dependencies]
-addr = "0.15.6"
-aes = "0.8.1"
-aes-gcm = "0.10.1"
 anyhow = "1.0.71"
-argon2 = "0.5.0"
 async-trait = "0.1.68"
-axum = "0.7.5"
-axum-extra = "0.9.3"
+axum = "0.6.20"
 base64 = "0.21.4"
-bincode = "1.3.3"
+bs58 = "0.5.0"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
-bitvec = "1.0.0"
-blake3 = "1.3.1"
-bs58 = "0.5.1"
-bytecodec = "0.4.15"
-bytes = "1.5.0"
-cargo_metadata = "0.18.1"
-celes = "2.4.0"
-cfg-if = "1.0.0"
-chacha20 = "0.9.0"
-chacha20poly1305 = "0.10.1"
-chrono = "0.4.31"
-cipher = "0.4.3"
 clap = "4.4.7"
-clap_complete = "4.0"
-clap_complete_fig = "4.0"
-colored = "2.0"
-comfy-table = "6.0.0"
-console-subscriber = "0.1.1"
-console_error_panic_hook = "0.1"
-const-str = "0.5.6"
-const_format = "0.2.32"
-criterion = "0.4"
-csv = "1.3.0"
-ctr = "0.9.1"
-cupid = "0.6.1"
-curve25519-dalek = "4.1"
+cfg-if = "1.0.0"
 dashmap = "5.5.3"
-defguard_wireguard_rs = "0.4.2"
-digest = "0.10.7"
-dirs = "4.0"
-doc-comment = "0.3"
 dotenvy = "0.15.6"
-ecdsa = "0.16"
-ed25519-dalek = "2.1"
-etherparse = "0.13.0"
-eyre = "0.6.9"
-fastrand = "2.1.0"
-flate2 = "1.0.28"
 futures = "0.3.28"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
-getset = "0.1.1"
-handlebars = "3.5.5"
-headers = "0.4.0"
-hex = "0.4.3"
-hex-literal = "0.3.3"
-hkdf = "0.12.3"
-hmac = "0.12.1"
-http = "1"
-httpcodec = "0.2.3"
-humantime = "2.1.0"
 humantime-serde = "1.1.1"
-hyper = "1.3.1"
-indexed_db_futures = "0.3.0"
-inquire = "0.6.2"
-ip_network = "0.4.1"
-ipnetwork = "0.16"
-isocountry = "0.3.2"
+hyper = "0.14.27"
 k256 = "0.13"
 lazy_static = "1.4.0"
-ledger-transport = "0.10.0"
-ledger-transport-hid = "0.10.0"
 log = "0.4"
-maxminddb = "0.23.0"
-mime = "0.3.17"
-nix = "0.27.1"
-notify = "5.1.0"
-okapi = "0.7.0"
 once_cell = "1.7.2"
-opentelemetry = "0.19.0"
-opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.1"
-pem = "0.8"
-pin-project = "1.0"
-pretty_env_logger = "0.4.0"
-publicsuffix = "2.2.3"
-quote = "1"
 rand = "0.8.5"
-rand-07 = "0.7.3"
-rand_chacha = "0.3"
-rand_chacha_02 = "0.2"
-rand_core = "0.6.3"
-rand_distr = "0.4"
-rand_pcg = "0.3.1"
-rand_seeder = "0.2.3"
-rayon = "1.5.1"
-regex = "1.8.4"
-reqwest = { version = "0.12.4", default-features = false }
-rocket = "0.5.0"
-rocket_cors = "0.6.0"
-rocket_okapi = "0.8.0"
-safer-ffi = "0.1.4"
+reqwest = { version = "0.11.22", default-features = false }
 schemars = "0.8.1"
-semver = "1.0.23"
 serde = "1.0.152"
-serde_bytes = "0.11.6"
-serde_derive = "1.0"
 serde_json = "1.0.91"
-serde_repr = "0.1"
-serde_with = "3.4.0"
-serde_yaml = "0.9.25"
-sha2 = "0.10.8"
-si-scale = "0.2.2"
-sphinx-packet = "0.1.1"
 sqlx = "0.6.3"
-strum = "0.25"
-subtle-encoding = "0.5"
-syn = "1"
-sysinfo = "0.30.12"
 tap = "1.0.1"
-tar = "0.4.40"
-tempfile = "3.5.0"
-thiserror = "1.0.48"
 time = "0.3.30"
+thiserror = "1.0.48"
 tokio = "1.33.0"
-tokio-stream = "0.1.14"
-tokio-test = "0.4.2"
-tokio-tungstenite = { version = "0.20.1" }
 tokio-util = "0.7.10"
-toml = "0.8.14"
-tower = "0.4.13"
-tower-http = "0.5.2"
+tokio-tungstenite = { version = "0.20.1" }
 tracing = "0.1.37"
-tracing-opentelemetry = "0.19.0"
-tracing-subscriber = "0.3.16"
-tracing-tree = "0.2.2"
-ts-rs = "7.0.0"
 tungstenite = { version = "0.20.1", default-features = false }
+ts-rs = "7.0.0"
+utoipa = "3.5.0"
+utoipa-swagger-ui = "3.1.5"
 url = "2.4"
-utoipa = "4.2.0"
-utoipa-swagger-ui = "6.0.0"
-vergen = { version = "=8.3.1", default-features = false }
-walkdir = "2"
-wasm-bindgen-test = "0.3.36"
-x25519-dalek = "2.0.0"
 zeroize = "1.6.0"
 
 prometheus = { version = "0.13.0" }
@@ -303,9 +205,10 @@ prometheus = { version = "0.13.0" }
 # coconut/DKG related
 # unfortunately until https://github.com/zkcrypto/bls12_381/issues/10 is resolved, we have to rely on the fork
 # as we need to be able to serialize Gt so that we could create the lookup table for baby-step-giant-step algorithm
-bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", default-features = false,  branch = "feature/gt-serialization-0.8.0" }
-group = { version = "0.13.0", default-features = false }
-ff = { version = "0.13.0", default-features = false }
+bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch = "feature/gt-serialization-0.8.0" }
+group = "0.13.0"
+ff = "0.13.0"
+
 
 # cosmwasm-related
 cosmwasm-derive = "=1.4.3"
@@ -324,27 +227,24 @@ cw4 = { version = "=1.1.2" }
 cw-controllers = { version = "=1.1.0" }
 
 # cosmrs-related
-bip32 = { version = "0.5.1", default-features = false }
+bip32 = "0.5.1"
 
 # temporarily using a fork again (yay.) because we need staking and slashing support
 cosmrs = { git = "https://github.com/jstuczyn/cosmos-rust", branch = "nym-temp/all-validator-features" }
 #cosmrs = {  git = "https://github.com/jstuczyn/cosmos-rust", branch = "nym-temp/all-validator-features" } # unfortuntely we need a fork by yours truly to get the staking support
 tendermint = "0.34"     # same version as used by cosmrs
 tendermint-rpc = "0.34" # same version as used by cosmrs
-prost = { version = "0.12", default-features = false }
+prost = "0.12"
 
 # wasm-related dependencies
-gloo-utils = "0.2.0"
-gloo-net = "0.5.0"
-js-sys = "0.3.69"
-serde-wasm-bindgen = "0.6.5"
+gloo-utils = "0.1.7"
+js-sys = "0.3.63"
+serde-wasm-bindgen = "0.5.0"
 tsify = "0.4.5"
-wasm-bindgen = "0.2.92"
-wasm-bindgen-futures = "0.4.39"
+wasm-bindgen = "0.2.86"
+wasm-bindgen-futures = "0.4.37"
 wasmtimer = "0.2.0"
-web-sys = "0.3.69"
-itertools = "0.12.0"
-
+web-sys = "0.3.63"
 
 # Profile settings for individual crates
 
@@ -360,12 +260,9 @@ opt-level = 'z'
 # lto = true
 opt-level = 'z'
 
-# Commented out since the crate is also commented out from the inclusion in the
-# workspace above. We should uncomment this if we re-include it in the
-# workspace
-#[profile.release.package.nym-wasm-sdk]
-## lto = true
-#opt-level = 'z'
+[profile.release.package.nym-wasm-sdk]
+# lto = true
+opt-level = 'z'
 
 [profile.release.package.mix-fetch-wasm]
 # lto = true

Makefile

@@ -92,6 +92,7 @@ endef
 $(eval $(call add_cargo_workspace,main,.))
 $(eval $(call add_cargo_workspace,contracts,contracts,--lib --target wasm32-unknown-unknown,RUSTFLAGS='-C link-arg=-s'))
 $(eval $(call add_cargo_workspace,wallet,nym-wallet))
+$(eval $(call add_cargo_workspace,connect,nym-connect/desktop))
 
 # -----------------------------------------------------------------------------
 # SDK
@@ -104,7 +105,6 @@ sdk-wasm-build:
 	$(MAKE) -C wasm/client
 	$(MAKE) -C wasm/node-tester
 	$(MAKE) -C wasm/mix-fetch
-	$(MAKE) -C wasm/zknym-lib
 	#$(MAKE) -C wasm/full-nym-wasm
 
 # run this from npm/yarn to ensure tools are in the path, e.g. yarn build:sdk from root of repo
@@ -115,7 +115,7 @@ sdk-typescript-build:
 	yarn --cwd sdk/typescript/codegen/contract-clients build
 
 # NOTE: These targets are part of the main workspace (but not as wasm32-unknown-unknown)
-WASM_CRATES = extension-storage nym-client-wasm nym-node-tester-wasm zknym-lib
+WASM_CRATES = extension-storage nym-client-wasm nym-node-tester-wasm
 
 sdk-wasm-test:
 	#cargo test $(addprefix -p , $(WASM_CRATES)) --target wasm32-unknown-unknown -- -Dwarnings
@@ -133,7 +133,7 @@ clippy: sdk-wasm-lint
 # Build contracts ready for deploy
 # -----------------------------------------------------------------------------
 
-CONTRACTS=vesting_contract mixnet_contract
+CONTRACTS=vesting_contract mixnet_contract nym_service_provider_directory nym_name_service
 CONTRACTS_WASM=$(addsuffix .wasm, $(CONTRACTS))
 CONTRACTS_OUT_DIR=contracts/target/wasm32-unknown-unknown/release
 
@@ -185,4 +185,4 @@ deb-gateway: build-nym-gateway
 deb-cli: build-nym-cli
 	cargo deb -p nym-cli
 
-deb: deb-mixnode deb-gateway deb-cli
+deb: deb-mixnode deb-gateway deb-cli

README.md

@@ -7,66 +7,86 @@ SPDX-License-Identifier: Apache-2.0
 
 The platform is composed of multiple Rust crates. Top-level executable binary crates include:
 
-* `nym-node` - a tool for running a node within the Nym network. Nym Nodes containing functionality such as `mixnode`, `entry-gateway` and `exit-gateway` are fundamental components of Nym Mixnet architecture. Nym Nodes are ran by decentralised node operators. Read more about `nym-node` in [Operators Guide documentation](https://nymtech.net/operators/nodes/nym-node.html). Network functionality of `nym-node` (labeled with `--mode` flag) can be:
-	- `mixnode` - shuffles [Sphinx](https://github.com/nymtech/sphinx) packets together to provide privacy against network-level attackers.
-	- `gateway` - acts sort of like a mailbox for mixnet messages, which removes the need for direct delivery to potentially offline or firewalled devices. Gateways can be further categorized as `entry-gateway` and `exit-gateway`. The latter has an extra embedded IP packet router and Network requester to route data to the internet.
-* `nym-client` - an executable which you can build into your own applications. Use it for interacting with Nym nodes.
-* `nym-socks5-client` - a Socks5 proxy you can run on your machine and use with existing applications.
-* `nym-explorer` - a (projected) block explorer and (existing) mixnet viewer.
-* `nym-wallet` - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework.
-<!-- coming soon
-* `nym-network-monitor` - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
--->
-
-```ascii
-                      ┌─►mix──┐  mix     mix
-                      │       │
-            Entry     │       │                   Exit
-client ───► Gateway ──┘  mix  │  mix  ┌─►mix ───► Gateway ───► internet
-                              │       │
-                              │       │
-                         mix  └─►mix──┘  mix
-
-```
+* nym-mixnode - shuffles [Sphinx](https://github.com/nymtech/sphinx) packets together to provide privacy against network-level attackers.
+* nym-client - an executable which you can build into your own applications. Use it for interacting with Nym nodes.
+* nym-socks5-client - a Socks5 proxy you can run on your machine and use with existing applications.
+* nym-gateway - acts sort of like a mailbox for mixnet messages, which removes the need for direct delivery to potentially offline or firewalled devices.
+* nym-network-monitor - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
+* nym-explorer - a (projected) block explorer and (existing) mixnet viewer.
+* nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework.
 
 [![Build Status](https://img.shields.io/github/actions/workflow/status/nymtech/nym/build.yml?branch=develop&style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
 
 
 ### Building
 
-* Platform build instructions are available on Nym [Operators Guide documentation](https://nymtech.net/operators/binaries/building-nym.html).
-* Wallet build instructions are available on Nym [Technical docs](https://nymtech.net/docs/wallet/desktop-wallet.html).
+Platform build instructions are available on [our docs site](https://nymtech.net/docs/binaries/pre-built-binaries.html).
+Wallet build instructions are also available on [our docs site](https://nymtech.net/docs/wallet/desktop-wallet.html).
 
 ### Developing
 
-There's a [`sandbox.env`](https://github.com/nymtech/nym/envs/sandbox.env) file provided which you can rename to `.env` if you want convenient testing environment. Read more about sandbox environment in our [Operators Guide page](https://nymtech.net/operators/sandbox.html).
+There's a `.env.sample-dev` file provided which you can rename to `.env` if you want convenient logging, backtrace, or other environment variables pre-set. The `.env` file is ignored so you don't need to worry about checking it in.
 
-References for developers:
-
-* [Developers Portal](https://nymtech.net/developers)
-* [Typescript SDKs](https://sdk.nymtech.net/)
-* [Technical Documentation - Nym network overview](https://nymtech.net/docs/)
-* [Release Cycle - git flow](https://nymtech.net/operators/release-cycle.html)
+For Typescript components, please see [ts-packages](./ts-packages).
 
 ### Developer chat
 
+> We used to use Keybase for developer chats, but we have since migrated to Matrix and Discord. We no longer check the old **nymtech.friends** Keybase team.
+
 You can chat to us in two places:
 * The #dev channel on [Matrix](https://matrix.to/#/#dev:nymtech.chat)
-* The various developer channels on [Discord](discord.gg/nymproject)
+* The various developer channels on [Discord](https://discord.gg/nym)
 
-### Tokenomics & Rewards
+### Rewards
 
-Nym network economic incentives, operator and validator rewards, and scalability of the network are determined according to the principles laid out in the section 6 of [Nym Whitepaper](https://nymtech.net/nym-whitepaper.pdf).
-Initial reward pool is set to 250 million Nym, making the circulating supply 750 million Nym.
+Node, node operator and delegator rewards are determined according to the principles laid out in the section 6 of [Nym Whitepaper](https://nymtech.net/nym-whitepaper.pdf). Below is a TLDR of the variables and formulas involved in calculating the epoch rewards. Initial reward pool is set to 250 million Nym, making the circulating supply 750 million Nym.
+
+|Symbol|Definition|
+|---|---|
+|<img src="https://render.githubusercontent.com/render/math?math=R#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}R#gh-dark-mode-only">|global share of rewards available, starts at 2% of the reward pool.
+|<img src="https://render.githubusercontent.com/render/math?math=R_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}R_{i}#gh-dark-mode-only">|node reward for mixnode `i`.
+|<img src="https://render.githubusercontent.com/render/math?math=\sigma_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\sigma_{i}#gh-dark-mode-only">|ratio of total node stake (node bond + all delegations) to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\lambda_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\lambda_{i}#gh-dark-mode-only">|ratio of stake operator has pledged to their node to the token circulating supply.
+|<img src="https://render.githubusercontent.com/render/math?math=\omega_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\omega_{i}#gh-dark-mode-only">|fraction of total effort undertaken by node `i`, set to `1/k`.
+|<img src="https://render.githubusercontent.com/render/math?math=k#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}k#gh-dark-mode-only">|number of nodes stakeholders are incentivised to create, set by the validators, a matter of governance. Currently determined by the `reward set` size, and set to 720 in testnet Sandbox.
+|<img src="https://render.githubusercontent.com/render/math?math=\alpha#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}\alpha#gh-dark-mode-only">|A Sybil attack resistance parameter - the higher this parameter is set, the stronger the reduction in competitiveness for a Sybil attacker.
+|<img src="https://render.githubusercontent.com/render/math?math=PM_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PM_{i}#gh-dark-mode-only">|declared profit margin of operator `i`, defaults to 10%.
+|<img src="https://render.githubusercontent.com/render/math?math=PF_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PF_{i}#gh-dark-mode-only">|uptime of node `i`, scaled to 0 - 1, for the rewarding epoch
+|<img src="https://render.githubusercontent.com/render/math?math=PP_{i}#gh-light-mode-only"><img src="https://render.githubusercontent.com/render/math?math=\color{white}PP_{i}#gh-dark-mode-only">|cost of operating node `i` for the duration of the rewarding epoch, set to 40 NYMs.
+
+Node reward for node `i` is determined as:
+
+<img src="https://render.githubusercontent.com/render/math?math=R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}R_{i}=PF_{i} \cdot R \cdot (\sigma^'_{i} \cdot \omega_{i} \cdot k %2b \alpha \cdot \lambda^'_{i} \cdot \sigma^'_{i} \cdot k)/(1 %2b \alpha)#gh-dark-mode-only">
+where:
+
+<img src="https://render.githubusercontent.com/render/math?math=\sigma^'_{i} = min\{\sigma_{i}, 1/k\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}\sigma^'_{i} = min\{\sigma_{i}, 1/k\}#gh-dark-mode-only">
+
+and
+
+<img src="https://render.githubusercontent.com/render/math?math=\lambda^'_{i} = min\{\lambda_{i}, 1/k\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}\lambda^'_{i} = min\{\lambda_{i}, 1/k\}#gh-dark-mode-only">
+
+Operator of node `i` is credited with the following amount:
+
+<img src="https://render.githubusercontent.com/render/math?math=min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}min\{PP_{i},R_{i})\} %2b max\{0, (PM_{i} %2b (1 - PM_{i}) \cdot \lambda_{i}/\delta_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">
+
+Delegate with stake `s` receives:
+
+<img src="https://render.githubusercontent.com/render/math?math=max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-light-mode-only">
+<img src="https://render.githubusercontent.com/render/math?math=\color{white}max\{0, (1-PM_{i}) \cdot (s^'/\sigma_{i}) \cdot (R_{i} - PP_{i})\}#gh-dark-mode-only">
+
+where `s'` is stake `s` scaled over total token circulating supply.
 
 ### Licensing and copyright information
 
 This is a monorepo and components that make up Nym as a system are licensed individually, so for accurate information, please check individual files.
 
 As a general approach, licensing is as follows this pattern:
-
 - applications and binaries are GPLv3
 - libraries and components are Apache 2.0 or MIT
 - documentation is Apache 2.0 or CC0-1.0
 
-Nym Node Operators and Validators Temrs and Conditions can be found [here](https://nymtech.net/terms-and-conditions/operators/v1.0.0).
+Again, for accurate information, please check individual files.

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.36"
+version = "1.1.34"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -23,13 +23,13 @@ url = { workspace = true }
 
 bs58 = { workspace = true }
 clap = { workspace = true, features = ["cargo", "derive"] }
-dirs = { workspace = true }
+dirs = "4.0"
 log = { workspace = true } # self explanatory
-rand = { workspace = true }
+rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
 serde_json = { workspace = true }
 thiserror = { workspace = true }
-tap = { workspace = true }
+tap = "1.0.1"
 time = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = { workspace = true }
@@ -37,7 +37,7 @@ zeroize = { workspace = true }
 
 ## internal
 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
-nym-bin-common = { path = "../../common/bin-common", features = ["output_format", "clap"] }
+nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
 nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage", "fs-gateways-storage", "cli"] }
 nym-config = { path = "../../common/config" }
 nym-credential-storage = { path = "../../common/credential-storage" }

clients/native/examples/js-examples/websocket/package-lock.json

@@ -744,18 +744,6 @@
         "concat-map": "0.0.1"
       }
     },
-    "node_modules/braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
-      "dependencies": {
-        "fill-range": "^7.1.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/browserslist": {
       "version": "4.20.2",
       "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.20.2.tgz",
@@ -874,6 +862,51 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/chokidar/node_modules/braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/chokidar/node_modules/fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/chokidar/node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/chokidar/node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
     "node_modules/chrome-trace-event": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.3.tgz",
@@ -1560,6 +1593,39 @@
         "node": ">=8.6.0"
       }
     },
+    "node_modules/fast-glob/node_modules/braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fast-glob/node_modules/fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fast-glob/node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
     "node_modules/fast-glob/node_modules/micromatch": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
@@ -1573,6 +1639,18 @@
         "node": ">=8.6"
       }
     },
+    "node_modules/fast-glob/node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
     "node_modules/fast-json-stable-stringify": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
@@ -1605,18 +1683,6 @@
         "node": ">=0.8.0"
       }
     },
-    "node_modules/fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
-      "dependencies": {
-        "to-regex-range": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/finalhandler": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
@@ -2071,6 +2137,39 @@
         }
       }
     },
+    "node_modules/http-proxy-middleware/node_modules/braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/http-proxy-middleware/node_modules/fill-range": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+      "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/http-proxy-middleware/node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
     "node_modules/http-proxy-middleware/node_modules/micromatch": {
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
@@ -2084,6 +2183,18 @@
         "node": ">=8.6"
       }
     },
+    "node_modules/http-proxy-middleware/node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
     "node_modules/human-signals": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz",
@@ -2250,15 +2361,6 @@
         "node": ">=0.10.0"
       }
     },
-    "node_modules/is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.12.0"
-      }
-    },
     "node_modules/is-path-cwd": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-2.2.0.tgz",
@@ -3751,18 +3853,6 @@
       "integrity": "sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==",
       "dev": true
     },
-    "node_modules/to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
-      "dependencies": {
-        "is-number": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=8.0"
-      }
-    },
     "node_modules/toidentifier": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
@@ -5123,15 +5213,6 @@
         "concat-map": "0.0.1"
       }
     },
-    "braces": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
-      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
-      "dev": true,
-      "requires": {
-        "fill-range": "^7.1.1"
-      }
-    },
     "browserslist": {
       "version": "4.20.2",
       "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.20.2.tgz",
@@ -5202,6 +5283,41 @@
         "is-glob": "~4.0.1",
         "normalize-path": "~3.0.0",
         "readdirp": "~3.6.0"
+      },
+      "dependencies": {
+        "braces": {
+          "version": "3.0.2",
+          "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+          "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+          "dev": true,
+          "requires": {
+            "fill-range": "^7.0.1"
+          }
+        },
+        "fill-range": {
+          "version": "7.0.1",
+          "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+          "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+          "dev": true,
+          "requires": {
+            "to-regex-range": "^5.0.1"
+          }
+        },
+        "is-number": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+          "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+          "dev": true
+        },
+        "to-regex-range": {
+          "version": "5.0.1",
+          "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+          "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+          "dev": true,
+          "requires": {
+            "is-number": "^7.0.0"
+          }
+        }
       }
     },
     "chrome-trace-event": {
@@ -5736,6 +5852,30 @@
         "micromatch": "^4.0.4"
       },
       "dependencies": {
+        "braces": {
+          "version": "3.0.2",
+          "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+          "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+          "dev": true,
+          "requires": {
+            "fill-range": "^7.0.1"
+          }
+        },
+        "fill-range": {
+          "version": "7.0.1",
+          "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+          "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+          "dev": true,
+          "requires": {
+            "to-regex-range": "^5.0.1"
+          }
+        },
+        "is-number": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+          "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+          "dev": true
+        },
         "micromatch": {
           "version": "4.0.4",
           "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
@@ -5745,6 +5885,15 @@
             "braces": "^3.0.1",
             "picomatch": "^2.2.3"
           }
+        },
+        "to-regex-range": {
+          "version": "5.0.1",
+          "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+          "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+          "dev": true,
+          "requires": {
+            "is-number": "^7.0.0"
+          }
         }
       }
     },
@@ -5777,15 +5926,6 @@
         "websocket-driver": ">=0.5.1"
       }
     },
-    "fill-range": {
-      "version": "7.1.1",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
-      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
-      "dev": true,
-      "requires": {
-        "to-regex-range": "^5.0.1"
-      }
-    },
     "finalhandler": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz",
@@ -6107,6 +6247,30 @@
         "micromatch": "^4.0.2"
       },
       "dependencies": {
+        "braces": {
+          "version": "3.0.2",
+          "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+          "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+          "dev": true,
+          "requires": {
+            "fill-range": "^7.0.1"
+          }
+        },
+        "fill-range": {
+          "version": "7.0.1",
+          "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+          "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+          "dev": true,
+          "requires": {
+            "to-regex-range": "^5.0.1"
+          }
+        },
+        "is-number": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+          "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+          "dev": true
+        },
         "micromatch": {
           "version": "4.0.4",
           "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.4.tgz",
@@ -6116,6 +6280,15 @@
             "braces": "^3.0.1",
             "picomatch": "^2.2.3"
           }
+        },
+        "to-regex-range": {
+          "version": "5.0.1",
+          "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+          "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+          "dev": true,
+          "requires": {
+            "is-number": "^7.0.0"
+          }
         }
       }
     },
@@ -6234,12 +6407,6 @@
         "is-extglob": "^2.1.1"
       }
     },
-    "is-number": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
-      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
-      "dev": true
-    },
     "is-path-cwd": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-2.2.0.tgz",
@@ -7357,15 +7524,6 @@
       "integrity": "sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==",
       "dev": true
     },
-    "to-regex-range": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
-      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
-      "dev": true,
-      "requires": {
-        "is-number": "^7.0.0"
-      }
-    },
     "toidentifier": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",

clients/native/src/client/mod.rs

@@ -106,10 +106,8 @@ impl SocketClient {
         };
 
         let storage = self.initialise_storage().await?;
-        let user_agent = nym_bin_common::bin_info!().into();
 
-        let mut base_client = BaseClientBuilder::new(&self.config.base, storage, dkg_query_client)
-            .with_user_agent(user_agent);
+        let mut base_client = BaseClientBuilder::new(&self.config.base, storage, dkg_query_client);
 
         if let Some(custom_mixnet) = &self.custom_mixnet {
             base_client = base_client.with_stored_topology(custom_mixnet)?;

clients/native/src/commands/add_gateway.rs

@@ -22,9 +22,8 @@ impl AsRef<CommonClientAddGatewayArgs> for Args {
 }
 
 pub(crate) async fn execute(args: Args) -> Result<(), ClientError> {
-    let user_agent = nym_bin_common::bin_info!().into();
     let output = args.output;
-    let res = add_gateway::<CliNativeClient, _>(args, Some(user_agent)).await?;
+    let res = add_gateway::<CliNativeClient, _>(args).await?;
 
     println!("{}", output.format(&res));
     Ok(())

clients/native/src/commands/init.rs

@@ -114,9 +114,8 @@ impl Display for InitResults {
 pub(crate) async fn execute(args: Init) -> Result<(), ClientError> {
     eprintln!("Initialising client...");
 
-    let user_agent = nym_bin_common::bin_info!().into();
     let output = args.output;
-    let res = initialise_client::<CliNativeClient>(args, Some(user_agent)).await?;
+    let res = initialise_client::<CliNativeClient>(args).await?;
 
     let init_results = InitResults::new(res);
     println!("{}", output.format(&init_results));

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.36"
+version = "1.1.34"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -13,10 +13,10 @@ clap = { workspace = true, features = ["cargo", "derive"] }
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
 serde_json = { workspace = true }
-tap = { workspace = true }
+tap = "1.0.1"
 thiserror = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread", "net", "signal"] }
-rand = { workspace = true }
+tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
+rand = "0.7.3"
 time = { workspace = true }
 url = { workspace = true }
 zeroize = { workspace = true }
@@ -25,18 +25,17 @@ zeroize = { workspace = true }
 nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
 nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage", "fs-gateways-storage", "cli"] }
 nym-config = { path = "../../common/config" }
-nym-credential-storage = { path = "../../common/credential-storage" }
 nym-credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
 nym-gateway-requests = { path = "../../gateway/gateway-requests" }
-nym-id = { path = "../../common/nym-id" }
+nym-credential-storage = { path = "../../common/credential-storage" }
 nym-network-defaults = { path = "../../common/network-defaults" }
+nym-sphinx = { path = "../../common/nymsphinx" }
 nym-ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
 nym-pemstore = { path = "../../common/pemstore" }
-nym-socks5-client-core = { path = "../../common/socks5-client-core" }
-nym-sphinx = { path = "../../common/nymsphinx" }
 nym-topology = { path = "../../common/topology" }
-nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["http-client"] }
+nym-socks5-client-core = { path = "../../common/socks5-client-core" }
+nym-id = { path = "../../common/nym-id" }
 
 [features]
 default = []

clients/socks5/src/commands/add_gateway.rs

@@ -22,9 +22,8 @@ impl AsRef<CommonClientAddGatewayArgs> for Args {
 }
 
 pub(crate) async fn execute(args: Args) -> Result<(), Socks5ClientError> {
-    let user_agent = nym_bin_common::bin_info!().into();
     let output = args.output;
-    let res = add_gateway::<CliSocks5Client, _>(args, Some(user_agent)).await?;
+    let res = add_gateway::<CliSocks5Client, _>(args).await?;
 
     println!("{}", output.format(&res));
     Ok(())

clients/socks5/src/commands/init.rs

@@ -129,9 +129,8 @@ impl Display for InitResults {
 pub(crate) async fn execute(args: Init) -> Result<(), Socks5ClientError> {
     eprintln!("Initialising client...");
 
-    let user_agent = nym_bin_common::bin_info!().into();
     let output = args.output;
-    let res = initialise_client::<CliSocks5Client>(args, Some(user_agent)).await?;
+    let res = initialise_client::<CliSocks5Client>(args).await?;
 
     let init_results = InitResults::new(res);
     println!("{}", output.format(&init_results));

clients/socks5/src/commands/run.rs

@@ -116,13 +116,7 @@ pub(crate) async fn execute(args: Run) -> Result<(), Box<dyn std::error::Error +
     let storage =
         OnDiskPersistent::from_paths(config.storage_paths.common_paths, &config.core.base.debug)
             .await?;
-    let user_agent = nym_bin_common::bin_info!().into();
-    NymClient::new(
-        config.core,
-        storage,
-        user_agent,
-        args.common_args.custom_mixnet,
-    )
-    .run_forever()
-    .await
+    NymClient::new(config.core, storage, args.common_args.custom_mixnet)
+        .run_forever()
+        .await
 }

common/async-file-watcher/Cargo.toml

@@ -8,6 +8,6 @@ license.workspace = true
 
 [dependencies]
 futures = { workspace = true }
-log = { workspace = true }
-notify = { workspace = true }
+log = "0.4"
+notify = "5.1.0"
 tokio = { workspace = true, features = ["time"] }

common/bandwidth-controller/Cargo.toml

@@ -9,7 +9,7 @@ license.workspace = true
 [dependencies]
 bip39 = { workspace = true }
 log = { workspace = true }
-rand = { workspace = true }
+rand = "0.7.3"
 thiserror = { workspace = true }
 url = { workspace = true }
 zeroize = { workspace = true }
@@ -21,6 +21,7 @@ nym-credentials-interface = { path = "../credentials-interface" }
 nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
 nym-network-defaults = { path = "../network-defaults" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
+nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
 path = "../client-libs/validator-client"

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

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

common/bandwidth-controller/src/error.rs

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

common/bandwidth-controller/src/lib.rs

@@ -3,16 +3,23 @@
 
 use crate::error::BandwidthControllerError;
 use crate::utils::stored_credential_to_issued_bandwidth;
-use log::{debug, error, warn};
+use log::info;
+use log::{error, warn};
+
+use nym_credential_storage::models::StorableIssuedCredential;
+use nym_credentials::coconut::utils::{obtain_coin_indices_signatures, signatures_to_string};
+use nym_credentials_interface::{constants, PayInfo, VerificationKeyAuth};
+
 use nym_credential_storage::storage::Storage;
-use nym_credentials::coconut::bandwidth::issued::BandwidthCredentialIssuedDataVariant;
+
 use nym_credentials::coconut::bandwidth::CredentialSpendingData;
-use nym_credentials::coconut::utils::obtain_aggregate_verification_key;
+use nym_credentials::coconut::utils::signatures_from_string;
+use nym_credentials::obtain_aggregate_verification_key;
 use nym_credentials::IssuedBandwidthCredential;
-use nym_credentials_interface::VerificationKey;
-use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
+use zeroize::Zeroizing;
 
 pub mod acquire;
 pub mod error;
@@ -34,6 +41,9 @@ pub struct PreparedCredential {
 
     /// The database id of the stored credential.
     pub credential_id: i64,
+
+    ///the updated credential after the payment
+    pub updated_credential: IssuedBandwidthCredential,
 }
 
 pub struct RetrievedCredential {
@@ -50,7 +60,6 @@ impl<C, St: Storage> BandwidthController<C, St> {
     /// It marks any retrieved intermediate credentials as expired.
     pub async fn get_next_usable_credential(
         &self,
-        gateway_id: &str,
     ) -> Result<RetrievedCredential, BandwidthControllerError>
     where
         <St as Storage>::StorageError: Send + Sync + 'static,
@@ -58,7 +67,7 @@ impl<C, St: Storage> BandwidthController<C, St> {
         loop {
             let Some(maybe_next) = self
                 .storage
-                .get_next_unspent_credential(gateway_id)
+                .get_next_unspent_credential()
                 .await
                 .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))?
             else {
@@ -69,23 +78,16 @@ impl<C, St: Storage> BandwidthController<C, St> {
             // try to deserialize it
             let valid_credential = match stored_credential_to_issued_bandwidth(maybe_next) {
                 // check if it has already expired
-                Ok(credential) => match credential.variant_data() {
-                    BandwidthCredentialIssuedDataVariant::Voucher(_) => {
-                        debug!("credential {id} is a bandwidth voucher");
-                        credential
+                Ok(credential) => {
+                    if credential.expired() {
+                        warn!("the credential (id: {id}) has already expired! The expiration was set to {}", credential.expiration_date_formatted());
+                        self.storage.mark_expired(id).await.map_err(|err| {
+                            BandwidthControllerError::CredentialStorageError(Box::new(err))
+                        })?;
+                        continue;
                     }
-                    BandwidthCredentialIssuedDataVariant::FreePass(freepass_info) => {
-                        debug!("credential {id} is a free pass");
-                        if freepass_info.expired() {
-                            warn!("the free pass (id: {id}) has already expired! The expiration was set to {}", freepass_info.expiry_date());
-                            self.storage.mark_expired(id).await.map_err(|err| {
-                                BandwidthControllerError::CredentialStorageError(Box::new(err))
-                            })?;
-                            continue;
-                        }
-                        credential
-                    }
-                },
+                    credential
+                }
                 Err(err) => {
                     error!("failed to deserialize credential with id {id}: {err}. it may need to be manually removed from the storage");
                     return Err(err);
@@ -105,51 +107,108 @@ impl<C, St: Storage> BandwidthController<C, St> {
     async fn get_aggregate_verification_key(
         &self,
         epoch_id: EpochId,
-    ) -> Result<VerificationKey, BandwidthControllerError>
+    ) -> Result<VerificationKeyAuth, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
-        let coconut_api_clients = all_coconut_api_clients(&self.client, epoch_id).await?;
+        let coconut_api_clients = all_ecash_api_clients(&self.client, epoch_id).await?;
         Ok(obtain_aggregate_verification_key(&coconut_api_clients)?)
     }
 
-    pub async fn prepare_bandwidth_credential(
+    pub async fn prepare_ecash_credential(
         &self,
-        gateway_id: &str,
+        provider_pk: [u8; 32],
     ) -> Result<PreparedCredential, BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
-        let retrieved_credential = self.get_next_usable_credential(gateway_id).await?;
+        let retrieved_credential = self.get_next_usable_credential().await?;
 
         let epoch_id = retrieved_credential.credential.epoch_id();
         let credential_id = retrieved_credential.credential_id;
 
         let verification_key = self.get_aggregate_verification_key(epoch_id).await?;
 
-        let spend_request = retrieved_credential
-            .credential
-            .prepare_for_spending(&verification_key)?;
+        let coin_indices_signatures_bs58 = self
+            .storage
+            .get_coin_indices_sig(epoch_id.to_string())
+            .await
+            .ok();
 
+        let coin_indices_signatures = match coin_indices_signatures_bs58 {
+            Some(epoch_signatures) => signatures_from_string(epoch_signatures.signatures)?,
+            None => {
+                info!("We're missing some signatures, let's query them now");
+                //let's try to query them if we don't have them at that point
+                let ecash_api_client = all_ecash_api_clients(&self.client, epoch_id).await?;
+                let threshold = self
+                    .client
+                    .get_current_epoch_threshold()
+                    .await?
+                    .ok_or(BandwidthControllerError::NoThreshold)?;
+
+                let coin_indices_signatures =
+                    obtain_coin_indices_signatures(&ecash_api_client, &verification_key, threshold)
+                        .await?;
+
+                self.storage
+                    .insert_coin_indices_sig(
+                        epoch_id.to_string(),
+                        signatures_to_string(&coin_indices_signatures),
+                    )
+                    .await
+                    .map_err(|err| {
+                        BandwidthControllerError::CredentialStorageError(Box::new(err))
+                    })?;
+                coin_indices_signatures
+            }
+        };
+
+        let pay_info = PayInfo::generate_pay_info(provider_pk);
+
+        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
+
+        let spend_request = retrieved_credential.credential.prepare_for_spending(
+            &verification_key,
+            pay_info,
+            coin_indices_signatures,
+        )?;
         Ok(PreparedCredential {
             data: spend_request,
             epoch_id,
             credential_id,
+            updated_credential: retrieved_credential.credential,
         })
     }
 
-    pub async fn consume_credential(
+    pub async fn update_ecash_wallet(
         &self,
+        credential: IssuedBandwidthCredential,
         id: i64,
-        gateway_id: &str,
     ) -> Result<(), BandwidthControllerError>
     where
         <St as Storage>::StorageError: Send + Sync + 'static,
     {
+        // JS: shouldn't we send some contract/validator/gateway message here to actually, you know,
+        // consume it?
+        let consumed = credential.wallet().l() >= constants::NB_TICKETS;
+
+        // make sure the data gets zeroized after persisting it
+        let credential_data = Zeroizing::new(credential.pack_v1());
+        let storable = StorableIssuedCredential {
+            serialization_revision: credential.current_serialization_revision(),
+            credential_data: credential_data.as_ref(),
+            credential_type: credential.typ().to_string(),
+            epoch_id: credential
+                .epoch_id()
+                .try_into()
+                .expect("our epoch is has run over u32::MAX!"),
+        };
+
         self.storage
-            .consume_coconut_credential(id, gateway_id)
+            .update_issued_credential(storable, id, consumed)
             .await
             .map_err(|err| BandwidthControllerError::CredentialStorageError(Box::new(err)))
     }

common/bin-common/Cargo.toml

@@ -8,33 +8,45 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-const-str = { workspace = true }
-clap = { workspace = true, features = ["derive"], optional = true }
-clap_complete = { workspace = true, optional = true }
-clap_complete_fig = { workspace = true, optional = true }
+const-str = "0.5.6"
+clap = { workspace = true, features = ["derive"] }
+clap_complete = "4.0"
+clap_complete_fig = "4.0"
 log = { workspace = true }
-pretty_env_logger = { workspace = true }
+pretty_env_logger = "0.4.0"
 semver = "0.11"
 schemars = { workspace = true, features = ["preserve_order"], optional = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
 
 ## tracing
-tracing-subscriber = { workspace = true, features = ["env-filter"], optional = true }
-tracing-tree = { workspace = true, optional = true }
-opentelemetry-jaeger = { workspace = true, features = ["rt-tokio", "collector_client", "isahc_collector_client"], optional = true }
-tracing-opentelemetry = { workspace = true, optional = true }
+tracing-subscriber = { version = "0.3.16", features = [
+    "env-filter",
+], optional = true }
+tracing-tree = { version = "0.2.2", optional = true }
+opentelemetry-jaeger = { version = "0.18.0", optional = true, features = [
+    "rt-tokio",
+    "collector_client",
+    "isahc_collector_client",
+] }
+tracing-opentelemetry = { version = "0.19.0", optional = true }
 utoipa = { workspace = true, optional = true }
-opentelemetry = { workspace = true, features = ["rt-tokio"], optional = true }
+opentelemetry = { version = "0.19.0", optional = true, features = ["rt-tokio"] }
 
 
 [build-dependencies]
-vergen = { workspace = true, features = ["build", "git", "gitcl", "rustc", "cargo"] }
+vergen = { version = "=8.2.6", default-features = false, features = [
+    "build",
+    "git",
+    "gitcl",
+    "rustc",
+    "cargo",
+] }
 
 [features]
 default = []
 openapi = ["utoipa"]
-output_format = ["serde_json", "dep:clap"]
+output_format = ["serde_json"]
 bin_info_schema = ["schemars"]
 basic_tracing = ["tracing-subscriber"]
 tracing = [
@@ -44,4 +56,3 @@ tracing = [
     "tracing-opentelemetry",
     "opentelemetry",
 ]
-clap = [ "dep:clap", "dep:clap_complete", "dep:clap_complete_fig" ]

common/bin-common/src/build_information/mod.rs

@@ -44,10 +44,6 @@ pub struct BinaryBuildInformation {
     /// Provides the cargo debug mode that was used for the build.
     // NOTE: keep the old name cargo_profile instead of cargo_debug for backwards compatibility
     pub cargo_profile: &'static str,
-
-    // VERGEN_CARGO_TARGET_TRIPLE
-    /// Provides the cargo target triple that was used for the build.
-    pub cargo_triple: &'static str,
 }
 
 impl BinaryBuildInformation {
@@ -70,7 +66,6 @@ impl BinaryBuildInformation {
             rustc_version: env!("VERGEN_RUSTC_SEMVER"),
             rustc_channel: env!("VERGEN_RUSTC_CHANNEL"),
             cargo_profile,
-            cargo_triple: env!("VERGEN_CARGO_TARGET_TRIPLE"),
         }
     }
 
@@ -100,7 +95,6 @@ impl BinaryBuildInformation {
             rustc_version: env!("VERGEN_RUSTC_SEMVER"),
             rustc_channel: env!("VERGEN_RUSTC_CHANNEL"),
             cargo_profile,
-            cargo_triple: env!("VERGEN_CARGO_TARGET_TRIPLE"),
         }
     }
 
@@ -115,7 +109,6 @@ impl BinaryBuildInformation {
             rustc_version: self.rustc_version.to_owned(),
             rustc_channel: self.rustc_channel.to_owned(),
             cargo_profile: self.cargo_profile.to_owned(),
-            cargo_triple: self.cargo_triple.to_owned(),
         }
     }
 
@@ -163,15 +156,6 @@ pub struct BinaryBuildInformationOwned {
     /// Provides the cargo debug mode that was used for the build.
     // NOTE: keep the old name cargo_profile instead of cargo_debug for backwards compatibility
     pub cargo_profile: String,
-
-    // VERGEN_CARGO_TARGET_TRIPLE
-    /// Provides the cargo target triple that was used for the build.
-    #[serde(default = "unknown")]
-    pub cargo_triple: String,
-}
-
-fn unknown() -> String {
-    "unknown".to_string()
 }
 
 impl Display for BinaryBuildInformationOwned {

common/bin-common/src/lib.rs

@@ -2,11 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod build_information;
+pub mod completions;
 pub mod logging;
 pub mod version_checker;
 
-#[cfg(feature = "clap")]
-pub mod completions;
-
 #[cfg(feature = "output_format")]
 pub mod output_format;

common/client-core/Cargo.toml

@@ -3,28 +3,29 @@ name = "nym-client-core"
 version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
-rust-version = "1.70"
+rust-version = "1.66"
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 async-trait = { workspace = true }
-base64 = { workspace = true }
+base64 = "0.21.2"
 bs58 = { workspace = true }
-cfg-if = { workspace = true }
+cfg-if = "1.0.0"
 clap = { workspace = true, optional = true }
 futures = { workspace = true }
 humantime-serde = { workspace = true }
 log = { workspace = true }
-rand = { workspace = true }
+rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-sha2 = { workspace = true }
-si-scale = { workspace = true }
-tap = { workspace = true }
+sha2 = "0.10.6"
+si-scale = "0.2.2"
+tap = "1.0.1"
 thiserror = { workspace = true }
 url = { workspace = true, features = ["serde"] }
+tungstenite = { workspace = true, default-features = false }
 tokio = { workspace = true, features = ["macros"] }
 time = { workspace = true }
 zeroize = { workspace = true }
@@ -47,7 +48,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" }
-nym-client-core-config-types = { path = "./config-types", features = ["disk-persistence"] }
+nym-client-core-config-types = { path = "./config-types", features = ["disk-persistence"]}
 nym-client-core-surb-storage = { path = "./surb-storage" }
 nym-client-core-gateways-storage = { path = "./gateways-storage" }
 
@@ -73,17 +74,8 @@ workspace = true
 features = ["time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
-workspace = true
-features = ["rustls-tls-webpki-roots"]
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tungstenite]
-workspace = true
-default-features = true
-features = ["rustls-tls-webpki-roots"]
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.tungstenite]
-workspace = true
-default-features = false
+version = "0.20.1"
+features = ["rustls-tls-native-roots"]
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
 workspace = true
@@ -108,7 +100,7 @@ version = "0.3.17"
 features = ["wasm-bindgen"]
 
 [dev-dependencies]
-tempfile = { workspace = true }
+tempfile = "3.1.0"
 
 [features]
 default = []

common/client-core/config-types/src/error.rs

@@ -8,12 +8,3 @@ use thiserror::Error;
 pub struct ConfigUpgradeFailure {
     pub current_version: String,
 }
-
-#[derive(Error, Debug)]
-pub enum InvalidTrafficModeFailure {
-    #[error("attempted to set medium toggle traffic mode with fast mode flag")]
-    MediumToggleWithFastMode,
-
-    #[error("attempted to set medium toggle traffic mode with no cover flag")]
-    MediumToggleWithNoCover,
-}

common/client-core/config-types/src/lib.rs

@@ -24,11 +24,6 @@ const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20)
 const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
 const DEFAULT_TOPOLOGY_REFRESH_RATE: Duration = Duration::from_secs(5 * 60); // every 5min
 const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_000);
-
-// the same values as our current (10.06.24) blacklist
-const DEFAULT_MIN_MIXNODE_PERFORMANCE: u8 = 50;
-const DEFAULT_MIN_GATEWAY_PERFORMANCE: u8 = 50;
-
 const DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD: Duration = Duration::from_secs(70 * 60); // 70min -> full epoch (1h) + a bit of overhead
 
 // Set this to a high value for now, so that we don't risk sporadic timeouts that might cause
@@ -61,7 +56,6 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
-use crate::error::InvalidTrafficModeFailure;
 pub use nym_country_group::CountryGroup;
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
@@ -133,56 +127,6 @@ impl Config {
         self
     }
 
-    // TODO: this should be refactored properly
-    // as of 12.09.23 the below is true (not sure how this comment will rot in the future)
-    // medium_toggle:
-    // - sets secondary packet size to 16kb
-    // - disables poisson distribution of the main traffic stream
-    // - sets the cover traffic stream to 1 packet / 5s (on average)
-    // - disables per hop delay
-    //
-    // fastmode (to be renamed to `fast-poisson`):
-    // - sets average per hop delay to 10ms
-    // - sets the cover traffic stream to 1 packet / 2000s (on average); for all intents and purposes it disables the stream
-    // - sets the poisson distribution of the main traffic stream to 4ms, i.e. 250 packets / s on average
-    //
-    // no_cover:
-    // - disables poisson distribution of the main traffic stream
-    // - disables the secondary cover traffic stream
-    #[doc(hidden)]
-    pub fn try_apply_traffic_modes(
-        &mut self,
-        disable_poisson_process: bool,
-        medium_toggle: bool,
-        fast_mode: bool,
-        no_cover: bool,
-    ) -> Result<(), InvalidTrafficModeFailure> {
-        if disable_poisson_process {
-            self.set_no_poisson_process()
-        }
-
-        if medium_toggle {
-            if fast_mode {
-                return Err(InvalidTrafficModeFailure::MediumToggleWithFastMode);
-            }
-            if no_cover {
-                return Err(InvalidTrafficModeFailure::MediumToggleWithNoCover);
-            }
-
-            self.set_experimental_medium_toggle();
-        }
-
-        if fast_mode {
-            self.set_high_default_traffic_volume()
-        }
-
-        if no_cover {
-            self.set_no_cover_traffic();
-        }
-
-        Ok(())
-    }
-
     pub fn set_high_default_traffic_volume(&mut self) {
         self.debug.traffic.average_packet_delay = Duration::from_millis(10);
         // basically don't really send cover messages
@@ -192,15 +136,6 @@ impl Config {
         self.debug.traffic.message_sending_average_delay = Duration::from_millis(4);
     }
 
-    /// Enable medium mixnet traffic, for experiments only.
-    /// This includes things like disabling cover traffic, no per hop delays, etc.
-    #[doc(hidden)]
-    pub fn set_experimental_medium_toggle(&mut self) {
-        self.set_no_cover_traffic_with_keepalive();
-        self.set_no_per_hop_delays();
-        self.debug.traffic.secondary_packet_size = Some(PacketSize::ExtendedPacket16);
-    }
-
     pub fn with_disabled_poisson_process(mut self, disabled: bool) -> Self {
         if disabled {
             self.set_no_poisson_process()
@@ -521,14 +456,6 @@ pub struct Topology {
 
     /// Specifies the mixnode topology to be used for sending packets.
     pub topology_structure: TopologyStructure,
-
-    /// Specifies a minimum performance of a mixnode that is used on route construction.
-    /// This setting is only applicable when `NymApi` topology is used.
-    pub minimum_mixnode_performance: u8,
-
-    /// Specifies a minimum performance of a gateway that is used on route construction.
-    /// This setting is only applicable when `NymApi` topology is used.
-    pub minimum_gateway_performance: u8,
 }
 
 #[allow(clippy::large_enum_variant)]
@@ -563,8 +490,6 @@ impl Default for Topology {
             disable_refreshing: false,
             max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
             topology_structure: TopologyStructure::default(),
-            minimum_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
-            minimum_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
         }
     }
 }

common/client-core/config-types/src/old/v5.rs

@@ -146,7 +146,6 @@ impl From<ConfigV5> for Config {
                         .topology
                         .max_startup_gateway_waiting_period,
                     topology_structure: value.debug.topology.topology_structure.into(),
-                    ..Default::default()
                 },
                 reply_surbs: ReplySurbs {
                     minimum_reply_surb_storage_threshold: value

common/client-core/gateways-storage/fs_gateways_migrations/20240610120000_nullable_gateway_owner.sql

@@ -1,18 +0,0 @@
-/*
- * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-CREATE TABLE remote_gateway_details_temp
-(
-    gateway_id_bs58                          TEXT NOT NULL UNIQUE PRIMARY KEY REFERENCES registered_gateway (gateway_id_bs58),
-    derived_aes128_ctr_blake3_hmac_keys_bs58 TEXT NOT NULL,
-    gateway_owner_address                    TEXT,
-    gateway_listener                         TEXT NOT NULL,
-    wg_tun_address                           TEXT
-);
-
-INSERT INTO remote_gateway_details_temp SELECT * FROM remote_gateway_details;
-
-DROP TABLE remote_gateway_details;
-ALTER TABLE remote_gateway_details_temp RENAME TO remote_gateway_details;

common/client-core/gateways-storage/src/types.rs

@@ -65,7 +65,7 @@ impl GatewayDetails {
     pub fn new_remote(
         gateway_id: identity::PublicKey,
         derived_aes128_ctr_blake3_hmac_keys: Arc<SharedKeys>,
-        gateway_owner_address: Option<AccountId>,
+        gateway_owner_address: AccountId,
         gateway_listener: Url,
         wg_tun_address: Option<Url>,
     ) -> Self {
@@ -170,7 +170,7 @@ pub struct RegisteredGateway {
 pub struct RawRemoteGatewayDetails {
     pub gateway_id_bs58: String,
     pub derived_aes128_ctr_blake3_hmac_keys_bs58: String,
-    pub gateway_owner_address: Option<String>,
+    pub gateway_owner_address: String,
     pub gateway_listener: String,
     pub wg_tun_address: Option<String>,
 }
@@ -195,19 +195,14 @@ impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {
                 })?,
         );
 
-        let gateway_owner_address = value
-            .gateway_owner_address
-            .as_ref()
-            .map(|raw_owner| {
-                AccountId::from_str(raw_owner).map_err(|source| {
-                    BadGateway::MalformedGatewayOwnerAccountAddress {
-                        gateway_id: value.gateway_id_bs58.clone(),
-                        raw_owner: raw_owner.clone(),
-                        source,
-                    }
-                })
-            })
-            .transpose()?;
+        let gateway_owner_address =
+            AccountId::from_str(&value.gateway_owner_address).map_err(|source| {
+                BadGateway::MalformedGatewayOwnerAccountAddress {
+                    gateway_id: value.gateway_id_bs58.clone(),
+                    raw_owner: value.gateway_owner_address.clone(),
+                    source,
+                }
+            })?;
 
         let gateway_listener = Url::parse(&value.gateway_listener).map_err(|source| {
             BadGateway::MalformedListener {
@@ -246,7 +241,7 @@ impl<'a> From<&'a RemoteGatewayDetails> for RawRemoteGatewayDetails {
             derived_aes128_ctr_blake3_hmac_keys_bs58: value
                 .derived_aes128_ctr_blake3_hmac_keys
                 .to_base58_string(),
-            gateway_owner_address: value.gateway_owner_address.as_ref().map(|o| o.to_string()),
+            gateway_owner_address: value.gateway_owner_address.to_string(),
             gateway_listener: value.gateway_listener.to_string(),
             wg_tun_address: value.wg_tun_address.as_ref().map(|addr| addr.to_string()),
         }
@@ -261,7 +256,7 @@ pub struct RemoteGatewayDetails {
     // the keys will be zeroized
     pub derived_aes128_ctr_blake3_hmac_keys: Arc<SharedKeys>,
 
-    pub gateway_owner_address: Option<AccountId>,
+    pub gateway_owner_address: AccountId,
 
     pub gateway_listener: Url,
 

common/client-core/src/cli_helpers/client_add_gateway.rs

@@ -16,7 +16,6 @@ use log::info;
 use nym_client_core_gateways_storage::GatewayDetails;
 use nym_crypto::asymmetric::identity;
 use nym_topology::NymTopology;
-use nym_validator_client::UserAgent;
 use std::path::PathBuf;
 
 #[cfg_attr(feature = "cli", derive(clap::Args))]
@@ -61,10 +60,7 @@ pub struct CommonClientAddGatewayArgs {
     pub custom_mixnet: Option<PathBuf>,
 }
 
-pub async fn add_gateway<C, A>(
-    args: A,
-    user_agent: Option<UserAgent>,
-) -> Result<GatewayInfo, C::Error>
+pub async fn add_gateway<C, A>(args: A) -> Result<GatewayInfo, C::Error>
 where
     A: AsRef<CommonClientAddGatewayArgs>,
     C: CliClient,
@@ -115,8 +111,7 @@ where
         hardcoded_topology.get_gateways()
     } else {
         let mut rng = rand::thread_rng();
-        crate::init::helpers::current_gateways(&mut rng, &core.client.nym_api_urls, user_agent)
-            .await?
+        crate::init::helpers::current_gateways(&mut rng, &core.client.nym_api_urls).await?
     };
 
     // since we're registering with a brand new gateway,

common/client-core/src/cli_helpers/client_init.rs

@@ -16,7 +16,6 @@ use log::info;
 use nym_client_core_gateways_storage::GatewayDetails;
 use nym_crypto::asymmetric::identity;
 use nym_topology::NymTopology;
-use nym_validator_client::UserAgent;
 use rand::rngs::OsRng;
 use std::path::PathBuf;
 
@@ -97,7 +96,6 @@ pub struct InitResultsWithConfig<T> {
 
 pub async fn initialise_client<C>(
     init_args: C::InitArgs,
-    user_agent: Option<UserAgent>,
 ) -> Result<InitResultsWithConfig<C::Config>, C::Error>
 where
     C: InitialisableClient,
@@ -165,8 +163,7 @@ where
         hardcoded_topology.get_gateways()
     } else {
         let mut rng = rand::thread_rng();
-        crate::init::helpers::current_gateways(&mut rng, &core.client.nym_api_urls, user_agent)
-            .await?
+        crate::init::helpers::current_gateways(&mut rng, &core.client.nym_api_urls).await?
     };
 
     let gateway_setup = GatewaySetup::New {

common/client-core/src/client/base_client/mod.rs

@@ -25,7 +25,7 @@ use crate::client::replies::reply_storage::{
 };
 use crate::client::topology_control::nym_api_provider::NymApiTopologyProvider;
 use crate::client::topology_control::{
-    nym_api_provider, TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
+    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use crate::config::{Config, DebugConfig};
 use crate::error::ClientCoreError;
@@ -39,7 +39,7 @@ use log::{debug, error, info, warn};
 use nym_bandwidth_controller::BandwidthController;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewaysDetailsStore};
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::{encryption, identity};
+use nym_crypto::asymmetric::encryption;
 use nym_gateway_client::{
     AcknowledgementReceiver, GatewayClient, GatewayConfig, MixnetMessageReceiver, PacketRouter,
 };
@@ -53,7 +53,7 @@ use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender,
 use nym_task::{TaskClient, TaskHandle};
 use nym_topology::provider_trait::TopologyProvider;
 use nym_topology::HardcodedTopologyProvider;
-use nym_validator_client::{nyxd::contract_traits::DkgQueryClient, UserAgent};
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use rand::rngs::OsRng;
 use std::fmt::Debug;
 use std::os::raw::c_int as RawFd;
@@ -184,7 +184,6 @@ pub struct BaseClientBuilder<'a, C, S: MixnetClientStorage> {
     custom_topology_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
     custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
     shutdown: Option<TaskClient>,
-    user_agent: Option<UserAgent>,
 
     setup_method: GatewaySetup,
 }
@@ -208,7 +207,6 @@ where
             custom_topology_provider: None,
             custom_gateway_transceiver: None,
             shutdown: None,
-            user_agent: None,
             setup_method: GatewaySetup::MustLoad { gateway_id: None },
         }
     }
@@ -252,12 +250,6 @@ where
         self
     }
 
-    #[must_use]
-    pub fn with_user_agent(mut self, user_agent: UserAgent) -> Self {
-        self.user_agent = Some(user_agent);
-        self
-    }
-
     pub fn with_stored_topology<P: AsRef<Path>>(
         mut self,
         file: P,
@@ -396,10 +388,7 @@ where
 
             let cfg = GatewayConfig::new(
                 details.gateway_id,
-                details
-                    .gateway_owner_address
-                    .as_ref()
-                    .map(|o| o.to_string()),
+                Some(details.gateway_owner_address.to_string()),
                 gateway_listener,
             );
             GatewayClient::new(
@@ -473,20 +462,14 @@ where
 
     fn setup_topology_provider(
         custom_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
-        config_topology: config::Topology,
+        provider_from_config: config::TopologyStructure,
         nym_api_urls: Vec<Url>,
-        user_agent: Option<UserAgent>,
     ) -> Box<dyn TopologyProvider + Send + Sync> {
         // if no custom provider was ... provided ..., create one using nym-api
-        custom_provider.unwrap_or_else(|| match config_topology.topology_structure {
+        custom_provider.unwrap_or_else(|| match provider_from_config {
             config::TopologyStructure::NymApi => Box::new(NymApiTopologyProvider::new(
-                nym_api_provider::Config {
-                    min_mixnode_performance: config_topology.minimum_mixnode_performance,
-                    min_gateway_performance: config_topology.minimum_gateway_performance,
-                },
                 nym_api_urls,
                 env!("CARGO_PKG_VERSION").to_string(),
-                user_agent,
             )),
             config::TopologyStructure::GeoAware(group_by) => {
                 Box::new(GeoAwareTopologyProvider::new(
@@ -687,7 +670,6 @@ where
         let self_address = Self::mix_address(&init_res);
         let ack_key = init_res.client_keys.ack_key();
         let encryption_keys = init_res.client_keys.encryption_keypair();
-        let identity_keys = init_res.client_keys.identity_keypair();
 
         // the components are started in very specific order. Unless you know what you are doing,
         // do not change that.
@@ -697,9 +679,8 @@ where
 
         let topology_provider = Self::setup_topology_provider(
             self.custom_topology_provider.take(),
-            self.config.debug.topology,
+            self.config.debug.topology.topology_structure,
             self.config.get_nym_api_endpoints(),
-            self.user_agent.clone(),
         );
 
         // needs to be started as the first thing to block if required waiting for the gateway
@@ -811,7 +792,6 @@ where
 
         Ok(BaseClient {
             address: self_address,
-            identity_keys,
             client_input: ClientInputStatus::AwaitingProducer {
                 client_input: ClientInput {
                     connection_command_sender: client_connection_tx,
@@ -836,7 +816,6 @@ where
 
 pub struct BaseClient {
     pub address: Recipient,
-    pub identity_keys: Arc<identity::KeyPair>,
     pub client_input: ClientInputStatus,
     pub client_output: ClientOutputStatus,
     pub client_state: ClientState,

common/client-core/src/client/base_client/storage/migration_helpers.rs

@@ -92,11 +92,11 @@ pub mod v1_1_33 {
                     message: format!("the stored gateway id was malformed: {err}"),
                 })?,
             derived_aes128_ctr_blake3_hmac_keys: Arc::new(gateway_shared_key),
-            gateway_owner_address: Some(gateway_owner.parse().map_err(|err| {
+            gateway_owner_address: gateway_owner.parse().map_err(|err| {
                 ClientCoreError::UpgradeFailure {
                     message: format!("the stored gateway owner address was malformed: {err}"),
                 }
-            })?),
+            })?,
             gateway_listener: gateway_listener.parse().map_err(|err| {
                 ClientCoreError::UpgradeFailure {
                     message: format!("the stored gateway listener address was malformed: {err}"),

common/client-core/src/client/mix_traffic/transceiver.rs

@@ -3,10 +3,12 @@
 
 use async_trait::async_trait;
 use log::{debug, error};
+use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_crypto::asymmetric::identity;
 use nym_gateway_client::GatewayClient;
 pub use nym_gateway_client::{GatewayPacketRouter, PacketRouter};
 use nym_sphinx::forwarding::packet::MixPacket;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::fmt::Debug;
 use std::os::raw::c_int as RawFd;
 use thiserror::Error;
@@ -111,8 +113,9 @@ impl<C, St> RemoteGateway<C, St> {
 
 impl<C, St> GatewayTransceiver for RemoteGateway<C, St>
 where
-    C: Send,
-    St: Send,
+    C: DkgQueryClient + Send + Sync,
+    St: CredentialStorage,
+    <St as CredentialStorage>::StorageError: Send + Sync + 'static,
 {
     fn gateway_identity(&self) -> identity::PublicKey {
         self.gateway_client.gateway_identity()
@@ -126,8 +129,9 @@ where
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl<C, St> GatewaySender for RemoteGateway<C, St>
 where
-    C: Send,
-    St: Send,
+    C: DkgQueryClient + Send + Sync,
+    St: CredentialStorage,
+    <St as CredentialStorage>::StorageError: Send + Sync + 'static,
 {
     async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
         self.gateway_client

common/client-core/src/client/topology_control/nym_api_provider.rs

@@ -2,36 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use async_trait::async_trait;
-use log::{debug, error, warn};
+use log::{error, warn};
 use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::{NymTopology, NymTopologyError};
-use nym_validator_client::UserAgent;
+use nym_topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
 use rand::prelude::SliceRandom;
 use rand::thread_rng;
 use url::Url;
 
-// the same values as our current (10.06.24) blacklist
-pub const DEFAULT_MIN_MIXNODE_PERFORMANCE: u8 = 50;
-pub const DEFAULT_MIN_GATEWAY_PERFORMANCE: u8 = 50;
-
-pub(crate) struct Config {
-    pub(crate) min_mixnode_performance: u8,
-    pub(crate) min_gateway_performance: u8,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        // old values that decided on blacklist membership
-        Config {
-            min_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
-            min_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
-        }
-    }
-}
-
 pub(crate) struct NymApiTopologyProvider {
-    config: Config,
-
     validator_client: nym_validator_client::client::NymApiClient,
     nym_api_urls: Vec<Url>,
 
@@ -40,26 +18,13 @@ pub(crate) struct NymApiTopologyProvider {
 }
 
 impl NymApiTopologyProvider {
-    pub(crate) fn new(
-        config: Config,
-        mut nym_api_urls: Vec<Url>,
-        client_version: String,
-        user_agent: Option<UserAgent>,
-    ) -> Self {
+    pub(crate) fn new(mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
         nym_api_urls.shuffle(&mut thread_rng());
 
-        let validator_client = if let Some(user_agent) = user_agent {
-            nym_validator_client::client::NymApiClient::new_with_user_agent(
-                nym_api_urls[0].clone(),
-                user_agent,
-            )
-        } else {
-            nym_validator_client::client::NymApiClient::new(nym_api_urls[0].clone())
-        };
-
         NymApiTopologyProvider {
-            config,
-            validator_client,
+            validator_client: nym_validator_client::client::NymApiClient::new(
+                nym_api_urls[0].clone(),
+            ),
             nym_api_urls,
             client_version,
             currently_used_api: 0,
@@ -96,11 +61,7 @@ impl NymApiTopologyProvider {
     }
 
     async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
-        let mixnodes = match self
-            .validator_client
-            .get_basic_mixnodes(Some(self.client_version.clone()))
-            .await
-        {
+        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
             Err(err) => {
                 error!("failed to get network mixnodes - {err}");
                 return None;
@@ -108,11 +69,7 @@ impl NymApiTopologyProvider {
             Ok(mixes) => mixes,
         };
 
-        let gateways = match self
-            .validator_client
-            .get_basic_gateways(Some(self.client_version.clone()))
-            .await
-        {
+        let gateways = match self.validator_client.get_cached_described_gateways().await {
             Err(err) => {
                 error!("failed to get network gateways - {err}");
                 return None;
@@ -120,20 +77,8 @@ impl NymApiTopologyProvider {
             Ok(gateways) => gateways,
         };
 
-        debug!(
-            "there are {} mixnodes and {} gateways in total (before performance filtering)",
-            mixnodes.len(),
-            gateways.len()
-        );
-
-        let topology = NymTopology::from_unordered(
-            mixnodes.iter().filter(|m| {
-                m.performance.round_to_integer() >= self.config.min_mixnode_performance
-            }),
-            gateways.iter().filter(|g| {
-                g.performance.round_to_integer() >= self.config.min_gateway_performance
-            }),
-        );
+        let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .filter_system_version(&self.client_version);
 
         if let Err(err) = self.check_layer_distribution(&topology) {
             warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used: {err}");

common/client-core/src/init/helpers.rs

@@ -9,7 +9,6 @@ use nym_crypto::asymmetric::identity;
 use nym_gateway_client::GatewayClient;
 use nym_topology::{filter::VersionFilterable, gateway, mix};
 use nym_validator_client::client::IdentityKeyRef;
-use nym_validator_client::UserAgent;
 use rand::{seq::SliceRandom, Rng};
 use std::{sync::Arc, time::Duration};
 use tungstenite::Message;
@@ -60,16 +59,11 @@ impl<'a> GatewayWithLatency<'a> {
 pub async fn current_gateways<R: Rng>(
     rng: &mut R,
     nym_apis: &[Url],
-    user_agent: Option<UserAgent>,
 ) -> Result<Vec<gateway::Node>, ClientCoreError> {
     let nym_api = nym_apis
         .choose(rng)
         .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-    let client = if let Some(user_agent) = user_agent {
-        nym_validator_client::client::NymApiClient::new_with_user_agent(nym_api.clone(), user_agent)
-    } else {
-        nym_validator_client::client::NymApiClient::new(nym_api.clone())
-    };
+    let client = nym_validator_client::client::NymApiClient::new(nym_api.clone());
 
     log::debug!("Fetching list of gateways from: {nym_api}");
 

common/client-core/src/init/types.rs

@@ -29,7 +29,7 @@ pub enum SelectedGateway {
     Remote {
         gateway_id: identity::PublicKey,
 
-        gateway_owner_address: Option<AccountId>,
+        gateway_owner_address: AccountId,
 
         gateway_listener: Url,
 
@@ -84,19 +84,13 @@ impl SelectedGateway {
 
         let wg_tun_address = wg_tun_address(wg_tun_ip_address, &node)?;
 
-        let gateway_owner_address = node
-            .owner
-            .as_ref()
-            .map(|raw_owner| {
-                AccountId::from_str(raw_owner).map_err(|source| {
-                    ClientCoreError::MalformedGatewayOwnerAccountAddress {
-                        gateway_id: node.identity_key.to_base58_string(),
-                        raw_owner: raw_owner.clone(),
-                        err: source.to_string(),
-                    }
-                })
-            })
-            .transpose()?;
+        let gateway_owner_address = AccountId::from_str(&node.owner).map_err(|source| {
+            ClientCoreError::MalformedGatewayOwnerAccountAddress {
+                gateway_id: node.identity_key.to_base58_string(),
+                raw_owner: node.owner,
+                err: source.to_string(),
+            }
+        })?;
 
         let gateway_listener =
             Url::parse(&gateway_listener).map_err(|source| ClientCoreError::MalformedListener {

common/client-libs/gateway-client/Cargo.toml

@@ -14,9 +14,9 @@ futures = { workspace = true }
 log = { workspace = true }
 thiserror = { workspace = true }
 url = { workspace = true }
-rand = { workspace = true }
-tokio = { workspace = true, features = ["macros"] }
-si-scale = { workspace = true }
+rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+tokio = { version = "1.24.1", features = ["macros"] }
+si-scale = "0.2.2"
 time.workspace = true
 
 # internal
@@ -48,7 +48,10 @@ features = ["net", "sync", "time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 workspace = true
-features = ["rustls-tls-webpki-roots"]
+# the choice of this particular tls feature was arbitrary;
+# if you reckon a different one would be more appropriate, feel free to change it
+# features = ["native-tls"]
+features = ["rustls-tls-native-roots"]
 
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]

common/client-libs/gateway-client/src/client.rs

@@ -23,12 +23,13 @@ use nym_gateway_requests::{
     BinaryRequest, ClientControlRequest, ServerResponse, CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION,
     CURRENT_PROTOCOL_VERSION,
 };
-use nym_network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
+use nym_network_defaults::REMAINING_BANDWIDTH_THRESHOLD;
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_task::TaskClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use rand::rngs::OsRng;
-
+use std::convert::TryFrom;
+use std::sync::atomic::{AtomicI64, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 use tungstenite::protocol::Message;
@@ -83,7 +84,7 @@ impl GatewayConfig {
 pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
     authenticated: bool,
     disabled_credentials_mode: bool,
-    bandwidth_remaining: i64,
+    bandwidth_remaining: Arc<AtomicI64>,
     gateway_address: String,
     gateway_identity: identity::PublicKey,
     local_identity: Arc<identity::KeyPair>,
@@ -122,7 +123,7 @@ impl<C, St> GatewayClient<C, St> {
         GatewayClient {
             authenticated: false,
             disabled_credentials_mode: true,
-            bandwidth_remaining: 0,
+            bandwidth_remaining: Arc::new(AtomicI64::new(0)),
             gateway_address: config.gateway_listener,
             gateway_identity: config.gateway_identity,
             local_identity,
@@ -182,7 +183,7 @@ impl<C, St> GatewayClient<C, St> {
     }
 
     pub fn remaining_bandwidth(&self) -> i64 {
-        self.bandwidth_remaining
+        self.bandwidth_remaining.load(Ordering::Acquire)
     }
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -220,18 +221,9 @@ impl<C, St> GatewayClient<C, St> {
 
     #[cfg(not(target_arch = "wasm32"))]
     pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
-        debug!(
-            "Attemting to establish connection to gateway at: {}",
-            self.gateway_address
-        );
         let ws_stream = match connect_async(&self.gateway_address).await {
             Ok((ws_stream, _)) => ws_stream,
-            Err(error) => {
-                return Err(GatewayClientError::NetworkConnectionFailed {
-                    address: self.gateway_address.clone(),
-                    source: error,
-                })
-            }
+            Err(e) => return Err(GatewayClientError::NetworkError(e)),
         };
 
         self.connection = SocketState::Available(Box::new(ws_stream));
@@ -537,7 +529,8 @@ impl<C, St> GatewayClient<C, St> {
             } => {
                 self.check_gateway_protocol(protocol_version)?;
                 self.authenticated = status;
-                self.bandwidth_remaining = bandwidth_remaining;
+                self.bandwidth_remaining
+                    .store(bandwidth_remaining, Ordering::Release);
                 self.negotiated_protocol = protocol_version;
                 log::debug!("authenticated: {status}, bandwidth remaining: {bandwidth_remaining}");
                 Ok(())
@@ -573,35 +566,38 @@ impl<C, St> GatewayClient<C, St> {
         }
     }
 
-    async fn claim_coconut_bandwidth(
+    async fn claim_ecash_bandwidth(
         &mut self,
         credential: CredentialSpendingData,
     ) -> Result<(), GatewayClientError> {
         let mut rng = OsRng;
         let iv = IV::new_random(&mut rng);
 
-        let msg = ClientControlRequest::new_enc_coconut_bandwidth_credential_v2(
+        let msg = ClientControlRequest::new_enc_ecash_credential(
             credential,
             self.shared_key.as_ref().unwrap(),
             iv,
         )
         .into();
-        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
+        let bandwidth_remaining = match self.send_websocket_message(msg).await? {
             ServerResponse::Bandwidth { available_total } => Ok(available_total),
             ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
             _ => Err(GatewayClientError::UnexpectedResponse),
         }?;
+        self.bandwidth_remaining
+            .store(bandwidth_remaining, Ordering::Release);
         Ok(())
     }
 
     async fn try_claim_testnet_bandwidth(&mut self) -> Result<(), GatewayClientError> {
         let msg = ClientControlRequest::ClaimFreeTestnetBandwidth.into();
-        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
+        let bandwidth_remaining = match self.send_websocket_message(msg).await? {
             ServerResponse::Bandwidth { available_total } => Ok(available_total),
             ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
             _ => Err(GatewayClientError::UnexpectedResponse),
         }?;
-
+        self.bandwidth_remaining
+            .store(bandwidth_remaining, Ordering::Release);
         Ok(())
     }
 
@@ -638,49 +634,45 @@ impl<C, St> GatewayClient<C, St> {
                 negotiated_protocol: Some(gateway_protocol),
             });
         }
-
-        let gateway_id = self.gateway_identity().to_base58_string();
-
         let prepared_credential = self
             .bandwidth_controller
             .as_ref()
             .unwrap()
-            .prepare_bandwidth_credential(&gateway_id)
+            .prepare_ecash_credential(self.gateway_identity.to_bytes())
             .await?;
 
-        self.claim_coconut_bandwidth(prepared_credential.data)
-            .await?;
+        self.claim_ecash_bandwidth(prepared_credential.data).await?;
         self.bandwidth_controller
             .as_ref()
             .unwrap()
-            .consume_credential(prepared_credential.credential_id, &gateway_id)
+            .update_ecash_wallet(
+                prepared_credential.updated_credential,
+                prepared_credential.credential_id,
+            )
             .await?;
 
         Ok(())
     }
 
-    fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
-        packets
-            .iter()
-            .map(|packet| packet.packet().len())
-            .sum::<usize>() as i64
-    }
-
     pub async fn batch_send_mix_packets(
         &mut self,
         packets: Vec<MixPacket>,
-    ) -> Result<(), GatewayClientError> {
+    ) -> Result<(), GatewayClientError>
+    where
+        C: DkgQueryClient + Send + Sync,
+        St: CredentialStorage,
+        <St as CredentialStorage>::StorageError: Send + Sync + 'static,
+    {
         debug!("Sending {} mix packets", packets.len());
 
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
-        if self.estimate_required_bandwidth(&packets) > self.bandwidth_remaining {
-            return Err(GatewayClientError::NotEnoughBandwidth(
-                self.estimate_required_bandwidth(&packets),
-                self.bandwidth_remaining,
-            ));
+        let bandwidth_remaining = self.bandwidth_remaining.load(Ordering::Acquire);
+        if bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
+            self.claim_bandwidth().await?;
         }
+
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
         }
@@ -739,19 +731,20 @@ impl<C, St> GatewayClient<C, St> {
     }
 
     // TODO: possibly make responses optional
-    pub async fn send_mix_packet(
-        &mut self,
-        mix_packet: MixPacket,
-    ) -> Result<(), GatewayClientError> {
+    pub async fn send_mix_packet(&mut self, mix_packet: MixPacket) -> Result<(), GatewayClientError>
+    where
+        C: DkgQueryClient + Send + Sync,
+        St: CredentialStorage,
+        <St as CredentialStorage>::StorageError: Send + Sync + 'static,
+    {
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
-        if (mix_packet.packet().len() as i64) > self.bandwidth_remaining {
-            return Err(GatewayClientError::NotEnoughBandwidth(
-                mix_packet.packet().len() as i64,
-                self.bandwidth_remaining,
-            ));
+        let bandwidth_remaining = self.bandwidth_remaining.load(Ordering::Acquire);
+        if bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
+            self.claim_bandwidth().await?;
         }
+
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
         }
@@ -805,6 +798,7 @@ impl<C, St> GatewayClient<C, St> {
                                 .as_ref()
                                 .expect("no shared key present even though we're authenticated!"),
                         ),
+                        self.bandwidth_remaining.clone(),
                         self.shutdown.clone(),
                     )
                 }
@@ -845,10 +839,9 @@ impl<C, St> GatewayClient<C, St> {
             self.establish_connection().await?;
         }
         let shared_key = self.perform_initial_authentication().await?;
-
-        if self.bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
-            info!("Claiming more bandwidth for your tokens. This will use {} token(s) from your wallet. \
-            Stop the process now if you don't want that to happen.", TOKENS_TO_BURN);
+        let bandwidth_remaining = self.bandwidth_remaining.load(Ordering::Acquire);
+        if bandwidth_remaining < REMAINING_BANDWIDTH_THRESHOLD {
+            info!("Claiming more bandwidth with existing credentials. Stop the process now if you don't want that to happen.");
             self.claim_bandwidth().await?;
         }
 
@@ -885,7 +878,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
         GatewayClient {
             authenticated: false,
             disabled_credentials_mode: true,
-            bandwidth_remaining: 0,
+            bandwidth_remaining: Arc::new(AtomicI64::new(0)),
             gateway_address: gateway_listener.to_string(),
             gateway_identity,
             local_identity,

common/client-libs/gateway-client/src/error.rs

@@ -23,9 +23,6 @@ pub enum GatewayClientError {
     #[error("There was a network error: {0}")]
     NetworkErrorWasm(#[from] JsError),
 
-    #[error("connection failed: {address}: {source}")]
-    NetworkConnectionFailed { address: String, source: WsError },
-
     #[error("Invalid URL: {0}")]
     InvalidURL(String),
 

common/client-libs/gateway-client/src/socket_state.rs

@@ -79,6 +79,7 @@ impl PartiallyDelegated {
     fn recover_received_plaintexts(
         ws_msgs: Vec<Message>,
         shared_key: &SharedKeys,
+        bandwidth_remaining: Arc<AtomicI64>,
     ) -> Result<Vec<Vec<u8>>, GatewayClientError> {
         let mut plaintexts = Vec::with_capacity(ws_msgs.len());
         for ws_msg in ws_msgs {
@@ -104,7 +105,11 @@ impl PartiallyDelegated {
                     {
                         ServerResponse::Send {
                             remaining_bandwidth,
-                        } => maybe_log_bandwidth(remaining_bandwidth),
+                        } => {
+                            maybe_log_bandwidth(remaining_bandwidth);
+                            bandwidth_remaining
+                                .store(remaining_bandwidth, std::sync::atomic::Ordering::Release)
+                        }
                         ServerResponse::Error { message } => {
                             error!("gateway failure: {message}");
                             return Err(GatewayClientError::GatewayError(message));
@@ -129,8 +134,10 @@ impl PartiallyDelegated {
         ws_msgs: Vec<Message>,
         packet_router: &PacketRouter,
         shared_key: &SharedKeys,
+        bandwidth_remaining: Arc<AtomicI64>,
     ) -> Result<(), GatewayClientError> {
-        let plaintexts = Self::recover_received_plaintexts(ws_msgs, shared_key)?;
+        let plaintexts =
+            Self::recover_received_plaintexts(ws_msgs, shared_key, bandwidth_remaining)?;
         packet_router.route_received(plaintexts)
     }
 
@@ -138,6 +145,7 @@ impl PartiallyDelegated {
         conn: WsConn,
         mut packet_router: PacketRouter,
         shared_key: Arc<SharedKeys>,
+        bandwidth_remaining: Arc<AtomicI64>,
         mut shutdown: TaskClient,
     ) -> Self {
         // when called for, it NEEDS TO yield back the stream so that we could merge it and
@@ -169,7 +177,7 @@ impl PartiallyDelegated {
                             Ok(msgs) => msgs
                         };
 
-                        if let Err(err) = Self::route_socket_messages(ws_msgs, &packet_router, shared_key.as_ref()) {
+                        if let Err(err) = Self::route_socket_messages(ws_msgs, &packet_router, shared_key.as_ref(), bandwidth_remaining.clone()) {
                             log::error!("Route socket messages failed: {err}");
                             break Err(err)
                         }

common/client-libs/validator-client/Cargo.toml

@@ -10,25 +10,30 @@ license.workspace = true
 
 [dependencies]
 base64 = "0.13"
-colored = { workspace = true }
+colored = "2.0"
 
 nym-coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
 nym-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
+nym-ephemera-common = { path = "../../cosmwasm-smart-contracts/ephemera" }
 nym-mixnet-contract-common = { path = "../../cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../../cosmwasm-smart-contracts/vesting-contract" }
 nym-coconut-bandwidth-contract-common = { path = "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
+nym-ecash-contract-common = { path = "../../cosmwasm-smart-contracts/ecash-contract" }
 nym-multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
+nym-name-service-common = { path = "../../cosmwasm-smart-contracts/name-service" }
 nym-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contract" }
+nym-service-provider-directory-common = { path = "../../cosmwasm-smart-contracts/service-provider-directory" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-nym-http-api-client = { path = "../../../common/http-api-client" }
+reqwest = { workspace = true, features = ["json"] }
+nym-http-api-client = { path = "../../../common/http-api-client"}
 thiserror = { workspace = true }
 log = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 tokio = { workspace = true, features = ["sync", "time"] }
 futures = { workspace = true }
 
-nym-coconut = { path = "../../nymcoconut" }
+nym-compact-ecash = { path = "../../nym_offline_compact_ecash" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-api-requests = { path = "../../../nym-api/nym-api-requests" }
 
@@ -45,16 +50,16 @@ tendermint-rpc = { workspace = true }
 # of cargo's feature unification we'd get `bip32/std` meaning we'd get `std::error::Error` for the re-exported (via cosmrs) bip32::Error type
 bip32 = { workspace = true, default-features = false, features = ["std"] }
 
-eyre = { workspace = true }
+eyre = { version = "0.6" }
 cw-utils = { workspace = true }
 cw2 = { workspace = true }
 cw3 = { workspace = true }
 cw4 = { workspace = true }
 cw-controllers = { workspace = true }
 prost = { workspace = true, default-features = false }
-flate2 = { workspace = true }
+flate2 = { version = "1.0.20" }
 sha2 = { version = "0.9.5" }
-itertools = { workspace = true }
+itertools = { version = "0.10" }
 zeroize = { workspace = true, features = ["zeroize_derive"] }
 cosmwasm-std = { workspace = true }
 
@@ -63,14 +68,6 @@ cosmwasm-std = { workspace = true }
 workspace = true
 features = ["tokio"]
 
-[target."cfg(target_arch = \"wasm32\")".dependencies.reqwest]
-workspace = true
-features = ["json"]
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.reqwest]
-workspace = true
-features = ["json", "rustls-tls"]
-
 [dev-dependencies]
 bip39 = { workspace = true }
 cosmrs = { workspace = true, features = ["bip32"] }
@@ -83,6 +80,14 @@ name = "offline_signing"
 # (traits would need to be moved around and refactored themselves)
 required-features = ["http-client"]
 
+[[example]]
+name = "query_service_provider_directory"
+required-features = ["http-client"]
+
+[[example]]
+name = "query_name_service"
+required-features = ["http-client"]
+
 [features]
 default = ["http-client"]
 http-client = ["cosmrs/rpc"]

common/client-libs/validator-client/examples/query_name_service.rs

@@ -0,0 +1,37 @@
+use std::str::FromStr;
+
+use cosmrs::AccountId;
+use nym_name_service_common::Address;
+use nym_network_defaults::{setup_env, NymNetworkDetails};
+use nym_validator_client::nyxd::contract_traits::{
+    NameServiceQueryClient, PagedNameServiceQueryClient,
+};
+
+#[tokio::main]
+async fn main() {
+    setup_env(Some("../../../envs/qa.env"));
+    let network_details = NymNetworkDetails::new_from_env();
+    let config =
+        nym_validator_client::Config::try_from_nym_network_details(&network_details).unwrap();
+    let client = nym_validator_client::Client::new_query(config).unwrap();
+
+    let config = client.nyxd.get_name_service_config().await.unwrap();
+    println!("config: {config:?}");
+
+    let names_paged = client.nyxd.get_names_paged(None, None).await.unwrap();
+    println!("names (paged): {names_paged:#?}");
+
+    let names = client.nyxd.get_all_names().await.unwrap();
+    println!("names: {names:#?}");
+
+    let owner = AccountId::from_str("n1hmf957kc7arcd39rl7xq8l0a4zyg7kxnv7su87").unwrap();
+    let names_by_owner = client.nyxd.get_names_by_owner(owner).await.unwrap();
+    println!("names (by owner): {names_by_owner:#?}");
+
+    let nym_address = Address::new("client_id.client_key@gateway_id").unwrap();
+    let names_by_address = client.nyxd.get_names_by_address(nym_address).await.unwrap();
+    println!("names (by address): {names_by_address:#?}");
+
+    let service_info = client.nyxd.get_name_entry(1).await;
+    println!("service info: {service_info:#?}");
+}

common/client-libs/validator-client/examples/query_service_provider_directory.rs

@@ -0,0 +1,45 @@
+use std::str::FromStr;
+
+use cosmrs::AccountId;
+use nym_network_defaults::{setup_env, NymNetworkDetails};
+use nym_service_provider_directory_common::NymAddress;
+use nym_validator_client::nyxd::contract_traits::{
+    PagedSpDirectoryQueryClient, SpDirectoryQueryClient,
+};
+
+#[tokio::main]
+async fn main() {
+    setup_env(Some("../../../envs/qa.env"));
+    let network_details = NymNetworkDetails::new_from_env();
+    let config =
+        nym_validator_client::Config::try_from_nym_network_details(&network_details).unwrap();
+    let client = nym_validator_client::Client::new_query(config).unwrap();
+
+    let config = client.nyxd.get_service_config().await.unwrap();
+    println!("config: {config:?}");
+
+    let services_paged = client.nyxd.get_services_paged(None, None).await.unwrap();
+    println!("services (paged): {services_paged:#?}");
+
+    let services = client.nyxd.get_all_services().await.unwrap();
+    println!("services: {services:#?}");
+
+    let announcer = AccountId::from_str("n1hmf957kc7arcd39rl7xq8l0a4zyg7kxnv7su87").unwrap();
+    let services_by_announcer = client
+        .nyxd
+        .get_services_by_announcer(announcer)
+        .await
+        .unwrap();
+    println!("services (by announcer): {services_by_announcer:#?}");
+
+    let nym_address = NymAddress::new("foo.bar@gateway");
+    let services_by_nym_address = client
+        .nyxd
+        .get_services_by_nym_address(nym_address)
+        .await
+        .unwrap();
+    assert_eq!(services_by_announcer, services_by_nym_address);
+
+    let service_info = client.nyxd.get_service_info(1).await;
+    println!("service info: {service_info:#?}");
+}

common/client-libs/validator-client/src/client.rs

@@ -8,18 +8,20 @@ use crate::{
     nym_api, DirectSigningReqwestRpcValidatorClient, QueryReqwestRpcValidatorClient,
     ReqwestRpcClient, ValidatorClientError,
 };
-use nym_api_requests::coconut::models::FreePassNonceResponse;
+use nym_api_requests::coconut::models::{
+    FreePassNonceResponse, SpentCredentialsResponse, VerifyCredentialBody,
+    VerifyEcashCredentialResponse,
+};
 use nym_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, FreePassRequest, VerifyCredentialBody,
-    VerifyCredentialResponse,
+    BlindSignRequestBody, BlindedSignatureResponse, FreePassRequest,
+    PartialCoinIndicesSignatureResponse, PartialExpirationDateSignatureResponse,
+    VerifyCredentialResponse, VerifyEcashCredentialBody,
 };
 use nym_api_requests::models::{DescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::models::{
     GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
     RewardEstimationResponse, StakeSaturationResponse,
 };
-use nym_api_requests::nym_nodes::SkimmedNode;
-use nym_http_api_client::UserAgent;
 use nym_network_defaults::NymNetworkDetails;
 use url::Url;
 
@@ -259,16 +261,6 @@ impl NymApiClient {
         NymApiClient { nym_api }
     }
 
-    pub fn new_with_user_agent(api_url: Url, user_agent: UserAgent) -> Self {
-        let nym_api = nym_api::Client::builder::<_, ValidatorClientError>(api_url)
-            .expect("invalid api url")
-            .with_user_agent(user_agent)
-            .build::<ValidatorClientError>()
-            .expect("failed to build nym api client");
-
-        NymApiClient { nym_api }
-    }
-
     pub fn api_url(&self) -> &Url {
         self.nym_api.current_url()
     }
@@ -277,28 +269,6 @@ impl NymApiClient {
         self.nym_api.change_base_url(new_endpoint);
     }
 
-    pub async fn get_basic_mixnodes(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        Ok(self
-            .nym_api
-            .get_basic_mixnodes(semver_compatibility)
-            .await?
-            .nodes)
-    }
-
-    pub async fn get_basic_gateways(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        Ok(self
-            .nym_api
-            .get_basic_gateways(semver_compatibility)
-            .await?
-            .nodes)
-    }
-
     pub async fn get_cached_active_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
@@ -385,6 +355,48 @@ impl NymApiClient {
             .await?)
     }
 
+    pub async fn verify_offline_credential(
+        &self,
+        request_body: &VerifyEcashCredentialBody,
+    ) -> Result<VerifyEcashCredentialResponse, ValidatorClientError> {
+        Ok(self.nym_api.verify_offline_credential(request_body).await?)
+    }
+
+    pub async fn verify_online_credential(
+        &self,
+        request_body: &VerifyEcashCredentialBody,
+    ) -> Result<VerifyEcashCredentialResponse, ValidatorClientError> {
+        Ok(self.nym_api.verify_online_credential(request_body).await?)
+    }
+
+    pub async fn spent_credentials(
+        &self,
+    ) -> Result<SpentCredentialsResponse, ValidatorClientError> {
+        Ok(self.nym_api.spent_credentials().await?)
+    }
+
+    pub async fn expiration_date_signatures(
+        &self,
+    ) -> Result<PartialExpirationDateSignatureResponse, ValidatorClientError> {
+        Ok(self.nym_api.expiration_date_signatures().await?)
+    }
+
+    pub async fn expiration_date_signatures_timestamp(
+        &self,
+        timestamp: u64,
+    ) -> Result<PartialExpirationDateSignatureResponse, ValidatorClientError> {
+        Ok(self
+            .nym_api
+            .expiration_date_signatures_timestamp(&timestamp.to_string())
+            .await?)
+    }
+
+    pub async fn coin_indices_signatures(
+        &self,
+    ) -> Result<PartialCoinIndicesSignatureResponse, ValidatorClientError> {
+        Ok(self.nym_api.coin_indices_signatures().await?)
+    }
+
     pub async fn free_pass_nonce(&self) -> Result<FreePassNonceResponse, ValidatorClientError> {
         Ok(self.nym_api.free_pass_nonce().await?)
     }

common/client-libs/validator-client/src/coconut/mod.rs

@@ -4,9 +4,10 @@
 use crate::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
 use crate::nyxd::error::NyxdError;
 use crate::NymApiClient;
-use nym_coconut::{Base58, CoconutError, VerificationKey};
 use nym_coconut_dkg_common::types::{EpochId, NodeIndex};
 use nym_coconut_dkg_common::verification_key::ContractVKShare;
+use nym_compact_ecash::error::CompactEcashError;
+use nym_compact_ecash::{Base58, VerificationKeyAuth};
 use thiserror::Error;
 use url::Url;
 
@@ -14,7 +15,7 @@ use url::Url;
 #[derive(Clone)]
 pub struct CoconutApiClient {
     pub api_client: NymApiClient,
-    pub verification_key: VerificationKey,
+    pub verification_key: VerificationKeyAuth,
     pub node_id: NodeIndex,
     pub cosmos_address: cosmrs::AccountId,
 }
@@ -43,7 +44,7 @@ pub enum CoconutApiError {
     #[error("the provided verification key is malformed: {source}")]
     MalformedVerificationKey {
         #[from]
-        source: CoconutError,
+        source: CompactEcashError,
     },
 
     #[error("the provided account address is malformed: {source}")]
@@ -65,14 +66,14 @@ impl TryFrom<ContractVKShare> for CoconutApiClient {
 
         Ok(CoconutApiClient {
             api_client: NymApiClient::new(url_address),
-            verification_key: VerificationKey::try_from_bs58(&share.share)?,
+            verification_key: VerificationKeyAuth::try_from_bs58(&share.share)?,
             node_id: share.node_index,
             cosmos_address: share.owner.as_str().parse()?,
         })
     }
 }
 
-pub async fn all_coconut_api_clients<C>(
+pub async fn all_ecash_api_clients<C>(
     client: &C,
     epoch_id: EpochId,
 ) -> Result<Vec<CoconutApiClient>, CoconutApiError>

common/client-libs/validator-client/src/lib.rs

@@ -17,7 +17,6 @@ pub use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 pub use client::NymApiClient;
 pub use client::{Client, CoconutApiClient, Config};
 pub use nym_api_requests::*;
-pub use nym_http_api_client::UserAgent;
 
 #[cfg(feature = "http-client")]
 pub use cosmrs::rpc::HttpClient as HttpRpcClient;

common/client-libs/validator-client/src/nym_api/mod.rs

@@ -8,10 +8,11 @@ pub use nym_api_requests::{
     coconut::{
         models::{
             EpochCredentialsResponse, IssuedCredential, IssuedCredentialBody,
-            IssuedCredentialResponse, IssuedCredentialsResponse,
+            IssuedCredentialResponse, IssuedCredentialsResponse, SpentCredentialsResponse,
         },
         BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody,
-        VerifyCredentialBody, VerifyCredentialResponse,
+        PartialCoinIndicesSignatureResponse, PartialExpirationDateSignatureResponse,
+        VerifyCredentialResponse, VerifyEcashCredentialBody,
     },
     models::{
         ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
@@ -25,13 +26,16 @@ pub use nym_coconut_dkg_common::types::EpochId;
 use nym_http_api_client::{ApiClient, NO_PARAMS};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
+use nym_name_service_common::response::NamesListResponse;
+use nym_service_provider_directory_common::response::ServicesListResponse;
 
 pub mod error;
 pub mod routes;
 
-use nym_api_requests::coconut::models::FreePassNonceResponse;
+use nym_api_requests::coconut::models::{
+    FreePassNonceResponse, VerifyCredentialBody, VerifyEcashCredentialResponse,
+};
 use nym_api_requests::coconut::FreePassRequest;
-use nym_api_requests::nym_nodes::{CachedNodesResponse, SkimmedNode};
 pub use nym_http_api_client::Client;
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -96,52 +100,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    async fn get_basic_mixnodes(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
-        let params = if let Some(semver_compatibility) = &semver_compatibility {
-            vec![("semver_compatibility", semver_compatibility.as_str())]
-        } else {
-            vec![]
-        };
-
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                "unstable",
-                "nym-nodes",
-                "mixnodes",
-                "skimmed",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    async fn get_basic_gateways(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
-        let params = if let Some(semver_compatibility) = &semver_compatibility {
-            vec![("semver_compatibility", semver_compatibility.as_str())]
-        } else {
-            vec![]
-        };
-
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                "unstable",
-                "nym-nodes",
-                "gateways",
-                "skimmed",
-            ],
-            &params,
-        )
-        .await
-    }
-
     async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(
             &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
@@ -484,6 +442,100 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
+    async fn verify_offline_credential(
+        &self,
+        request_body: &VerifyEcashCredentialBody,
+    ) -> Result<VerifyEcashCredentialResponse, NymAPIError> {
+        self.post_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::ECASH_VERIFY_OFFLINE_CREDENTIAL,
+            ],
+            NO_PARAMS,
+            request_body,
+        )
+        .await
+    }
+
+    async fn verify_online_credential(
+        &self,
+        request_body: &VerifyEcashCredentialBody,
+    ) -> Result<VerifyEcashCredentialResponse, NymAPIError> {
+        self.post_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::ECASH_VERIFY_ONLINE_CREDENTIAL,
+            ],
+            NO_PARAMS,
+            request_body,
+        )
+        .await
+    }
+
+    async fn spent_credentials(&self) -> Result<SpentCredentialsResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::SPENT_CREDENTIALS,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    async fn expiration_date_signatures(
+        &self,
+    ) -> Result<PartialExpirationDateSignatureResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::EXPIRATION_DATE_SIGNATURES,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    async fn expiration_date_signatures_timestamp(
+        &self,
+        timestamp: &str,
+    ) -> Result<PartialExpirationDateSignatureResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::EXPIRATION_DATE_SIGNATURES,
+                timestamp,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    async fn coin_indices_signatures(
+        &self,
+    ) -> Result<PartialCoinIndicesSignatureResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COIN_INDICES_SIGNATURES,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
     async fn epoch_credentials(
         &self,
         dkg_epoch: EpochId,
@@ -537,6 +589,19 @@ pub trait NymApiClientExt: ApiClient {
         )
         .await
     }
+
+    async fn get_service_providers(&self) -> Result<ServicesListResponse, NymAPIError> {
+        log::trace!("Getting service providers");
+        self.get_json(&[routes::API_VERSION, routes::SERVICE_PROVIDERS], NO_PARAMS)
+            .await
+    }
+
+    //async fn get_registered_names(&self) -> Result<Vec<NameEntry>, NymAPIError> {
+    async fn get_registered_names(&self) -> Result<NamesListResponse, NymAPIError> {
+        log::trace!("Getting registered names");
+        self.get_json(&[routes::API_VERSION, routes::REGISTERED_NAMES], NO_PARAMS)
+            .await
+    }
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]

common/client-libs/validator-client/src/nym_api/routes.rs

@@ -14,11 +14,17 @@ pub const ACTIVE: &str = "active";
 pub const REWARDED: &str = "rewarded";
 pub const COCONUT_ROUTES: &str = "coconut";
 pub const BANDWIDTH: &str = "bandwidth";
+pub const SPENT_CREDENTIALS: &str = "spent-credentials";
 
 pub const COCONUT_FREE_PASS: &str = "free-pass";
 pub const COCONUT_FREE_PASS_NONCE: &str = "free-pass-nonce";
 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
+pub const ECASH_VERIFY_OFFLINE_CREDENTIAL: &str = "verify-offline-credential";
+pub const ECASH_VERIFY_ONLINE_CREDENTIAL: &str = "verify-online-credential";
 pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
+pub const EXPIRATION_DATE_SIGNATURES: &str = "expiration-date-signatures";
+pub const EXPIRATION_DATE_SIGNATURES_TIMESTAMP: &str = "expiration-date-signatures-ts";
+pub const COIN_INDICES_SIGNATURES: &str = "coin-indices-signatures";
 pub const COCONUT_EPOCH_CREDENTIALS: &str = "epoch-credentials";
 pub const COCONUT_ISSUED_CREDENTIAL: &str = "issued-credential";
 pub const COCONUT_ISSUED_CREDENTIALS: &str = "issued-credentials";
@@ -40,3 +46,4 @@ pub const STAKE_SATURATION: &str = "stake-saturation";
 pub const INCLUSION_CHANCE: &str = "inclusion-probability";
 
 pub const SERVICE_PROVIDERS: &str = "services";
+pub const REGISTERED_NAMES: &str = "names";

common/client-libs/validator-client/src/nyxd/contract_traits/coconut_bandwidth_query_client.rs

@@ -1,100 +0,0 @@
-// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::collect_paged;
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::CosmWasmClient;
-use async_trait::async_trait;
-use nym_coconut_bandwidth_contract_common::msg::QueryMsg as CoconutBandwidthQueryMsg;
-use nym_coconut_bandwidth_contract_common::spend_credential::{
-    PagedSpendCredentialResponse, SpendCredential, SpendCredentialResponse,
-};
-use serde::Deserialize;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait CoconutBandwidthQueryClient {
-    async fn query_coconut_bandwidth_contract<T>(
-        &self,
-        query: CoconutBandwidthQueryMsg,
-    ) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>;
-
-    async fn get_spent_credential(
-        &self,
-        blinded_serial_number: String,
-    ) -> Result<SpendCredentialResponse, NyxdError> {
-        self.query_coconut_bandwidth_contract(CoconutBandwidthQueryMsg::GetSpentCredential {
-            blinded_serial_number,
-        })
-        .await
-    }
-
-    async fn get_all_spent_credential_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<PagedSpendCredentialResponse, NyxdError> {
-        self.query_coconut_bandwidth_contract(CoconutBandwidthQueryMsg::GetAllSpentCredentials {
-            limit,
-            start_after,
-        })
-        .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PagedCoconutBandwidthQueryClient: CoconutBandwidthQueryClient {
-    async fn get_all_spent_credentials(&self) -> Result<Vec<SpendCredential>, NyxdError> {
-        collect_paged!(self, get_all_spent_credential_paged, spend_credentials)
-    }
-}
-
-#[async_trait]
-impl<T> PagedCoconutBandwidthQueryClient for T where T: CoconutBandwidthQueryClient {}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> CoconutBandwidthQueryClient for C
-where
-    C: CosmWasmClient + NymContractsProvider + Send + Sync,
-{
-    async fn query_coconut_bandwidth_contract<T>(
-        &self,
-        query: CoconutBandwidthQueryMsg,
-    ) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>,
-    {
-        let coconut_bandwidth_contract_address = self
-            .coconut_bandwidth_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
-        self.query_contract_smart(coconut_bandwidth_contract_address, &query)
-            .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_query_variants_are_covered<C: CoconutBandwidthQueryClient + Send + Sync>(
-        client: C,
-        msg: CoconutBandwidthQueryMsg,
-    ) {
-        match msg {
-            CoconutBandwidthQueryMsg::GetSpentCredential {
-                blinded_serial_number,
-            } => client.get_spent_credential(blinded_serial_number).ignore(),
-            CoconutBandwidthQueryMsg::GetAllSpentCredentials { limit, start_after } => client
-                .get_all_spent_credential_paged(start_after, limit)
-                .ignore(),
-        };
-    }
-}

common/client-libs/validator-client/src/nyxd/contract_traits/coconut_bandwidth_signing_client.rs

@@ -1,153 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::cosmwasm_client::types::ExecuteResult;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
-use crate::signing::signer::OfflineSigner;
-use async_trait::async_trait;
-use nym_coconut_bandwidth_contract_common::spend_credential::SpendCredentialData;
-use nym_coconut_bandwidth_contract_common::{
-    deposit::DepositData, msg::ExecuteMsg as CoconutBandwidthExecuteMsg,
-};
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait CoconutBandwidthSigningClient {
-    async fn execute_coconut_bandwidth_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: CoconutBandwidthExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError>;
-
-    async fn deposit(
-        &self,
-        amount: Coin,
-        info: String,
-        verification_key: String,
-        encryption_key: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = CoconutBandwidthExecuteMsg::DepositFunds {
-            data: DepositData::new(info, verification_key, encryption_key),
-        };
-        self.execute_coconut_bandwidth_contract(
-            fee,
-            req,
-            "CoconutBandwidth::Deposit".to_string(),
-            vec![amount],
-        )
-        .await
-    }
-
-    async fn spend_credential(
-        &self,
-        funds: Coin,
-        blinded_serial_number: String,
-        gateway_cosmos_address: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = CoconutBandwidthExecuteMsg::SpendCredential {
-            data: SpendCredentialData::new(
-                funds.into(),
-                blinded_serial_number,
-                gateway_cosmos_address,
-            ),
-        };
-        self.execute_coconut_bandwidth_contract(
-            fee,
-            req,
-            "CoconutBandwidth::SpendCredential".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn release_funds(
-        &self,
-        amount: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_coconut_bandwidth_contract(
-            fee,
-            CoconutBandwidthExecuteMsg::ReleaseFunds {
-                funds: amount.into(),
-            },
-            "CoconutBandwidth::ReleaseFunds".to_string(),
-            vec![],
-        )
-        .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> CoconutBandwidthSigningClient for C
-where
-    C: SigningCosmWasmClient + NymContractsProvider + Sync,
-    NyxdError: From<<Self as OfflineSigner>::Error>,
-{
-    async fn execute_coconut_bandwidth_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: CoconutBandwidthExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let coconut_bandwidth_contract_address = self
-            .coconut_bandwidth_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
-
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let signer_address = &self.signer_addresses()?[0];
-
-        self.execute(
-            signer_address,
-            coconut_bandwidth_contract_address,
-            &msg,
-            fee,
-            memo,
-            funds,
-        )
-        .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue};
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_execute_variants_are_covered<C: CoconutBandwidthSigningClient + Send + Sync>(
-        client: C,
-        msg: CoconutBandwidthExecuteMsg,
-    ) {
-        match msg {
-            CoconutBandwidthExecuteMsg::DepositFunds { data } => client
-                .deposit(
-                    mock_coin(),
-                    data.deposit_info().to_string(),
-                    data.identity_key().to_string(),
-                    data.encryption_key().to_string(),
-                    None,
-                )
-                .ignore(),
-            CoconutBandwidthExecuteMsg::SpendCredential { data } => client
-                .spend_credential(
-                    mock_coin(),
-                    data.blinded_serial_number().to_string(),
-                    data.gateway_cosmos_address().to_string(),
-                    None,
-                )
-                .ignore(),
-            CoconutBandwidthExecuteMsg::ReleaseFunds { funds } => {
-                client.release_funds(funds.into(), None).ignore()
-            }
-        };
-    }
-}

common/client-libs/validator-client/src/nyxd/contract_traits/ecash_query_client.rs

@@ -0,0 +1,101 @@
+// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collect_paged;
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::CosmWasmClient;
+use async_trait::async_trait;
+use nym_ecash_contract_common::blacklist::BlacklistedAccountResponse;
+use nym_ecash_contract_common::msg::QueryMsg as EcashQueryMsg;
+use nym_ecash_contract_common::spend_credential::{
+    EcashSpentCredential, EcashSpentCredentialResponse, PagedEcashSpentCredentialResponse,
+};
+use serde::Deserialize;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait EcashQueryClient {
+    async fn query_ecash_contract<T>(&self, query: EcashQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_spent_credential(
+        &self,
+        serial_number: String,
+    ) -> Result<EcashSpentCredentialResponse, NyxdError> {
+        self.query_ecash_contract(EcashQueryMsg::GetSpentCredential { serial_number })
+            .await
+    }
+
+    async fn get_all_spent_credential_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedEcashSpentCredentialResponse, NyxdError> {
+        self.query_ecash_contract(EcashQueryMsg::GetAllSpentCredentials { limit, start_after })
+            .await
+    }
+
+    async fn get_blacklisted_account(
+        &self,
+        public_key: String,
+    ) -> Result<BlacklistedAccountResponse, NyxdError> {
+        self.query_ecash_contract(EcashQueryMsg::GetBlacklistedAccount { public_key })
+            .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait PagedEcashQueryClient: EcashQueryClient {
+    async fn get_all_spent_credentials(&self) -> Result<Vec<EcashSpentCredential>, NyxdError> {
+        collect_paged!(self, get_all_spent_credential_paged, spend_credentials)
+    }
+}
+
+#[async_trait]
+impl<T> PagedEcashQueryClient for T where T: EcashQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> EcashQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_ecash_contract<T>(&self, query: EcashQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let ecash_contract_address = self
+            .coconut_bandwidth_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
+        self.query_contract_smart(ecash_contract_address, &query)
+            .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::IgnoreValue;
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_query_variants_are_covered<C: EcashQueryClient + Send + Sync>(
+        client: C,
+        msg: EcashQueryMsg,
+    ) {
+        match msg {
+            EcashQueryMsg::GetSpentCredential { serial_number } => {
+                client.get_spent_credential(serial_number).ignore()
+            }
+            EcashQueryMsg::GetAllSpentCredentials { limit, start_after } => client
+                .get_all_spent_credential_paged(start_after, limit)
+                .ignore(),
+            EcashQueryMsg::GetBlacklistedAccount { public_key } => {
+                client.get_blacklisted_account(public_key).ignore()
+            }
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/contract_traits/ecash_signing_client.rs

@@ -0,0 +1,143 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::cosmwasm_client::types::ExecuteResult;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
+use crate::signing::signer::OfflineSigner;
+use async_trait::async_trait;
+use nym_ecash_contract_common::events::TICKET_BOOK_VALUE;
+use nym_ecash_contract_common::msg::ExecuteMsg as EcashExecuteMsg;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait EcashSigningClient {
+    async fn execute_ecash_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: EcashExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn deposit(
+        &self,
+        info: String,
+        verification_key: String,
+        encryption_key: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = EcashExecuteMsg::DepositFunds {
+            deposit_info: info,
+            identity_key: verification_key,
+            encryption_key,
+        };
+        let amount = Coin::new(TICKET_BOOK_VALUE, "unym");
+        self.execute_ecash_contract(fee, req, "Ecash::Deposit".to_string(), vec![amount])
+            .await
+    }
+
+    async fn prepare_credential(
+        &self,
+        serial_number: String,
+        gateway_cosmos_address: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = EcashExecuteMsg::PrepareCredential {
+            serial_number,
+            gateway_cosmos_address,
+        };
+        self.execute_ecash_contract(fee, req, "Ecash::PrepareCredential".to_string(), vec![])
+            .await
+    }
+
+    async fn propose_for_blacklist(
+        &self,
+        public_key: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = EcashExecuteMsg::ProposeToBlacklist { public_key };
+        self.execute_ecash_contract(fee, req, "Ecash::ProposeToBlacklist".to_string(), vec![])
+            .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> EcashSigningClient for C
+where
+    C: SigningCosmWasmClient + NymContractsProvider + Sync,
+    NyxdError: From<<Self as OfflineSigner>::Error>,
+{
+    async fn execute_ecash_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: EcashExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let coconut_bandwidth_contract_address = self
+            .coconut_bandwidth_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
+
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
+        let signer_address = &self.signer_addresses()?[0];
+
+        self.execute(
+            signer_address,
+            coconut_bandwidth_contract_address,
+            &msg,
+            fee,
+            memo,
+            funds,
+        )
+        .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::IgnoreValue;
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: EcashSigningClient + Send + Sync>(
+        client: C,
+        msg: EcashExecuteMsg,
+    ) {
+        match msg {
+            EcashExecuteMsg::DepositFunds {
+                deposit_info,
+                identity_key,
+                encryption_key,
+            } => client
+                .deposit(
+                    deposit_info.to_string(),
+                    identity_key.to_string(),
+                    encryption_key.to_string(),
+                    None,
+                )
+                .ignore(),
+            EcashExecuteMsg::PrepareCredential {
+                serial_number,
+                gateway_cosmos_address,
+            } => client
+                .prepare_credential(
+                    serial_number.to_string(),
+                    gateway_cosmos_address.to_string(),
+                    None,
+                )
+                .ignore(),
+            EcashExecuteMsg::SpendCredential {
+                serial_number: _,
+                gateway_cosmos_address: _,
+            } => unimplemented!(), //no spend credential method for the client
+            EcashExecuteMsg::AddToBlacklist { public_key: _ } => unimplemented!(), //no add to blacklist method on client
+            EcashExecuteMsg::ProposeToBlacklist { public_key } => {
+                client.propose_for_blacklist(public_key, None).ignore()
+            }
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/contract_traits/ephemera_query_client.rs

@@ -0,0 +1,79 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collect_paged;
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::CosmWasmClient;
+use async_trait::async_trait;
+use nym_ephemera_common::msg::QueryMsg as EphemeraQueryMsg;
+use nym_ephemera_common::peers::PagedPeerResponse;
+use nym_ephemera_common::types::JsonPeerInfo;
+use serde::Deserialize;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait EphemeraQueryClient {
+    async fn query_ephemera_contract<T>(&self, query: EphemeraQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_peers_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedPeerResponse, NyxdError> {
+        let request = EphemeraQueryMsg::GetPeers { start_after, limit };
+        self.query_ephemera_contract(request).await
+    }
+}
+
+// extension trait to the query client to deal with the paged queries
+// (it didn't feel appropriate to combine it with the existing trait
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait PagedEphemeraQueryClient: EphemeraQueryClient {
+    async fn get_all_ephemera_peers(&self) -> Result<Vec<JsonPeerInfo>, NyxdError> {
+        collect_paged!(self, get_peers_paged, peers)
+    }
+}
+
+#[async_trait]
+impl<T> PagedEphemeraQueryClient for T where T: EphemeraQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> EphemeraQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_ephemera_contract<T>(&self, query: EphemeraQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let ephemera_contract_address = &self
+            .ephemera_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("ephemera contract"))?;
+        self.query_contract_smart(ephemera_contract_address, &query)
+            .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::IgnoreValue;
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_query_variants_are_covered<C: EphemeraQueryClient + Send + Sync>(
+        client: C,
+        msg: EphemeraQueryMsg,
+    ) {
+        match msg {
+            EphemeraQueryMsg::GetPeers { limit, start_after } => {
+                client.get_peers_paged(start_after, limit).ignore()
+            }
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/contract_traits/ephemera_signing_client.rs

@@ -0,0 +1,86 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::cosmwasm_client::types::ExecuteResult;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
+use crate::signing::signer::OfflineSigner;
+use async_trait::async_trait;
+use nym_ephemera_common::msg::ExecuteMsg as EphemeraExecuteMsg;
+use nym_ephemera_common::types::JsonPeerInfo;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait EphemeraSigningClient {
+    async fn execute_ephemera_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: EphemeraExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn register_as_peer(
+        &self,
+        peer_info: JsonPeerInfo,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = EphemeraExecuteMsg::RegisterPeer { peer_info };
+
+        self.execute_ephemera_contract(fee, req, "registering as peer".to_string(), vec![])
+            .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> EphemeraSigningClient for C
+where
+    C: SigningCosmWasmClient + NymContractsProvider + Sync,
+    NyxdError: From<<Self as OfflineSigner>::Error>,
+{
+    async fn execute_ephemera_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: EphemeraExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let ephemera_contract_address = self
+            .ephemera_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("ephemera contract"))?;
+
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
+        let signer_address = &self.signer_addresses()?[0];
+
+        self.execute(
+            signer_address,
+            ephemera_contract_address,
+            &msg,
+            fee,
+            memo,
+            funds,
+        )
+        .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::IgnoreValue;
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: EphemeraSigningClient + Send + Sync>(
+        client: C,
+        msg: EphemeraExecuteMsg,
+    ) {
+        match msg {
+            EphemeraExecuteMsg::RegisterPeer { peer_info } => {
+                client.register_as_peer(peer_info, None).ignore()
+            }
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/contract_traits/mod.rs

@@ -8,37 +8,47 @@ use std::str::FromStr;
 // TODO: all of those could/should be derived via a macro
 
 // query clients
-pub mod coconut_bandwidth_query_client;
 pub mod dkg_query_client;
+pub mod ecash_query_client;
+pub mod ephemera_query_client;
 pub mod group_query_client;
 pub mod mixnet_query_client;
 pub mod multisig_query_client;
+pub mod name_service_query_client;
+pub mod sp_directory_query_client;
 pub mod vesting_query_client;
 
 // signing clients
-pub mod coconut_bandwidth_signing_client;
 pub mod dkg_signing_client;
+pub mod ecash_signing_client;
+pub mod ephemera_signing_client;
 pub mod group_signing_client;
 pub mod mixnet_signing_client;
 pub mod multisig_signing_client;
+pub mod name_service_signing_client;
+pub mod sp_directory_signing_client;
 pub mod vesting_signing_client;
 
 // re-export query traits
-pub use coconut_bandwidth_query_client::{
-    CoconutBandwidthQueryClient, PagedCoconutBandwidthQueryClient,
-};
 pub use dkg_query_client::{DkgQueryClient, PagedDkgQueryClient};
+pub use ecash_query_client::{EcashQueryClient, PagedEcashQueryClient};
+pub use ephemera_query_client::{EphemeraQueryClient, PagedEphemeraQueryClient};
 pub use group_query_client::{GroupQueryClient, PagedGroupQueryClient};
 pub use mixnet_query_client::{MixnetQueryClient, PagedMixnetQueryClient};
 pub use multisig_query_client::{MultisigQueryClient, PagedMultisigQueryClient};
+pub use name_service_query_client::{NameServiceQueryClient, PagedNameServiceQueryClient};
+pub use sp_directory_query_client::{PagedSpDirectoryQueryClient, SpDirectoryQueryClient};
 pub use vesting_query_client::{PagedVestingQueryClient, VestingQueryClient};
 
 // re-export signing traits
-pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
 pub use dkg_signing_client::DkgSigningClient;
+pub use ecash_signing_client::EcashSigningClient;
+pub use ephemera_signing_client::EphemeraSigningClient;
 pub use group_signing_client::GroupSigningClient;
 pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_signing_client::MultisigSigningClient;
+pub use name_service_signing_client::NameServiceSigningClient;
+pub use sp_directory_signing_client::SpDirectorySigningClient;
 pub use vesting_signing_client::VestingSigningClient;
 
 // helper for providing blanket implementation for query clients
@@ -52,6 +62,13 @@ pub trait NymContractsProvider {
     fn dkg_contract_address(&self) -> Option<&AccountId>;
     fn group_contract_address(&self) -> Option<&AccountId>;
     fn multisig_contract_address(&self) -> Option<&AccountId>;
+
+    // ephemera-related
+    fn ephemera_contract_address(&self) -> Option<&AccountId>;
+
+    // SPs
+    fn name_service_contract_address(&self) -> Option<&AccountId>;
+    fn service_provider_contract_address(&self) -> Option<&AccountId>;
 }
 
 #[derive(Debug, Clone)]
@@ -63,6 +80,11 @@ pub struct TypedNymContracts {
     pub group_contract_address: Option<AccountId>,
     pub multisig_contract_address: Option<AccountId>,
     pub coconut_dkg_contract_address: Option<AccountId>,
+
+    pub ephemera_contract_address: Option<AccountId>,
+
+    pub service_provider_directory_contract_address: Option<AccountId>,
+    pub name_service_contract_address: Option<AccountId>,
 }
 
 impl TryFrom<NymContracts> for TypedNymContracts {
@@ -94,6 +116,18 @@ impl TryFrom<NymContracts> for TypedNymContracts {
                 .coconut_dkg_contract_address
                 .map(|addr| addr.parse())
                 .transpose()?,
+            ephemera_contract_address: value
+                .ephemera_contract_address
+                .map(|addr| addr.parse())
+                .transpose()?,
+            service_provider_directory_contract_address: value
+                .service_provider_directory_contract_address
+                .map(|addr| addr.parse())
+                .transpose()?,
+            name_service_contract_address: value
+                .name_service_contract_address
+                .map(|addr| addr.parse())
+                .transpose()?,
         })
     }
 }

common/client-libs/validator-client/src/nyxd/contract_traits/name_service_query_client.rs

@@ -0,0 +1,144 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::collect_paged;
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::{error::NyxdError, CosmWasmClient};
+use async_trait::async_trait;
+use cosmrs::AccountId;
+use nym_contracts_common::{signing::Nonce, ContractBuildInformation};
+use nym_name_service_common::{
+    msg::QueryMsg as NameQueryMsg,
+    response::{ConfigResponse, NamesListResponse, PagedNamesListResponse},
+    Address, NameId, NymName, RegisteredName,
+};
+use serde::Deserialize;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait NameServiceQueryClient {
+    async fn query_name_service_contract<T>(&self, query: NameQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_name_service_config(&self) -> Result<ConfigResponse, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::Config {})
+            .await
+    }
+
+    async fn get_name_entry(&self, name_id: NameId) -> Result<RegisteredName, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::NameId { name_id })
+            .await
+    }
+
+    async fn get_names_paged(
+        &self,
+        start_after: Option<NameId>,
+        limit: Option<u32>,
+    ) -> Result<PagedNamesListResponse, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::All { limit, start_after })
+            .await
+    }
+
+    async fn get_name_signing_nonce(&self, address: &AccountId) -> Result<Nonce, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::SigningNonce {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    async fn get_names_by_owner(&self, owner: AccountId) -> Result<NamesListResponse, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::ByOwner {
+            owner: owner.to_string(),
+        })
+        .await
+    }
+
+    async fn get_names_by_nym_name(&self, name: NymName) -> Result<NamesListResponse, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::ByName { name })
+            .await
+    }
+
+    async fn get_names_by_address(&self, address: Address) -> Result<NamesListResponse, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::ByAddress { address })
+            .await
+    }
+
+    async fn get_name_service_contract_version(
+        &self,
+    ) -> Result<ContractBuildInformation, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::GetContractVersion {})
+            .await
+    }
+
+    async fn get_name_service_contract_cw2_version(
+        &self,
+    ) -> Result<cw2::ContractVersion, NyxdError> {
+        self.query_name_service_contract(NameQueryMsg::GetCW2ContractVersion {})
+            .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait PagedNameServiceQueryClient: NameServiceQueryClient {
+    async fn get_all_names(&self) -> Result<Vec<RegisteredName>, NyxdError> {
+        collect_paged!(self, get_names_paged, names)
+    }
+}
+
+#[async_trait]
+impl<T> PagedNameServiceQueryClient for T where T: NameServiceQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> NameServiceQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_name_service_contract<T>(&self, query: NameQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let name_service_contract_address = &self
+            .name_service_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("name service contract"))?;
+        self.query_contract_smart(name_service_contract_address, &query)
+            .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::IgnoreValue;
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_query_variants_are_covered<C: NameServiceQueryClient + Send + Sync>(
+        client: C,
+        msg: NameQueryMsg,
+    ) {
+        match msg {
+            NameQueryMsg::NameId { name_id } => client.get_name_entry(name_id).ignore(),
+            NameQueryMsg::ByOwner { owner } => {
+                client.get_names_by_owner(owner.parse().unwrap()).ignore()
+            }
+            NameQueryMsg::ByName { name } => client.get_names_by_nym_name(name).ignore(),
+            NameQueryMsg::ByAddress { address } => client.get_names_by_address(address).ignore(),
+            NameQueryMsg::All { limit, start_after } => {
+                client.get_names_paged(limit, start_after).ignore()
+            }
+            NameQueryMsg::SigningNonce { address } => client
+                .get_name_signing_nonce(&address.parse().unwrap())
+                .ignore(),
+            NameQueryMsg::Config {} => client.get_name_service_config().ignore(),
+            NameQueryMsg::GetContractVersion {} => {
+                client.get_name_service_contract_version().ignore()
+            }
+            NameQueryMsg::GetCW2ContractVersion {} => {
+                client.get_name_service_contract_cw2_version().ignore()
+            }
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/contract_traits/name_service_signing_client.rs

@@ -0,0 +1,138 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use async_trait::async_trait;
+use nym_contracts_common::signing::MessageSignature;
+use nym_name_service_common::{msg::ExecuteMsg as NameExecuteMsg, NameDetails, NameId, NymName};
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::{
+    coin::Coin, cosmwasm_client::types::ExecuteResult, error::NyxdError, Fee, SigningCosmWasmClient,
+};
+use crate::signing::signer::OfflineSigner;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait NameServiceSigningClient {
+    async fn execute_name_service_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: NameExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn register_name(
+        &self,
+        name: NameDetails,
+        owner_signature: MessageSignature,
+        deposit: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_name_service_contract(
+            fee,
+            NameExecuteMsg::Register {
+                name,
+                owner_signature,
+            },
+            vec![deposit],
+        )
+        .await
+    }
+
+    async fn delete_name_by_id(
+        &self,
+        name_id: NameId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_name_service_contract(fee, NameExecuteMsg::DeleteId { name_id }, vec![])
+            .await
+    }
+
+    async fn delete_service_provider_by_name(
+        &self,
+        name: NymName,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_name_service_contract(fee, NameExecuteMsg::DeleteName { name }, vec![])
+            .await
+    }
+
+    async fn update_deposit_required(
+        &self,
+        deposit_required: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_name_service_contract(
+            fee,
+            NameExecuteMsg::UpdateDepositRequired {
+                deposit_required: deposit_required.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> NameServiceSigningClient for C
+where
+    C: SigningCosmWasmClient + NymContractsProvider + Sync,
+    NyxdError: From<<Self as OfflineSigner>::Error>,
+{
+    async fn execute_name_service_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: NameExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let name_service_contract_address = &self
+            .name_service_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("name service contract"))?;
+
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
+        let memo = msg.default_memo();
+
+        let signer_address = &self.signer_addresses()?[0];
+        self.execute(
+            signer_address,
+            name_service_contract_address,
+            &msg,
+            fee,
+            memo,
+            funds,
+        )
+        .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue};
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: NameServiceSigningClient + Send + Sync>(
+        client: C,
+        msg: NameExecuteMsg,
+    ) {
+        match msg {
+            NameExecuteMsg::Register {
+                name,
+                owner_signature,
+            } => client
+                .register_name(name, owner_signature, mock_coin(), None)
+                .ignore(),
+            NameExecuteMsg::DeleteId { name_id } => {
+                client.delete_name_by_id(name_id, None).ignore()
+            }
+            NameExecuteMsg::DeleteName { name } => {
+                client.delete_service_provider_by_name(name, None).ignore()
+            }
+            NameExecuteMsg::UpdateDepositRequired { deposit_required } => client
+                .update_deposit_required(deposit_required.into(), None)
+                .ignore(),
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/contract_traits/sp_directory_query_client.rs

@@ -0,0 +1,142 @@
+use crate::collect_paged;
+use async_trait::async_trait;
+use cosmrs::AccountId;
+use nym_contracts_common::{signing::Nonce, ContractBuildInformation};
+use nym_service_provider_directory_common::{
+    msg::QueryMsg as SpQueryMsg,
+    response::{
+        ConfigResponse, PagedServicesListResponse, ServiceInfoResponse, ServicesListResponse,
+    },
+    NymAddress, Service, ServiceId,
+};
+use serde::Deserialize;
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::{error::NyxdError, CosmWasmClient};
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait SpDirectoryQueryClient {
+    async fn query_service_provider_contract<T>(&self, query: SpQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_service_config(&self) -> Result<ConfigResponse, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::Config {})
+            .await
+    }
+
+    async fn get_service_info(
+        &self,
+        service_id: ServiceId,
+    ) -> Result<ServiceInfoResponse, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::ServiceId { service_id })
+            .await
+    }
+
+    async fn get_services_paged(
+        &self,
+        start_after: Option<ServiceId>,
+        limit: Option<u32>,
+    ) -> Result<PagedServicesListResponse, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::All { limit, start_after })
+            .await
+    }
+
+    async fn get_services_by_announcer(
+        &self,
+        announcer: AccountId,
+    ) -> Result<ServicesListResponse, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::ByAnnouncer {
+            announcer: announcer.to_string(),
+        })
+        .await
+    }
+
+    async fn get_services_by_nym_address(
+        &self,
+        nym_address: NymAddress,
+    ) -> Result<ServicesListResponse, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::ByNymAddress { nym_address })
+            .await
+    }
+
+    async fn get_sp_contract_version(&self) -> Result<ContractBuildInformation, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::GetContractVersion {})
+            .await
+    }
+
+    async fn get_sp_contract_cw2_version(&self) -> Result<cw2::ContractVersion, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::GetCW2ContractVersion {})
+            .await
+    }
+
+    async fn get_service_signing_nonce(&self, address: &AccountId) -> Result<Nonce, NyxdError> {
+        self.query_service_provider_contract(SpQueryMsg::SigningNonce {
+            address: address.to_string(),
+        })
+        .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait PagedSpDirectoryQueryClient: SpDirectoryQueryClient {
+    async fn get_all_services(&self) -> Result<Vec<Service>, NyxdError> {
+        collect_paged!(self, get_services_paged, services)
+    }
+}
+
+#[async_trait]
+impl<T> PagedSpDirectoryQueryClient for T where T: SpDirectoryQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> SpDirectoryQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_service_provider_contract<T>(&self, query: SpQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let sp_directory_contract_address =
+            &self.service_provider_contract_address().ok_or_else(|| {
+                NyxdError::unavailable_contract_address("service provider directory contract")
+            })?;
+        self.query_contract_smart(sp_directory_contract_address, &query)
+            .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::IgnoreValue;
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_query_variants_are_covered<C: SpDirectoryQueryClient + Send + Sync>(
+        client: C,
+        msg: SpQueryMsg,
+    ) {
+        match msg {
+            SpQueryMsg::ServiceId { service_id } => client.get_service_info(service_id).ignore(),
+            SpQueryMsg::ByAnnouncer { announcer } => client
+                .get_services_by_announcer(announcer.parse().unwrap())
+                .ignore(),
+            SpQueryMsg::ByNymAddress { nym_address } => {
+                client.get_services_by_nym_address(nym_address).ignore()
+            }
+            SpQueryMsg::All { limit, start_after } => {
+                client.get_services_paged(start_after, limit).ignore()
+            }
+            SpQueryMsg::SigningNonce { address } => client
+                .get_service_signing_nonce(&address.parse().unwrap())
+                .ignore(),
+            SpQueryMsg::Config {} => client.get_service_config().ignore(),
+            SpQueryMsg::GetContractVersion {} => client.get_sp_contract_version().ignore(),
+            SpQueryMsg::GetCW2ContractVersion {} => client.get_sp_contract_cw2_version().ignore(),
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/contract_traits/sp_directory_signing_client.rs

@@ -0,0 +1,148 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::{
+    coin::Coin, cosmwasm_client::types::ExecuteResult, error::NyxdError, Fee, SigningCosmWasmClient,
+};
+use crate::signing::signer::OfflineSigner;
+use async_trait::async_trait;
+use nym_contracts_common::signing::MessageSignature;
+use nym_service_provider_directory_common::{
+    msg::ExecuteMsg as SpExecuteMsg, NymAddress, ServiceDetails, ServiceId,
+};
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait SpDirectorySigningClient {
+    async fn execute_service_provider_directory_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: SpExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn announce_service_provider(
+        &self,
+        service: ServiceDetails,
+        owner_signature: MessageSignature,
+        deposit: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_service_provider_directory_contract(
+            fee,
+            SpExecuteMsg::Announce {
+                service,
+                owner_signature,
+            },
+            vec![deposit],
+        )
+        .await
+    }
+
+    async fn delete_service_provider_by_id(
+        &self,
+        service_id: ServiceId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_service_provider_directory_contract(
+            fee,
+            SpExecuteMsg::DeleteId { service_id },
+            vec![],
+        )
+        .await
+    }
+
+    async fn delete_service_provider_by_nym_address(
+        &self,
+        nym_address: NymAddress,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_service_provider_directory_contract(
+            fee,
+            SpExecuteMsg::DeleteNymAddress { nym_address },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_deposit_required(
+        &self,
+        deposit_required: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_service_provider_directory_contract(
+            fee,
+            SpExecuteMsg::UpdateDepositRequired {
+                deposit_required: deposit_required.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> SpDirectorySigningClient for C
+where
+    C: SigningCosmWasmClient + NymContractsProvider + Sync,
+    NyxdError: From<<Self as OfflineSigner>::Error>,
+{
+    async fn execute_service_provider_directory_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: SpExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let sp_directory_contract_address =
+            &self.service_provider_contract_address().ok_or_else(|| {
+                NyxdError::unavailable_contract_address("service provider directory contract")
+            })?;
+
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
+        let memo = msg.default_memo();
+
+        let signer_address = &self.signer_addresses()?[0];
+        self.execute(
+            signer_address,
+            sp_directory_contract_address,
+            &msg,
+            fee,
+            memo,
+            funds,
+        )
+        .await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue};
+
+    // it's enough that this compiles and clippy is happy about it
+    #[allow(dead_code)]
+    fn all_execute_variants_are_covered<C: SpDirectorySigningClient + Send + Sync>(
+        client: C,
+        msg: SpExecuteMsg,
+    ) {
+        match msg {
+            SpExecuteMsg::Announce {
+                service,
+                owner_signature,
+            } => client
+                .announce_service_provider(service, owner_signature, mock_coin(), None)
+                .ignore(),
+            SpExecuteMsg::DeleteId { service_id } => client
+                .delete_service_provider_by_id(service_id, None)
+                .ignore(),
+            SpExecuteMsg::DeleteNymAddress { nym_address } => client
+                .delete_service_provider_by_nym_address(nym_address, None)
+                .ignore(),
+            SpExecuteMsg::UpdateDepositRequired { deposit_required } => client
+                .update_deposit_required(deposit_required.into(), None)
+                .ignore(),
+        };
+    }
+}

common/client-libs/validator-client/src/nyxd/cosmwasm_client/logs.rs

@@ -5,8 +5,8 @@ use crate::nyxd::error::NyxdError;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
-pub use nym_coconut_bandwidth_contract_common::event_attributes::*;
 pub use nym_coconut_dkg_common::event_attributes::*;
+pub use nym_ecash_contract_common::event_attributes::*;
 
 // it seems that currently validators just emit stringified events (which are also returned as part of deliverTx response)
 // as theirs logs

common/client-libs/validator-client/src/nyxd/fee/gas_price.rs

@@ -140,6 +140,6 @@ mod tests {
 
         let fee = &gas_price * gas_limit;
         // the failing behaviour was result value of 3937
-        assert_eq!(fee.amount, 3938u128);
+        assert_eq!(fee.amount, 3938u64.into());
     }
 }

common/client-libs/validator-client/src/nyxd/mod.rs

@@ -70,8 +70,6 @@ use crate::http_client;
 use crate::{DirectSigningHttpRpcNyxdClient, QueryHttpRpcNyxdClient};
 #[cfg(feature = "http-client")]
 use cosmrs::rpc::{HttpClient, HttpClientUrl};
-use nym_contracts_common::build_information::CONTRACT_BUILD_INFO_STORAGE_KEY;
-use nym_contracts_common::ContractBuildInformation;
 
 pub mod coin;
 pub mod contract_traits;
@@ -248,6 +246,12 @@ impl<C, S> NyxdClient<C, S> {
         self.config.contracts.multisig_contract_address = Some(address);
     }
 
+    pub fn set_service_provider_contract_address(&mut self, address: AccountId) {
+        self.config
+            .contracts
+            .service_provider_directory_contract_address = Some(address);
+    }
+
     pub fn set_simulated_gas_multiplier(&mut self, multiplier: f32) {
         self.config.simulated_gas_multiplier = multiplier;
     }
@@ -280,6 +284,21 @@ impl<C, S> NymContractsProvider for NyxdClient<C, S> {
     fn multisig_contract_address(&self) -> Option<&AccountId> {
         self.config.contracts.multisig_contract_address.as_ref()
     }
+
+    fn ephemera_contract_address(&self) -> Option<&AccountId> {
+        self.config.contracts.ephemera_contract_address.as_ref()
+    }
+
+    fn name_service_contract_address(&self) -> Option<&AccountId> {
+        self.config.contracts.name_service_contract_address.as_ref()
+    }
+
+    fn service_provider_contract_address(&self) -> Option<&AccountId> {
+        self.config
+            .contracts
+            .service_provider_directory_contract_address
+            .as_ref()
+    }
 }
 
 // queries
@@ -330,33 +349,6 @@ where
             .await
             .map(|block| block.block_id.hash)
     }
-
-    pub async fn try_get_cw2_contract_version(
-        &self,
-        contract_address: &AccountId,
-    ) -> Option<cw2::ContractVersion> {
-        let raw_info = self
-            .query_contract_raw(contract_address, b"contract_info".to_vec())
-            .await
-            .ok()?;
-
-        serde_json::from_slice(&raw_info).ok()
-    }
-
-    pub async fn try_get_contract_build_information(
-        &self,
-        contract_address: &AccountId,
-    ) -> Option<ContractBuildInformation> {
-        let raw_info = self
-            .query_contract_raw(
-                contract_address,
-                CONTRACT_BUILD_INFO_STORAGE_KEY.as_bytes().to_vec(),
-            )
-            .await
-            .ok()?;
-
-        serde_json::from_slice(&raw_info).ok()
-    }
 }
 
 // signing

common/commands/Cargo.toml

@@ -10,26 +10,26 @@ anyhow = { workspace = true }
 base64 = "0.13.0"
 bip39 = { workspace = true }
 bs58 = { workspace = true }
-comfy-table = { workspace = true }
-cfg-if = { workspace = true }
+comfy-table = "6.0.0"
+cfg-if = "1.0.0"
 clap = { workspace = true, features = ["derive"] }
-csv = { workspace = true }
+csv = "1.3.0"
 cw-utils = { workspace = true }
 futures = { workspace = true }
-handlebars = { workspace = true }
+handlebars = "3.0.1"
 humantime-serde = { workspace = true }
-inquire = { workspace = true }
+inquire = "0.6.2"
 k256 = { workspace = true, features = ["ecdsa", "sha256"] }
 log = { workspace = true }
 rand = {version = "0.6", features = ["std"] }
-serde = { workspace = true, features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 time = { workspace = true, features = ["parsing", "formatting"] }
 tokio = { workspace = true, features = ["sync"]}
 toml = "0.5.6"
 url = { workspace = true }
-tap = { workspace = true }
+tap = "1"
 zeroize = { workspace = true }
 
 cosmrs = { workspace = true }
@@ -43,9 +43,11 @@ nym-contracts-common = { path = "../cosmwasm-smart-contracts/contracts-common" }
 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }
-nym-coconut-bandwidth-contract-common = { path = "../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 nym-coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
 nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }
+nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
+nym-service-provider-directory-common = { path = "../cosmwasm-smart-contracts/service-provider-directory" }
+nym-name-service-common = { path = "../cosmwasm-smart-contracts/name-service" }
 nym-sphinx = { path = "../../common/nymsphinx" }
 nym-client-core = { path = "../../common/client-core" }
 nym-config = { path = "../../common/config" }

common/commands/src/coconut/generate_freepass.rs

@@ -9,12 +9,15 @@ use futures::StreamExt;
 use log::{error, info};
 use nym_coconut_dkg_common::types::EpochId;
 use nym_credential_utils::utils::block_until_coconut_is_available;
-use nym_credentials::coconut::bandwidth::freepass::MAX_FREE_PASS_VALIDITY;
+use nym_credentials::coconut::bandwidth::bandwidth_credential_params;
+use nym_credentials::coconut::utils::freepass_exp_date_timestamp;
+use nym_credentials::coconut::utils::today_timestamp;
 use nym_credentials::{
     obtain_aggregate_verification_key, IssuanceBandwidthCredential, IssuedBandwidthCredential,
 };
-use nym_credentials_interface::VerificationKey;
-use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_credentials_interface::aggregate_expiration_signatures;
+use nym_credentials_interface::VerificationKeyAuth;
+use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nyxd::contract_traits::{DkgQueryClient, NymContractsProvider};
 use nym_validator_client::nyxd::CosmWasmClient;
 use nym_validator_client::signing::AccountData;
@@ -24,6 +27,7 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::sync::Arc;
 use time::format_description::well_known::Rfc3339;
+use time::macros::time;
 use time::OffsetDateTime;
 use zeroize::Zeroizing;
 
@@ -55,17 +59,17 @@ pub struct Args {
 
 async fn get_freepass(
     api_clients: Vec<CoconutApiClient>,
-    aggregate_vk: &VerificationKey,
+    aggregate_vk: &VerificationKeyAuth,
     threshold: u64,
     epoch_id: EpochId,
     signing_account: &AccountData,
-    expiration_date: OffsetDateTime,
+    expiration_date_ts: u64,
 ) -> anyhow::Result<IssuedBandwidthCredential> {
-    let issuance_pass = IssuanceBandwidthCredential::new_freepass(Some(expiration_date));
+    let issuance_pass = IssuanceBandwidthCredential::new_freepass(expiration_date_ts);
     let signing_data = issuance_pass.prepare_for_signing();
 
-    let credential_shares = Arc::new(tokio::sync::Mutex::new(Vec::new()));
-
+    let wallet_shares = Arc::new(tokio::sync::Mutex::new(Vec::new()));
+    let signatures_shares = Arc::new(tokio::sync::Mutex::new(Vec::new()));
     futures::stream::iter(api_clients)
         .for_each_concurrent(None, |client| async {
             // move the client into the block
@@ -77,35 +81,65 @@ async fn get_freepass(
             match issuance_pass
                 .obtain_partial_freepass_credential(
                     &client.api_client,
+                    client.node_id,
                     signing_account,
                     &client.verification_key,
                     signing_data.clone(),
                 )
                 .await
             {
-                Ok(partial_credential) => {
-                    credential_shares
-                        .lock()
-                        .await
-                        .push((partial_credential, client.node_id).into());
+                Ok(partial_wallet) => {
+                    wallet_shares.lock().await.push(partial_wallet);
                 }
                 Err(err) => {
                     error!("failed to obtain partial free pass from {api_url}: {err}")
                 }
             }
+
+            info!("contacting {api_url} for expiration date signatures");
+            match client
+                .api_client
+                .expiration_date_signatures_timestamp(expiration_date_ts)
+                .await
+            {
+                Ok(signature) => {
+                    let index = client.node_id;
+                    let share = client.verification_key.clone();
+                    signatures_shares
+                        .lock()
+                        .await
+                        .push((index, share, signature.signs));
+                }
+                Err(err) => {
+                    error!("failed to obtain expiration date signature from {api_url}: {err}");
+                }
+            }
         })
         .await;
 
     // SAFETY: the futures have completed, so we MUST have the only arc reference
     #[allow(clippy::unwrap_used)]
-    let credential_shares = Arc::into_inner(credential_shares).unwrap().into_inner();
+    let wallet_shares = Arc::into_inner(wallet_shares).unwrap().into_inner();
+    let signatures_shares = Arc::into_inner(signatures_shares).unwrap().into_inner();
 
-    if credential_shares.len() < threshold as usize {
-        bail!("we managed to obtain only {} partial credentials while the minimum threshold is {threshold}", credential_shares.len());
+    if wallet_shares.len() < threshold as usize {
+        bail!("we managed to obtain only {} partial credentials while the minimum threshold is {threshold}", wallet_shares.len());
     }
 
-    let signature = issuance_pass.aggregate_signature_shares(aggregate_vk, &credential_shares)?;
-    Ok(issuance_pass.into_issued_credential(signature, epoch_id))
+    let wallet =
+        issuance_pass.aggregate_signature_shares(aggregate_vk, &wallet_shares, signing_data)?;
+
+    if signatures_shares.len() < threshold as usize {
+        bail!("we managed to obtain only {} partial expiration date signatures while the minimum threshold is {threshold}", signatures_shares.len());
+    }
+
+    let exp_date_sigs = aggregate_expiration_signatures(
+        bandwidth_credential_params(),
+        aggregate_vk,
+        expiration_date_ts,
+        &signatures_shares,
+    )?;
+    Ok(issuance_pass.into_issued_credential(wallet, exp_date_sigs, epoch_id))
 }
 
 pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
@@ -142,13 +176,18 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
         None => OffsetDateTime::from_unix_timestamp(args.expiration_timestamp.unwrap())?,
     };
 
-    let now = OffsetDateTime::now_utc();
+    //SAFETY : positive timestamp, so conversion to unsigned will not fail
+    let expiration_date_ts: u64 = expiration_date
+        .replace_time(time!(0:00))
+        .unix_timestamp()
+        .try_into()
+        .unwrap();
 
-    if expiration_date > now + MAX_FREE_PASS_VALIDITY {
+    if expiration_date_ts > freepass_exp_date_timestamp() {
         bail!("the provided free pass request has too long expiry (expiry is set to on {expiration_date})")
     }
 
-    if expiration_date < now {
+    if expiration_date_ts < today_timestamp() {
         bail!("the provided free pass expiry is set in the past!")
     }
 
@@ -162,7 +201,7 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
         .get_current_epoch_threshold()
         .await?
         .ok_or(anyhow!("no threshold available"))?;
-    let api_clients = all_coconut_api_clients(&client, epoch_id).await?;
+    let api_clients = all_ecash_api_clients(&client, epoch_id).await?;
 
     if api_clients.len() < threshold as usize {
         bail!(
@@ -181,7 +220,7 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
             threshold,
             epoch_id,
             &signing_account,
-            expiration_date,
+            expiration_date_ts,
         )
         .await?;
         let credential_data = Zeroizing::new(free_pass.pack_v1());

common/commands/src/coconut/issue_credentials.rs

@@ -7,7 +7,7 @@ use anyhow::bail;
 use clap::Parser;
 use nym_credential_storage::initialise_persistent_storage;
 use nym_credential_utils::utils;
-use nym_validator_client::nyxd::Coin;
+use nym_crypto::asymmetric::identity;
 use std::path::PathBuf;
 
 #[derive(Debug, Parser)]
@@ -16,20 +16,12 @@ pub struct Args {
     #[clap(long)]
     pub(crate) client_config: PathBuf,
 
-    /// The amount of utokens the credential will hold.
-    #[clap(long, default_value = "0")]
-    pub(crate) amount: u64,
-
     /// Path to a directory used to store recovery files for unconsumed deposits
     #[clap(long)]
     pub(crate) recovery_dir: PathBuf,
 }
 
 pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
-    if args.amount == 0 {
-        bail!("did not specify credential amount")
-    }
-
     let loaded = CommonConfigsWrapper::try_load(args.client_config)?;
 
     if let Ok(id) = loaded.try_get_id() {
@@ -40,16 +32,24 @@ pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
         bail!("the loaded config does not have a credentials store information")
     };
 
+    let Ok(private_id_key) = loaded.try_get_private_id_key() else {
+        bail!("the loaded config does not have a public id key information")
+    };
+
     println!(
         "using credentials store at '{}'",
         credentials_store.display()
     );
 
-    let denom = &client.current_chain_details().mix_denom.base;
-    let coin = Coin::new(args.amount as u128, denom);
-
     let persistent_storage = initialise_persistent_storage(credentials_store).await;
-    utils::issue_credential(&client, coin, &persistent_storage, args.recovery_dir).await?;
+    let private_id_key: identity::PrivateKey = nym_pemstore::load_key(private_id_key)?;
+    utils::issue_credential(
+        &client,
+        &private_id_key.to_bytes(),
+        &persistent_storage,
+        args.recovery_dir,
+    )
+    .await?;
 
     Ok(())
 }

common/commands/src/utils.rs

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

common/commands/src/validator/cosmwasm/generators/coconut_bandwidth.rs

@@ -6,13 +6,13 @@ use std::str::FromStr;
 use clap::Parser;
 use log::{debug, info};
 
-use nym_coconut_bandwidth_contract_common::msg::InstantiateMsg;
+use nym_ecash_contract_common::msg::InstantiateMsg;
 use nym_validator_client::nyxd::AccountId;
 
 #[derive(Debug, Parser)]
 pub struct Args {
     #[clap(long)]
-    pub pool_addr: String,
+    pub group_addr: Option<AccountId>,
 
     #[clap(long)]
     pub multisig_addr: Option<AccountId>,
@@ -26,8 +26,15 @@ pub async fn generate(args: Args) {
 
     debug!("Received arguments: {:?}", args);
 
+    let group_addr = args.group_addr.unwrap_or_else(|| {
+        let address = std::env::var(nym_network_defaults::var_names::GROUP_CONTRACT_ADDRESS)
+            .expect("Multisig address has to be set");
+        AccountId::from_str(address.as_str())
+            .expect("Failed converting multisig address to AccountId")
+    });
+
     let multisig_addr = args.multisig_addr.unwrap_or_else(|| {
-        let address = std::env::var(nym_network_defaults::var_names::REWARDING_VALIDATOR_ADDRESS)
+        let address = std::env::var(nym_network_defaults::var_names::MULTISIG_CONTRACT_ADDRESS)
             .expect("Multisig address has to be set");
         AccountId::from_str(address.as_str())
             .expect("Failed converting multisig address to AccountId")
@@ -38,7 +45,7 @@ pub async fn generate(args: Args) {
     });
 
     let instantiate_msg = InstantiateMsg {
-        pool_addr: args.pool_addr,
+        group_addr: group_addr.to_string(),
         multisig_addr: multisig_addr.to_string(),
         mix_denom,
     };

common/commands/src/validator/mixnet/delegators/delegate_to_multiple_mixnodes.rs

@@ -157,7 +157,7 @@ async fn fetch_delegation_data(
             // If a pending undelegate tx is found, remove it from delegation map
             Undelegate { owner, mix_id, .. } => {
                 if owner == address.as_ref()
-                    && existing_delegation_map.contains_key(&mix_id.to_string())
+                    && existing_delegation_map.get(&mix_id.to_string()).is_some()
                 {
                     existing_delegation_map.remove(&mix_id.to_string());
                 }

common/commands/src/validator/mixnet/operators/mod.rs

@@ -6,6 +6,8 @@ use clap::{Args, Subcommand};
 pub mod gateway;
 pub mod identity_key;
 pub mod mixnode;
+pub mod name;
+pub mod service;
 
 #[derive(Debug, Args)]
 #[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
@@ -21,6 +23,10 @@ pub enum MixnetOperatorsCommands {
     Mixnode(mixnode::MixnetOperatorsMixnode),
     /// Manage your gateway
     Gateway(gateway::MixnetOperatorsGateway),
+    /// Manage your service
+    ServiceProvider(service::MixnetOperatorsService),
+    /// Manage your registered name
+    Name(name::MixnetOperatorsName),
     /// Sign messages using your private identity key
     IdentityKey(identity_key::MixnetOperatorsIdentityKey),
 }

common/commands/src/validator/mixnet/operators/name/delete.rs

@@ -0,0 +1,25 @@
+use clap::Parser;
+use log::{error, info};
+use nym_name_service_common::NameId;
+use nym_validator_client::nyxd::{contract_traits::NameServiceSigningClient, error::NyxdError};
+use tap::TapFallible;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub id: NameId,
+}
+
+pub async fn delete(args: Args, client: SigningClient) -> Result<(), NyxdError> {
+    info!("Deleting registered name alias with id {}", args.id);
+
+    let res = client
+        .delete_name_by_id(args.id, None)
+        .await
+        .tap_err(|err| error!("Failed to delete name: {err:#?}"))?;
+
+    info!("Deleted: {res:?}");
+    Ok(())
+}

common/commands/src/validator/mixnet/operators/name/mod.rs

@@ -0,0 +1,22 @@
+use clap::{Args, Subcommand};
+
+pub mod delete;
+pub mod register;
+pub mod register_sign_payload;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsName {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsNameCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsNameCommands {
+    /// Register a name alias for a nym address
+    Register(register::Args),
+    /// Delete name alias for a nym address
+    Delete(delete::Args),
+    /// Create base58-encoded payload required for producing valiid register signature.
+    CreateNameRegisterPayload(register_sign_payload::Args),
+}

common/commands/src/validator/mixnet/operators/name/register.rs

@@ -0,0 +1,53 @@
+use clap::Parser;
+use log::{error, info};
+use nym_contracts_common::signing::MessageSignature;
+use nym_name_service_common::{Address, Coin, NameDetails, NymName};
+use nym_sphinx::addressing::clients::Recipient;
+use nym_validator_client::nyxd::{contract_traits::NameServiceSigningClient, error::NyxdError};
+use tap::TapFallible;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Name alias
+    #[clap(long)]
+    pub name: NymName,
+
+    /// Nym address that the alias is pointing to
+    #[clap(long)]
+    pub nym_address: Recipient,
+
+    #[clap(long)]
+    pub signature: MessageSignature,
+
+    /// Deposit to be made to the service provider directory, in curent DENOMINATION (e.g. 'unym')
+    #[clap(long)]
+    pub deposit: u128,
+}
+
+pub async fn register(args: Args, client: SigningClient) -> Result<(), NyxdError> {
+    info!(
+        "Registering name alias '{}' for nym address '{}'",
+        args.name, args.nym_address
+    );
+
+    let address = Address::new(&args.nym_address.to_string()).expect("invalid address");
+    let identity_key = address.client_id().to_string();
+    let name = NameDetails {
+        name: args.name,
+        address,
+        identity_key,
+    };
+
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+    let deposit = Coin::new(args.deposit, denom);
+
+    let res = client
+        .register_name(name, args.signature, deposit.into(), None)
+        .await
+        .tap_err(|err| error!("Failed to register name: {err:#?}"))?;
+
+    info!("Registered name: {res:?}");
+    Ok(())
+}

common/commands/src/validator/mixnet/operators/name/register_sign_payload.rs

@@ -0,0 +1,65 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{
+    context::SigningClient,
+    utils::{account_id_to_cw_addr, DataWrapper},
+};
+
+use clap::Parser;
+use cosmwasm_std::Coin;
+
+use nym_bin_common::output_format::OutputFormat;
+use nym_name_service_common::{
+    signing_types::construct_name_register_sign_payload, Address, NymName,
+};
+use nym_sphinx::addressing::clients::Recipient;
+use nym_validator_client::nyxd::{contract_traits::NameServiceQueryClient, error::NyxdError};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    // The name to register.
+    #[arg(long)]
+    pub name: NymName,
+
+    /// The nym address the name should point to.
+    #[arg(long)]
+    pub nym_address: Recipient,
+
+    #[arg(long)]
+    pub amount: u128,
+
+    #[arg(short, long, default_value_t = OutputFormat::default())]
+    output: OutputFormat,
+}
+
+pub async fn create_payload(args: Args, client: SigningClient) -> Result<(), NyxdError> {
+    let address = Address::new(&args.nym_address.to_string()).expect("invalid address");
+    let identity_key = address.client_id().to_string();
+    let name = nym_name_service_common::NameDetails {
+        name: args.name,
+        address,
+        identity_key,
+    };
+
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+    let deposit = Coin::new(args.amount, denom);
+
+    let nonce = match client.get_name_signing_nonce(&client.address()).await {
+        Ok(nonce) => nonce,
+        Err(err) => {
+            eprint!(
+                "failed to query for the signing nonce of {}: {err}",
+                client.address()
+            );
+            return Err(err);
+        }
+    };
+
+    let address = account_id_to_cw_addr(&client.address());
+    let payload = construct_name_register_sign_payload(nonce, address, deposit, name);
+    let wrapper = DataWrapper::new(payload.to_base58_string().unwrap());
+    println!("{}", args.output.format(&wrapper));
+
+    Ok(())
+}

common/commands/src/validator/mixnet/operators/service/announce.rs

@@ -0,0 +1,45 @@
+use clap::Parser;
+use log::info;
+use nym_contracts_common::signing::MessageSignature;
+use nym_service_provider_directory_common::{Coin, NymAddress, ServiceDetails, ServiceType};
+use nym_validator_client::nyxd::contract_traits::SpDirectorySigningClient;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub nym_address: String,
+
+    #[clap(long)]
+    pub signature: MessageSignature,
+
+    /// Deposit to be made to the service provider directory, in curent DENOMINATION (e.g. 'unym')
+    #[clap(long)]
+    pub deposit: u128,
+
+    #[clap(long)]
+    pub identity_key: String,
+}
+
+pub async fn announce(args: Args, client: SigningClient) {
+    info!("Annoucing service provider");
+
+    let nym_address = NymAddress::Address(args.nym_address);
+    let service_type = ServiceType::NetworkRequester;
+    let service = ServiceDetails {
+        nym_address,
+        service_type,
+        identity_key: args.identity_key,
+    };
+
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+    let deposit = Coin::new(args.deposit, denom);
+
+    let res = client
+        .announce_service_provider(service, args.signature, deposit.into(), None)
+        .await
+        .expect("Failed to announce service provider");
+
+    info!("Announced service provider: {res:?}");
+}

common/commands/src/validator/mixnet/operators/service/announce_sign_payload.rs

@@ -0,0 +1,61 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{
+    context::SigningClient,
+    utils::{account_id_to_cw_addr, DataWrapper},
+};
+
+use clap::Parser;
+use cosmwasm_std::Coin;
+
+use nym_bin_common::output_format::OutputFormat;
+use nym_service_provider_directory_common::{
+    signing_types::construct_service_provider_announce_sign_payload, NymAddress,
+    ServiceType::NetworkRequester,
+};
+use nym_sphinx::addressing::clients::Recipient;
+use nym_validator_client::nyxd::contract_traits::SpDirectoryQueryClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub nym_address: Recipient,
+
+    #[clap(long)]
+    pub amount: u128,
+
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(short, long, default_value_t = OutputFormat::default())]
+    output: OutputFormat,
+}
+
+pub async fn create_payload(args: Args, client: SigningClient) {
+    let service = nym_service_provider_directory_common::ServiceDetails {
+        nym_address: NymAddress::new(&args.nym_address.to_string()),
+        service_type: NetworkRequester,
+        identity_key: args.identity_key,
+    };
+
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+    let deposit = Coin::new(args.amount, denom);
+
+    let nonce = match client.get_service_signing_nonce(&client.address()).await {
+        Ok(nonce) => nonce,
+        Err(err) => {
+            eprint!(
+                "failed to query for the signing nonce of {}: {err}",
+                client.address()
+            );
+            return;
+        }
+    };
+
+    let address = account_id_to_cw_addr(&client.address());
+    let payload =
+        construct_service_provider_announce_sign_payload(nonce, address, deposit, service);
+    let wrapper = DataWrapper::new(payload.to_base58_string().unwrap());
+    println!("{}", args.output.format(&wrapper))
+}

common/commands/src/validator/mixnet/operators/service/delete.rs

@@ -0,0 +1,23 @@
+use clap::Parser;
+use log::info;
+use nym_service_provider_directory_common::ServiceId;
+use nym_validator_client::nyxd::contract_traits::SpDirectorySigningClient;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub id: ServiceId,
+}
+
+pub async fn delete(args: Args, client: SigningClient) {
+    info!("Deleting service provider with id {}", args.id);
+
+    let res = client
+        .delete_service_provider_by_id(args.id, None)
+        .await
+        .expect("Failed to delete service provider");
+
+    info!("Deleted: {res:?}");
+}

common/commands/src/validator/mixnet/operators/service/mod.rs

@@ -0,0 +1,23 @@
+use clap::{Args, Subcommand};
+
+pub mod announce;
+pub mod announce_sign_payload;
+pub mod delete;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsService {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsServiceCommands,
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsServiceCommands {
+    /// Announce service provider to the world
+    Announce(announce::Args),
+    /// Delete entry for service provider from the directory
+    Delete(delete::Args),
+    /// Create base58-encoded payload required for producing valid announce signature.
+    CreateServiceAnnounceSignPayload(announce_sign_payload::Args),
+}

common/commands/src/validator/mixnet/query/mod.rs

@@ -5,6 +5,8 @@ use clap::{Args, Subcommand};
 
 pub mod query_all_gateways;
 pub mod query_all_mixnodes;
+pub mod query_all_names;
+pub mod query_all_service_providers;
 
 #[derive(Debug, Args)]
 #[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
@@ -19,4 +21,8 @@ pub enum MixnetQueryCommands {
     Mixnodes(query_all_mixnodes::Args),
     /// Query gateways
     Gateways(query_all_gateways::Args),
+    /// Query announced service-providers
+    ServiceProviders(query_all_service_providers::Args),
+    /// Query registed names
+    Names(query_all_names::Args),
 }

common/commands/src/validator/mixnet/query/query_all_names.rs

@@ -0,0 +1,53 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::QueryClientWithNyxd;
+use crate::utils::show_error;
+use clap::Parser;
+use comfy_table::Table;
+use nym_validator_client::client::NymApiClientExt;
+use nym_validator_client::nym_api::error::NymAPIError;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Optionally, the registered name to display")]
+    pub name: Option<String>,
+}
+
+pub async fn query(args: Args, client: &QueryClientWithNyxd) {
+    log::trace!("Querying all registered names");
+
+    match client.nym_api.get_registered_names().await {
+        Ok(res) => {
+            if let Some(name) = args.name {
+                let name = res.names.iter().find(|name_entry| {
+                    name_entry.name.name.to_string().eq_ignore_ascii_case(&name)
+                });
+                println!(
+                    "{}",
+                    ::serde_json::to_string_pretty(&name).expect("json formatting error")
+                );
+            } else {
+                let mut table = Table::new();
+
+                table.set_header(vec!["Name Id", "Owner", "Nym Address", "Name"]);
+                for name_entry in res.names {
+                    table.add_row(vec![
+                        name_entry.id.to_string(),
+                        name_entry.owner.to_string(),
+                        name_entry.name.address.to_string(),
+                        name_entry.name.name.to_string(),
+                    ]);
+                }
+
+                println!("The registered names in the directory are:");
+                println!("{table}");
+            }
+        }
+        Err(NymAPIError::NotFound) => {
+            println!("nym-api reports no name endpoint available");
+        }
+        Err(e) => show_error(e),
+    }
+}

common/commands/src/validator/mixnet/query/query_all_service_providers.rs

@@ -0,0 +1,55 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::QueryClientWithNyxd;
+use crate::utils::show_error;
+use clap::Parser;
+use comfy_table::Table;
+use nym_validator_client::client::NymApiClientExt;
+use nym_validator_client::nym_api::error::NymAPIError;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "Optionally, the service provider to display")]
+    pub nym_address: Option<String>,
+}
+
+pub async fn query(args: Args, client: &QueryClientWithNyxd) {
+    match client.nym_api.get_service_providers().await {
+        Ok(res) => {
+            if let Some(nym_address) = args.nym_address {
+                let service = res.services.iter().find(|service| {
+                    service
+                        .service
+                        .nym_address
+                        .to_string()
+                        .eq_ignore_ascii_case(&nym_address)
+                });
+                println!(
+                    "{}",
+                    ::serde_json::to_string_pretty(&service).expect("json formatting error")
+                );
+            } else {
+                let mut table = Table::new();
+
+                table.set_header(vec!["Service Id", "Announcer", "Type", "Nym Address"]);
+                for service in res.services {
+                    table.add_row(vec![
+                        service.service_id.to_string(),
+                        service.announcer.to_string(),
+                        service.service.service_type.to_string(),
+                        service.service.nym_address.to_string(),
+                    ]);
+                }
+
+                println!("The service providers in the directory are:");
+                println!("{table}");
+            }
+        }
+        Err(NymAPIError::NotFound) => {
+            println!("nym-api reports no service provider endpoint available");
+        }
+        Err(e) => show_error(e),
+    }
+}

common/config/Cargo.toml

@@ -9,7 +9,7 @@ license.workspace = true
 
 [dependencies]
 dirs = { version = "5.0.1", optional = true }
-handlebars = { workspace = true }
+handlebars = "3.5.5"
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 toml = "0.7.4"

common/cosmwasm-smart-contracts/coconut-dkg/src/types.rs

@@ -328,8 +328,4 @@ impl EpochState {
     pub fn is_dealing_exchange(&self) -> bool {
         matches!(self, EpochState::DealingExchange { .. })
     }
-
-    pub fn is_waiting_initialisation(&self) -> bool {
-        matches!(self, EpochState::WaitingInitialisation)
-    }
 }