merge conflict changes

Feature/ephemera upgrade

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

@@ -109,6 +109,7 @@ jobs:
           cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/nym_service_provider_directory.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/nym_name_service.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_ephemera.wasm $OUTPUT_DIR
 
       - name: Deploy branch to CI www
         continue-on-error: true

.github/workflows/cd-dev.yml

@@ -1,76 +0,0 @@
-name: CD dev-portal
-
-on:
-  push:
-    branches: master
-    paths:
-      - 'documentation/dev-portal/**'
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install rsync
-        run: sudo apt-get install rsync
-      - uses: rlespinasse/github-slug-action@v3.x
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
-            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck
-      - name: Clean website
-        run: cd documentation/dev-portal && mdbook clean
-      - name: Build website
-        run: cd documentation/dev-portal && mdbook build
-      - name: Deploy branch master to dev
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/dev-portal/book/html/"
-          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_DEV }}
-          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET_DEVP }}/
-          EXCLUDE: "/dist/, /node_modules/"
-      - name: Deploy branch master to prod
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/dev-portal/book/html/"
-          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_PROD }}
-          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET_DEVP }}/
-          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: cd-dev
-          NYM_PROJECT_NAME: "Dev portal CD"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CD_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DEVP }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/cd-docs.yml

@@ -1,6 +1,7 @@
 name: CD docs
 
 on:
+  workflow_dispatch:
   push:
     branches: master
     paths:
@@ -27,39 +28,38 @@ jobs:
           command: build
           args: --workspace --release --all
       - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
+        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.33" mdbook)
       - name: Install mdbook plugins
         run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
+          cargo install --vers "=0.2.2" mdbook-variables && cargo install \
             --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
-            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck && \
-            cargo install --vers "^0.5.0" mdbook-cmdrun
-      - name: Clean website
-        run: cd documentation/docs && mdbook clean
-      - name: Build website
-        run: cd documentation/docs && mdbook build
+            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
+            && cargo install --vers "^0.7.7" mdbook-linkcheck
+      - name: Build all projects in documentation/ & move to ~/dist/docs/
+        run: cd documentation && ./build_all_to_dist.sh
+        continue-on-error: false
       - name: Deploy branch master to dev
         continue-on-error: true
         uses: easingthemes/ssh-deploy@main
         env:
           SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
           ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/docs/book/"
+          SOURCE: "dist/docs/"
           REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_DEV }}
           REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
           TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
-          EXCLUDE: "/dist/, /node_modules/"
+          EXCLUDE: "/node_modules/"
       - name: Deploy branch master to prod
+        if: github.ref == 'refs/heads/master'
         uses: easingthemes/ssh-deploy@main
         env:
           SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
           ARGS: "-rltgoDzvO --delete"
-          SOURCE: "documentation/docs/book/"
+          SOURCE: "dist/docs/"
           REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_PROD }}
           REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
           TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
-          EXCLUDE: "/dist/, /node_modules/"
+          EXCLUDE: "/node_modules/"
       - name: Matrix - Node Install
         run: npm install
         working-directory: .github/workflows/support-files

.github/workflows/check-contract-schema.yml

@@ -0,0 +1,31 @@
+name: Check Contract Schema
+
+on:
+  push:
+    paths:
+      - 'contracts/**'
+      - 'common/**'
+  pull_request:
+    paths:
+      - 'contracts/**'
+      - 'common/**'
+
+jobs:
+  check-schema:
+    name: Generate and check schema
+    runs-on: custom-runner-linux
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+
+      - name: Generate the schema
+        run: make contract-schema
+
+      - name: Check for diff
+        run: git diff --exit-code -- contracts/*/schema

.github/workflows/ci-dev.yml

@@ -1,66 +0,0 @@
-name: CI dev-portal
-
-on:
-  push:
-    branches-ignore: master
-    paths:
-      - 'documentation/dev-portal/**'
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install rsync
-        run: sudo apt-get install rsync
-      - uses: rlespinasse/github-slug-action@v3.x
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 18
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
-            && cargo install --vers "^0.7.7" mdbook-linkcheck 
-      - name: Clean website
-        run: cd documentation/dev-portal && mdbook clean
-      - name: Build website
-        run: cd documentation/dev-portal && mdbook 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: "documentation/dev-portal/book/html/"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/dev-portal-${{ 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: ci-dev
-          NYM_PROJECT_NAME: "Dev portal CI"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "dev-portal-${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DEVP }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/ci-docs.yml

@@ -1,6 +1,7 @@
 name: CI docs
 
 on:
+  workflow_dispatch:
   push:
     branches-ignore: master
     paths:
@@ -27,29 +28,27 @@ jobs:
           command: build
           args: --workspace --release --all
       - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
+        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.33" mdbook)
       - name: Install mdbook plugins
         run: |
-          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
+          cargo install --vers "=0.2.2" mdbook-variables && cargo install \
             --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
-            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck && \
-            cargo install --vers "^0.5.0" mdbook-cmdrun
-      - name: Clean website
-        run: cd documentation/docs && mdbook clean
-      - name: Build website
-        run: cd documentation/docs && mdbook build
+            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
+            && cargo install --vers "^0.7.7" mdbook-linkcheck
+      - name: Build all projects in documentation/ & move to ~/dist/docs/
+        run: cd documentation && ./build_all_to_dist.sh
+        continue-on-error: false
       - 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: "documentation/docs/book/"
+          SOURCE: "dist/docs/"
           REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
           REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
           TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/docs-${{ env.GITHUB_REF_SLUG }}
-          EXCLUDE: "/dist/, /node_modules/"
+          EXCLUDE: "/node_modules/"
       - name: Matrix - Node Install
         run: npm install
         working-directory: .github/workflows/support-files

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

@@ -23,7 +23,12 @@ jobs:
         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
       

.github/workflows/connect-mobile.yml

@@ -1,72 +0,0 @@
-name: Nym Connect - mobile (Rust)
-
-on:
-  push:
-    paths:
-      - "nym-connect/mobile/src-tauri/**"
-      - "nym-connect/mobile/src-tauri/Cargo.toml"
-      - "!nym-connect/mobile/src-tauri/gen/**"
-      - "clients/client-core/**"
-      - "clients/socks5/**"
-      - "common/**"
-      - "gateway/gateway-requests/**"
-      - "contracts/vesting/**"
-      - "nym-api/nym-api-requests/**"
-  pull_request:
-    paths:
-      - "nym-connect/mobile/src-tauri/**"
-      - "nym-connect/mobile/src-tauri/Cargo.toml"
-      - "!nym-connect/mobile/src-tauri/gen/**"
-      - "clients/client-core/**"
-      - "clients/socks5/**"
-      - "common/**"
-      - "gateway/gateway-requests/**"
-      - "contracts/vesting/**"
-      - "nym-api/nym-api-requests/**"
-
-jobs:
-  build:
-    #runs-on: [self-hosted, custom-linux]
-    runs-on: ubuntu-22.04
-    #env:
-      #RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
-    #defaults:
-      #run:
-        #working-directory: nym-connect/mobile/src-tauri/
-    steps:
-      - name: Install Dependencies (Linux)
-        run: |
-          sudo apt-get update
-          sudo apt-get -y install \
-          libwebkit2gtk-4.1-dev \
-          build-essential \
-          curl \
-          wget \
-          libssl-dev \
-          libgtk-3-dev \
-          squashfs-tools \
-          libayatana-appindicator3-dev \
-          librsvg2-dev \
-          libsoup-3.0-dev \
-          libjavascriptcoregtk-4.1-dev
-
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: stable
-          components: clippy, rustfmt
-
-      - name: Check formatting
-        run: cargo fmt --manifest-path nym-connect/mobile/src-tauri/Cargo.toml -- --check
-
-      - name: Build all binaries
-        run: cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
-
-      - name: Run all tests
-        run: cargo test  --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
-
-      - name: Clippy
-        run: cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-targets -- -D warnings

.github/workflows/contracts-build.yml

@@ -14,7 +14,7 @@ jobs:
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: 1.69.0
           target: wasm32-unknown-unknown
           override: true
           components: rustfmt, clippy

.github/workflows/contracts.yml

@@ -48,12 +48,12 @@ jobs:
           RUSTFLAGS: '-C link-arg=-s'
         with:
           command: build
-          args: --manifest-path contracts/Cargo.toml --workspace --target wasm32-unknown-unknown
+          args: --manifest-path contracts/Cargo.toml --workspace --lib --target wasm32-unknown-unknown
 
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --manifest-path contracts/Cargo.toml
+          args: --lib --manifest-path contracts/Cargo.toml
 
       - uses: actions-rs/cargo@v1
         with:
@@ -64,4 +64,4 @@ jobs:
         if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
-          args: --manifest-path contracts/Cargo.toml --workspace --all-targets -- -D warnings
+          args: --lib --manifest-path contracts/Cargo.toml --workspace --all-targets -- -D warnings

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

@@ -19,7 +19,7 @@ jobs:
 
     outputs:
       release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
+      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 }}
@@ -31,10 +31,20 @@ jobs:
         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 }}
@@ -78,6 +88,8 @@ jobs:
           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
@@ -103,9 +115,10 @@ jobs:
       - id: release-info
         name: Prepare release info
         run: |
-          semver="${${{ github.ref_name }}##nym-connect-}" && semver="${semver##v}"
-          echo "version=$semver" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-connect_$version_x64.dmg" >> "$GITHUB_OUTPUT"
+          ref=${{ github.ref_name }}
+          semver="${ref##nym-connect-}" && semver="${semver##v}"
+          echo "version=${semver}" >> "$GITHUB_OUTPUT"
+          echo "filename=nym-connect_${semver}_x64.dmg " >> "$GITHUB_OUTPUT"
           echo "file_hash=${{ hashFiles('nym-connect/desktop/target/release/bundle/dmg/nym-connect_*_x64.dmg') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:

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

@@ -19,7 +19,7 @@ jobs:
 
     outputs:
       release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
+      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 }}
@@ -61,6 +61,8 @@ jobs:
         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
@@ -80,9 +82,10 @@ jobs:
       - id: release-info
         name: Prepare release info
         run: |
-          semver="${${{ github.ref_name }}##nym-connect-}" && semver="${semver##v}"
-          echo "version=$semver" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-connect_$version_amd64.AppImage" >> "$GITHUB_OUTPUT"
+          ref=${{ github.ref_name }}
+          semver="${ref##nym-connect-}" && semver="${semver##v}"
+          echo "version=${semver}" >> "$GITHUB_OUTPUT"
+          echo "filename=nym-connect_${semver}_amd64.AppImage" >> "$GITHUB_OUTPUT"
           echo "file_hash=${{ hashFiles('nym-connect/desktop/target/release/bundle/appimage/nym-connect_*_amd64.AppImage') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:

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

@@ -19,7 +19,7 @@ jobs:
 
     outputs:
       release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
+      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 }}
@@ -79,6 +79,8 @@ jobs:
           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
@@ -99,9 +101,10 @@ jobs:
       - id: release-info
         name: Prepare release info
         run: |
-          semver="${${{ github.ref_name }}##nym-connect-}" && semver="${semver##v}"
-          echo "version=$semver" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-connect_$version_x64_en-US.msi" >> "$GITHUB_OUTPUT"
+          ref=${{ github.ref_name }}
+          semver="${ref##nym-connect-}" && semver="${semver##v}"
+          echo "version=${semver}" >> "$GITHUB_OUTPUT"
+          echo "filename=nym-connect_${semver}_x64_en-US.msi" >> "$GITHUB_OUTPUT"
           echo "file_hash=${{ hashFiles('nym-connect/desktop/target/release/bundle/msi/nym-connect_*_x64_en-US.msi') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:

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

@@ -1,104 +0,0 @@
-name: Publish Nym Connect - desktop (MacOS)
-on:
-  workflow_dispatch:
-    inputs:
-      release_tag:
-        required: true
-        description: Release tag (nym-connect-s-v*)
-        type: string
-        default: 'nym-connect-s-v1.0.0'
-  push:
-    tags:
-      - nym-connect-s-v*
-
-defaults:
-  run:
-    working-directory: nym-connect/desktop
-
-jobs:
-  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-s-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [macos-latest]
-    runs-on: ${{ matrix.platform }}
-
-    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
-      - 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: Prepare for build
-        env:
-          RELEASE_TAG: ${{ github.ref_name || inputs.release_tag }}
-        run: ./scripts/pre_medium_build.sh
-
-      - 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 }}
-          NYM_CONNECT_ENABLE_MEDIUM: 1
-        run: yarn && yarn build
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nym-connect-s_1.0.0_x64.dmg
-          path: nym-connect/desktop/target/release/bundle/dmg/nym-connect-s_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*

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

@@ -1,85 +0,0 @@
-name: Publish NymConnect S - desktop (Ubuntu)
-on:
-  workflow_dispatch:
-    inputs:
-      release_tag:
-        required: true
-        description: Release tag (nym-connect-s-v*)
-        type: string
-        default: 'nym-connect-s-v1.0.0'
-  push:
-    tags:
-      - nym-connect-s-v*
-
-defaults:
-  run:
-    working-directory: nym-connect/desktop
-
-jobs:
-  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-s-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [custom-runner-linux]
-    runs-on: ${{ matrix.platform }}
-
-    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: Prepare for build
-        env:
-          RELEASE_TAG: ${{ github.ref_name || inputs.release_tag }}
-        run: ./scripts/pre_medium_build.sh
-
-      - name: Build app
-        run: yarn build
-        env:
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          NYM_CONNECT_ENABLE_MEDIUM: 1
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nym-connect-s.AppImage.tar.gz
-          path: nym-connect/desktop/target/release/bundle/appimage/nym-connect-s_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*

.github/workflows/nym-connect-s-publish-windows10.yml

@@ -1,104 +0,0 @@
-name: Publish Nym Connect - desktop (Windows 10)
-on:
-  workflow_dispatch:
-    inputs:
-      release_tag:
-        required: true
-        description: Release tag (nym-connect-s-v*)
-        type: string
-        default: 'nym-connect-s-v1.0.0'
-  push:
-    tags:
-      - nym-connect-s-v*
-
-defaults:
-  run:
-    working-directory: nym-connect/desktop
-
-jobs:
-  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-s-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        platform: [windows10]
-    runs-on: ${{ matrix.platform }}
-
-    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: Prepare for build
-        env:
-          RELEASE_TAG: ${{ github.ref_name || inputs.release_tag }}
-        run: ./scripts/pre_medium_build.sh
-
-      - 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 }}
-          NYM_CONNECT_ENABLE_MEDIUM: 1
-        run: yarn build
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: nym-connect-s_1.0.0_x64_en-US.msi
-          path: nym-connect/desktop/target/release/bundle/msi/nym-connect-s_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*

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

@@ -19,7 +19,7 @@ jobs:
 
     outputs:
       release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
+      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 }}
@@ -106,7 +106,7 @@ jobs:
           ref=${{ github.ref_name }}
           semver="${ref##nym-wallet-}" && semver="${semver##v}"
           echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-wallet_${version}_x64.dmg" >> "$GITHUB_OUTPUT"
+          echo "filename=nym-wallet_${semver}_x64.dmg" >> "$GITHUB_OUTPUT"
           echo "file_hash=${{ hashFiles('nym-wallet/target/release/bundle/dmg/nym-wallet_*_x64.dmg') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:

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

@@ -19,7 +19,7 @@ jobs:
 
     outputs:
       release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
+      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 }}
@@ -83,7 +83,7 @@ jobs:
           ref=${{ github.ref_name }}
           semver="${ref##nym-wallet-}" && semver="${semver##v}"
           echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-wallet_${version}_amd64.AppImage" >> "$GITHUB_OUTPUT"
+          echo "filename=nym-wallet_${semver}_amd64.AppImage" >> "$GITHUB_OUTPUT"
           echo "file_hash=${{ hashFiles('nym-wallet/target/release/bundle/appimage/nym-wallet_*_amd64.AppImage') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:

.github/workflows/nym-wallet-publish-windows10.yml

@@ -19,7 +19,7 @@ jobs:
 
     outputs:
       release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
+      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 }}
@@ -103,7 +103,7 @@ jobs:
           ref=${{ github.ref_name }}
           semver="${ref##nym-wallet-}" && semver="${semver##v}"
           echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-wallet_${version}_x64_en-US.msi" >> "$GITHUB_OUTPUT"
+          echo "filename=nym-wallet_${semver}_x64_en-US.msi" >> "$GITHUB_OUTPUT"
           echo "file_hash=${{ hashFiles('nym-wallet/target/release/bundle/msi/nym-wallet_*_x64_en-US.msi') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:

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

@@ -0,0 +1,50 @@
+name: Typescript SDK docs
+
+on:
+  push:
+    paths:
+      - "sdk/typescript/**"
+  pull_request:
+    paths:
+      - "sdk/typescript/**"
+
+jobs:
+  build:
+    runs-on: custom-runner-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 Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Setup yarn
+        run: npm install -g yarn
+      - name: Install
+        run: yarn
+      - name: Matrix - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Matrix - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: ts-packages
+          NYM_PROJECT_NAME: "ts-packages"
+          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+          NYM_CI_WWW_LOCATION: "ts-${{ 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/typescript-lint.yml

@@ -7,8 +7,6 @@ on:
       - "sdk/typescript/**"
       - "nym-connect/desktop/src/**"
       - "nym-connect/desktop/package.json"
-      - "nym-connect/mobile/src/**"
-      - "nym-connect/mobile/package.json"
       - "nym-wallet/src/**"
       - "nym-wallet/package.json"
       - "explorer/**"
@@ -18,8 +16,6 @@ on:
       - "sdk/typescript/**"
       - "nym-connect/desktop/src/**"
       - "nym-connect/desktop/package.json"
-      - "nym-connect/mobile/src/**"
-      - "nym-connect/mobile/package.json"
       - "nym-wallet/src/**"
       - "nym-wallet/package.json"
       - "explorer/**"

CHANGELOG.md

@@ -4,6 +4,55 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
+## [1.1.28] (2023-08-22)
+
+- [final step3]: add [rust] support to nyxd client in wasm ([#3743])
+- Feature/ephemera upgrade ([#3791])
+- [rust-sdk] feat: make it more convenient to send and receive messages in different tasks ([#3756])
+- feat: validator client refactoring + wasm compatible nyxd client ([#3726])
+- feat: retain connection between client init and run ([#3767])
+
+[#3743]: https://github.com/nymtech/nym/issues/3743
+[#3791]: https://github.com/nymtech/nym/pull/3791
+[#3756]: https://github.com/nymtech/nym/pull/3756
+[#3726]: https://github.com/nymtech/nym/pull/3726
+[#3767]: https://github.com/nymtech/nym/pull/3767
+
+
+## [1.1.27] (2023-08-16)
+
+- fix serialisation of contract types ([#3752])
+- Investigate spending credentials from the main API (coconut enabled to a gateway) from feature/ephemera branch ([#3741])
+- NymConnect UI stuck in showing "Gateway has issues" ([#3594])
+- [UPDATE] Update MiniBolt community-applications-and-guides dev docs ([#3754])
+
+[#3752]: https://github.com/nymtech/nym/issues/3752
+[#3741]: https://github.com/nymtech/nym/issues/3741
+[#3594]: https://github.com/nymtech/nym/issues/3594
+[#3754]: https://github.com/nymtech/nym/pull/3754
+
+## [v1.1.24] (2023-08-08)
+
+- Latency based gateway selection is serial and slow ([#3710])
+- Network-requester: strip comments from allow lists ([#3625])
+- Remove (or start maintaining) `upgrade` commands from all binaries ([#3600])
+- Set sphinx as default packet type ([#3748])
+- Apply fix from feature/ephemera to develop too (#3698) ([#3742])
+- Feature/coco demos ([#3732])
+- Add updates to community list projects ([#3722])
+- Add geo-aware mixnet topology provider ([#3713])
+- Add updates to community list projects ([#3711])
+
+[#3710]: https://github.com/nymtech/nym/issues/3710
+[#3625]: https://github.com/nymtech/nym/issues/3625
+[#3600]: https://github.com/nymtech/nym/issues/3600
+[#3748]: https://github.com/nymtech/nym/pull/3748
+[#3742]: https://github.com/nymtech/nym/pull/3742
+[#3732]: https://github.com/nymtech/nym/pull/3732
+[#3722]: https://github.com/nymtech/nym/pull/3722
+[#3713]: https://github.com/nymtech/nym/pull/3713
+[#3711]: https://github.com/nymtech/nym/pull/3711
+
 ## [v1.1.23] (2023-07-04)
 
 - nym-cli: add client identity key signing support ([#3576])

Cargo.toml

@@ -34,6 +34,7 @@ members = [
     "common/cosmwasm-smart-contracts/coconut-bandwidth-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",
@@ -74,6 +75,7 @@ members = [
     "common/types",
     "common/wasm-utils",
     "explorer-api",
+    "explorer-api/explorer-api-requests",
     "gateway",
     "gateway/gateway-requests",
     "integrations/bity",
@@ -117,30 +119,39 @@ anyhow = "1.0.71"
 async-trait = "0.1.64"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
 cfg-if = "1.0.0"
-cosmwasm-derive = "=1.2.5"
-cosmwasm-schema = "=1.2.5"
-cosmwasm-std = "=1.2.5"
-cosmwasm-storage = "=1.2.5"
-cosmrs = "=0.8.0"
+cosmwasm-derive = "=1.3.0"
+cosmwasm-schema = "=1.3.0"
+cosmwasm-std = "=1.3.0"
+# use 0.5.0 as that's the version used by cosmwasm-std 1.3.0
+# (and ideally we don't want to pull the same dependency twice)
+serde-json-wasm = "=0.5.0"
+cosmwasm-storage = "=1.3.0"
+cosmrs = "=0.14.0"
+# same version as used by cosmrs
 cw-utils = "=1.0.1"
-cw-storage-plus = "=1.0.1"
-cw2 = { version = "=1.0.1" }
-cw3 = { version = "=1.0.1" }
-cw3-fixed-multisig = { version = "=1.0.1" }
-cw4 = { version = "=1.0.1" }
-cw-controllers = { version = "=1.0.1" }
+cw-storage-plus = "=1.1.0"
+cw2 = { version = "=1.1.0" }
+cw3 = { version = "=1.1.0" }
+cw4 = { version = "=1.1.0" }
+cw-controllers = { version = "=1.1.0" }
 dotenvy = "0.15.6"
+futures = "0.3.28"
 generic-array = "0.14.7"
-k256 = "0.11"
 getrandom = "0.2.10"
+k256 = "0.13"
 lazy_static = "1.4.0"
 log = "0.4"
 once_cell = "1.7.2"
 rand = "0.8.5"
+reqwest = "0.11.18"
 serde = "1.0.152"
 serde_json = "1.0.91"
 tap = "1.0.1"
+tendermint-rpc = "0.32" # same version as used by cosmrs
 thiserror = "1.0.38"
 tokio = "1.24.1"
-url = "2.2"
+url = "2.4"
 zeroize = "1.6.0"
+
+# wasm-related dependencies
+wasmtimer = "0.2.0"

Makefile

@@ -73,7 +73,7 @@ endef
 # Generate targets for the various cargo workspaces
 
 $(eval $(call add_cargo_workspace,main,.))
-$(eval $(call add_cargo_workspace,contracts,contracts,--target wasm32-unknown-unknown))
+$(eval $(call add_cargo_workspace,contracts,contracts,--lib --target wasm32-unknown-unknown))
 $(eval $(call add_cargo_workspace,wasm-client,clients/webassembly,--target wasm32-unknown-unknown))
 $(eval $(call add_cargo_workspace,wallet,nym-wallet,))
 $(eval $(call add_cargo_workspace,connect,nym-connect/desktop))
@@ -104,7 +104,7 @@ NAME_SERVICE_CONTRACT=$(CONTRACTS_OUT_DIR)/nym_name_service.wasm
 wasm: wasm-build wasm-opt
 
 wasm-build:
-	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
+	RUSTFLAGS='-C link-arg=-s' cargo build --lib --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
 
 wasm-opt:
 	wasm-opt --disable-sign-ext -Os $(VESTING_CONTRACT) -o $(VESTING_CONTRACT)
@@ -112,6 +112,9 @@ wasm-opt:
 	wasm-opt --disable-sign-ext -Os $(SERVICE_PROVIDER_DIRECTORY_CONTRACT) -o $(SERVICE_PROVIDER_DIRECTORY_CONTRACT)
 	wasm-opt --disable-sign-ext -Os $(NAME_SERVICE_CONTRACT) -o $(NAME_SERVICE_CONTRACT)
 
+contract-schema:
+	$(MAKE) -C contracts schema
+
 # -----------------------------------------------------------------------------
 # Misc
 # -----------------------------------------------------------------------------

clients/credential/Cargo.toml

@@ -21,5 +21,5 @@ nym-credential-storage = { path = "../../common/credential-storage" }
 nym-bin-common = { path = "../../common/bin-common"}
 nym-network-defaults = { path = "../../common/network-defaults" }
 nym-pemstore = { path = "../../common/pemstore" }
-nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+nym-validator-client = { path = "../../common/client-libs/validator-client" }
 

clients/credential/src/client.rs

@@ -4,14 +4,14 @@
 use crate::error::Result;
 use bip39::Mnemonic;
 use nym_network_defaults::{NymNetworkDetails, VOUCHER_INFO};
-use nym_validator_client::nyxd;
-use nym_validator_client::nyxd::traits::CoconutBandwidthSigningClient;
-use nym_validator_client::nyxd::{Coin, DirectSigningNyxdClient, Fee, NyxdClient};
+use nym_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
+use nym_validator_client::nyxd::{self, DirectSigningHttpRpcNyxdClient};
+use nym_validator_client::nyxd::{Coin, Fee, NyxdClient};
 use std::str::FromStr;
 use url::Url;
 
 pub(crate) struct Client {
-    nyxd_client: NyxdClient<DirectSigningNyxdClient>,
+    nyxd_client: DirectSigningHttpRpcNyxdClient,
     mix_denom_base: String,
 }
 

clients/credential/src/commands.rs

@@ -6,7 +6,7 @@ use log::*;
 use nym_bandwidth_controller::acquire::state::State;
 use nym_bin_common::completions::ArgShell;
 use nym_credential_storage::persistent_storage::PersistentStorage;
-use nym_validator_client::nyxd::traits::DkgQueryClient;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 
 use crate::error::Result;
 use crate::recovery_storage::RecoveryStorage;

clients/credential/src/main.rs

@@ -17,9 +17,9 @@ use std::time::{Duration, SystemTime};
 use clap::{CommandFactory, Parser};
 use nym_bin_common::logging::setup_logging;
 use nym_client_core::config::disk_persistence::CommonClientPaths;
-use nym_validator_client::nyxd::traits::DkgQueryClient;
-use nym_validator_client::nyxd::{Coin, CosmWasmClient};
-use nym_validator_client::Config;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
+use nym_validator_client::nyxd::{Coin, Config};
+use nym_validator_client::DirectSigningHttpRpcNyxdClient;
 
 const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute
 
@@ -34,11 +34,11 @@ struct Cli {
     pub(crate) command: Command,
 }
 
-async fn block_until_coconut_is_available<C: CosmWasmClient + Send + Sync>(
-    client: &nym_validator_client::Client<C>,
+async fn block_until_coconut_is_available<C: DkgQueryClient + Send + Sync>(
+    client: &C,
 ) -> Result<()> {
     loop {
-        let epoch = client.nyxd.get_current_epoch().await?;
+        let epoch = client.get_current_epoch().await?;
         let current_timestamp_secs = SystemTime::now()
             .duration_since(SystemTime::UNIX_EPOCH)?
             .as_secs();
@@ -89,15 +89,18 @@ async fn main() -> Result<()> {
                 r.amount as u128,
                 network_details.chain_details.mix_denom.base,
             );
-            let client =
-                nym_validator_client::Client::new_signing(config, r.mnemonic.parse().unwrap())?;
+            let endpoint = network_details.endpoints[0].nyxd_url.as_str();
+            let client = DirectSigningHttpRpcNyxdClient::connect_with_mnemonic(
+                config,
+                endpoint,
+                r.mnemonic.parse().unwrap(),
+            )?;
 
             block_until_coconut_is_available(&client).await?;
             info!("Starting depositing funds, don't kill the process");
 
             if !r.recovery_mode {
-                let state =
-                    nym_bandwidth_controller::acquire::deposit(&client.nyxd, amount).await?;
+                let state = nym_bandwidth_controller::acquire::deposit(&client, amount).await?;
                 if nym_bandwidth_controller::acquire::get_credential(
                     &state,
                     &client,
@@ -117,7 +120,7 @@ async fn main() -> Result<()> {
                     }
                 }
             } else {
-                recover_credentials(&client.nyxd, &recovery_storage, &shared_storage).await?;
+                recover_credentials(&client, &recovery_storage, &shared_storage).await?;
             }
         }
         Command::Completions(c) => c.generate(&mut Cli::command(), bin_name),

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.23"
+version = "1.1.26"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -14,11 +14,11 @@ path = "src/lib.rs"
 
 [dependencies]
 # dependencies to review:
-futures = "0.3" # bunch of futures stuff, however, now that I think about it, it could perhaps be completely removed
+futures = { workspace = true } # bunch of futures stuff, however, now that I think about it, it could perhaps be completely removed
 # the AsyncRead, AsyncWrite, Stream, Sink, etc. traits could be used from tokio
 # channels should really be replaced with crossbeam due to that implementation being more efficient
 # and the single instance of abortable we have should really be refactored anyway
-url = "2.2"
+url = { workspace = true }
 
 clap = { version = "4.0", features = ["cargo", "derive"] }
 dirs = "4.0"
@@ -28,7 +28,7 @@ pretty_env_logger = "0.4" # for formatting log messages
 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 = "1.0.34"
+thiserror = { workspace = true }
 tap = "1.0.1"
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket
@@ -48,7 +48,7 @@ nym-sphinx = { path = "../../common/nymsphinx" }
 nym-pemstore = { path = "../../common/pemstore" }
 nym-task = { path = "../../common/task" }
 nym-topology = { path = "../../common/topology" }
-nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["http-client"] }
 nym-client-websocket-requests = { path = "websocket-requests" }
 
 [dev-dependencies]

clients/native/src/client/mod.rs

@@ -19,8 +19,7 @@ use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::params::PacketType;
 use nym_task::connections::TransmissionLane;
 use nym_task::TaskManager;
-use nym_validator_client::nyxd::QueryNyxdClient;
-use nym_validator_client::Client;
+use nym_validator_client::QueryHttpRpcNyxdClient;
 use std::error::Error;
 use tokio::sync::watch::error::SendError;
 
@@ -29,7 +28,7 @@ pub use nym_sphinx::receiver::ReconstructedMessage;
 
 pub mod config;
 
-type NativeClientBuilder<'a> = BaseClientBuilder<'a, Client<QueryNyxdClient>, OnDiskPersistent>;
+type NativeClientBuilder<'a> = BaseClientBuilder<'a, QueryHttpRpcNyxdClient, OnDiskPersistent>;
 
 pub struct SocketClient {
     /// Client configuration options, including, among other things, packet sending rates,

clients/native/src/commands/build_info.rs

@@ -0,0 +1,16 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Args;
+use nym_bin_common::bin_info_owned;
+use nym_bin_common::output_format::OutputFormat;
+
+#[derive(Args)]
+pub(crate) struct BuildInfo {
+    #[clap(short, long, default_value_t = OutputFormat::default())]
+    output: OutputFormat,
+}
+
+pub(crate) fn execute(args: BuildInfo) {
+    println!("{}", args.output.format(&bin_info_owned!()))
+}

clients/native/src/commands/init.rs

@@ -174,14 +174,15 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
     let details_store =
         OnDiskGatewayDetails::new(&config.storage_paths.common_paths.gateway_details);
     let init_details = nym_client_core::init::setup_gateway(
-        &gateway_setup,
+        gateway_setup,
         &key_store,
         &details_store,
         register_gateway,
         Some(&config.base.client.nym_api_urls),
     )
     .await
-    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?;
+    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?
+    .details;
 
     let config_save_location = config.default_location();
     config.save_to_default_location().tap_err(|_| {

clients/native/src/commands/mod.rs

@@ -10,7 +10,7 @@ use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use lazy_static::lazy_static;
 use log::{error, info};
-use nym_bin_common::build_information::BinaryBuildInformation;
+use nym_bin_common::bin_info;
 use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_client_core::client::base_client::storage::gateway_details::{
     OnDiskGatewayDetails, PersistedGatewayDetails,
@@ -22,12 +22,12 @@ use nym_config::OptionalSet;
 use std::error::Error;
 use std::net::IpAddr;
 
+pub(crate) mod build_info;
 pub(crate) mod init;
 pub(crate) mod run;
 
 lazy_static! {
-    pub static ref PRETTY_BUILD_INFORMATION: String =
-        BinaryBuildInformation::new(env!("CARGO_PKG_VERSION")).pretty_print();
+    pub static ref PRETTY_BUILD_INFORMATION: String = bin_info!().pretty_print();
 }
 
 // Helper for passing LONG_VERSION to clap
@@ -42,6 +42,10 @@ pub(crate) struct Cli {
     #[clap(short, long)]
     pub(crate) config_env_file: Option<std::path::PathBuf>,
 
+    /// Flag used for disabling the printed banner in tty.
+    #[clap(long)]
+    pub(crate) no_banner: bool,
+
     #[clap(subcommand)]
     command: Commands,
 }
@@ -54,6 +58,9 @@ pub(crate) enum Commands {
     /// Run the Nym client with provided configuration client optionally overriding set parameters
     Run(run::Run),
 
+    /// Show build information of this binary
+    BuildInfo(build_info::BuildInfo),
+
     /// Generate shell completions
     Completions(ArgShell),
 
@@ -73,12 +80,13 @@ pub(crate) struct OverrideConfig {
     enabled_credentials_mode: Option<bool>,
 }
 
-pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn execute(args: Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
     let bin_name = "nym-native-client";
 
-    match &args.command {
-        Commands::Init(m) => init::execute(m).await?,
-        Commands::Run(m) => run::execute(m).await?,
+    match args.command {
+        Commands::Init(m) => init::execute(&m).await?,
+        Commands::Run(m) => run::execute(&m).await?,
+        Commands::BuildInfo(m) => build_info::execute(m),
         Commands::Completions(s) => s.generate(&mut Cli::command(), bin_name),
         Commands::GenerateFigSpec => fig_generate(&mut Cli::command(), bin_name),
     }

clients/native/src/main.rs

@@ -14,10 +14,13 @@ pub mod websocket;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
-    setup_logging();
-    maybe_print_banner(crate_name!(), crate_version!());
-
     let args = commands::Cli::parse();
     setup_env(args.config_env_file.as_ref());
-    commands::execute(&args).await
+
+    if !args.no_banner {
+        maybe_print_banner(crate_name!(), crate_version!());
+    }
+    setup_logging();
+
+    commands::execute(args).await
 }

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.23"
+version = "1.1.26"
 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"
@@ -14,9 +14,9 @@ pretty_env_logger = "0.4"
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
 serde_json = { workspace = true }
 tap = "1.0.1"
-thiserror = "1.0.34"
+thiserror = { workspace = true }
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
-url = "2.2"
+url = { workspace = true }
 
 # internal
 nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }

clients/socks5/src/commands/build_info.rs

@@ -0,0 +1,16 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Args;
+use nym_bin_common::bin_info_owned;
+use nym_bin_common::output_format::OutputFormat;
+
+#[derive(Args)]
+pub(crate) struct BuildInfo {
+    #[clap(short, long, default_value_t = OutputFormat::default())]
+    output: OutputFormat,
+}
+
+pub(crate) fn execute(args: BuildInfo) {
+    println!("{}", args.output.format(&bin_info_owned!()))
+}

clients/socks5/src/commands/init.rs

@@ -94,6 +94,7 @@ impl From<Init> for OverrideConfig {
             use_anonymous_replies: init_config.use_reply_surbs,
             fastmode: init_config.fastmode,
             no_cover: init_config.no_cover,
+            geo_routing: None,
             medium_toggle: false,
             nyxd_urls: init_config.nyxd_urls,
             enabled_credentials_mode: init_config.enabled_credentials_mode,
@@ -185,14 +186,15 @@ pub(crate) async fn execute(args: &Init) -> Result<(), Socks5ClientError> {
     let details_store =
         OnDiskGatewayDetails::new(&config.storage_paths.common_paths.gateway_details);
     let init_details = nym_client_core::init::setup_gateway(
-        &gateway_setup,
+        gateway_setup,
         &key_store,
         &details_store,
         register_gateway,
         Some(&config.core.base.client.nym_api_urls),
     )
     .await
-    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?;
+    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?
+    .details;
 
     // TODO: ask the service provider we specified for its interface version and set it in the config
 

clients/socks5/src/commands/mod.rs

@@ -10,24 +10,25 @@ use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use lazy_static::lazy_static;
 use log::{error, info};
-use nym_bin_common::build_information::BinaryBuildInformation;
+use nym_bin_common::bin_info;
 use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_client_core::client::base_client::storage::gateway_details::{
     OnDiskGatewayDetails, PersistedGatewayDetails,
 };
 use nym_client_core::client::key_manager::persistence::OnDiskKeys;
-use nym_client_core::config::GatewayEndpointConfig;
+use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
+use nym_client_core::config::{GatewayEndpointConfig, TopologyStructure};
 use nym_client_core::error::ClientCoreError;
 use nym_config::OptionalSet;
 use nym_sphinx::params::{PacketSize, PacketType};
 use std::error::Error;
 
+pub(crate) mod build_info;
 pub mod init;
 pub(crate) mod run;
 
 lazy_static! {
-    pub static ref PRETTY_BUILD_INFORMATION: String =
-        BinaryBuildInformation::new(env!("CARGO_PKG_VERSION")).pretty_print();
+    pub static ref PRETTY_BUILD_INFORMATION: String = bin_info!().pretty_print();
 }
 
 // Helper for passing LONG_VERSION to clap
@@ -42,6 +43,10 @@ pub(crate) struct Cli {
     #[clap(short, long)]
     pub(crate) config_env_file: Option<std::path::PathBuf>,
 
+    /// Flag used for disabling the printed banner in tty.
+    #[clap(long)]
+    pub(crate) no_banner: bool,
+
     #[clap(subcommand)]
     command: Commands,
 }
@@ -54,6 +59,9 @@ pub(crate) enum Commands {
     /// Run the Nym client with provided configuration client optionally overriding set parameters
     Run(run::Run),
 
+    /// Show build information of this binary
+    BuildInfo(build_info::BuildInfo),
+
     /// Generate shell completions
     Completions(ArgShell),
 
@@ -68,18 +76,20 @@ pub(crate) struct OverrideConfig {
     use_anonymous_replies: Option<bool>,
     fastmode: bool,
     no_cover: bool,
+    geo_routing: Option<CountryGroup>,
     medium_toggle: bool,
     nyxd_urls: Option<Vec<url::Url>>,
     enabled_credentials_mode: Option<bool>,
     outfox: bool,
 }
 
-pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
+pub(crate) async fn execute(args: Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
     let bin_name = "nym-socks5-client";
 
-    match &args.command {
-        Commands::Init(m) => init::execute(m).await?,
-        Commands::Run(m) => run::execute(m).await?,
+    match args.command {
+        Commands::Init(m) => init::execute(&m).await?,
+        Commands::Run(m) => run::execute(&m).await?,
+        Commands::BuildInfo(m) => build_info::execute(m),
         Commands::Completions(s) => s.generate(&mut Cli::command(), bin_name),
         Commands::GenerateFigSpec => fig_generate(&mut Cli::command(), bin_name),
     }
@@ -91,6 +101,13 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
     let secondary_packet_size = args.medium_toggle.then_some(PacketSize::ExtendedPacket16);
     let no_per_hop_delays = args.medium_toggle;
 
+    let topology_structure = if args.medium_toggle || args.geo_routing.is_some() {
+        // TODO: rethink the default group. I just picked one for now.
+        TopologyStructure::GeoAware(args.geo_routing.unwrap_or(CountryGroup::Europe))
+    } else {
+        TopologyStructure::default()
+    };
+
     let packet_type = if args.outfox {
         PacketType::Outfox
     } else {
@@ -114,6 +131,10 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
         // NOTE: see comment above about the order of the other disble cover traffic config
         .with_base(BaseClientConfig::with_disabled_cover_traffic, args.no_cover)
         .with_base(BaseClientConfig::with_packet_type, packet_type)
+        .with_base(
+            BaseClientConfig::with_topology_structure,
+            topology_structure,
+        )
         .with_optional(Config::with_anonymous_replies, args.use_anonymous_replies)
         .with_optional(Config::with_port, args.port)
         .with_optional_base_custom_env(

clients/socks5/src/commands/run.rs

@@ -11,6 +11,7 @@ use clap::Args;
 use log::*;
 use nym_bin_common::version_checker::is_minor_version_compatible;
 use nym_client_core::client::base_client::storage::OnDiskPersistent;
+use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
 use nym_crypto::asymmetric::identity;
 use nym_socks5_client_core::NymClient;
 use nym_sphinx::addressing::clients::Recipient;
@@ -60,6 +61,10 @@ pub(crate) struct Run {
     #[clap(long, hide = true)]
     no_cover: bool,
 
+    /// Set geo-aware mixnode selection when sending mixnet traffic, for experiments only.
+    #[clap(long, hide = true, value_parser = validate_country_group)]
+    geo_routing: Option<CountryGroup>,
+
     /// Enable medium mixnet traffic, for experiments only.
     /// This includes things like disabling cover traffic, no per hop delays, etc.
     #[clap(long, hide = true)]
@@ -82,6 +87,7 @@ impl From<Run> for OverrideConfig {
             use_anonymous_replies: run_config.use_anonymous_replies,
             fastmode: run_config.fastmode,
             no_cover: run_config.no_cover,
+            geo_routing: run_config.geo_routing,
             medium_toggle: run_config.medium_toggle,
             nyxd_urls: run_config.nyxd_urls,
             enabled_credentials_mode: run_config.enabled_credentials_mode,
@@ -90,6 +96,13 @@ impl From<Run> for OverrideConfig {
     }
 }
 
+fn validate_country_group(s: &str) -> Result<CountryGroup, String> {
+    match s.parse() {
+        Ok(cg) => Ok(cg),
+        Err(_) => Err(format!("failed to parse country group: {}", s)),
+    }
+}
+
 // this only checks compatibility between config the binary. It does not take into consideration
 // network version. It might do so in the future.
 fn version_check(cfg: &Config) -> bool {

clients/socks5/src/main.rs

@@ -13,10 +13,13 @@ pub mod error;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
-    setup_logging();
-    maybe_print_banner(crate_name!(), crate_version!());
-
     let args = commands::Cli::parse();
     setup_env(args.config_env_file.as_ref());
-    commands::execute(&args).await
+
+    if !args.no_banner {
+        maybe_print_banner(crate_name!(), crate_version!());
+    }
+    setup_logging();
+
+    commands::execute(args).await
 }

clients/webassembly/Cargo.toml

@@ -3,7 +3,7 @@ name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
 version = "1.1.1"
 edition = "2021"
-keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
+keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy"]
 license = "Apache-2.0"
 repository = "https://github.com/nymtech/nym"
 description = "A webassembly client which can be used to interact with the the Nym privacy platform. Wasm is used for Sphinx packet generation."
@@ -33,7 +33,7 @@ wasm-bindgen-futures = "0.4"
 thiserror = "1.0.40"
 zeroize = "1.6.0"
 
-wasm-timer = { git = "https://github.com/mmsinclair/wasm-timer", rev = "b9d1a54ad514c2f230a026afe0dde341e98cd7b6"}
+wasmtimer = { version = "0.2.0", features = ["tokio"] }
 
 # internal
 nym-node-tester-utils = { path = "../../common/node-tester-utils" }

clients/webassembly/src/client/config.rs

@@ -246,6 +246,7 @@ impl From<TopologyWasm> for ConfigTopology {
                 topology.topology_resolution_timeout_ms,
             ),
             disable_refreshing: topology.disable_refreshing,
+            topology_structure: Default::default(),
         }
     }
 }

clients/webassembly/src/client/mod.rs

@@ -14,7 +14,6 @@ use crate::storage::traits::FullWasmClientStorage;
 use crate::storage::ClientStorage;
 use crate::topology::WasmNymTopology;
 use js_sys::Promise;
-use nym_bandwidth_controller::wasm_mockups::{Client as FakeClient, DirectSigningNyxdClient};
 use nym_client_core::client::base_client::{
     BaseClientBuilder, ClientInput, ClientOutput, ClientState,
 };
@@ -26,6 +25,7 @@ use nym_task::TaskManager;
 use nym_topology::provider_trait::{HardcodedTopologyProvider, TopologyProvider};
 use nym_topology::NymTopology;
 use nym_validator_client::client::IdentityKey;
+use nym_validator_client::QueryReqwestRpcNyxdClient;
 use rand::rngs::OsRng;
 use rand::RngCore;
 use std::sync::Arc;
@@ -152,7 +152,7 @@ impl NymClientBuilder {
         let maybe_topology_provider = self.topology_provider();
 
         let mut base_builder: BaseClientBuilder<_, FullWasmClientStorage> =
-            BaseClientBuilder::<FakeClient<DirectSigningNyxdClient>, _>::new(
+            BaseClientBuilder::<QueryReqwestRpcNyxdClient, _>::new(
                 &self.config.base,
                 storage,
                 None,

clients/webassembly/src/helpers.rs

@@ -8,7 +8,7 @@ use js_sys::Promise;
 use nym_client_core::client::replies::reply_storage::browser_backend;
 use nym_client_core::config;
 use nym_client_core::init::helpers::current_gateways;
-use nym_client_core::init::{setup_gateway_from, GatewaySetup, InitialisationDetails};
+use nym_client_core::init::{setup_gateway_from, GatewaySetup, InitialisationResult};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_topology::{gateway, NymTopology};
@@ -82,14 +82,14 @@ async fn setup_gateway(
     client_store: &ClientStorage,
     chosen_gateway: Option<IdentityKey>,
     gateways: &[gateway::Node],
-) -> Result<InitialisationDetails, WasmClientError> {
+) -> Result<InitialisationResult, WasmClientError> {
     let setup = if client_store.has_full_gateway_info().await? {
         GatewaySetup::MustLoad
     } else {
         GatewaySetup::new_fresh(chosen_gateway.clone(), None)
     };
 
-    setup_gateway_from(&setup, client_store, client_store, false, Some(gateways))
+    setup_gateway_from(setup, client_store, client_store, false, Some(gateways))
         .await
         .map_err(Into::into)
 }
@@ -98,7 +98,7 @@ pub(crate) async fn setup_gateway_from_api(
     client_store: &ClientStorage,
     chosen_gateway: Option<IdentityKey>,
     nym_apis: &[Url],
-) -> Result<InitialisationDetails, WasmClientError> {
+) -> Result<InitialisationResult, WasmClientError> {
     let mut rng = thread_rng();
     let gateways = current_gateways(&mut rng, nym_apis).await?;
     setup_gateway(client_store, chosen_gateway, &gateways).await
@@ -108,7 +108,7 @@ pub(crate) async fn setup_from_topology(
     explicit_gateway: Option<IdentityKey>,
     topology: &NymTopology,
     client_store: &ClientStorage,
-) -> Result<InitialisationDetails, WasmClientError> {
+) -> Result<InitialisationResult, WasmClientError> {
     let gateways = topology.gateways();
     setup_gateway(client_store, explicit_gateway, gateways).await
 }

clients/webassembly/src/tester/ephemeral_receiver.rs

@@ -10,6 +10,7 @@ use std::collections::HashSet;
 use std::time::Duration;
 use tokio::sync::MutexGuard as AsyncMutexGuard;
 use wasm_utils::{console_error, console_log, console_warn};
+use wasmtimer::tokio::sleep;
 
 pub(crate) struct EphemeralTestReceiver<'a> {
     sent_packets: u32,
@@ -90,7 +91,7 @@ impl<'a> EphemeralTestReceiver<'a> {
     }
 
     pub(crate) async fn perform_test(mut self) -> NodeTestResult {
-        let mut timeout_fut = wasm_timer::Delay::new(self.timeout_duration);
+        let mut timeout_fut = sleep(self.timeout_duration);
 
         loop {
             tokio::select! {

clients/webassembly/src/tester/mod.rs

@@ -12,10 +12,9 @@ use crate::tester::helpers::{
 use crate::topology::WasmNymTopology;
 use futures::channel::mpsc;
 use js_sys::Promise;
-use nym_bandwidth_controller::wasm_mockups::{Client as FakeClient, DirectSigningNyxdClient};
 use nym_bandwidth_controller::BandwidthController;
 use nym_client_core::client::key_manager::ManagedKeys;
-use nym_client_core::init::InitialisationDetails;
+use nym_client_core::init::{InitialisationDetails, InitialisationResult};
 use nym_credential_storage::ephemeral_storage::EphemeralStorage;
 use nym_gateway_client::GatewayClient;
 use nym_node_tester_utils::receiver::SimpleMessageReceiver;
@@ -27,6 +26,7 @@ use nym_sphinx::preparer::PreparedFragment;
 use nym_task::TaskManager;
 use nym_topology::NymTopology;
 use nym_validator_client::client::IdentityKey;
+use nym_validator_client::QueryReqwestRpcNyxdClient;
 use rand::rngs::OsRng;
 use std::collections::HashSet;
 use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
@@ -42,7 +42,7 @@ pub(crate) mod helpers;
 
 pub type NodeTestMessage = TestMessage<WasmTestMessageExt>;
 type LockedGatewayClient =
-    Arc<AsyncMutex<GatewayClient<FakeClient<DirectSigningNyxdClient>, EphemeralStorage>>>;
+    Arc<AsyncMutex<GatewayClient<QueryReqwestRpcNyxdClient, EphemeralStorage>>>;
 
 pub(crate) const DEFAULT_TEST_TIMEOUT: Duration = Duration::from_secs(10);
 pub(crate) const DEFAULT_TEST_PACKETS: u32 = 20;
@@ -78,8 +78,7 @@ pub struct NymNodeTesterBuilder {
     base_topology: NymTopology,
 
     // unimplemented
-    bandwidth_controller:
-        Option<BandwidthController<FakeClient<DirectSigningNyxdClient>, EphemeralStorage>>,
+    bandwidth_controller: Option<BandwidthController<QueryReqwestRpcNyxdClient, EphemeralStorage>>,
 }
 
 fn address(keys: &ManagedKeys, gateway_identity: NodeIdentity) -> Recipient {
@@ -130,9 +129,9 @@ impl NymNodeTesterBuilder {
     async fn gateway_info(
         &self,
         client_store: &ClientStorage,
-    ) -> Result<InitialisationDetails, WasmClientError> {
+    ) -> Result<InitialisationResult, WasmClientError> {
         if let Ok(loaded) = InitialisationDetails::try_load(client_store, client_store).await {
-            Ok(loaded)
+            Ok(loaded.into())
         } else {
             setup_from_topology(self.gateway.clone(), &self.base_topology, client_store).await
         }
@@ -148,26 +147,37 @@ impl NymNodeTesterBuilder {
         };
 
         let client_store = ClientStorage::new_async(&storage_id, None).await?;
-
-        let init_details = self.gateway_info(&client_store).await?;
+        let initialisation_result = self.gateway_info(&client_store).await?;
+        let init_details = initialisation_result.details;
+        let managed_keys = init_details.managed_keys;
         let gateway_endpoint = init_details.gateway_details;
         let gateway_identity = gateway_endpoint.try_get_gateway_identity_key()?;
-        let managed_keys = init_details.managed_keys;
 
         let (mixnet_message_sender, mixnet_message_receiver) = mpsc::unbounded();
         let (ack_sender, ack_receiver) = mpsc::unbounded();
 
-        let mut gateway_client = GatewayClient::new(
-            gateway_endpoint.gateway_listener,
-            managed_keys.identity_keypair(),
-            gateway_identity,
-            Some(managed_keys.must_get_gateway_shared_key()),
-            mixnet_message_sender,
-            ack_sender,
-            Duration::from_secs(10),
-            self.bandwidth_controller.take(),
-            task_manager.subscribe(),
-        );
+        let mut gateway_client =
+            if let Some(existing_client) = initialisation_result.authenticated_ephemeral_client {
+                existing_client.upgrade(
+                    mixnet_message_sender,
+                    ack_sender,
+                    Duration::from_secs(10),
+                    self.bandwidth_controller.take(),
+                    task_manager.subscribe(),
+                )
+            } else {
+                GatewayClient::new(
+                    gateway_endpoint.gateway_listener,
+                    managed_keys.identity_keypair(),
+                    gateway_identity,
+                    Some(managed_keys.must_get_gateway_shared_key()),
+                    mixnet_message_sender,
+                    ack_sender,
+                    Duration::from_secs(10),
+                    self.bandwidth_controller.take(),
+                    task_manager.subscribe(),
+                )
+            };
 
         gateway_client.set_disabled_credentials_mode(true);
         gateway_client.authenticate_and_start().await?;

common/async-file-watcher/Cargo.toml

@@ -8,5 +8,5 @@ edition = "2021"
 [dependencies]
 log = "0.4"
 tokio = { workspace = true, features = ["time"] }
-futures = "0.3"
+futures = { workspace = true }
 notify = "5.1.0"

common/bandwidth-controller/Cargo.toml

@@ -9,7 +9,7 @@ edition = "2021"
 bip39 = { workspace = true }
 rand = "0.7.3"
 thiserror = "1.0"
-url = "2.2"
+url = { workspace = true }
 
 nym-coconut-interface = { path = "../coconut-interface" }
 nym-credential-storage = { path = "../credential-storage" }
@@ -18,7 +18,6 @@ nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric"
 nym-network-defaults = { path = "../network-defaults" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 
-
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
 path = "../client-libs/validator-client"
-features = ["nyxd-client"]
+features = ["http-client"]

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

@@ -8,11 +8,11 @@ use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 use nym_credentials::coconut::utils::obtain_aggregate_signature;
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_network_defaults::VOUCHER_INFO;
-use nym_validator_client::nyxd::traits::CoconutBandwidthSigningClient;
-use nym_validator_client::nyxd::traits::DkgQueryClient;
-use nym_validator_client::nyxd::tx::Hash;
+use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use nym_validator_client::nyxd::Coin;
-use nym_validator_client::CoconutApiClient;
+use nym_validator_client::nyxd::Hash;
 use rand::rngs::OsRng;
 use state::{KeyPair, State};
 use std::str::FromStr;
@@ -21,7 +21,7 @@ pub mod state;
 
 pub async fn deposit<C>(client: &C, amount: Coin) -> Result<State, BandwidthControllerError>
 where
-    C: CoconutBandwidthSigningClient,
+    C: CoconutBandwidthSigningClient + Sync,
 {
     let mut rng = OsRng;
     let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
@@ -70,7 +70,8 @@ where
         .get_current_epoch_threshold()
         .await?
         .ok_or(BandwidthControllerError::NoThreshold)?;
-    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(client, epoch_id).await?;
+
+    let coconut_api_clients = all_coconut_api_clients(client, epoch_id).await?;
 
     let signature = obtain_aggregate_signature(
         &state.params,

common/bandwidth-controller/src/error.rs

@@ -6,15 +6,18 @@ use nym_credential_storage::error::StorageError;
 use nym_credentials::error::Error as CredentialsError;
 use nym_crypto::asymmetric::encryption::KeyRecoveryError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_validator_client::coconut::CoconutApiError;
 use nym_validator_client::error::ValidatorClientError;
 use thiserror::Error;
 
 #[derive(Debug, Error)]
 pub enum BandwidthControllerError {
-    #[cfg(not(target_arch = "wasm32"))]
     #[error("Nyxd error: {0}")]
     Nyxd(#[from] nym_validator_client::nyxd::error::NyxdError),
 
+    #[error("coconut api query failure: {0}")]
+    CoconutApiError(#[from] CoconutApiError),
+
     #[error("There was a credential storage error - {0}")]
     CredentialStorageError(Box<dyn std::error::Error + Send + Sync>),
 

common/bandwidth-controller/src/lib.rs

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::BandwidthControllerError;
-
 use nym_credential_storage::error::StorageError;
 use nym_credential_storage::storage::Storage;
-
+use nym_validator_client::coconut::all_coconut_api_clients;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::str::FromStr;
 use {
     nym_coconut_interface::Base58,
@@ -14,17 +14,8 @@ use {
     },
 };
 
-#[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::traits::DkgQueryClient;
-
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::DkgQueryClient;
-
-#[cfg(not(target_arch = "wasm32"))]
 pub mod acquire;
 pub mod error;
-#[cfg(target_arch = "wasm32")]
-pub mod wasm_mockups;
 
 pub struct BandwidthController<C, St> {
     storage: St,
@@ -64,12 +55,8 @@ impl<C, St: Storage> BandwidthController<C, St> {
         let epoch_id = u64::from_str(&bandwidth_credential.epoch_id)
             .map_err(|_| StorageError::InconsistentData)?;
 
-        #[cfg(not(target_arch = "wasm32"))]
-        let coconut_api_clients =
-            nym_validator_client::CoconutApiClient::all_coconut_api_clients(&self.client, epoch_id)
-                .await?;
-        #[cfg(target_arch = "wasm32")]
-        let coconut_api_clients = vec![];
+        let coconut_api_clients = all_coconut_api_clients(&self.client, epoch_id).await?;
+
         let verification_key = obtain_aggregate_verification_key(&coconut_api_clients).await?;
 
         // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)

common/bandwidth-controller/src/wasm_mockups.rs

@@ -1,17 +0,0 @@
-// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::marker::PhantomData;
-
-pub struct DirectSigningNyxdClient {}
-
-pub trait DkgQueryClient {}
-
-// impl CosmWasmClient for DirectSigningNyxdClient {}
-
-#[derive(Clone)]
-pub struct Client<C> {
-    _phantom: PhantomData<C>,
-}
-
-impl<C> DkgQueryClient for Client<C> {}

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

@@ -5,9 +5,13 @@
 // and be used by our smart contracts
 
 use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Formatter};
 
 #[derive(Debug)]
 pub struct BinaryBuildInformation {
+    /// Provides the name of the binary, i.e. the content of `CARGO_PKG_NAME` environmental variable.
+    pub binary_name: &'static str,
+
     // VERGEN_BUILD_TIMESTAMP
     /// Provides the build timestamp, for example `2021-02-23T20:14:46.558472672+00:00`.
     pub build_timestamp: &'static str,
@@ -43,8 +47,9 @@ pub struct BinaryBuildInformation {
 
 impl BinaryBuildInformation {
     // explicitly require the build_version to be passed as it's binary specific
-    pub const fn new(build_version: &'static str) -> Self {
+    pub const fn new(binary_name: &'static str, build_version: &'static str) -> Self {
         BinaryBuildInformation {
+            binary_name,
             build_timestamp: env!("VERGEN_BUILD_TIMESTAMP"),
             build_version,
             commit_sha: env!("VERGEN_GIT_SHA"),
@@ -58,6 +63,7 @@ impl BinaryBuildInformation {
 
     pub fn to_owned(&self) -> BinaryBuildInformationOwned {
         BinaryBuildInformationOwned {
+            binary_name: self.binary_name.to_owned(),
             build_timestamp: self.build_timestamp.to_owned(),
             build_version: self.build_version.to_owned(),
             commit_sha: self.commit_sha.to_owned(),
@@ -70,39 +76,15 @@ impl BinaryBuildInformation {
     }
 
     pub fn pretty_print(&self) -> String {
-        format!(
-            r#"
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-"#,
-            "Build Timestamp:",
-            self.build_timestamp,
-            "Build Version:",
-            self.build_version,
-            "Commit SHA:",
-            self.commit_sha,
-            "Commit Date:",
-            self.commit_timestamp,
-            "Commit Branch:",
-            self.commit_branch,
-            "rustc Version:",
-            self.rustc_version,
-            "rustc Channel:",
-            self.rustc_channel,
-            "cargo Profile:",
-            self.cargo_profile,
-        )
+        self.to_owned().to_string()
     }
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct BinaryBuildInformationOwned {
+    /// Provides the name of the binary, i.e. the content of `CARGO_PKG_NAME` environmental variable.
+    pub binary_name: String,
+
     // VERGEN_BUILD_TIMESTAMP
     /// Provides the build timestamp, for example `2021-02-23T20:14:46.558472672+00:00`.
     pub build_timestamp: String,
@@ -135,3 +117,62 @@ pub struct BinaryBuildInformationOwned {
     /// Provides the cargo profile that was used for the build, for example `debug`.
     pub cargo_profile: String,
 }
+
+impl Display for BinaryBuildInformationOwned {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            r#"
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+"#,
+            "Binary Name:",
+            self.binary_name,
+            "Build Timestamp:",
+            self.build_timestamp,
+            "Build Version:",
+            self.build_version,
+            "Commit SHA:",
+            self.commit_sha,
+            "Commit Date:",
+            self.commit_timestamp,
+            "Commit Branch:",
+            self.commit_branch,
+            "rustc Version:",
+            self.rustc_version,
+            "rustc Channel:",
+            self.rustc_channel,
+            "cargo Profile:",
+            self.cargo_profile,
+        )
+    }
+}
+
+// since this macro will get expanded at the callsite, it will pull in correct binary version
+#[macro_export]
+macro_rules! bin_info {
+    () => {
+        $crate::build_information::BinaryBuildInformation::new(
+            env!("CARGO_PKG_NAME"),
+            env!("CARGO_PKG_VERSION"),
+        )
+    };
+}
+
+#[macro_export]
+macro_rules! bin_info_owned {
+    () => {
+        $crate::build_information::BinaryBuildInformation::new(
+            env!("CARGO_PKG_NAME"),
+            env!("CARGO_PKG_VERSION"),
+        )
+        .to_owned()
+    };
+}

common/client-core/Cargo.toml

@@ -10,27 +10,29 @@ rust-version = "1.66"
 [dependencies]
 async-trait = { workspace = true }
 base64 = "0.21.2"
-dirs = "4.0"
 dashmap = "5.4.0"
-futures = "0.3"
+dirs = "4.0"
+futures = { workspace = true }
 humantime-serde = "1.0"
 log = { workspace = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+reqwest = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = "0.10.6"
 tap = "1.0.1"
 thiserror = "1.0.34"
-url = { version ="2.2", features = ["serde"] }
-tungstenite = { version = "0.13.0", default-features = false }
-tokio = { version = "1.24.1", features = ["macros"]}
 time = "0.3.17"
+tokio = { version = "1.24.1", features = ["macros"]}
+tungstenite = { version = "0.13.0", default-features = false }
+url = { workspace = true, features = ["serde"] }
 zeroize = { workspace = true }
 
 # internal
 nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
 nym-crypto = { path = "../crypto" }
+nym-explorer-api-requests = { path = "../../explorer-api/explorer-api-requests" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 #gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 nym-gateway-requests = { path = "../../gateway/gateway-requests" }
@@ -43,10 +45,6 @@ nym-task = { path = "../task" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-network-defaults = { path = "../network-defaults" }
 
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
-path = "../client-libs/validator-client"
-features = ["nyxd-client"]
-
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
 version = "0.1.11"
 features = ["time"]
@@ -69,9 +67,9 @@ version = "0.4"
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2.83"
 
-[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-timer]
-git = "https://github.com/mmsinclair/wasm-timer"
-rev = "b9d1a54ad514c2f230a026afe0dde341e98cd7b6"
+[target."cfg(target_arch = \"wasm32\")".dependencies.wasmtimer]
+workspace = true
+features = ["tokio"]
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.gloo-timers]
 version = "0.2.4"

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

@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use super::received_buffer::ReceivedBufferMessage;
+use super::topology_control::geo_aware_provider::GeoAwareTopologyProvider;
+use crate::client::base_client::storage::gateway_details::GatewayDetailsStore;
 use crate::client::base_client::storage::MixnetClientStorage;
 use crate::client::cover_traffic_stream::LoopCoverTrafficStream;
 use crate::client::inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender};
 use crate::client::key_manager::persistence::KeyStore;
-use crate::client::key_manager::ManagedKeys;
 use crate::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
 use crate::client::real_messages_control;
 use crate::client::real_messages_control::RealMessagesController;
@@ -22,8 +23,9 @@ use crate::client::topology_control::nym_api_provider::NymApiTopologyProvider;
 use crate::client::topology_control::{
     TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
-use crate::config::{Config, DebugConfig, GatewayEndpointConfig};
+use crate::config::{Config, DebugConfig};
 use crate::error::ClientCoreError;
+use crate::init::{setup_gateway, GatewaySetup, InitialisationDetails, InitialisationResult};
 use crate::{config, spawn_future};
 use futures::channel::mpsc;
 use log::{debug, info};
@@ -42,18 +44,14 @@ use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
 use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
 use nym_task::{TaskClient, TaskManager};
 use nym_topology::provider_trait::TopologyProvider;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
+use nym_validator_client::NymApiClient;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use std::sync::Arc;
 use tap::TapFallible;
 use url::Url;
 
-#[cfg(target_arch = "wasm32")]
-use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
-
-use crate::client::base_client::storage::gateway_details::GatewayDetailsStore;
-use crate::init::{setup_gateway, GatewaySetup, InitialisationDetails};
-#[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::traits::DkgQueryClient;
-
 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
 pub mod non_wasm_helpers;
 
@@ -199,16 +197,13 @@ where
 
     // note: do **NOT** make this method public as its only valid usage is from within `start_base`
     // because it relies on the crypto keys being already loaded
-    fn mix_address(
-        managed_keys: &ManagedKeys,
-        gateway_config: &GatewayEndpointConfig,
-    ) -> Recipient {
+    fn mix_address(details: &InitialisationDetails) -> Recipient {
         Recipient::new(
-            *managed_keys.identity_public_key(),
-            *managed_keys.encryption_public_key(),
+            *details.managed_keys.identity_public_key(),
+            *details.managed_keys.encryption_public_key(),
             // TODO: below only works under assumption that gateway address == gateway id
             // (which currently is true)
-            NodeIdentity::from_base58_string(&gateway_config.gateway_id).unwrap(),
+            NodeIdentity::from_base58_string(&details.gateway_details.gateway_id).unwrap(),
         )
     }
 
@@ -293,35 +288,56 @@ where
 
     async fn start_gateway_client(
         config: &Config,
-        gateway_config: GatewayEndpointConfig,
-        managed_keys: &ManagedKeys,
+        initialisation_result: InitialisationResult,
         bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
+        api_client: NymApiClient,
         shutdown: TaskClient,
     ) -> Result<GatewayClient<C, S::CredentialStore>, ClientCoreError>
     where
         <S::KeyStore as KeyStore>::StorageError: Send + Sync + 'static,
         <S::CredentialStore as CredentialStorage>::StorageError: Send + Sync + 'static,
     {
-        let gateway_address = gateway_config.gateway_listener.clone();
-        let gateway_id = gateway_config.gateway_id;
+        let managed_keys = initialisation_result.details.managed_keys;
 
-        // TODO: in theory, at this point, this should be infallible
-        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
-            .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;
+        let mut gateway_client =
+            if let Some(existing_client) = initialisation_result.authenticated_ephemeral_client {
+                existing_client.upgrade(
+                    mixnet_message_sender,
+                    ack_sender,
+                    config.debug.gateway_connection.gateway_response_timeout,
+                    bandwidth_controller,
+                    shutdown,
+                )
+            } else {
+                let gateway_config = initialisation_result.details.gateway_details;
 
-        let mut gateway_client = GatewayClient::new(
-            gateway_address,
-            managed_keys.identity_keypair(),
-            gateway_identity,
-            Some(managed_keys.must_get_gateway_shared_key()),
-            mixnet_message_sender,
-            ack_sender,
-            config.debug.gateway_connection.gateway_response_timeout,
-            bandwidth_controller,
-            shutdown,
-        );
+                let gateway_address = gateway_config.gateway_listener.clone();
+                let gateway_id = gateway_config.gateway_id;
+                let gateway_sphinx = gateway_config.gateway_sphinx;
+
+                // TODO: in theory, at this point, this should be infallible
+                let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
+                    .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;
+                let gateway_sphinx_key = encryption::PublicKey::from_base58_string(gateway_sphinx)
+                    .map_err(ClientCoreError::UnableToCreateSphinxKeyFromGatewayId)?;
+
+                GatewayClient::new(
+                    gateway_address,
+                    managed_keys.identity_keypair(),
+                    managed_keys.encryption_keypair(),
+                    gateway_identity,
+                    gateway_sphinx_key,
+                    Some(managed_keys.must_get_gateway_shared_key()),
+                    mixnet_message_sender,
+                    ack_sender,
+                    config.debug.gateway_connection.gateway_response_timeout,
+                    bandwidth_controller,
+                    api_client,
+                    shutdown,
+                )
+            };
 
         gateway_client.set_disabled_credentials_mode(config.client.disabled_credentials_mode);
 
@@ -337,16 +353,31 @@ where
         Ok(gateway_client)
     }
 
+    fn random_api_client(&self) -> nym_validator_client::NymApiClient {
+        let endpoints = self.config.get_nym_api_endpoints();
+        let nym_api = endpoints
+            .choose(&mut thread_rng())
+            .expect("The list of validator apis is empty");
+
+        nym_validator_client::NymApiClient::new(nym_api.clone())
+    }
+
     fn setup_topology_provider(
         custom_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
+        provider_from_config: config::TopologyStructure,
         nym_api_urls: Vec<Url>,
     ) -> Box<dyn TopologyProvider + Send + Sync> {
         // if no custom provider was ... provided ..., create one using nym-api
-        custom_provider.unwrap_or_else(|| {
-            Box::new(NymApiTopologyProvider::new(
+        custom_provider.unwrap_or_else(|| match provider_from_config {
+            config::TopologyStructure::NymApi => Box::new(NymApiTopologyProvider::new(
                 nym_api_urls,
                 env!("CARGO_PKG_VERSION").to_string(),
-            ))
+            )),
+            config::TopologyStructure::GeoAware(group) => Box::new(GeoAwareTopologyProvider::new(
+                nym_api_urls,
+                env!("CARGO_PKG_VERSION").to_string(),
+                group,
+            )),
         })
     }
 
@@ -438,17 +469,23 @@ where
         Ok(mem_store)
     }
 
-    async fn initialise_keys_and_gateway(&self) -> Result<InitialisationDetails, ClientCoreError>
+    async fn initialise_keys_and_gateway(
+        setup_method: GatewaySetup,
+        key_store: &S::KeyStore,
+        details_store: &S::GatewayDetailsStore,
+        overwrite_data: bool,
+        validator_servers: Option<&[Url]>,
+    ) -> Result<InitialisationResult, ClientCoreError>
     where
         <S::KeyStore as KeyStore>::StorageError: Sync + Send,
         <S::GatewayDetailsStore as GatewayDetailsStore>::StorageError: Sync + Send,
     {
         setup_gateway(
-            &self.setup_method,
-            self.client_store.key_store(),
-            self.client_store.gateway_details_store(),
-            false,
-            Some(&self.config.client.nym_api_urls),
+            setup_method,
+            key_store,
+            details_store,
+            overwrite_data,
+            validator_servers,
         )
         .await
     }
@@ -463,10 +500,16 @@ where
     {
         info!("Starting nym client");
 
+        let random_api_client = self.random_api_client();
         // derive (or load) client keys and gateway configuration
-        let details = self.initialise_keys_and_gateway().await?;
-        let gateway_config = details.gateway_details;
-        let managed_keys = details.managed_keys;
+        let init_res = Self::initialise_keys_and_gateway(
+            self.setup_method,
+            self.client_store.key_store(),
+            self.client_store.gateway_details_store(),
+            false,
+            Some(&self.config.client.nym_api_urls),
+        )
+        .await?;
 
         let (reply_storage_backend, credential_store) = self.client_store.into_runtime_stores();
 
@@ -500,17 +543,19 @@ where
         let (reply_controller_sender, reply_controller_receiver) =
             reply_controller::requests::new_control_channels();
 
-        let self_address = Self::mix_address(&managed_keys, &gateway_config);
+        let self_address = Self::mix_address(&init_res.details);
+        let ack_key = init_res.details.managed_keys.ack_key();
+        let encryption_keys = init_res.details.managed_keys.encryption_keypair();
 
         // the components are started in very specific order. Unless you know what you are doing,
         // do not change that.
         let gateway_client = Self::start_gateway_client(
             self.config,
-            gateway_config,
-            &managed_keys,
+            init_res,
             bandwidth_controller,
             mixnet_messages_sender,
             ack_sender,
+            random_api_client,
             task_manager.subscribe(),
         )
         .await?;
@@ -521,8 +566,10 @@ where
 
         let topology_provider = Self::setup_topology_provider(
             self.custom_topology_provider.take(),
+            self.config.debug.topology.topology_structure,
             self.config.get_nym_api_endpoints(),
         );
+
         Self::start_topology_refresher(
             topology_provider,
             self.config.debug.topology,
@@ -532,7 +579,7 @@ where
         .await?;
 
         Self::start_received_messages_buffer_controller(
-            managed_keys.encryption_keypair(),
+            encryption_keys,
             received_buffer_request_receiver,
             mixnet_messages_receiver,
             reply_storage.key_storage(),
@@ -557,7 +604,7 @@ where
 
         let controller_config = real_messages_control::Config::new(
             &self.config.debug,
-            managed_keys.ack_key(),
+            Arc::clone(&ack_key),
             self_address,
         );
 
@@ -584,7 +631,7 @@ where
         {
             Self::start_cover_traffic_stream(
                 &self.config.debug,
-                managed_keys.ack_key(),
+                ack_key,
                 self_address,
                 shared_topology_accessor.clone(),
                 message_sender,

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

@@ -10,8 +10,8 @@ use crate::error::ClientCoreError;
 use log::{error, info};
 use nym_bandwidth_controller::BandwidthController;
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_validator_client::nyxd::QueryNyxdClient;
-use nym_validator_client::Client;
+use nym_validator_client::nyxd;
+use nym_validator_client::QueryHttpRpcNyxdClient;
 use std::path::Path;
 use std::{fs, io};
 use time::OffsetDateTime;
@@ -104,48 +104,38 @@ pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
 pub fn create_bandwidth_controller<St: CredentialStorage>(
     config: &Config,
     storage: St,
-) -> BandwidthController<Client<QueryNyxdClient>, St> {
+) -> BandwidthController<QueryHttpRpcNyxdClient, St> {
     let nyxd_url = config
         .get_validator_endpoints()
         .pop()
         .expect("No nyxd validator endpoint provided");
-    let api_url = config
-        .get_nym_api_endpoints()
-        .pop()
-        .expect("No validator api endpoint provided");
 
-    create_bandwidth_controller_with_urls(nyxd_url, api_url, storage)
+    create_bandwidth_controller_with_urls(nyxd_url, storage)
 }
 
 pub fn create_bandwidth_controller_with_urls<St: CredentialStorage>(
     nyxd_url: Url,
-    nym_api_url: Url,
     storage: St,
-) -> BandwidthController<Client<QueryNyxdClient>, St> {
-    let client = default_query_dkg_client(nyxd_url, nym_api_url);
+) -> BandwidthController<QueryHttpRpcNyxdClient, St> {
+    let client = default_query_dkg_client(nyxd_url);
 
     BandwidthController::new(storage, client)
 }
 
-pub fn default_query_dkg_client_from_config(config: &Config) -> Client<QueryNyxdClient> {
+pub fn default_query_dkg_client_from_config(config: &Config) -> QueryHttpRpcNyxdClient {
     let nyxd_url = config
         .get_validator_endpoints()
         .pop()
         .expect("No nyxd validator endpoint provided");
-    let api_url = config
-        .get_nym_api_endpoints()
-        .pop()
-        .expect("No validator api endpoint provided");
 
-    default_query_dkg_client(nyxd_url, api_url)
+    default_query_dkg_client(nyxd_url)
 }
 
-pub fn default_query_dkg_client(nyxd_url: Url, nym_api_url: Url) -> Client<QueryNyxdClient> {
+pub fn default_query_dkg_client(nyxd_url: Url) -> QueryHttpRpcNyxdClient {
     let details = nym_network_defaults::NymNetworkDetails::new_from_env();
-    let mut client_config = nym_validator_client::Config::try_from_nym_network_details(&details)
+    let client_config = nyxd::Config::try_from_nym_network_details(&details)
         .expect("failed to construct validator client config");
     // overwrite env configuration with config URLs
-    client_config = client_config.with_urls(nyxd_url, nym_api_url);
-    nym_validator_client::Client::new_query(client_config)
+    QueryHttpRpcNyxdClient::connect(client_config, nyxd_url.as_str())
         .expect("Could not construct query client")
 }

common/client-core/src/client/cover_traffic_stream.rs

@@ -19,10 +19,10 @@ use std::time::Duration;
 use tokio::sync::mpsc::error::TrySendError;
 
 #[cfg(not(target_arch = "wasm32"))]
-use tokio::time;
+use tokio::time::{sleep, Sleep};
 
 #[cfg(target_arch = "wasm32")]
-use wasm_timer;
+use wasmtimer::tokio::{sleep, Sleep};
 
 pub struct LoopCoverTrafficStream<R>
 where
@@ -39,11 +39,7 @@ where
 
     /// Internal state, determined by `average_message_sending_delay`,
     /// used to keep track of when a next packet should be sent out.
-    #[cfg(not(target_arch = "wasm32"))]
-    next_delay: Pin<Box<time::Sleep>>,
-
-    #[cfg(target_arch = "wasm32")]
-    next_delay: Pin<Box<wasm_timer::Delay>>,
+    next_delay: Pin<Box<Sleep>>,
 
     /// Channel used for sending prepared nym packets to `MixTrafficController` that sends them
     /// out to the network without any further delays.
@@ -90,17 +86,9 @@ where
 
         // The next interval value is `next_poisson_delay` after the one that just
         // yielded.
-        #[cfg(not(target_arch = "wasm32"))]
-        {
-            let now = self.next_delay.deadline();
-            let next = now + next_poisson_delay;
-            self.next_delay.as_mut().reset(next);
-        }
-
-        #[cfg(target_arch = "wasm32")]
-        {
-            self.next_delay.as_mut().reset(next_poisson_delay);
-        }
+        let now = self.next_delay.deadline();
+        let next = now + next_poisson_delay;
+        self.next_delay.as_mut().reset(next);
 
         Poll::Ready(Some(()))
     }
@@ -120,11 +108,7 @@ impl LoopCoverTrafficStream<OsRng> {
     ) -> Self {
         let rng = OsRng;
 
-        #[cfg(not(target_arch = "wasm32"))]
-        let next_delay = Box::pin(time::sleep(Default::default()));
-
-        #[cfg(target_arch = "wasm32")]
-        let next_delay = Box::pin(wasm_timer::Delay::new(Default::default()));
+        let next_delay = Box::pin(sleep(Default::default()));
 
         LoopCoverTrafficStream {
             ack_key,
@@ -142,12 +126,7 @@ impl LoopCoverTrafficStream<OsRng> {
     }
 
     fn set_next_delay(&mut self, amount: Duration) {
-        #[cfg(not(target_arch = "wasm32"))]
-        let next_delay = Box::pin(time::sleep(amount));
-
-        #[cfg(target_arch = "wasm32")]
-        let next_delay = Box::pin(wasm_timer::Delay::new(amount));
-
+        let next_delay = Box::pin(sleep(amount));
         self.next_delay = next_delay;
     }
 

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

@@ -2,13 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use std::time::Duration;
-use wasm_timer;
 
-pub use wasm_timer::*;
+pub use wasmtimer::{std::Instant, tokio::*};
 pub type IntervalStream = gloo_timers::future::IntervalStream;
 
 pub(crate) fn get_time_now() -> Instant {
-    wasm_timer::Instant::now()
+    Instant::now()
 }
 
 pub(crate) fn new_interval_stream(polling_rate: Duration) -> IntervalStream {

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

@@ -3,15 +3,10 @@
 
 use crate::spawn_future;
 use log::*;
+use nym_credential_storage::storage::Storage;
 use nym_gateway_client::GatewayClient;
 use nym_sphinx::forwarding::packet::MixPacket;
-
-use nym_credential_storage::storage::Storage;
-#[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::traits::DkgQueryClient;
-
-#[cfg(target_arch = "wasm32")]
-use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 
 pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
 pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;

common/client-core/src/client/real_messages_control/real_traffic_stream.rs

@@ -27,9 +27,10 @@ use std::sync::Arc;
 use std::time::Duration;
 
 #[cfg(not(target_arch = "wasm32"))]
-use tokio::time;
+use tokio::time::{sleep, Sleep};
+
 #[cfg(target_arch = "wasm32")]
-use wasm_timer;
+use wasmtimer::tokio::{sleep, Sleep};
 
 mod sending_delay_controller;
 
@@ -82,11 +83,7 @@ where
 
     /// Internal state, determined by `average_message_sending_delay`,
     /// used to keep track of when a next packet should be sent out.
-    #[cfg(not(target_arch = "wasm32"))]
-    next_delay: Option<Pin<Box<time::Sleep>>>,
-
-    #[cfg(target_arch = "wasm32")]
-    next_delay: Option<Pin<Box<wasm_timer::Delay>>>,
+    next_delay: Option<Pin<Box<Sleep>>>,
 
     // To make sure we don't overload the mix_tx channel, we limit the rate we are pushing
     // messages.
@@ -373,17 +370,9 @@ where
 
             // The next interval value is `next_poisson_delay` after the one that just
             // yielded.
-            #[cfg(not(target_arch = "wasm32"))]
-            {
-                let now = next_delay.deadline();
-                let next = now + next_poisson_delay;
-                next_delay.as_mut().reset(next);
-            }
-
-            #[cfg(target_arch = "wasm32")]
-            {
-                next_delay.as_mut().reset(next_poisson_delay);
-            }
+            let now = next_delay.deadline();
+            let next = now + next_poisson_delay;
+            next_delay.as_mut().reset(next);
 
             // On every iteration we get new messages from upstream. Given that these come bunched
             // in `Vec`, this ensures that on average we will fetch messages faster than we can
@@ -421,12 +410,7 @@ where
                 self.config.traffic.message_sending_average_delay,
             );
 
-            #[cfg(not(target_arch = "wasm32"))]
-            let next_delay = Box::pin(time::sleep(sampled));
-
-            #[cfg(target_arch = "wasm32")]
-            let next_delay = Box::pin(wasm_timer::Delay::new(sampled));
-
+            let next_delay = Box::pin(sleep(sampled));
             self.next_delay = Some(next_delay);
 
             Poll::Pending

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

@@ -83,6 +83,16 @@ impl<'a> TopologyReadPermit<'a> {
 
         Ok(topology)
     }
+
+    pub fn try_get_raw_topology_ref(&'a self) -> Result<&'a NymTopology, NymTopologyError> {
+        // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
+        let topology = self
+            .permit
+            .as_ref()
+            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
+
+        Ok(topology)
+    }
 }
 
 impl<'a> From<RwLockReadGuard<'a, Option<NymTopology>>> for TopologyReadPermit<'a> {

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

@@ -0,0 +1,319 @@
+use std::{collections::HashMap, fmt};
+
+use log::{debug, error, info};
+use nym_explorer_api_requests::PrettyDetailedMixNodeBond;
+use nym_topology::{
+    nym_topology_from_detailed,
+    provider_trait::{async_trait, TopologyProvider},
+    NymTopology,
+};
+use nym_validator_client::client::MixId;
+use rand::{prelude::SliceRandom, thread_rng};
+use serde::{Deserialize, Serialize};
+use url::Url;
+
+const MIN_NODES_PER_LAYER: usize = 1;
+const EXPLORER_API_MIXNODES_URL: &str = "https://explorer.nymtech.net/api/v1/mix-nodes";
+
+// TODO: create a explorer-api-client
+async fn fetch_mixnodes_from_explorer_api() -> Option<Vec<PrettyDetailedMixNodeBond>> {
+    reqwest::get(EXPLORER_API_MIXNODES_URL)
+        .await
+        .ok()?
+        .json::<Vec<PrettyDetailedMixNodeBond>>()
+        .await
+        .ok()
+}
+
+#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
+pub enum CountryGroup {
+    Europe,
+    NorthAmerica,
+    SouthAmerica,
+    Oceania,
+    Asia,
+    Africa,
+    Unknown,
+}
+
+impl CountryGroup {
+    // We map contry codes into group, which initially are continent codes to a first approximation,
+    // but we do it manually to reserve the right to tweak this distribution for our purposes.
+    fn new(country_code: &str) -> Self {
+        let country_code = country_code.to_uppercase();
+        use CountryGroup::*;
+        match country_code.as_ref() {
+            // Europe
+            "AT" => Europe,
+            "BG" => Europe,
+            "CH" => Europe,
+            "CY" => Europe,
+            "CZ" => Europe,
+            "DE" => Europe,
+            "DK" => Europe,
+            "ES" => Europe,
+            "FI" => Europe,
+            "FR" => Europe,
+            "GB" => Europe,
+            "GR" => Europe,
+            "IE" => Europe,
+            "IT" => Europe,
+            "LT" => Europe,
+            "LU" => Europe,
+            "LV" => Europe,
+            "MD" => Europe,
+            "MT" => Europe,
+            "NL" => Europe,
+            "NO" => Europe,
+            "PL" => Europe,
+            "RO" => Europe,
+            "SE" => Europe,
+            "SK" => Europe,
+            "TR" => Europe,
+            "UA" => Europe,
+
+            // North America
+            "CA" => NorthAmerica,
+            "MX" => NorthAmerica,
+            "US" => NorthAmerica,
+
+            // South America
+            "AR" => SouthAmerica,
+            "BR" => SouthAmerica,
+            "CL" => SouthAmerica,
+            "CO" => SouthAmerica,
+            "CR" => SouthAmerica,
+            "GT" => SouthAmerica,
+
+            // Oceania
+            "AU" => Oceania,
+
+            // Asia
+            "AM" => Asia,
+            "BH" => Asia,
+            "CN" => Asia,
+            "GE" => Asia,
+            "HK" => Asia,
+            "ID" => Asia,
+            "IL" => Asia,
+            "IN" => Asia,
+            "JP" => Asia,
+            "KH" => Asia,
+            "KR" => Asia,
+            "KZ" => Asia,
+            "MY" => Asia,
+            "RU" => Asia,
+            "SG" => Asia,
+            "TH" => Asia,
+            "VN" => Asia,
+
+            // Africa
+            "SC" => Africa,
+            "UG" => Africa,
+            "ZA" => Africa,
+
+            // And group level codes work too
+            "EU" => Europe,
+            "NA" => NorthAmerica,
+            "SA" => SouthAmerica,
+            "OC" => Oceania,
+            "AS" => Asia,
+            "AF" => Africa,
+
+            // And some aliases
+            "EUROPE" => Europe,
+            "NORTHAMERICA" => NorthAmerica,
+            "SOUTHAMERICA" => SouthAmerica,
+            "OCEANIA" => Oceania,
+            "ASIA" => Asia,
+            "AFRICA" => Africa,
+
+            _ => {
+                info!("Unknown country code: {}", country_code);
+                Unknown
+            }
+        }
+    }
+}
+
+impl fmt::Display for CountryGroup {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use CountryGroup::*;
+        match self {
+            Europe => write!(f, "EU"),
+            NorthAmerica => write!(f, "NA"),
+            SouthAmerica => write!(f, "SA"),
+            Oceania => write!(f, "OC"),
+            Asia => write!(f, "AS"),
+            Africa => write!(f, "AF"),
+            Unknown => write!(f, "Unknown"),
+        }
+    }
+}
+
+impl std::str::FromStr for CountryGroup {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let group = CountryGroup::new(s);
+        if group == CountryGroup::Unknown {
+            Err(())
+        } else {
+            Ok(group)
+        }
+    }
+}
+
+impl CountryGroup {
+    #[allow(unused)]
+    fn known(self) -> Option<CountryGroup> {
+        use CountryGroup::*;
+        match self {
+            Europe | NorthAmerica | SouthAmerica | Oceania | Asia | Africa => Some(self),
+            Unknown => None,
+        }
+    }
+}
+
+fn group_mixnodes_by_country_code(
+    mixnodes: Vec<PrettyDetailedMixNodeBond>,
+) -> HashMap<CountryGroup, Vec<MixId>> {
+    mixnodes
+        .into_iter()
+        .fold(HashMap::<CountryGroup, Vec<MixId>>::new(), |mut acc, m| {
+            if let Some(ref location) = m.location {
+                let country_code = location.two_letter_iso_country_code.clone();
+                let group_code = CountryGroup::new(country_code.as_str());
+                let mixnodes = acc.entry(group_code).or_insert_with(Vec::new);
+                mixnodes.push(m.mix_id);
+            }
+            acc
+        })
+}
+
+fn log_mixnode_distribution(mixnodes: &HashMap<CountryGroup, Vec<MixId>>) {
+    let mixnode_distribution = mixnodes
+        .iter()
+        .map(|(k, v)| format!("{}: {}", k, v.len()))
+        .collect::<Vec<_>>()
+        .join(", ");
+    debug!("Mixnode distribution - {}", mixnode_distribution);
+}
+
+fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {
+    let mixes = topology.mixes();
+    if mixes.keys().len() < 3 {
+        error!("Layer is missing in topology!");
+        return Err(());
+    }
+    for (layer, mixnodes) in mixes {
+        debug!("Layer {:?} has {} mixnodes", layer, mixnodes.len());
+        if mixnodes.len() < MIN_NODES_PER_LAYER {
+            error!(
+                "There are only {} mixnodes in layer {:?}",
+                mixnodes.len(),
+                layer
+            );
+            return Err(());
+        }
+    }
+    Ok(())
+}
+
+pub struct GeoAwareTopologyProvider {
+    validator_client: nym_validator_client::client::NymApiClient,
+    filter_on: CountryGroup,
+    client_version: String,
+}
+
+impl GeoAwareTopologyProvider {
+    pub fn new(
+        mut nym_api_urls: Vec<Url>,
+        client_version: String,
+        filter_on: CountryGroup,
+    ) -> GeoAwareTopologyProvider {
+        log::info!(
+            "Creating geo-aware topology provider with filter on {:?}",
+            filter_on
+        );
+        nym_api_urls.shuffle(&mut thread_rng());
+
+        GeoAwareTopologyProvider {
+            validator_client: nym_validator_client::client::NymApiClient::new(
+                nym_api_urls[0].clone(),
+            ),
+            filter_on,
+            client_version,
+        }
+    }
+
+    async fn get_topology(&self) -> Option<NymTopology> {
+        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
+            Err(err) => {
+                error!("failed to get network mixnodes - {err}");
+                return None;
+            }
+            Ok(mixes) => mixes,
+        };
+
+        let gateways = match self.validator_client.get_cached_gateways().await {
+            Err(err) => {
+                error!("failed to get network gateways - {err}");
+                return None;
+            }
+            Ok(gateways) => gateways,
+        };
+
+        // Also fetch mixnodes cached by explorer-api, with the purpose of getting their
+        // geolocation.
+        debug!("Fetching mixnodes from explorer-api...");
+        let Some(mixnodes_from_explorer_api) = fetch_mixnodes_from_explorer_api().await else {
+            error!("failed to get mixnodes from explorer-api");
+            return None;
+        };
+
+        // Partition mixnodes_from_explorer_api according to the value of
+        // two_letter_iso_country_code.
+        // NOTE: we construct the full distribution here, but only use the one we're interested in.
+        // The reason we this instead of a straight filter is that this opens up the possibility to
+        // complement a small grouping with mixnodes from adjecent countries.
+        let mixnode_distribution = group_mixnodes_by_country_code(mixnodes_from_explorer_api);
+        log_mixnode_distribution(&mixnode_distribution);
+
+        let Some(filtered_mixnode_ids) = mixnode_distribution.get(&self.filter_on) else {
+            error!("no mixnodes found for: {}", self.filter_on);
+            return None;
+        };
+
+        let mixnodes = mixnodes
+            .into_iter()
+            .filter(|m| filtered_mixnode_ids.contains(&m.mix_id()))
+            .collect::<Vec<_>>();
+
+        let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .filter_system_version(&self.client_version);
+
+        // TODO: return real error type
+        check_layer_integrity(topology.clone()).ok()?;
+
+        Some(topology)
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[async_trait]
+impl TopologyProvider for GeoAwareTopologyProvider {
+    // this will be manually refreshed on a timer specified inside mixnet client config
+    async fn get_new_topology(&mut self) -> Option<NymTopology> {
+        self.get_topology().await
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+#[async_trait(?Send)]
+impl TopologyProvider for GeoAwareTopologyProvider {
+    // this will be manually refreshed on a timer specified inside mixnet client config
+    async fn get_new_topology(&mut self) -> Option<NymTopology> {
+        self.get_topology().await
+    }
+}

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

@@ -9,8 +9,9 @@ use nym_topology::provider_trait::TopologyProvider;
 use nym_topology::NymTopologyError;
 use std::time::Duration;
 
-mod accessor;
-pub(crate) mod nym_api_provider;
+pub mod accessor;
+pub mod geo_aware_provider;
+pub mod nym_api_provider;
 
 // TODO: move it to config later
 const MAX_FAILURE_COUNT: usize = 10;

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

@@ -9,7 +9,7 @@ use rand::prelude::SliceRandom;
 use rand::thread_rng;
 use url::Url;
 
-pub(crate) struct NymApiTopologyProvider {
+pub struct NymApiTopologyProvider {
     validator_client: nym_validator_client::client::NymApiClient,
     nym_api_urls: Vec<Url>,
 
@@ -18,7 +18,7 @@ pub(crate) struct NymApiTopologyProvider {
 }
 
 impl NymApiTopologyProvider {
-    pub(crate) fn new(mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
+    pub fn new(mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
         nym_api_urls.shuffle(&mut thread_rng());
 
         NymApiTopologyProvider {
@@ -77,13 +77,34 @@ impl NymApiTopologyProvider {
             Ok(gateways) => gateways,
         };
 
+        let all_mixes = match self.validator_client.get_all_mixnodes().await {
+            Err(err) => {
+                error!("failed to get all mixes - {err}");
+                return None;
+            }
+            Ok(epoch) => epoch,
+        };
+
+        let all_gateways = match self.validator_client.get_all_gateways().await {
+            Err(err) => {
+                error!("failed to get all gateways - {err}");
+                return None;
+            }
+            Ok(epoch) => epoch,
+        };
+
         let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .with_all_mixes(all_mixes.clone())
+            .with_all_gateways(all_gateways.clone())
             .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}");
             self.use_next_nym_api();
-            None
+            let empty_topology = NymTopology::empty()
+                .with_all_mixes(all_mixes)
+                .with_all_gateways(all_gateways);
+            Some(empty_topology)
         } else {
             Some(topology)
         }

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

@@ -2,13 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_config::defaults::NymNetworkDetails;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::{encryption, identity};
 use nym_sphinx::params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
 
-use crate::error::ClientCoreError;
+use crate::{client::topology_control::geo_aware_provider::CountryGroup, error::ClientCoreError};
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;
 
@@ -158,6 +158,15 @@ impl Config {
         self
     }
 
+    pub fn with_topology_structure(mut self, topology_structure: TopologyStructure) -> Self {
+        self.set_topology_structure(topology_structure);
+        self
+    }
+
+    pub fn set_topology_structure(&mut self, topology_structure: TopologyStructure) {
+        self.debug.topology.topology_structure = topology_structure;
+    }
+
     pub fn with_no_per_hop_delays(mut self, no_per_hop_delays: bool) -> Self {
         if no_per_hop_delays {
             self.set_no_per_hop_delays()
@@ -207,6 +216,8 @@ pub struct GatewayEndpointConfig {
     /// If initially omitted, a random gateway will be chosen from the available topology.
     pub gateway_id: String,
 
+    pub gateway_sphinx: String,
+
     /// Address of the gateway owner to which the client should send messages.
     pub gateway_owner: String,
 
@@ -219,11 +230,13 @@ impl GatewayEndpointConfig {
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen(constructor))]
     pub fn new(
         gateway_id: String,
+        gateway_sphinx: String,
         gateway_owner: String,
         gateway_listener: String,
     ) -> GatewayEndpointConfig {
         GatewayEndpointConfig {
             gateway_id,
+            gateway_sphinx,
             gateway_owner,
             gateway_listener,
         }
@@ -236,6 +249,11 @@ impl GatewayEndpointConfig {
         identity::PublicKey::from_base58_string(&self.gateway_id)
             .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)
     }
+
+    pub fn try_get_gateway_sphinx_key(&self) -> Result<encryption::PublicKey, ClientCoreError> {
+        encryption::PublicKey::from_base58_string(&self.gateway_sphinx)
+            .map_err(ClientCoreError::UnableToCreateSphinxKeyFromGatewayId)
+    }
 }
 
 impl From<nym_topology::gateway::Node> for GatewayEndpointConfig {
@@ -243,6 +261,7 @@ impl From<nym_topology::gateway::Node> for GatewayEndpointConfig {
         let gateway_listener = node.clients_address();
         GatewayEndpointConfig {
             gateway_id: node.identity_key.to_base58_string(),
+            gateway_sphinx: node.sphinx_key.to_base58_string(),
             gateway_owner: node.owner,
             gateway_listener,
         }
@@ -466,6 +485,16 @@ pub struct Topology {
     /// the first valid instance.
     /// Supersedes `topology_refresh_rate_ms`.
     pub disable_refreshing: bool,
+
+    /// Specifies the mixnode topology to be used for sending packets.
+    pub topology_structure: TopologyStructure,
+}
+
+#[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TopologyStructure {
+    #[default]
+    NymApi,
+    GeoAware(CountryGroup),
 }
 
 impl Default for Topology {
@@ -474,6 +503,7 @@ impl Default for Topology {
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
             disable_refreshing: false,
+            topology_structure: TopologyStructure::default(),
         }
     }
 }

common/client-core/src/config/old_config_v1_1_20.rs

@@ -68,6 +68,7 @@ pub struct ConfigV1_1_20<T> {
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
 pub struct GatewayEndpointConfigV1_1_20 {
     pub gateway_id: String,
+    pub gateway_sphinx: String,
     pub gateway_owner: String,
     pub gateway_listener: String,
 }
@@ -76,6 +77,7 @@ impl From<GatewayEndpointConfigV1_1_20> for GatewayEndpointConfigV1_1_20_2 {
     fn from(value: GatewayEndpointConfigV1_1_20) -> Self {
         GatewayEndpointConfigV1_1_20_2 {
             gateway_id: value.gateway_id,
+            gateway_sphinx: value.gateway_sphinx,
             gateway_owner: value.gateway_owner,
             gateway_listener: value.gateway_listener,
         }

common/client-core/src/config/old_config_v1_1_20_2.rs

@@ -73,6 +73,8 @@ pub struct GatewayEndpointConfigV1_1_20_2 {
     /// If initially omitted, a random gateway will be chosen from the available topology.
     pub gateway_id: String,
 
+    pub gateway_sphinx: String,
+
     /// Address of the gateway owner to which the client should send messages.
     pub gateway_owner: String,
 
@@ -84,6 +86,7 @@ impl From<GatewayEndpointConfigV1_1_20_2> for GatewayEndpointConfig {
     fn from(value: GatewayEndpointConfigV1_1_20_2) -> Self {
         GatewayEndpointConfig {
             gateway_id: value.gateway_id,
+            gateway_sphinx: value.gateway_sphinx,
             gateway_owner: value.gateway_owner,
             gateway_listener: value.gateway_listener,
         }
@@ -267,6 +270,7 @@ impl From<TopologyV1_1_20_2> for Topology {
             topology_refresh_rate: value.topology_refresh_rate,
             topology_resolution_timeout: value.topology_resolution_timeout,
             disable_refreshing: value.disable_refreshing,
+            topology_structure: Default::default(),
         }
     }
 }

common/client-core/src/error.rs

@@ -1,6 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use nym_crypto::asymmetric::encryption::KeyRecoveryError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use nym_gateway_client::error::GatewayClientError;
 use nym_topology::gateway::GatewayConversionError;
@@ -58,6 +59,9 @@ pub enum ClientCoreError {
     #[error("The gateway id is invalid - {0}")]
     UnableToCreatePublicKeyFromGatewayId(Ed25519RecoveryError),
 
+    #[error("The gateway sphinx is invalid - {0}")]
+    UnableToCreateSphinxKeyFromGatewayId(KeyRecoveryError),
+
     #[error("The identity of the gateway is unknown - did you run init?")]
     GatewayIdUnknown,
 

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

@@ -3,20 +3,19 @@
 
 use crate::config::GatewayEndpointConfig;
 use crate::error::ClientCoreError;
+use crate::init::RegistrationResult;
 use futures::{SinkExt, StreamExt};
 use log::{debug, info, trace, warn};
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::{encryption, identity};
 use nym_gateway_client::GatewayClient;
-use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_topology::{filter::VersionFilterable, gateway};
+use nym_validator_client::NymApiClient;
 use rand::{seq::SliceRandom, Rng};
 use std::{sync::Arc, time::Duration};
 use tap::TapFallible;
 use tungstenite::Message;
 use url::Url;
 
-#[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::DirectSigningNyxdClient;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::net::TcpStream;
 #[cfg(not(target_arch = "wasm32"))]
@@ -27,17 +26,20 @@ use tokio_tungstenite::connect_async;
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 #[cfg(not(target_arch = "wasm32"))]
 type WsConn = WebSocketStream<MaybeTlsStream<TcpStream>>;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time::sleep;
 
-#[cfg(target_arch = "wasm32")]
-use nym_bandwidth_controller::wasm_mockups::DirectSigningNyxdClient;
-#[cfg(target_arch = "wasm32")]
-use wasm_timer::Instant;
 #[cfg(target_arch = "wasm32")]
 use wasm_utils::websocket::JSWebsocket;
+#[cfg(target_arch = "wasm32")]
+use wasmtimer::std::Instant;
+#[cfg(target_arch = "wasm32")]
+use wasmtimer::tokio::sleep;
 
 #[cfg(target_arch = "wasm32")]
 type WsConn = JSWebsocket;
 
+const CONCURRENT_GATEWAYS_MEASURED: usize = 20;
 const MEASUREMENTS: usize = 3;
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -124,15 +126,9 @@ async fn measure_latency(gateway: &gateway::Node) -> Result<GatewayWithLatency,
             Ok::<(), ClientCoreError>(())
         };
 
-        // thanks to wasm we can't use tokio::time::timeout : (
-        #[cfg(not(target_arch = "wasm32"))]
-        let timeout = tokio::time::sleep(PING_TIMEOUT);
-        #[cfg(not(target_arch = "wasm32"))]
+        let timeout = sleep(PING_TIMEOUT);
         tokio::pin!(timeout);
 
-        #[cfg(target_arch = "wasm32")]
-        let mut timeout = wasm_timer::Delay::new(PING_TIMEOUT);
-
         tokio::select! {
             _ = &mut timeout => {
                 warn!("timed out while trying to perform measurement...")
@@ -158,23 +154,29 @@ pub(super) async fn choose_gateway_by_latency<R: Rng>(
     rng: &mut R,
     gateways: &[gateway::Node],
 ) -> Result<gateway::Node, ClientCoreError> {
-    info!("choosing gateway by latency...");
+    info!(
+        "choosing gateway by latency, pinging {} gateways ...",
+        gateways.len()
+    );
 
-    let mut gateways_with_latency = Vec::new();
-    for gateway in gateways {
-        let id = *gateway.identity();
-        trace!("measuring latency to {id}...");
-        let with_latency = match measure_latency(gateway).await {
-            Ok(res) => res,
-            Err(err) => {
-                warn!("failed to measure {id}: {err}");
-                continue;
-            }
-        };
-        debug!("{id}: {:?}", with_latency.latency);
-        gateways_with_latency.push(with_latency)
-    }
+    let gateways_with_latency = Arc::new(tokio::sync::Mutex::new(Vec::new()));
+    futures::stream::iter(gateways)
+        .for_each_concurrent(CONCURRENT_GATEWAYS_MEASURED, |gateway| async {
+            let id = *gateway.identity();
+            trace!("measuring latency to {id}...");
+            match measure_latency(gateway).await {
+                Ok(with_latency) => {
+                    debug!("{id}: {:?}", with_latency.latency);
+                    gateways_with_latency.lock().await.push(with_latency);
+                }
+                Err(err) => {
+                    warn!("failed to measure {id}: {err}");
+                }
+            };
+        })
+        .await;
 
+    let gateways_with_latency = gateways_with_latency.lock().await;
     let chosen = gateways_with_latency
         .choose_weighted(rng, |item| 1. / item.latency.as_secs_f32())
         .expect("invalid selection weight!");
@@ -200,13 +202,18 @@ pub(super) fn uniformly_random_gateway<R: Rng>(
 pub(super) async fn register_with_gateway(
     gateway: &GatewayEndpointConfig,
     our_identity: Arc<identity::KeyPair>,
-) -> Result<Arc<SharedKeys>, ClientCoreError> {
+    our_sphinx: Arc<encryption::KeyPair>,
+    nym_api_client: NymApiClient,
+) -> Result<RegistrationResult, ClientCoreError> {
     let timeout = Duration::from_millis(1500);
-    let mut gateway_client: GatewayClient<DirectSigningNyxdClient, _> = GatewayClient::new_init(
+    let mut gateway_client = GatewayClient::new_init(
         gateway.gateway_listener.clone(),
         gateway.try_get_gateway_identity_key()?,
+        gateway.try_get_gateway_sphinx_key()?,
         our_identity.clone(),
+        our_sphinx.clone(),
         timeout,
+        nym_api_client,
     );
     gateway_client
         .establish_connection()
@@ -216,5 +223,8 @@ pub(super) async fn register_with_gateway(
         .perform_initial_authentication()
         .await
         .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
-    Ok(shared_keys)
+    Ok(RegistrationResult {
+        shared_keys,
+        authenticated_ephemeral_client: Some(gateway_client),
+    })
 }

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

@@ -14,16 +14,41 @@ use crate::{
     error::ClientCoreError,
 };
 use nym_crypto::asymmetric::identity;
+use nym_gateway_client::client::InitOnly;
+use nym_gateway_client::GatewayClient;
+use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_sphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
 use nym_topology::gateway;
 use nym_validator_client::client::IdentityKey;
+use nym_validator_client::NymApiClient;
 use rand::rngs::OsRng;
+use rand::seq::SliceRandom;
 use serde::Serialize;
 use std::fmt::{Debug, Display};
+use std::sync::Arc;
 use url::Url;
 
 pub mod helpers;
 
+pub struct RegistrationResult {
+    pub shared_keys: Arc<SharedKeys>,
+    pub authenticated_ephemeral_client: Option<GatewayClient<InitOnly>>,
+}
+
+pub struct InitialisationResult {
+    pub details: InitialisationDetails,
+    pub authenticated_ephemeral_client: Option<GatewayClient<InitOnly>>,
+}
+
+impl From<InitialisationDetails> for InitialisationResult {
+    fn from(details: InitialisationDetails) -> Self {
+        InitialisationResult {
+            details,
+            authenticated_ephemeral_client: None,
+        }
+    }
+}
+
 // TODO: rename to something better...
 #[derive(Debug)]
 pub struct InitialisationDetails {
@@ -74,7 +99,6 @@ impl InitialisationDetails {
     }
 }
 
-#[derive(Debug, Clone)]
 pub enum GatewaySetup {
     /// The gateway specification MUST BE loaded from the underlying storage.
     MustLoad,
@@ -92,6 +116,13 @@ pub enum GatewaySetup {
         /// Full gateway configuration
         details: PersistedGatewayDetails,
     },
+    ReuseConnection {
+        /// The authenticated ephemeral client that was created during `init`
+        authenticated_ephemeral_client: GatewayClient<InitOnly>,
+
+        /// Details of this pre-initialised client
+        details: InitialisationDetails,
+    },
 }
 
 impl From<PersistedGatewayDetails> for GatewaySetup {
@@ -266,18 +297,33 @@ fn ensure_valid_details(
 }
 
 pub async fn setup_gateway_from<K, D>(
-    setup: &GatewaySetup,
+    setup: GatewaySetup,
     key_store: &K,
     details_store: &D,
     overwrite_data: bool,
     gateways: Option<&[gateway::Node]>,
-) -> Result<InitialisationDetails, ClientCoreError>
+    nym_api_client: NymApiClient,
+) -> Result<InitialisationResult, ClientCoreError>
 where
     K: KeyStore,
     D: GatewayDetailsStore,
     K::StorageError: Send + Sync + 'static,
     D::StorageError: Send + Sync + 'static,
 {
+    // I don't like how we can't deal with this variant in the match below, but we need to take ownership of internal values.
+    if let GatewaySetup::ReuseConnection {
+        authenticated_ephemeral_client,
+        details,
+    } = setup
+    {
+        // if we have already performed the full setup, forward the details.
+        // it's up to the caller to ensure persistence
+        return Ok(InitialisationResult {
+            details,
+            authenticated_ephemeral_client: Some(authenticated_ephemeral_client),
+        });
+    }
+
     let mut rng = OsRng;
 
     // try load gateway details
@@ -286,14 +332,14 @@ where
     // try load keys and decide what to do based on the GatewaySetup
     let mut managed_keys = match ManagedKeys::try_load(key_store).await {
         Ok(loaded_keys) => {
-            match setup {
+            match &setup {
                 GatewaySetup::MustLoad => {
                     // get EVERYTHING from the storage
                     let details = loaded_details?;
                     ensure_valid_details(&details, &loaded_keys)?;
 
                     // no need to persist anything as we got everything from the storage
-                    return Ok(InitialisationDetails::new(details.into(), loaded_keys));
+                    return Ok(InitialisationDetails::new(details.into(), loaded_keys).into());
                 }
                 GatewaySetup::Predefined { details } => {
                     // we already have defined gateway details AND a shared key
@@ -304,10 +350,9 @@ where
                         _store_gateway_details(details_store, details).await?;
                     }
 
-                    return Ok(InitialisationDetails::new(
-                        details.clone().into(),
-                        loaded_keys,
-                    ));
+                    return Ok(
+                        InitialisationDetails::new(details.clone().into(), loaded_keys).into(),
+                    );
                 }
                 GatewaySetup::Specified { gateway_identity } => {
                     // if that data was already stored...
@@ -323,7 +368,8 @@ where
                             return Ok(InitialisationDetails::new(
                                 existing_gateway.into(),
                                 loaded_keys,
-                            ));
+                            )
+                            .into());
                         }
                     }
 
@@ -341,7 +387,8 @@ where
                         return Ok(InitialisationDetails::new(
                             existing_gateway.into(),
                             loaded_keys,
-                        ));
+                        )
+                        .into());
                     }
 
                     // we didn't get full details from the store and we have loaded some keys
@@ -352,6 +399,9 @@ where
                         return Err(ClientCoreError::ForbiddenKeyOverwrite);
                     }
                 }
+                GatewaySetup::ReuseConnection { .. } => {
+                    unreachable!("the reuse connection variant was already manually covered")
+                }
             }
         }
         Err(_) => {
@@ -370,8 +420,13 @@ where
     // get our identity key
     let our_identity = managed_keys.identity_keypair();
 
+    let our_sphinx = managed_keys.encryption_keypair();
+
     // Establish connection, authenticate and generate keys for talking with the gateway
-    let shared_keys = helpers::register_with_gateway(&gateway_details, our_identity).await?;
+    let registration_result =
+        helpers::register_with_gateway(&gateway_details, our_identity, our_sphinx, nym_api_client)
+            .await?;
+    let shared_keys = registration_result.shared_keys;
 
     let persisted_details = PersistedGatewayDetails::new(gateway_details, &shared_keys);
 
@@ -386,19 +441,19 @@ where
     // persist gateway config
     _store_gateway_details(details_store, &persisted_details).await?;
 
-    Ok(InitialisationDetails::new(
-        persisted_details.into(),
-        managed_keys,
-    ))
+    Ok(InitialisationResult {
+        details: InitialisationDetails::new(persisted_details.into(), managed_keys),
+        authenticated_ephemeral_client: registration_result.authenticated_ephemeral_client,
+    })
 }
 
 pub async fn setup_gateway<K, D>(
-    setup: &GatewaySetup,
+    setup: GatewaySetup,
     key_store: &K,
     details_store: &D,
     overwrite_data: bool,
     validator_servers: Option<&[Url]>,
-) -> Result<InitialisationDetails, ClientCoreError>
+) -> Result<InitialisationResult, ClientCoreError>
 where
     K: KeyStore,
     D: GatewayDetailsStore,
@@ -408,12 +463,19 @@ where
     let mut rng = OsRng;
     let gateways = current_gateways(&mut rng, validator_servers.unwrap_or_default()).await?;
 
+    let nym_api = validator_servers
+        .unwrap_or_default()
+        .choose(&mut rng)
+        .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
+    let client = nym_validator_client::client::NymApiClient::new(nym_api.clone());
+
     setup_gateway_from(
         setup,
         key_store,
         details_store,
         overwrite_data,
         Some(&gateways),
+        client,
     )
     .await
 }

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

@@ -9,10 +9,10 @@ edition = "2021"
 [dependencies]
 # TODO: (for this and other crates), similarly to 'tokio', import only required "futures" modules rather than
 # the entire crate
-futures = "0.3"
+futures = { workspace = true }
 log = { workspace = true }
-thiserror = "1.0"
-url = "2.2"
+thiserror = { workspace = true }
+url = { workspace = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 tokio = { version = "1.24.1", features = ["macros"] }
 
@@ -25,7 +25,7 @@ nym-gateway-requests = { path = "../../../gateway/gateway-requests" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-sphinx = { path = "../../nymsphinx" }
 nym-pemstore = { path = "../../pemstore" }
-nym-validator-client = { path = "../validator-client" }
+nym-validator-client = { path = "../validator-client", default-features = false }
 nym-task = { path = "../../task" }
 serde = { workspace = true, features = ["derive"] }
 
@@ -35,6 +35,9 @@ version = "0.13"
 default-features = false
 
 # non-wasm-only dependencies
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-noise]
+path = "../../nymnoise"
+
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
 version = "1.24.1"
 features = ["macros", "rt", "net", "sync", "time"]
@@ -58,9 +61,9 @@ path = "../../wasm-utils"
 features = ["websocket"]
 
 # only import it in wasm. Prefer proper tokio timer in non-wasm
-[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-timer]
-git = "https://github.com/mmsinclair/wasm-timer"
-rev = "b9d1a54ad514c2f230a026afe0dde341e98cd7b6"
+[target."cfg(target_arch = \"wasm32\")".dependencies.wasmtimer]
+workspace = true
+features = ["tokio"]
 
 # this is due to tungstenite using `rand` 0.8 and associated changes in `getrandom` crate
 # which now does not support wasm32-unknown-unknown target by default.

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

@@ -1,4 +1,4 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::GatewayClientError;
@@ -14,7 +14,7 @@ use nym_bandwidth_controller::BandwidthController;
 use nym_coconut_interface::Credential;
 use nym_credential_storage::ephemeral_storage::EphemeralStorage as EphemeralCredentialStorage;
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::{encryption, identity};
 use nym_gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
 use nym_gateway_requests::iv::IV;
 use nym_gateway_requests::registration::handshake::{client_handshake, SharedKeys};
@@ -22,6 +22,8 @@ use nym_gateway_requests::{BinaryRequest, ClientControlRequest, ServerResponse,
 use nym_network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_task::TaskClient;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
+use nym_validator_client::NymApiClient;
 use rand::rngs::OsRng;
 use std::convert::TryFrom;
 use std::sync::Arc;
@@ -29,32 +31,39 @@ use std::time::Duration;
 use tungstenite::protocol::Message;
 
 #[cfg(not(target_arch = "wasm32"))]
-use nym_validator_client::nyxd::traits::DkgQueryClient;
+use nym_noise::upgrade_noise_initiator;
 #[cfg(not(target_arch = "wasm32"))]
-use tokio_tungstenite::connect_async;
+use std::net::SocketAddr;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::net::TcpStream;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time::sleep;
+#[cfg(not(target_arch = "wasm32"))]
+use tokio_tungstenite::client_async;
 
-#[cfg(target_arch = "wasm32")]
-use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
-#[cfg(target_arch = "wasm32")]
-use wasm_timer;
 #[cfg(target_arch = "wasm32")]
 use wasm_utils::websocket::JSWebsocket;
+#[cfg(target_arch = "wasm32")]
+use wasmtimer::tokio::sleep;
 
 const DEFAULT_RECONNECTION_ATTEMPTS: usize = 10;
 const DEFAULT_RECONNECTION_BACKOFF: Duration = Duration::from_secs(5);
 
-pub struct GatewayClient<C, St> {
+pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
     authenticated: bool,
     disabled_credentials_mode: bool,
     bandwidth_remaining: i64,
     gateway_address: String,
     gateway_identity: identity::PublicKey,
+    gateway_sphinx: encryption::PublicKey,
     local_identity: Arc<identity::KeyPair>,
+    local_sphinx: Arc<encryption::KeyPair>,
     shared_key: Option<Arc<SharedKeys>>,
     connection: SocketState,
     packet_router: PacketRouter,
     response_timeout_duration: Duration,
     bandwidth_controller: Option<BandwidthController<C, St>>,
+    nym_api_client: NymApiClient,
 
     // reconnection related variables
     /// Specifies whether client should try to reconnect to gateway on connection failure.
@@ -75,13 +84,16 @@ impl<C, St> GatewayClient<C, St> {
     pub fn new(
         gateway_address: String,
         local_identity: Arc<identity::KeyPair>,
+        local_sphinx: Arc<encryption::KeyPair>,
         gateway_identity: identity::PublicKey,
+        gateway_sphinx: encryption::PublicKey,
         // TODO: make it mandatory. if you don't want to pass it, use `new_init`
         shared_key: Option<Arc<SharedKeys>>,
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         response_timeout_duration: Duration,
         bandwidth_controller: Option<BandwidthController<C, St>>,
+        nym_api_client: NymApiClient,
         shutdown: TaskClient,
     ) -> Self {
         GatewayClient {
@@ -89,13 +101,16 @@ impl<C, St> GatewayClient<C, St> {
             disabled_credentials_mode: true,
             bandwidth_remaining: 0,
             gateway_address,
-            gateway_identity,
             local_identity,
+            local_sphinx,
+            gateway_identity,
+            gateway_sphinx,
             shared_key,
             connection: SocketState::NotConnected,
             packet_router: PacketRouter::new(ack_sender, mixnet_message_sender, shutdown.clone()),
             response_timeout_duration,
             bandwidth_controller,
+            nym_api_client,
             should_reconnect_on_failure: true,
             reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
             reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
@@ -163,7 +178,59 @@ impl<C, St> GatewayClient<C, St> {
 
     #[cfg(not(target_arch = "wasm32"))]
     pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
-        let ws_stream = match connect_async(&self.gateway_address).await {
+        let socket_addr: SocketAddr = self.gateway_address.parse().unwrap();
+        let connection_fut = TcpStream::connect(socket_addr);
+
+        //arbitrary TO, it's a POC
+        let noise_conn = match tokio::time::timeout(Duration::from_secs(5), connection_fut).await {
+            Ok(stream_res) => match stream_res {
+                Ok(stream) => {
+                    debug!("Managed to establish connection to gateway");
+                    let current_epoch_id = match self.nym_api_client.get_current_epoch_id().await {
+                        Ok(epoch_id) => epoch_id,
+                        Err(err) => {
+                            error!("Failed to retrieve epoch Id for Noise handshake - {err}");
+                            return Err(GatewayClientError::ConnectionNotEstablished);
+                        }
+                    };
+
+                    let noise_stream = match upgrade_noise_initiator(
+                        stream,
+                        None, //as a client, the gateway cannot know my pub key
+                        &self.local_sphinx.private_key().to_bytes(),
+                        &self.gateway_sphinx.to_bytes(),
+                        current_epoch_id,
+                    )
+                    .await
+                    {
+                        Ok(noise_stream) => noise_stream,
+                        Err(err) => {
+                            error!(
+                                "Failed to perform Noise handshake with {:?} - {err}",
+                                self.gateway_address
+                            );
+                            return Err(GatewayClientError::ConnectionNotEstablished);
+                        }
+                    };
+                    debug!(
+                        "Noise initiator handshake completed for {:?}",
+                        self.gateway_address
+                    );
+                    noise_stream
+                }
+                Err(err) => {
+                    debug!("failed to establish connection to gateway (err: {})", err);
+                    return Err(GatewayClientError::NetworkIoError(err));
+                }
+            },
+            Err(_) => {
+                debug!("failed to connect to {} within 5s", self.gateway_address);
+                return Err(GatewayClientError::Timeout);
+            }
+        };
+        let ws_address = format!("ws://{}", self.gateway_address);
+
+        let ws_stream = match client_async(ws_address, noise_conn).await {
             Ok((ws_stream, _)) => ws_stream,
             Err(e) => return Err(GatewayClientError::NetworkError(e)),
         };
@@ -197,16 +264,7 @@ impl<C, St> GatewayClient<C, St> {
                 return Ok(());
             }
 
-            #[cfg(not(target_arch = "wasm32"))]
-            tokio::time::sleep(self.reconnection_backoff).await;
-
-            #[cfg(target_arch = "wasm32")]
-            if let Err(err) = wasm_timer::Delay::new(self.reconnection_backoff).await {
-                error!(
-                    "the timer has gone away while in reconnection backoff! - {}",
-                    err
-                );
-            }
+            sleep(self.reconnection_backoff).await;
         }
 
         // final attempt (done separately to be able to return a proper error)
@@ -235,16 +293,9 @@ impl<C, St> GatewayClient<C, St> {
             _ => return Err(GatewayClientError::ConnectionInInvalidState),
         };
 
-        #[cfg(not(target_arch = "wasm32"))]
-        let timeout = tokio::time::sleep(self.response_timeout_duration);
-        #[cfg(not(target_arch = "wasm32"))]
+        let timeout = sleep(self.response_timeout_duration);
         tokio::pin!(timeout);
 
-        // technically the `wasm_timer` also works outside wasm, but unless required,
-        // I really prefer to just stick to tokio
-        #[cfg(target_arch = "wasm32")]
-        let mut timeout = wasm_timer::Delay::new(self.response_timeout_duration);
-
         loop {
             tokio::select! {
                 _ = self.shutdown.recv() => {
@@ -484,6 +535,14 @@ impl<C, St> GatewayClient<C, St> {
     pub async fn perform_initial_authentication(
         &mut self,
     ) -> Result<Arc<SharedKeys>, GatewayClientError> {
+        if self.authenticated {
+            return if let Some(shared_key) = &self.shared_key {
+                Ok(Arc::clone(shared_key))
+            } else {
+                Err(GatewayClientError::AuthenticationFailure)
+            };
+        }
+
         if self.shared_key.is_some() {
             self.authenticate(None).await?;
         } else {
@@ -768,13 +827,18 @@ impl<C, St> GatewayClient<C, St> {
     }
 }
 
-impl<C> GatewayClient<C, EphemeralCredentialStorage> {
+pub struct InitOnly;
+
+impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
     // for initialisation we do not need credential storage. Though it's still a bit weird we have to set the generic...
     pub fn new_init(
         gateway_address: String,
         gateway_identity: identity::PublicKey,
+        gateway_sphinx: encryption::PublicKey,
         local_identity: Arc<identity::KeyPair>,
+        local_sphinx: Arc<encryption::KeyPair>,
         response_timeout_duration: Duration,
+        nym_api_client: NymApiClient,
     ) -> Self {
         use futures::channel::mpsc;
 
@@ -785,22 +849,61 @@ impl<C> GatewayClient<C, EphemeralCredentialStorage> {
         let shutdown = TaskClient::dummy();
         let packet_router = PacketRouter::new(ack_tx, mix_tx, shutdown.clone());
 
-        GatewayClient::<C, EphemeralCredentialStorage> {
+        GatewayClient {
             authenticated: false,
             disabled_credentials_mode: true,
             bandwidth_remaining: 0,
             gateway_address,
             gateway_identity,
+            gateway_sphinx,
             local_identity,
+            local_sphinx,
             shared_key: None,
             connection: SocketState::NotConnected,
             packet_router,
             response_timeout_duration,
             bandwidth_controller: None,
+            nym_api_client,
             should_reconnect_on_failure: false,
             reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
             reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
             shutdown,
         }
     }
+
+    pub fn upgrade<C, St>(
+        self,
+        mixnet_message_sender: MixnetMessageSender,
+        ack_sender: AcknowledgementSender,
+        response_timeout_duration: Duration,
+        bandwidth_controller: Option<BandwidthController<C, St>>,
+        shutdown: TaskClient,
+    ) -> GatewayClient<C, St> {
+        // invariants that can't be broken
+        // (unless somebody decided to expose some field that wasn't meant to be exposed)
+        assert!(self.authenticated);
+        assert!(self.connection.is_available());
+        assert!(self.shared_key.is_some());
+
+        GatewayClient {
+            authenticated: self.authenticated,
+            disabled_credentials_mode: self.disabled_credentials_mode,
+            bandwidth_remaining: self.bandwidth_remaining,
+            gateway_address: self.gateway_address,
+            gateway_identity: self.gateway_identity,
+            gateway_sphinx: self.gateway_sphinx,
+            local_sphinx: self.local_sphinx,
+            local_identity: self.local_identity,
+            shared_key: self.shared_key,
+            connection: self.connection,
+            packet_router: PacketRouter::new(ack_sender, mixnet_message_sender, shutdown.clone()),
+            response_timeout_duration,
+            bandwidth_controller,
+            nym_api_client: self.nym_api_client,
+            should_reconnect_on_failure: self.should_reconnect_on_failure,
+            reconnection_attempts: self.reconnection_attempts,
+            reconnection_backoff: self.reconnection_backoff,
+            shutdown,
+        }
+    }
 }

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

@@ -19,6 +19,9 @@ pub enum GatewayClientError {
     #[error("There was a network error - {0}")]
     NetworkError(#[from] WsError),
 
+    #[error("There was a network error - {0}")]
+    NetworkIoError(#[from] io::Error),
+
     // TODO: see if `JsValue` is a reasonable type for this
     #[cfg(target_arch = "wasm32")]
     #[error("There was a network error")]

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

@@ -14,9 +14,9 @@ use std::sync::Arc;
 use tungstenite::Message;
 
 #[cfg(not(target_arch = "wasm32"))]
-use tokio::net::TcpStream;
+use nym_noise::NoiseStream;
 #[cfg(not(target_arch = "wasm32"))]
-use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+use tokio_tungstenite::WebSocketStream;
 
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen_futures;
@@ -26,7 +26,7 @@ use wasm_utils::websocket::JSWebsocket;
 // type alias for not having to type the whole thing every single time (and now it makes it easier
 // to use different types based on compilation target)
 #[cfg(not(target_arch = "wasm32"))]
-type WsConn = WebSocketStream<MaybeTlsStream<TcpStream>>;
+type WsConn = WebSocketStream<NoiseStream>;
 
 #[cfg(target_arch = "wasm32")]
 type WsConn = JSWebsocket;

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

@@ -7,7 +7,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-futures = "0.3"
+futures = { workspace = true }
 log = { workspace = true }
 tokio = { version = "1.24.1", features = ["time", "net", "rt"] }
 tokio-util = { version = "0.7.4", features = ["codec"] }
@@ -15,3 +15,7 @@ tokio-util = { version = "0.7.4", features = ["codec"] }
 # internal
 nym-sphinx = { path = "../../nymsphinx" }
 nym-task = { path = "../../task" }
+nym-client-core = { path = "../../client-core" }
+nym-noise = { path = "../../nymnoise"}
+nym-crypto = { path = "../../crypto" }
+nym-validator-client = { path = "../validator-client"}

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

@@ -4,11 +4,15 @@
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
+use nym_client_core::client::topology_control::accessor::TopologyAccessor;
+use nym_crypto::asymmetric::encryption;
+use nym_noise::upgrade_noise_initiator_with_topology;
 use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx::framing::codec::NymCodec;
 use nym_sphinx::framing::packet::FramedNymPacket;
 use nym_sphinx::params::PacketType;
 use nym_sphinx::NymPacket;
+use nym_validator_client::NymApiClient;
 use std::collections::HashMap;
 use std::io;
 use std::net::SocketAddr;
@@ -59,6 +63,9 @@ pub trait SendWithoutResponse {
 pub struct Client {
     conn_new: HashMap<NymNodeRoutingAddress, ConnectionSender>,
     config: Config,
+    topology_access: TopologyAccessor,
+    api_client: NymApiClient,
+    local_identity: Arc<encryption::KeyPair>,
 }
 
 struct ConnectionSender {
@@ -76,10 +83,18 @@ impl ConnectionSender {
 }
 
 impl Client {
-    pub fn new(config: Config) -> Client {
+    pub fn new(
+        config: Config,
+        topology_access: TopologyAccessor,
+        api_client: NymApiClient,
+        local_identity: Arc<encryption::KeyPair>,
+    ) -> Client {
         Client {
             conn_new: HashMap::new(),
             config,
+            topology_access,
+            api_client,
+            local_identity,
         }
     }
 
@@ -88,6 +103,10 @@ impl Client {
         receiver: mpsc::Receiver<FramedNymPacket>,
         connection_timeout: Duration,
         current_reconnection: &AtomicU32,
+        topology_access: TopologyAccessor,
+        api_client: NymApiClient,
+        local_public_key: &[u8],
+        local_private_key: &[u8],
     ) {
         let connection_fut = TcpStream::connect(address);
 
@@ -97,7 +116,40 @@ impl Client {
                     debug!("Managed to establish connection to {}", address);
                     // if we managed to connect, reset the reconnection count (whatever it might have been)
                     current_reconnection.store(0, Ordering::Release);
-                    Framed::new(stream, NymCodec)
+                    //Get the topology, because we need the keys for the handshake
+                    let topology_ref = match topology_access.current_topology().await {
+                        Some(topology) => topology,
+                        None => {
+                            error!("Cannot perform Noise handshake to {address}, due to topology error");
+                            return;
+                        }
+                    };
+
+                    let epoch_id = match api_client.get_current_epoch_id().await {
+                        Ok(id) => id,
+                        Err(err) => {
+                            error!("Cannot perform Noise handshake to {address}, due to epoch id error - {err}");
+                            return;
+                        }
+                    };
+
+                    let noise_stream = match upgrade_noise_initiator_with_topology(
+                        stream,
+                        &topology_ref,
+                        epoch_id,
+                        local_public_key,
+                        local_private_key,
+                    )
+                    .await
+                    {
+                        Ok(noise_stream) => noise_stream,
+                        Err(err) => {
+                            error!("Failed to perform Noise handshake with {address} - {err}");
+                            return;
+                        }
+                    };
+                    debug!("Noise initiator handshake completed for {:?}", address);
+                    Framed::new(noise_stream, NymCodec)
                 }
                 Err(err) => {
                     debug!(
@@ -175,6 +227,11 @@ impl Client {
         // copy the value before moving into another task
         let initial_connection_timeout = self.config.initial_connection_timeout;
 
+        let topology_access_clone = self.topology_access.clone();
+        let api_client_clone = self.api_client.clone();
+        let local_public_key = self.local_identity.public_key().to_bytes();
+        let local_private_key = self.local_identity.private_key().to_bytes();
+
         tokio::spawn(async move {
             // before executing the manager, wait for what was specified, if anything
             if let Some(backoff) = backoff {
@@ -187,6 +244,10 @@ impl Client {
                 receiver,
                 initial_connection_timeout,
                 &current_reconnection_attempt,
+                topology_access_clone,
+                api_client_clone,
+                &local_public_key,
+                &local_private_key,
             )
             .await
         });
@@ -255,13 +316,16 @@ mod tests {
     use super::*;
 
     fn dummy_client() -> Client {
-        Client::new(Config {
-            initial_reconnection_backoff: Duration::from_millis(10_000),
-            maximum_reconnection_backoff: Duration::from_millis(300_000),
-            initial_connection_timeout: Duration::from_millis(1_500),
-            maximum_connection_buffer_size: 128,
-            use_legacy_version: false,
-        })
+        Client::new(
+            Config {
+                initial_reconnection_backoff: Duration::from_millis(10_000),
+                maximum_reconnection_backoff: Duration::from_millis(300_000),
+                initial_connection_timeout: Duration::from_millis(1_500),
+                maximum_connection_buffer_size: 128,
+                use_legacy_version: false,
+            },
+            TopologyAccessor::new(),
+        )
     }
 
     #[test]

common/client-libs/mixnet-client/src/forwarder.rs

@@ -5,7 +5,11 @@ use crate::client::{Client, Config, SendWithoutResponse};
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
+use nym_client_core::client::topology_control::accessor::TopologyAccessor;
+use nym_crypto::asymmetric::encryption;
 use nym_sphinx::forwarding::packet::MixPacket;
+use nym_validator_client::NymApiClient;
+use std::sync::Arc;
 use std::time::Duration;
 
 pub type MixForwardingSender = mpsc::UnboundedSender<MixPacket>;
@@ -26,6 +30,9 @@ impl PacketForwarder {
         initial_connection_timeout: Duration,
         maximum_connection_buffer_size: usize,
         use_legacy_version: bool,
+        topology_access: TopologyAccessor,
+        api_client: NymApiClient,
+        local_identity: Arc<encryption::KeyPair>,
         shutdown: nym_task::TaskClient,
     ) -> (PacketForwarder, MixForwardingSender) {
         let client_config = Config::new(
@@ -40,7 +47,12 @@ impl PacketForwarder {
 
         (
             PacketForwarder {
-                mixnet_client: Client::new(client_config),
+                mixnet_client: Client::new(
+                    client_config,
+                    topology_access,
+                    api_client,
+                    local_identity,
+                ),
                 packet_receiver,
                 shutdown,
             },

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

@@ -13,6 +13,7 @@ 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" }
@@ -20,43 +21,50 @@ nym-multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig
 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" }
-nym-vesting-contract = { path = "../../../contracts/vesting" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-reqwest = { version = "0.11", features = ["json"] }
-thiserror = "1"
+reqwest = { workspace = true, features = ["json"] }
+thiserror = { workspace = true }
 log = { workspace = true }
-url = { version = "2.2", features = ["serde"] }
-tokio = { version = "1.24.1", features = ["sync", "time"] }
-futures = "0.3"
-openssl = { version = "0.10", features = ["vendored"], optional = true }
+url = { workspace = true, features = ["serde"] }
+tokio = { workspace = true, features = ["sync", "time"] }
+futures = { workspace = true }
+openssl = { version = "^0.10.55", features = ["vendored"], optional = true }
 
 nym-coconut-interface = { path = "../../coconut-interface" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-api-requests = { path = "../../../nym-api/nym-api-requests" }
 
-# required for nyxd-client
-# at some point it might be possible to make it wasm-compatible
-# perhaps after https://github.com/cosmos/cosmos-rust/pull/97 is resolved (and tendermint-rs is updated)
-async-trait = { workspace = true, optional = true }
-bip39 = { workspace = true, features = ["rand"], optional = true }
-nym-config = { path = "../../config", optional = true }
-cosmrs = { workspace = true, features = ["rpc", "bip32", "cosmwasm"], optional = true }
+async-trait = { workspace = true }
+bip39 = { workspace = true, features = ["rand"] }
+nym-config = { path = "../../config" }
+cosmrs = { workspace = true, features = ["bip32", "cosmwasm"] }
 # note that this has the same version as used by cosmrs
-eyre = { version = "0.6", optional = true }
-cw3 = { workspace = true, optional = true }
-cw4 = { workspace = true, optional = true }
-prost = { version = "0.10", default-features = false, optional = true }
-flate2 = { version = "1.0.20", optional = true }
-sha2 = { version = "0.9.5", optional = true }
-itertools = { version = "0.10", optional = true }
-zeroize = { version = "1.5.7", optional = true, features = ["zeroize_derive"] }
-cosmwasm-std = { workspace = true, optional = true }
+
+# import it just for the `Client` trait
+tendermint-rpc = { workspace = true }
+
+eyre = { version = "0.6" }
+cw-utils = { workspace = true }
+cw2 = { workspace = true }
+cw3 = { workspace = true }
+cw4 = { workspace = true }
+cw-controllers = { workspace = true }
+prost = { version = "0.11", default-features = false }
+flate2 = { version = "1.0.20" }
+sha2 = { version = "0.9.5" }
+itertools = { version = "0.10" }
+zeroize = { workspace = true, features = ["zeroize_derive"] }
+cosmwasm-std = { workspace = true }
+
+# required for polling for broadcast result
+[target."cfg(target_arch = \"wasm32\")".dependencies.wasmtimer]
+workspace = true
+features = ["tokio"]
 
 [dev-dependencies]
 bip39 = { workspace = true }
-cosmrs = { workspace = true, features = ["rpc", "bip32"] }
-tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }
+cosmrs = { workspace = true, features = ["bip32"] }
 ts-rs = "6.1.2"
 
 [[example]]
@@ -64,36 +72,18 @@ name = "offline_signing"
 # it should only really require the "signing" feature,
 # but that would require another round of refactoring to make it possible
 # (traits would need to be moved around and refactored themselves)
-required-features = ["nyxd-client"]
+required-features = ["http-client"]
 
 [[example]]
 name = "query_service_provider_directory"
-required-features = ["nyxd-client"]
+required-features = ["http-client"]
 
 [[example]]
 name = "query_name_service"
-required-features = ["nyxd-client"]
+required-features = ["http-client"]
 
 [features]
-nyxd-client = [
-    "async-trait",
-    "cosmrs",
-    "cosmwasm-std",
-    "cw3",
-    "cw4",
-    "flate2",
-    "itertools",
-    "openssl",
-    "prost",
-    "sha2",
-    "signing"
-]
-signing = [
-    "bip39",
-    "cosmrs",
-    "eyre",
-    "nym-config",
-    "zeroize"
-]
+default = ["http-client"]
+http-client = ["cosmrs/rpc", "openssl"]
 generate-ts = []
 

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use cosmrs::bank::MsgSend;
-use cosmrs::rpc::{self, HttpClient};
+use cosmrs::rpc::HttpClient;
 use cosmrs::tx::Msg;
 use cosmrs::{tx, AccountId, Coin, Denom};
 use nym_validator_client::nyxd::CosmWasmClient;
@@ -23,7 +23,7 @@ async fn main() {
     let signer_address = signer.try_derive_accounts().unwrap()[0].address().clone();
 
     // local 'client' ONLY signing messages
-    let tx_signer = TxSigner::new(signer);
+    let tx_signer = signer;
 
     // possibly remote client that doesn't do ANY signing
     // (only broadcasts + queries for sequence numbers)
@@ -54,7 +54,7 @@ async fn main() {
             denom,
             amount: 2500u32.into(),
         },
-        100000,
+        100000u32,
     );
 
     let tx_raw = tx_signer
@@ -70,7 +70,7 @@ async fn main() {
         .unwrap();
 
     // broadcast the tx
-    let res = rpc::Client::broadcast_tx_commit(&broadcaster, tx_bytes.into())
+    let res = tendermint_rpc::client::Client::broadcast_tx_commit(&broadcaster, tx_bytes)
         .await
         .unwrap();
 

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

@@ -3,7 +3,9 @@ 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::traits::NameServiceQueryClient;
+use nym_validator_client::nyxd::contract_traits::{
+    NameServiceQueryClient, PagedNameServiceQueryClient,
+};
 
 #[tokio::main]
 async fn main() {
@@ -26,7 +28,7 @@ async fn main() {
     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");
+    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:#?}");
 

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

@@ -3,7 +3,9 @@ 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::traits::SpDirectoryQueryClient;
+use nym_validator_client::nyxd::contract_traits::{
+    PagedSpDirectoryQueryClient, SpDirectoryQueryClient,
+};
 
 #[tokio::main]
 async fn main() {

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

@@ -1,61 +1,44 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::{nym_api, ValidatorClientError};
+use crate::nyxd::{self, NyxdClient};
+use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
+use crate::signing::signer::{NoSigner, OfflineSigner};
+use crate::{
+    nym_api, DirectSigningReqwestRpcValidatorClient, QueryReqwestRpcValidatorClient,
+    ReqwestRpcClient, ValidatorClientError,
+};
 use nym_api_requests::coconut::{
     BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
 };
+use nym_api_requests::models::MixNodeBondAnnotated;
 use nym_api_requests::models::{
     GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
     RewardEstimationResponse, StakeSaturationResponse,
 };
-use nym_coconut_dkg_common::types::NodeIndex;
-use nym_coconut_interface::VerificationKey;
+use nym_network_defaults::NymNetworkDetails;
+use url::Url;
+
 pub use nym_mixnet_contract_common::{
     mixnode::MixNodeDetails, GatewayBond, IdentityKey, IdentityKeyRef, MixId,
 };
-use url::Url;
 
-#[cfg(feature = "nyxd-client")]
-use crate::nyxd::traits::{DkgQueryClient, MixnetQueryClient};
-#[cfg(feature = "nyxd-client")]
-use crate::nyxd::{self, CosmWasmClient, NyxdClient, QueryNyxdClient, SigningNyxdClient};
-#[cfg(feature = "nyxd-client")]
-use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
-#[cfg(feature = "nyxd-client")]
-use nym_api_requests::models::MixNodeBondAnnotated;
-#[cfg(feature = "nyxd-client")]
-use nym_coconut_dkg_common::{types::EpochId, verification_key::ContractVKShare};
-#[cfg(feature = "nyxd-client")]
-use nym_coconut_interface::Base58;
-#[cfg(feature = "nyxd-client")]
-use nym_mixnet_contract_common::{
-    families::{Family, FamilyHead},
-    mixnode::MixNodeBond,
-    pending_events::{PendingEpochEvent, PendingIntervalEvent},
-    Delegation, RewardedSetNodeStatus, UnbondedMixnode,
-};
-#[cfg(feature = "nyxd-client")]
-use nym_network_defaults::NymNetworkDetails;
-#[cfg(feature = "nyxd-client")]
-use std::str::FromStr;
+// re-export the type to not break existing imports
+pub use crate::coconut::CoconutApiClient;
+
+#[cfg(feature = "http-client")]
+use crate::{DirectSigningHttpRpcValidatorClient, HttpRpcClient, QueryHttpRpcValidatorClient};
 
-#[cfg(feature = "nyxd-client")]
 #[must_use]
 #[derive(Debug, Clone)]
 pub struct Config {
     api_url: Url,
     nyxd_url: Url,
 
+    // TODO: until refactored, this is a dead field under some features
     nyxd_config: nyxd::Config,
-
-    mixnode_page_limit: Option<u32>,
-    gateway_page_limit: Option<u32>,
-    mixnode_delegations_page_limit: Option<u32>,
-    rewarded_set_page_limit: Option<u32>,
 }
 
-#[cfg(feature = "nyxd-client")]
 impl Config {
     pub fn try_from_nym_network_details(
         details: &NymNetworkDetails,
@@ -78,10 +61,6 @@ impl Config {
                 .parse()
                 .map_err(ValidatorClientError::MalformedUrlProvided)?,
             nyxd_config: nyxd::Config::try_from_nym_network_details(details)?,
-            mixnode_page_limit: None,
-            gateway_page_limit: None,
-            mixnode_delegations_page_limit: None,
-            rewarded_set_page_limit: None,
         })
     }
 
@@ -98,88 +77,57 @@ impl Config {
         self
     }
 
-    pub fn with_mixnode_page_limit(mut self, limit: Option<u32>) -> Config {
-        self.mixnode_page_limit = limit;
-        self
-    }
-
-    pub fn with_gateway_page_limit(mut self, limit: Option<u32>) -> Config {
-        self.gateway_page_limit = limit;
-        self
-    }
-
-    pub fn with_mixnode_delegations_page_limit(mut self, limit: Option<u32>) -> Config {
-        self.mixnode_delegations_page_limit = limit;
-        self
-    }
-
-    pub fn with_rewarded_set_page_limit(mut self, limit: Option<u32>) -> Config {
-        self.rewarded_set_page_limit = limit;
+    pub fn with_simulated_gas_multiplier(mut self, gas_multiplier: f32) -> Self {
+        self.nyxd_config.simulated_gas_multiplier = gas_multiplier;
         self
     }
 }
 
-#[cfg(feature = "nyxd-client")]
-pub struct Client<C> {
-    mixnode_page_limit: Option<u32>,
-    gateway_page_limit: Option<u32>,
-    mixnode_delegations_page_limit: Option<u32>,
-    rewarded_set_page_limit: Option<u32>,
-
+pub struct Client<C, S = NoSigner> {
     // ideally they would have been read-only, but unfortunately rust doesn't have such features
     pub nym_api: nym_api::Client,
-    pub nyxd: NyxdClient<C>,
+    pub nyxd: NyxdClient<C, S>,
 }
 
-#[cfg(feature = "nyxd-client")]
-impl Client<SigningNyxdClient<DirectSecp256k1HdWallet>> {
+#[cfg(feature = "http-client")]
+impl Client<HttpRpcClient, DirectSecp256k1HdWallet> {
     pub fn new_signing(
         config: Config,
         mnemonic: bip39::Mnemonic,
-    ) -> Result<Client<SigningNyxdClient<DirectSecp256k1HdWallet>>, ValidatorClientError> {
-        let nym_api_client = nym_api::Client::new(config.api_url.clone());
-        let nyxd_client = NyxdClient::connect_with_mnemonic(
-            config.nyxd_config.clone(),
-            config.nyxd_url.as_str(),
-            mnemonic,
-            None,
-        )?;
+    ) -> Result<DirectSigningHttpRpcValidatorClient, ValidatorClientError> {
+        let rpc_client = HttpRpcClient::new(config.nyxd_url.as_str())?;
+        let prefix = &config.nyxd_config.chain_details.bech32_account_prefix;
+        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
 
-        Ok(Client {
-            mixnode_page_limit: config.mixnode_page_limit,
-            gateway_page_limit: config.gateway_page_limit,
-            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
-            rewarded_set_page_limit: config.rewarded_set_page_limit,
-            nym_api: nym_api_client,
-            nyxd: nyxd_client,
-        })
+        Ok(Self::new_signing_with_rpc_client(
+            config, rpc_client, wallet,
+        ))
     }
 
     pub fn change_nyxd(&mut self, new_endpoint: Url) -> Result<(), ValidatorClientError> {
         self.nyxd.change_endpoint(new_endpoint.as_ref())?;
         Ok(())
     }
+}
 
-    pub fn set_nyxd_simulated_gas_multiplier(&mut self, multiplier: f32) {
-        self.nyxd.set_simulated_gas_multiplier(multiplier)
+impl Client<ReqwestRpcClient, DirectSecp256k1HdWallet> {
+    pub fn new_reqwest_signing(
+        config: Config,
+        mnemonic: bip39::Mnemonic,
+    ) -> DirectSigningReqwestRpcValidatorClient {
+        let rpc_client = ReqwestRpcClient::new(config.nyxd_url.clone());
+        let prefix = &config.nyxd_config.chain_details.bech32_account_prefix;
+        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
+
+        Self::new_signing_with_rpc_client(config, rpc_client, wallet)
     }
 }
 
-#[cfg(feature = "nyxd-client")]
-impl Client<QueryNyxdClient> {
-    pub fn new_query(config: Config) -> Result<Client<QueryNyxdClient>, ValidatorClientError> {
-        let nym_api_client = nym_api::Client::new(config.api_url.clone());
-        let nyxd_client =
-            NyxdClient::connect(config.nyxd_config.clone(), config.nyxd_url.as_str())?;
-
-        Ok(Client {
-            mixnode_page_limit: config.mixnode_page_limit,
-            gateway_page_limit: config.gateway_page_limit,
-            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
-            rewarded_set_page_limit: config.rewarded_set_page_limit,
-            nym_api: nym_api_client,
-            nyxd: nyxd_client,
-        })
+#[cfg(feature = "http-client")]
+impl Client<HttpRpcClient> {
+    pub fn new_query(config: Config) -> Result<QueryHttpRpcValidatorClient, ValidatorClientError> {
+        let rpc_client = HttpRpcClient::new(config.nyxd_url.as_str())?;
+        Ok(Self::new_with_rpc_client(config, rpc_client))
     }
 
     pub fn change_nyxd(&mut self, new_endpoint: Url) -> Result<(), ValidatorClientError> {
@@ -188,392 +136,40 @@ impl Client<QueryNyxdClient> {
     }
 }
 
-// nyxd wrappers
-#[cfg(feature = "nyxd-client")]
+impl Client<ReqwestRpcClient> {
+    pub fn new_reqwest_query(config: Config) -> QueryReqwestRpcValidatorClient {
+        let rpc_client = ReqwestRpcClient::new(config.nyxd_url.clone());
+        Self::new_with_rpc_client(config, rpc_client)
+    }
+}
+
 impl<C> Client<C> {
-    // use case: somebody initialised client without a contract in order to upload and initialise one
-    // and now they want to actually use it without making new client
+    pub fn new_with_rpc_client(config: Config, rpc_client: C) -> Self {
+        let nym_api_client = nym_api::Client::new(config.api_url.clone());
 
-    pub fn set_mixnet_contract_address(&mut self, mixnet_contract_address: cosmrs::AccountId) {
-        self.nyxd
-            .set_mixnet_contract_address(mixnet_contract_address)
-    }
-
-    pub fn get_mixnet_contract_address(&self) -> cosmrs::AccountId {
-        self.nyxd.mixnet_contract_address().clone()
-    }
-
-    pub async fn get_all_node_families(&self) -> Result<Vec<Family>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut families = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let paged_response = self
-                .nyxd
-                .get_all_node_families_paged(start_after.take(), None)
-                .await?;
-            families.extend(paged_response.families);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
+        Client {
+            nym_api: nym_api_client,
+            nyxd: NyxdClient::new(config.nyxd_config, rpc_client),
         }
-
-        Ok(families)
     }
+}
 
-    pub async fn get_all_family_members(
-        &self,
-    ) -> Result<Vec<(IdentityKey, FamilyHead)>, ValidatorClientError>
+impl<C, S> Client<C, S> {
+    pub fn new_signing_with_rpc_client(config: Config, rpc_client: C, signer: S) -> Self
     where
-        C: CosmWasmClient + Sync + Send,
+        S: OfflineSigner,
     {
-        let mut members = Vec::new();
-        let mut start_after = None;
+        let nym_api_client = nym_api::Client::new(config.api_url.clone());
 
-        loop {
-            let paged_response = self
-                .nyxd
-                .get_all_family_members_paged(start_after.take(), None)
-                .await?;
-            members.extend(paged_response.members);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
+        Client {
+            nym_api: nym_api_client,
+            nyxd: NyxdClient::new_signing(config.nyxd_config, rpc_client, signer),
         }
-
-        Ok(members)
-    }
-
-    // basically handles paging for us
-    pub async fn get_all_nyxd_rewarded_set_mixnodes(
-        &self,
-    ) -> Result<Vec<(MixId, RewardedSetNodeStatus)>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut identities = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_rewarded_set_paged(start_after.take(), self.rewarded_set_page_limit)
-                .await?;
-            identities.append(&mut paged_response.nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(identities)
-    }
-
-    pub async fn get_all_nyxd_mixnode_bonds(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut mixnodes = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_mixnode_bonds_paged(self.mixnode_page_limit, start_after.take())
-                .await?;
-            mixnodes.append(&mut paged_response.nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(mixnodes)
-    }
-
-    pub async fn get_all_nyxd_mixnodes_detailed(
-        &self,
-    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut mixnodes = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_mixnodes_detailed_paged(self.mixnode_page_limit, start_after.take())
-                .await?;
-            mixnodes.append(&mut paged_response.nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(mixnodes)
-    }
-
-    pub async fn get_all_nyxd_unbonded_mixnodes(
-        &self,
-    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut mixnodes = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_unbonded_paged(self.mixnode_page_limit, start_after.take())
-                .await?;
-            mixnodes.append(&mut paged_response.nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(mixnodes)
-    }
-
-    pub async fn get_all_nyxd_unbonded_mixnodes_by_owner(
-        &self,
-        owner: &cosmrs::AccountId,
-    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut mixnodes = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_unbonded_by_owner_paged(owner, self.mixnode_page_limit, start_after.take())
-                .await?;
-            mixnodes.append(&mut paged_response.nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(mixnodes)
-    }
-
-    pub async fn get_all_nyxd_unbonded_mixnodes_by_identity(
-        &self,
-        identity_key: String,
-    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut mixnodes = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_unbonded_by_identity_paged(
-                    identity_key.clone(),
-                    self.mixnode_page_limit,
-                    start_after.take(),
-                )
-                .await?;
-            mixnodes.append(&mut paged_response.nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(mixnodes)
-    }
-
-    pub async fn get_all_nyxd_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut gateways = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_gateways_paged(start_after.take(), self.gateway_page_limit)
-                .await?;
-            gateways.append(&mut paged_response.nodes);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(gateways)
-    }
-
-    pub async fn get_all_nyxd_single_mixnode_delegations(
-        &self,
-        mix_id: MixId,
-    ) -> Result<Vec<Delegation>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut delegations = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_mixnode_delegations_paged(
-                    mix_id,
-                    start_after.take(),
-                    self.mixnode_delegations_page_limit,
-                )
-                .await?;
-            delegations.append(&mut paged_response.delegations);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(delegations)
-    }
-
-    pub async fn get_all_delegator_delegations(
-        &self,
-        delegation_owner: &cosmrs::AccountId,
-    ) -> Result<Vec<Delegation>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut delegations = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_delegator_delegations_paged(
-                    delegation_owner.to_string(),
-                    start_after.take(),
-                    self.mixnode_delegations_page_limit,
-                )
-                .await?;
-            delegations.append(&mut paged_response.delegations);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(delegations)
-    }
-
-    pub async fn get_all_network_delegations(&self) -> Result<Vec<Delegation>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut delegations = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_all_network_delegations_paged(
-                    start_after.take(),
-                    self.mixnode_delegations_page_limit,
-                )
-                .await?;
-            delegations.append(&mut paged_response.delegations);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(delegations)
-    }
-
-    pub async fn get_all_nyxd_pending_epoch_events(
-        &self,
-    ) -> Result<Vec<PendingEpochEvent>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut events = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_pending_epoch_events_paged(start_after.take(), self.rewarded_set_page_limit)
-                .await?;
-            events.append(&mut paged_response.events);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(events)
-    }
-
-    pub async fn get_all_nyxd_pending_interval_events(
-        &self,
-    ) -> Result<Vec<PendingIntervalEvent>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut events = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let mut paged_response = self
-                .nyxd
-                .get_pending_interval_events_paged(start_after.take(), self.rewarded_set_page_limit)
-                .await?;
-            events.append(&mut paged_response.events);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(events)
     }
 }
 
 // validator-api wrappers
-#[cfg(feature = "nyxd-client")]
-impl<C> Client<C> {
+impl<C, S> Client<C, S> {
     pub fn change_nym_api(&mut self, new_endpoint: Url) {
         self.nym_api.change_url(new_endpoint)
     }
@@ -630,87 +226,56 @@ impl<C> Client<C> {
     }
 }
 
-#[derive(Clone)]
-pub struct CoconutApiClient {
-    pub api_client: NymApiClient,
-    pub verification_key: VerificationKey,
-    pub node_id: NodeIndex,
-    #[cfg(feature = "nyxd-client")]
-    pub cosmos_address: cosmrs::AccountId,
-}
-
-#[cfg(feature = "nyxd-client")]
-impl CoconutApiClient {
-    pub async fn all_coconut_api_clients<C>(
-        client: &C,
-        epoch_id: EpochId,
-    ) -> Result<Vec<Self>, ValidatorClientError>
-    where
-        C: DkgQueryClient + Sync + Send,
-    {
-        Ok(client
-            .get_all_verification_key_shares(epoch_id)
-            .await?
-            .into_iter()
-            .filter_map(Self::try_from)
-            .collect())
-    }
-
-    fn try_from(share: ContractVKShare) -> Option<Self> {
-        if share.verified {
-            if let Ok(url_address) = Url::parse(&share.announce_address) {
-                if let Ok(verification_key) = VerificationKey::try_from_bs58(&share.share) {
-                    if let Ok(cosmos_address) = cosmrs::AccountId::from_str(share.owner.as_str()) {
-                        return Some(CoconutApiClient {
-                            api_client: NymApiClient::new(url_address),
-                            verification_key,
-                            node_id: share.node_index,
-                            cosmos_address,
-                        });
-                    }
-                }
-            }
-        }
-        None
-    }
-}
-
 #[derive(Clone)]
 pub struct NymApiClient {
-    pub nym_api_client: nym_api::Client,
+    pub nym_api: nym_api::Client,
     // TODO: perhaps if we really need it at some (currently I don't see any reasons for it)
     // we could re-implement the communication with the REST API on port 1317
 }
 
 impl NymApiClient {
     pub fn new(api_url: Url) -> Self {
-        let nym_api_client = nym_api::Client::new(api_url);
+        let nym_api = nym_api::Client::new(api_url);
 
-        NymApiClient { nym_api_client }
+        NymApiClient { nym_api }
     }
 
     pub fn change_nym_api(&mut self, new_endpoint: Url) {
-        self.nym_api_client.change_url(new_endpoint);
+        self.nym_api.change_url(new_endpoint);
     }
 
     pub async fn get_cached_active_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
-        Ok(self.nym_api_client.get_active_mixnodes().await?)
+        Ok(self.nym_api.get_active_mixnodes().await?)
     }
 
     pub async fn get_cached_rewarded_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
-        Ok(self.nym_api_client.get_rewarded_mixnodes().await?)
+        Ok(self.nym_api.get_rewarded_mixnodes().await?)
     }
 
     pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
-        Ok(self.nym_api_client.get_mixnodes().await?)
+        Ok(self.nym_api.get_mixnodes().await?)
+    }
+
+    pub async fn get_all_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
+        Ok(self.nym_api.get_all_mixnodes().await?)
+    }
+
+    pub async fn get_all_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
+        Ok(self.nym_api.get_all_gateways().await?)
     }
 
     pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
-        Ok(self.nym_api_client.get_gateways().await?)
+        Ok(self.nym_api.get_gateways().await?)
+    }
+
+    pub async fn get_current_epoch_id(
+        &self,
+    ) -> Result<nym_mixnet_contract_common::EpochId, ValidatorClientError> {
+        Ok(self.nym_api.get_current_epoch().await?.current_epoch_id())
     }
 
     pub async fn get_gateway_core_status_count(
@@ -719,7 +284,7 @@ impl NymApiClient {
         since: Option<i64>,
     ) -> Result<GatewayCoreStatusResponse, ValidatorClientError> {
         Ok(self
-            .nym_api_client
+            .nym_api
             .get_gateway_core_status_count(identity, since)
             .await?)
     }
@@ -730,7 +295,7 @@ impl NymApiClient {
         since: Option<i64>,
     ) -> Result<MixnodeCoreStatusResponse, ValidatorClientError> {
         Ok(self
-            .nym_api_client
+            .nym_api
             .get_mixnode_core_status_count(mix_id, since)
             .await?)
     }
@@ -739,34 +304,28 @@ impl NymApiClient {
         &self,
         mix_id: MixId,
     ) -> Result<MixnodeStatusResponse, ValidatorClientError> {
-        Ok(self.nym_api_client.get_mixnode_status(mix_id).await?)
+        Ok(self.nym_api.get_mixnode_status(mix_id).await?)
     }
 
     pub async fn get_mixnode_reward_estimation(
         &self,
         mix_id: MixId,
     ) -> Result<RewardEstimationResponse, ValidatorClientError> {
-        Ok(self
-            .nym_api_client
-            .get_mixnode_reward_estimation(mix_id)
-            .await?)
+        Ok(self.nym_api.get_mixnode_reward_estimation(mix_id).await?)
     }
 
     pub async fn get_mixnode_stake_saturation(
         &self,
         mix_id: MixId,
     ) -> Result<StakeSaturationResponse, ValidatorClientError> {
-        Ok(self
-            .nym_api_client
-            .get_mixnode_stake_saturation(mix_id)
-            .await?)
+        Ok(self.nym_api.get_mixnode_stake_saturation(mix_id).await?)
     }
 
     pub async fn blind_sign(
         &self,
         request_body: &BlindSignRequestBody,
     ) -> Result<BlindedSignatureResponse, ValidatorClientError> {
-        Ok(self.nym_api_client.blind_sign(request_body).await?)
+        Ok(self.nym_api.blind_sign(request_body).await?)
     }
 
     pub async fn verify_bandwidth_credential(
@@ -774,7 +333,7 @@ impl NymApiClient {
         request_body: &VerifyCredentialBody,
     ) -> Result<VerifyCredentialResponse, ValidatorClientError> {
         Ok(self
-            .nym_api_client
+            .nym_api
             .verify_bandwidth_credential(request_body)
             .await?)
     }

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

@@ -0,0 +1,97 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
+use crate::nyxd::error::NyxdError;
+use crate::NymApiClient;
+use nym_coconut_dkg_common::types::{EpochId, NodeIndex};
+use nym_coconut_dkg_common::verification_key::ContractVKShare;
+use nym_coconut_interface::{Base58, CoconutError, VerificationKey};
+use thiserror::Error;
+use url::Url;
+
+// TODO: it really doesn't feel like this should live in this crate.
+#[derive(Clone)]
+pub struct CoconutApiClient {
+    pub api_client: NymApiClient,
+    pub verification_key: VerificationKey,
+    pub node_id: NodeIndex,
+    pub cosmos_address: cosmrs::AccountId,
+}
+
+// TODO: this should be using the coconut error
+// (which is in different crate; perhaps this client should be moved there?)
+
+#[derive(Debug, Error)]
+pub enum CoconutApiError {
+    // TODO: ask @BN whether this is a correct error message
+    #[error("the provided key share hasn't been verified")]
+    UnverifiedShare,
+
+    #[error("failed to query the contract: {source}")]
+    ContractQueryFailure {
+        #[from]
+        source: NyxdError,
+    },
+
+    #[error("the provided announce address is malformed: {source}")]
+    MalformedAnnounceAddress {
+        #[from]
+        source: url::ParseError,
+    },
+
+    #[error("the provided verification key is malformed: {source}")]
+    MalformedVerificationKey {
+        #[from]
+        source: CoconutError,
+    },
+
+    #[error("the provided account address is malformed: {source}")]
+    MalformedAccountAddress {
+        #[from]
+        source: cosmrs::ErrorReport,
+    },
+}
+
+impl TryFrom<ContractVKShare> for CoconutApiClient {
+    type Error = CoconutApiError;
+
+    fn try_from(share: ContractVKShare) -> Result<Self, Self::Error> {
+        if !share.verified {
+            return Err(CoconutApiError::UnverifiedShare);
+        }
+
+        let url_address = Url::parse(&share.announce_address)?;
+
+        Ok(CoconutApiClient {
+            api_client: NymApiClient::new(url_address),
+            verification_key: VerificationKey::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>(
+    client: &C,
+    epoch_id: EpochId,
+) -> Result<Vec<CoconutApiClient>, CoconutApiError>
+where
+    C: DkgQueryClient + Sync + Send,
+{
+    // TODO: this will error out if there's an invalid share out there. is that what we want?
+    client
+        .get_all_verification_key_shares(epoch_id)
+        .await?
+        .into_iter()
+        .map(TryInto::try_into)
+        .collect::<Result<Vec<_>, _>>()
+
+    // ... if not, let's switch to the below:
+    // client
+    //     .get_all_verification_key_shares(epoch_id)
+    //     .await?
+    //     .into_iter()
+    //     .filter_map(TryInto::try_into)
+    //     .collect::<Result<Vec<_>, _>>()
+}

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

@@ -1,8 +1,7 @@
+use crate::nyxd::contract_traits::MixnetQueryClient;
 use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Config as ClientConfig, NyxdClient, QueryNyxdClient};
-use crate::{NymApiClient, ValidatorClientError};
-
-use crate::nyxd::traits::MixnetQueryClient;
+use crate::nyxd::Config as ClientConfig;
+use crate::{NymApiClient, QueryHttpRpcNyxdClient, ValidatorClientError};
 use colored::Colorize;
 use core::fmt;
 use itertools::Itertools;
@@ -53,7 +52,7 @@ pub async fn test_nyxd_url_connection(
     let config = ClientConfig::try_from_nym_network_details(&network)
         .expect("failed to create valid nyxd client config");
 
-    let mut nyxd_client = NyxdClient::<QueryNyxdClient>::connect(config, nyxd_url.as_str())?;
+    let mut nyxd_client = QueryHttpRpcNyxdClient::connect(config, nyxd_url.as_str())?;
     // possibly redundant, but lets just leave it here
     nyxd_client.set_mixnet_contract_address(address);
     match test_nyxd_connection(network, &nyxd_url, &nyxd_client).await {
@@ -75,7 +74,7 @@ fn setup_connection_tests<H: BuildHasher + 'static>(
         let config = ClientConfig::try_from_nym_network_details(&network)
             .expect("failed to create valid nyxd client config");
 
-        if let Ok(mut client) = NyxdClient::<QueryNyxdClient>::connect(config, url.as_str()) {
+        if let Ok(mut client) = QueryHttpRpcNyxdClient::connect(config, url.as_str()) {
             // possibly redundant, but lets just leave it here
             client.set_mixnet_contract_address(address);
             Some(ClientForConnectionTest::Nyxd(
@@ -112,7 +111,7 @@ fn extract_and_collect_results_into_map(
 async fn test_nyxd_connection(
     network: NymNetworkDetails,
     url: &Url,
-    client: &NyxdClient<QueryNyxdClient>,
+    client: &QueryHttpRpcNyxdClient,
 ) -> ConnectionResult {
     let result = match timeout(
         Duration::from_secs(CONNECTION_TEST_TIMEOUT_SEC),
@@ -120,7 +119,7 @@ async fn test_nyxd_connection(
     )
     .await
     {
-        Ok(Err(NyxdError::TendermintError(e))) => {
+        Ok(Err(NyxdError::TendermintErrorRpc(e))) => {
             // If we get a tendermint-rpc error, we classify the node as not contactable
             log::warn!("Checking: nyxd url: {url}: {}: {}", "failed".red(), e);
             false
@@ -186,7 +185,7 @@ async fn test_nym_api_connection(
 }
 
 enum ClientForConnectionTest {
-    Nyxd(NymNetworkDetails, Url, Box<NyxdClient<QueryNyxdClient>>),
+    Nyxd(NymNetworkDetails, Url, Box<QueryHttpRpcNyxdClient>),
     Api(NymNetworkDetails, Url, NymApiClient),
 }
 

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::nym_api;
+pub use tendermint_rpc::error::Error as TendermintRpcError;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -12,10 +13,12 @@ pub enum ValidatorClientError {
         source: nym_api::error::NymAPIError,
     },
 
+    #[error("Tendermint RPC request failure: {0}")]
+    TendermintErrorRpc(#[from] TendermintRpcError),
+
     #[error("One of the provided URLs was malformed - {0}")]
     MalformedUrlProvided(#[from] url::ParseError),
 
-    #[cfg(feature = "nyxd-client")]
     #[error("nyxd request failed - {0}")]
     NyxdError(#[from] crate::nyxd::error::NyxdError),
 

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

@@ -1,20 +1,44 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod client;
-#[cfg(feature = "nyxd-client")]
+pub mod coconut;
+#[cfg(feature = "http-client")]
 pub mod connection_tester;
 pub mod error;
 pub mod nym_api;
-#[cfg(feature = "nyxd-client")]
 pub mod nyxd;
-
-#[cfg(feature = "signing")]
+pub mod rpc;
 pub mod signing;
 
 pub use crate::error::ValidatorClientError;
+pub use crate::rpc::reqwest::ReqwestRpcClient;
+pub use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 pub use client::NymApiClient;
+pub use client::{Client, CoconutApiClient, Config};
 pub use nym_api_requests::*;
 
-#[cfg(feature = "nyxd-client")]
-pub use client::{Client, CoconutApiClient, Config};
+#[cfg(feature = "http-client")]
+pub use cosmrs::rpc::HttpClient as HttpRpcClient;
+
+// some type aliasing
+
+pub type ValidatorClient<C> = Client<C>;
+pub type SigningValidatorClient<C, S> = Client<C, S>;
+
+#[cfg(feature = "http-client")]
+pub type QueryHttpRpcValidatorClient = Client<HttpRpcClient>;
+#[cfg(feature = "http-client")]
+pub type QueryHttpRpcNyxdClient = nyxd::NyxdClient<HttpRpcClient>;
+
+#[cfg(feature = "http-client")]
+pub type DirectSigningHttpRpcValidatorClient = Client<HttpRpcClient, DirectSecp256k1HdWallet>;
+#[cfg(feature = "http-client")]
+pub type DirectSigningHttpRpcNyxdClient = nyxd::NyxdClient<HttpRpcClient, DirectSecp256k1HdWallet>;
+
+pub type QueryReqwestRpcValidatorClient = Client<ReqwestRpcClient>;
+pub type QueryReqwestRpcNyxdClient = nyxd::NyxdClient<ReqwestRpcClient>;
+
+pub type DirectSigningReqwestRpcValidatorClient = Client<ReqwestRpcClient, DirectSecp256k1HdWallet>;
+pub type DirectSigningReqwestRpcNyxdClient =
+    nyxd::NyxdClient<ReqwestRpcClient, DirectSecp256k1HdWallet>;

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

@@ -7,14 +7,14 @@ use nym_api_requests::coconut::{
     BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
 };
 use nym_api_requests::models::{
-    ComputeRewardEstParam, GatewayCoreStatusResponse, GatewayStatusReportResponse,
-    GatewayUptimeHistoryResponse, InclusionProbabilityResponse, MixNodeBondAnnotated,
-    MixnodeCoreStatusResponse, MixnodeStatusReportResponse, MixnodeStatusResponse,
-    MixnodeUptimeHistoryResponse, RequestError, RewardEstimationResponse, StakeSaturationResponse,
-    UptimeResponse,
+    ComputeRewardEstParam, GatewayBondAnnotated, GatewayCoreStatusResponse,
+    GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
+    MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
+    MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RequestError, RewardEstimationResponse,
+    StakeSaturationResponse, UptimeResponse,
 };
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
-use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
+use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, Interval, MixId};
 use nym_name_service_common::response::NamesListResponse;
 use nym_service_provider_directory_common::response::ServicesListResponse;
 use reqwest::{Response, StatusCode};
@@ -130,11 +130,27 @@ impl Client {
         }
     }
 
+    pub async fn get_current_epoch(&self) -> Result<Interval, NymAPIError> {
+        self.query_nym_api(
+            &[routes::API_VERSION, routes::EPOCH, routes::CURRENT],
+            NO_PARAMS,
+        )
+        .await
+    }
+
     pub async fn get_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.query_nym_api(&[routes::API_VERSION, routes::MIXNODES], NO_PARAMS)
             .await
     }
 
+    pub async fn get_all_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
+        self.query_nym_api(
+            &[routes::API_VERSION, routes::MIXNODES, routes::ALL],
+            NO_PARAMS,
+        )
+        .await
+    }
+
     pub async fn get_mixnodes_detailed(&self) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
         self.query_nym_api(
             &[
@@ -148,6 +164,19 @@ impl Client {
         .await
     }
 
+    pub async fn get_gateways_detailed(&self) -> Result<Vec<GatewayBondAnnotated>, NymAPIError> {
+        self.query_nym_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::GATEWAYS,
+                routes::DETAILED,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
     pub async fn get_mixnodes_detailed_unfiltered(
         &self,
     ) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
@@ -168,6 +197,14 @@ impl Client {
             .await
     }
 
+    pub async fn get_all_gateways(&self) -> Result<Vec<GatewayBond>, NymAPIError> {
+        self.query_nym_api(
+            &[routes::API_VERSION, routes::GATEWAYS, routes::ALL],
+            NO_PARAMS,
+        )
+        .await
+    }
+
     pub async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.query_nym_api(
             &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],

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

@@ -6,6 +6,10 @@ use nym_network_defaults::NYM_API_VERSION;
 pub const API_VERSION: &str = NYM_API_VERSION;
 pub const MIXNODES: &str = "mixnodes";
 pub const GATEWAYS: &str = "gateways";
+pub const ALL: &str = "all";
+
+pub const EPOCH: &str = "epoch";
+pub const CURRENT: &str = "current";
 
 pub const DETAILED: &str = "detailed";
 pub const DETAILED_UNFILTERED: &str = "detailed-unfiltered";

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

@@ -52,7 +52,6 @@ impl<'a> Div<GasPrice> for &'a Coin {
         } else {
             implicit_gas_limit.u128() as u64
         }
-        .into()
     }
 }
 
@@ -191,32 +190,32 @@ mod tests {
         let amount = Coin::new(3938, "unym");
         let gas_price = "0.025unym".parse().unwrap();
         let res = amount / gas_price;
-        assert_eq!(157520, res.value());
+        assert_eq!(157520, res);
 
         let amount = Coin::new(1234567890, "unym");
         let gas_price = "0.025unym".parse().unwrap();
         let res = amount / gas_price;
-        assert_eq!(49382715600, res.value());
+        assert_eq!(49382715600, res);
 
         let amount = Coin::new(1, "unym");
         let gas_price = "0.025unym".parse().unwrap();
         let res = amount / gas_price;
-        assert_eq!(40, res.value());
+        assert_eq!(40, res);
 
         let amount = Coin::new(150_000_000, "unym");
         let gas_price = "0.001234unym".parse().unwrap();
         let res = amount / gas_price;
-        assert_eq!(121555915721, res.value());
+        assert_eq!(121555915721, res);
 
         let amount = Coin::new(150_000_000, "unym");
         let gas_price = "1unym".parse().unwrap();
         let res = amount / gas_price;
-        assert_eq!(150_000_000, res.value());
+        assert_eq!(150_000_000, res);
 
         let amount = Coin::new(150_000_000, "unym");
         let gas_price = "1234.56unym".parse().unwrap();
         let res = amount / gas_price;
-        assert_eq!(121500, res.value());
+        assert_eq!(121500, res);
     }
 
     #[test]

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

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

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

@@ -0,0 +1,153 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::cosmwasm_client::types::ExecuteResult;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
+use crate::signing::signer::OfflineSigner;
+use async_trait::async_trait;
+use nym_coconut_bandwidth_contract_common::spend_credential::SpendCredentialData;
+use nym_coconut_bandwidth_contract_common::{
+    deposit::DepositData, msg::ExecuteMsg as CoconutBandwidthExecuteMsg,
+};
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait CoconutBandwidthSigningClient {
+    async fn execute_coconut_bandwidth_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: CoconutBandwidthExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn deposit(
+        &self,
+        amount: Coin,
+        info: String,
+        verification_key: String,
+        encryption_key: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = CoconutBandwidthExecuteMsg::DepositFunds {
+            data: DepositData::new(info.to_string(), 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/dkg_query_client.rs

@@ -0,0 +1,182 @@
+// 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 cosmrs::AccountId;
+use nym_coconut_dkg_common::dealer::{
+    ContractDealing, DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
+};
+use nym_coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
+use nym_coconut_dkg_common::types::{DealerDetails, Epoch, EpochId, InitialReplacementData};
+use nym_coconut_dkg_common::verification_key::{ContractVKShare, PagedVKSharesResponse};
+use serde::Deserialize;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait DkgQueryClient {
+    async fn query_dkg_contract<T>(&self, query: DkgQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_current_epoch(&self) -> Result<Epoch, NyxdError> {
+        let request = DkgQueryMsg::GetCurrentEpochState {};
+        self.query_dkg_contract(request).await
+    }
+    async fn get_current_epoch_threshold(&self) -> Result<Option<u64>, NyxdError> {
+        let request = DkgQueryMsg::GetCurrentEpochThreshold {};
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_initial_dealers(&self) -> Result<Option<InitialReplacementData>, NyxdError> {
+        let request = DkgQueryMsg::GetInitialDealers {};
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_dealer_details(
+        &self,
+        address: &AccountId,
+    ) -> Result<DealerDetailsResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealerDetails {
+            dealer_address: address.to_string(),
+        };
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_current_dealers_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedDealerResponse, NyxdError> {
+        let request = DkgQueryMsg::GetCurrentDealers { start_after, limit };
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_past_dealers_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedDealerResponse, NyxdError> {
+        let request = DkgQueryMsg::GetPastDealers { start_after, limit };
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_dealings_paged(
+        &self,
+        idx: u64,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedDealingsResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealing {
+            idx,
+            limit,
+            start_after,
+        };
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_vk_shares_paged(
+        &self,
+        epoch_id: EpochId,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedVKSharesResponse, NyxdError> {
+        let request = DkgQueryMsg::GetVerificationKeys {
+            epoch_id,
+            limit,
+            start_after,
+        };
+        self.query_dkg_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 PagedDkgQueryClient: DkgQueryClient {
+    async fn get_all_current_dealers(&self) -> Result<Vec<DealerDetails>, NyxdError> {
+        collect_paged!(self, get_current_dealers_paged, dealers)
+    }
+
+    async fn get_all_past_dealers(&self) -> Result<Vec<DealerDetails>, NyxdError> {
+        collect_paged!(self, get_past_dealers_paged, dealers)
+    }
+
+    async fn get_all_epoch_dealings(&self, idx: u64) -> Result<Vec<ContractDealing>, NyxdError> {
+        collect_paged!(self, get_dealings_paged, dealings, idx)
+    }
+
+    async fn get_all_verification_key_shares(
+        &self,
+        epoch_id: EpochId,
+    ) -> Result<Vec<ContractVKShare>, NyxdError> {
+        collect_paged!(self, get_vk_shares_paged, shares, epoch_id)
+    }
+}
+
+#[async_trait]
+impl<T> PagedDkgQueryClient for T where T: DkgQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> DkgQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_dkg_contract<T>(&self, query: DkgQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let dkg_contract_address = &self
+            .dkg_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("dkg contract"))?;
+        self.query_contract_smart(dkg_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: DkgQueryClient + Send + Sync>(
+        client: C,
+        msg: DkgQueryMsg,
+    ) {
+        match msg {
+            DkgQueryMsg::GetCurrentEpochState {} => client.get_current_epoch().ignore(),
+            DkgQueryMsg::GetCurrentEpochThreshold {} => {
+                client.get_current_epoch_threshold().ignore()
+            }
+            DkgQueryMsg::GetInitialDealers {} => client.get_initial_dealers().ignore(),
+            DkgQueryMsg::GetDealerDetails { dealer_address } => client
+                .get_dealer_details(&dealer_address.parse().unwrap())
+                .ignore(),
+            DkgQueryMsg::GetCurrentDealers { limit, start_after } => client
+                .get_current_dealers_paged(start_after, limit)
+                .ignore(),
+            DkgQueryMsg::GetPastDealers { limit, start_after } => {
+                client.get_past_dealers_paged(start_after, limit).ignore()
+            }
+            DkgQueryMsg::GetDealing {
+                idx,
+                limit,
+                start_after,
+            } => client.get_dealings_paged(idx, start_after, limit).ignore(),
+            DkgQueryMsg::GetVerificationKeys {
+                epoch_id,
+                limit,
+                start_after,
+            } => client
+                .get_vk_shares_paged(epoch_id, start_after, limit)
+                .ignore(),
+        };
+    }
+}

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

@@ -0,0 +1,176 @@
+// 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 cosmrs::AccountId;
+use cosmwasm_std::Addr;
+use nym_coconut_dkg_common::msg::ExecuteMsg as DkgExecuteMsg;
+use nym_coconut_dkg_common::types::EncodedBTEPublicKeyWithProof;
+use nym_coconut_dkg_common::verification_key::VerificationKeyShare;
+use nym_contracts_common::dealings::ContractSafeBytes;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait DkgSigningClient {
+    async fn execute_dkg_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: DkgExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn advance_dkg_epoch_state(&self, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
+        let req = DkgExecuteMsg::AdvanceEpochState {};
+
+        self.execute_dkg_contract(fee, req, "advancing DKG state".to_string(), vec![])
+            .await
+    }
+
+    async fn surpass_threshold(&self, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
+        let req = DkgExecuteMsg::SurpassedThreshold {};
+
+        self.execute_dkg_contract(fee, req, "surpass DKG threshold".to_string(), vec![])
+            .await
+    }
+
+    async fn register_dealer(
+        &self,
+        bte_key: EncodedBTEPublicKeyWithProof,
+        announce_address: String,
+        resharing: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = DkgExecuteMsg::RegisterDealer {
+            bte_key_with_proof: bte_key,
+            announce_address,
+            resharing,
+        };
+
+        self.execute_dkg_contract(fee, req, "registering as a dealer".to_string(), vec![])
+            .await
+    }
+
+    async fn submit_dealing_bytes(
+        &self,
+        dealing_bytes: ContractSafeBytes,
+        resharing: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = DkgExecuteMsg::CommitDealing {
+            dealing_bytes,
+            resharing,
+        };
+
+        self.execute_dkg_contract(fee, req, "dealing commitment".to_string(), vec![])
+            .await
+    }
+
+    async fn submit_verification_key_share(
+        &self,
+        share: VerificationKeyShare,
+        resharing: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let req = DkgExecuteMsg::CommitVerificationKeyShare { share, resharing };
+
+        self.execute_dkg_contract(
+            fee,
+            req,
+            "verification key share commitment".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn verify_verification_key_share(
+        &self,
+        owner: &AccountId,
+        resharing: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        // the call to unchecked is fine as we're converting from pre-validated `AccountId`
+        let owner = Addr::unchecked(owner.to_string());
+        let req = DkgExecuteMsg::VerifyVerificationKeyShare { owner, resharing };
+
+        self.execute_dkg_contract(
+            fee,
+            req,
+            "verification key VerifyVerificationKeyShare".to_string(),
+            vec![],
+        )
+        .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> DkgSigningClient for C
+where
+    C: SigningCosmWasmClient + NymContractsProvider + Sync,
+    NyxdError: From<<Self as OfflineSigner>::Error>,
+{
+    async fn execute_dkg_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: DkgExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let dkg_contract_address = self
+            .dkg_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("dkg contract"))?;
+
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
+        let signer_address = &self.signer_addresses()?[0];
+
+        self.execute(signer_address, dkg_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: DkgSigningClient + Send + Sync>(
+        client: C,
+        msg: DkgExecuteMsg,
+    ) {
+        match msg {
+            DkgExecuteMsg::RegisterDealer {
+                bte_key_with_proof,
+                announce_address,
+                resharing,
+            } => client
+                .register_dealer(bte_key_with_proof, announce_address, resharing, None)
+                .ignore(),
+            DkgExecuteMsg::CommitDealing {
+                dealing_bytes,
+                resharing,
+            } => client
+                .submit_dealing_bytes(dealing_bytes, resharing, None)
+                .ignore(),
+            DkgExecuteMsg::CommitVerificationKeyShare { share, resharing } => client
+                .submit_verification_key_share(share, resharing, None)
+                .ignore(),
+            DkgExecuteMsg::VerifyVerificationKeyShare { owner, resharing } => client
+                .verify_verification_key_share(
+                    &owner.into_string().parse().unwrap(),
+                    resharing,
+                    None,
+                )
+                .ignore(),
+            DkgExecuteMsg::SurpassedThreshold {} => client.surpass_threshold(None).ignore(),
+            DkgExecuteMsg::AdvanceEpochState {} => client.advance_dkg_epoch_state(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/group_query_client.rs

@@ -0,0 +1,118 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::contract_traits::NymContractsProvider;
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::CosmWasmClient;
+use async_trait::async_trait;
+use cw4::{Member, MemberListResponse, MemberResponse, TotalWeightResponse};
+use nym_group_contract_common::msg::QueryMsg as GroupQueryMsg;
+use serde::Deserialize;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait GroupQueryClient {
+    async fn query_group_contract<T>(&self, query: GroupQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn admin(&self) -> Result<cw_controllers::AdminResponse, NyxdError> {
+        self.query_group_contract(GroupQueryMsg::Admin {}).await
+    }
+
+    async fn total_weight(&self, at_height: Option<u64>) -> Result<TotalWeightResponse, NyxdError> {
+        self.query_group_contract(GroupQueryMsg::TotalWeight { at_height })
+            .await
+    }
+
+    async fn list_members_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<MemberListResponse, NyxdError> {
+        self.query_group_contract(GroupQueryMsg::ListMembers { start_after, limit })
+            .await
+    }
+
+    async fn member(
+        &self,
+        addr: String,
+        at_height: Option<u64>,
+    ) -> Result<MemberResponse, NyxdError> {
+        self.query_group_contract(GroupQueryMsg::Member { addr, at_height })
+            .await
+    }
+
+    async fn hooks(&self) -> Result<cw_controllers::HooksResponse, NyxdError> {
+        self.query_group_contract(GroupQueryMsg::Hooks {}).await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait PagedGroupQueryClient: GroupQueryClient {
+    // can't use the macro due to different paging behaviour
+    async fn get_all_members(&self) -> Result<Vec<Member>, NyxdError> {
+        let mut members = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let mut paged_response = self.list_members_paged(start_after.take(), None).await?;
+
+            let last_id = paged_response.members.last().map(|mem| mem.addr.clone());
+            members.append(&mut paged_response.members);
+
+            if let Some(start_after_res) = last_id {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(members)
+    }
+}
+
+#[async_trait]
+impl<T> PagedGroupQueryClient for T where T: GroupQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> GroupQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_group_contract<T>(&self, query: GroupQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let group_contract_address = &self
+            .group_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("group contract"))?;
+        self.query_contract_smart(group_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: GroupQueryClient + Send + Sync>(
+        client: C,
+        msg: GroupQueryMsg,
+    ) {
+        match msg {
+            GroupQueryMsg::Admin {} => client.admin().ignore(),
+            GroupQueryMsg::TotalWeight { at_height } => client.total_weight(at_height).ignore(),
+            GroupQueryMsg::ListMembers { start_after, limit } => {
+                client.list_members_paged(start_after, limit).ignore()
+            }
+            GroupQueryMsg::Member { addr, at_height } => client.member(addr, at_height).ignore(),
+            GroupQueryMsg::Hooks {} => client.hooks().ignore(),
+        };
+    }
+}

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

@@ -0,0 +1,131 @@
+// Copyright 2023 - 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 cw4::Member;
+use nym_group_contract_common::msg::ExecuteMsg as GroupExecuteMsg;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait GroupSigningClient {
+    async fn execute_group_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: GroupExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError>;
+
+    async fn update_admin(
+        &self,
+        admin: Option<String>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_group_contract(
+            fee,
+            GroupExecuteMsg::UpdateAdmin { admin },
+            "GroupExecuteMsg::UpdateAdmin".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_members(
+        &self,
+        add: Vec<Member>,
+        remove: Vec<String>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_group_contract(
+            fee,
+            GroupExecuteMsg::UpdateMembers { add, remove },
+            "GroupExecuteMsg::UpdateMembers".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn add_hook(&self, addr: String, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
+        self.execute_group_contract(
+            fee,
+            GroupExecuteMsg::AddHook { addr },
+            "GroupExecuteMsg::AddHook".to_string(),
+            vec![],
+        )
+        .await
+    }
+
+    async fn remove_hook(
+        &self,
+        addr: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_group_contract(
+            fee,
+            GroupExecuteMsg::RemoveHook { addr },
+            "GroupExecuteMsg::RemoveHook".to_string(),
+            vec![],
+        )
+        .await
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> GroupSigningClient for C
+where
+    C: SigningCosmWasmClient + NymContractsProvider + Sync,
+    NyxdError: From<<Self as OfflineSigner>::Error>,
+{
+    async fn execute_group_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: GroupExecuteMsg,
+        memo: String,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        let group_contract_address = self
+            .group_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("group contract"))?;
+
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
+
+        let signer_address = &self.signer_addresses()?[0];
+        self.execute(
+            signer_address,
+            group_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: GroupSigningClient + Send + Sync>(
+        client: C,
+        msg: GroupExecuteMsg,
+    ) {
+        match msg {
+            GroupExecuteMsg::UpdateAdmin { admin } => client.update_admin(admin, None).ignore(),
+            GroupExecuteMsg::UpdateMembers { remove, add } => {
+                client.update_members(add, remove, None).ignore()
+            }
+            GroupExecuteMsg::AddHook { addr } => client.add_hook(addr, None).ignore(),
+            GroupExecuteMsg::RemoveHook { addr } => client.remove_hook(addr, None).ignore(),
+        };
+    }
+}

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

@@ -0,0 +1,745 @@
+// 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 cosmrs::AccountId;
+use nym_contracts_common::signing::Nonce;
+use nym_mixnet_contract_common::{
+    delegation,
+    delegation::{MixNodeDelegationResponse, OwnerProxySubKey},
+    families::{Family, FamilyHead},
+    mixnode::{
+        MixnodeRewardingDetailsResponse, PagedMixnodesDetailsResponse,
+        PagedUnbondedMixnodesResponse, StakeSaturationResponse, UnbondedMixnodeResponse,
+    },
+    reward_params::{Performance, RewardingParams},
+    rewarding::{EstimatedCurrentEpochRewardResponse, PendingRewardResponse},
+    ContractBuildInformation, ContractState, ContractStateParams, CurrentIntervalResponse,
+    Delegation, EpochEventId, EpochStatus, FamilyByHeadResponse, FamilyByLabelResponse,
+    FamilyMembersByHeadResponse, FamilyMembersByLabelResponse, GatewayBond, GatewayBondResponse,
+    GatewayOwnershipResponse, IdentityKey, IdentityKeyRef, IntervalEventId, LayerDistribution,
+    MixId, MixNodeBond, MixNodeDetails, MixOwnershipResponse, MixnodeDetailsByIdentityResponse,
+    MixnodeDetailsResponse, NumberOfPendingEventsResponse, PagedAllDelegationsResponse,
+    PagedDelegatorDelegationsResponse, PagedFamiliesResponse, PagedGatewayResponse,
+    PagedMembersResponse, PagedMixNodeDelegationsResponse, PagedMixnodeBondsResponse,
+    PagedRewardedSetResponse, PendingEpochEvent, PendingEpochEventResponse,
+    PendingEpochEventsResponse, PendingIntervalEvent, PendingIntervalEventResponse,
+    PendingIntervalEventsResponse, QueryMsg as MixnetQueryMsg, RewardedSetNodeStatus,
+    UnbondedMixnode,
+};
+use serde::Deserialize;
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait MixnetQueryClient {
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    // state/sys-params-related
+
+    async fn get_mixnet_contract_version(&self) -> Result<ContractBuildInformation, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetContractVersion {})
+            .await
+    }
+
+    async fn get_mixnet_contract_cw2_version(&self) -> Result<cw2::ContractVersion, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetCW2ContractVersion {})
+            .await
+    }
+
+    async fn get_rewarding_validator_address(&self) -> Result<AccountId, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardingValidatorAddress {})
+            .await
+    }
+
+    async fn get_mixnet_contract_settings(&self) -> Result<ContractStateParams, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetStateParams {})
+            .await
+    }
+
+    async fn get_mixnet_contract_state_params(&self) -> Result<ContractStateParams, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetStateParams {})
+            .await
+    }
+
+    async fn get_mixnet_contract_state(&self) -> Result<ContractState, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetState {})
+            .await
+    }
+
+    async fn get_rewarding_parameters(&self) -> Result<RewardingParams, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardingParams {})
+            .await
+    }
+
+    async fn get_current_epoch_status(&self) -> Result<EpochStatus, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetEpochStatus {})
+            .await
+    }
+
+    async fn get_current_interval_details(&self) -> Result<CurrentIntervalResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetCurrentIntervalDetails {})
+            .await
+    }
+
+    async fn get_rewarded_set_paged(
+        &self,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedRewardedSetResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardedSet { limit, start_after })
+            .await
+    }
+
+    async fn get_all_node_families_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedFamiliesResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetAllFamiliesPaged { limit, start_after })
+            .await
+    }
+
+    async fn get_all_family_members_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedMembersResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetAllMembersPaged { limit, start_after })
+            .await
+    }
+
+    async fn get_family_members_by_head<S: Into<String> + Send>(
+        &self,
+        head: S,
+    ) -> Result<FamilyMembersByHeadResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyMembersByHead { head: head.into() })
+            .await
+    }
+
+    async fn get_family_members_by_label<S: Into<String> + Send>(
+        &self,
+        label: S,
+    ) -> Result<FamilyMembersByLabelResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyMembersByLabel {
+            label: label.into(),
+        })
+        .await
+    }
+
+    // mixnode-related:
+
+    async fn get_mixnode_bonds_paged(
+        &self,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedMixnodeBondsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixNodeBonds { limit, start_after })
+            .await
+    }
+
+    async fn get_mixnodes_detailed_paged(
+        &self,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedMixnodesDetailsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixNodesDetailed { limit, start_after })
+            .await
+    }
+
+    async fn get_unbonded_paged(
+        &self,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodes { limit, start_after })
+            .await
+    }
+
+    async fn get_unbonded_by_owner_paged(
+        &self,
+        owner: &AccountId,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodesByOwner {
+            owner: owner.to_string(),
+            limit,
+            start_after,
+        })
+        .await
+    }
+
+    async fn get_unbonded_by_identity_paged(
+        &self,
+        identity_key: IdentityKeyRef<'_>,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodesByIdentityKey {
+            identity_key: identity_key.to_string(),
+            limit,
+            start_after,
+        })
+        .await
+    }
+
+    async fn get_owned_mixnode(
+        &self,
+        address: &AccountId,
+    ) -> Result<MixOwnershipResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetOwnedMixnode {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    async fn get_mixnode_details(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeDetailsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeDetails { mix_id })
+            .await
+    }
+
+    async fn get_mixnode_details_by_identity(
+        &self,
+        mix_identity: IdentityKey,
+    ) -> Result<MixnodeDetailsByIdentityResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetBondedMixnodeDetailsByIdentity {
+            mix_identity,
+        })
+        .await
+    }
+
+    async fn get_mixnode_rewarding_details(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeRewardingDetailsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeRewardingDetails { mix_id })
+            .await
+    }
+
+    async fn get_mixnode_stake_saturation(
+        &self,
+        mix_id: MixId,
+    ) -> Result<StakeSaturationResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetStakeSaturation { mix_id })
+            .await
+    }
+
+    async fn get_unbonded_mixnode_information(
+        &self,
+        mix_id: MixId,
+    ) -> Result<UnbondedMixnodeResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodeInformation { mix_id })
+            .await
+    }
+
+    async fn get_layer_distribution(&self) -> Result<LayerDistribution, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetLayerDistribution {})
+            .await
+    }
+
+    // gateway-related:
+
+    async fn get_gateways_paged(
+        &self,
+        start_after: Option<IdentityKey>,
+        limit: Option<u32>,
+    ) -> Result<PagedGatewayResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetGateways { start_after, limit })
+            .await
+    }
+
+    /// Checks whether there is a bonded gateway associated with the provided identity key
+    async fn get_gateway_bond(
+        &self,
+        identity: IdentityKey,
+    ) -> Result<GatewayBondResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetGatewayBond { identity })
+            .await
+    }
+
+    /// Checks whether there is a bonded gateway associated with the provided client's address
+    async fn get_owned_gateway(
+        &self,
+        address: &AccountId,
+    ) -> Result<GatewayOwnershipResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetOwnedGateway {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    // delegation-related:
+
+    /// Gets list of all delegations towards particular mixnode on particular page.
+    async fn get_mixnode_delegations_paged(
+        &self,
+        mix_id: MixId,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedMixNodeDelegationsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeDelegations {
+            mix_id,
+            start_after,
+            limit,
+        })
+        .await
+    }
+
+    /// Gets list of all the mixnodes to which a particular address delegated.
+    async fn get_delegator_delegations_paged(
+        &self,
+        delegator: &AccountId,
+        start_after: Option<(MixId, OwnerProxySubKey)>,
+        limit: Option<u32>,
+    ) -> Result<PagedDelegatorDelegationsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetDelegatorDelegations {
+            delegator: delegator.to_string(),
+            start_after,
+            limit,
+        })
+        .await
+    }
+
+    /// Checks value of delegation of given client towards particular mixnode.
+    async fn get_delegation_details(
+        &self,
+        mix_id: MixId,
+        delegator: &AccountId,
+        proxy: Option<String>,
+    ) -> Result<MixNodeDelegationResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetDelegationDetails {
+            mix_id,
+            delegator: delegator.to_string(),
+            proxy,
+        })
+        .await
+    }
+
+    /// Gets all the delegations on the entire network
+    async fn get_all_network_delegations_paged(
+        &self,
+        start_after: Option<delegation::StorageKey>,
+        limit: Option<u32>,
+    ) -> Result<PagedAllDelegationsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetAllDelegations { start_after, limit })
+            .await
+    }
+
+    // rewards related
+    async fn get_pending_operator_reward(
+        &self,
+        operator: &AccountId,
+    ) -> Result<PendingRewardResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingOperatorReward {
+            address: operator.to_string(),
+        })
+        .await
+    }
+
+    async fn get_pending_mixnode_operator_reward(
+        &self,
+        mix_id: MixId,
+    ) -> Result<PendingRewardResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingMixNodeOperatorReward { mix_id })
+            .await
+    }
+
+    async fn get_pending_delegator_reward(
+        &self,
+        delegator: &AccountId,
+        mix_id: MixId,
+        proxy: Option<String>,
+    ) -> Result<PendingRewardResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingDelegatorReward {
+            address: delegator.to_string(),
+            mix_id,
+            proxy,
+        })
+        .await
+    }
+
+    // given the provided performance, estimate the reward at the end of the current epoch
+    async fn get_estimated_current_epoch_operator_reward(
+        &self,
+        mix_id: MixId,
+        estimated_performance: Performance,
+    ) -> Result<EstimatedCurrentEpochRewardResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetEstimatedCurrentEpochOperatorReward {
+            mix_id,
+            estimated_performance,
+        })
+        .await
+    }
+
+    // given the provided performance, estimate the reward at the end of the current epoch
+    async fn get_estimated_current_epoch_delegator_reward(
+        &self,
+        delegator: &AccountId,
+        mix_id: MixId,
+        proxy: Option<String>,
+        estimated_performance: Performance,
+    ) -> Result<EstimatedCurrentEpochRewardResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetEstimatedCurrentEpochDelegatorReward {
+            address: delegator.to_string(),
+            mix_id,
+            proxy,
+            estimated_performance,
+        })
+        .await
+    }
+
+    // interval-related
+
+    async fn get_pending_epoch_events_paged(
+        &self,
+        start_after: Option<EpochEventId>,
+        limit: Option<u32>,
+    ) -> Result<PendingEpochEventsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingEpochEvents { start_after, limit })
+            .await
+    }
+
+    async fn get_pending_interval_events_paged(
+        &self,
+        start_after: Option<IntervalEventId>,
+        limit: Option<u32>,
+    ) -> Result<PendingIntervalEventsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingIntervalEvents { start_after, limit })
+            .await
+    }
+
+    async fn get_pending_epoch_event(
+        &self,
+        event_id: EpochEventId,
+    ) -> Result<PendingEpochEventResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingEpochEvent { event_id })
+            .await
+    }
+
+    async fn get_pending_interval_event(
+        &self,
+        event_id: IntervalEventId,
+    ) -> Result<PendingIntervalEventResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingIntervalEvent { event_id })
+            .await
+    }
+
+    async fn get_number_of_pending_events(
+        &self,
+    ) -> Result<NumberOfPendingEventsResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetNumberOfPendingEvents {})
+            .await
+    }
+
+    async fn get_signing_nonce(&self, address: &AccountId) -> Result<Nonce, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetSigningNonce {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    async fn get_node_family_by_label(
+        &self,
+        label: String,
+    ) -> Result<FamilyByLabelResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyByLabel { label })
+            .await
+    }
+
+    async fn get_node_family_by_head(
+        &self,
+        head: String,
+    ) -> Result<FamilyByHeadResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyByHead { head })
+            .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 PagedMixnetQueryClient: MixnetQueryClient {
+    async fn get_all_node_families(&self) -> Result<Vec<Family>, NyxdError> {
+        collect_paged!(self, get_all_node_families_paged, families)
+    }
+
+    async fn get_all_family_members(&self) -> Result<Vec<(IdentityKey, FamilyHead)>, NyxdError> {
+        collect_paged!(self, get_all_family_members_paged, members)
+    }
+
+    async fn get_all_rewarded_set_mixnodes(
+        &self,
+    ) -> Result<Vec<(MixId, RewardedSetNodeStatus)>, NyxdError> {
+        collect_paged!(self, get_rewarded_set_paged, nodes)
+    }
+
+    async fn get_all_mixnode_bonds(&self) -> Result<Vec<MixNodeBond>, NyxdError> {
+        collect_paged!(self, get_mixnode_bonds_paged, nodes)
+    }
+
+    async fn get_all_mixnodes_detailed(&self) -> Result<Vec<MixNodeDetails>, NyxdError> {
+        collect_paged!(self, get_mixnodes_detailed_paged, nodes)
+    }
+
+    async fn get_all_unbonded_mixnodes(&self) -> Result<Vec<(MixId, UnbondedMixnode)>, NyxdError> {
+        collect_paged!(self, get_unbonded_paged, nodes)
+    }
+
+    async fn get_all_unbonded_mixnodes_by_owner(
+        &self,
+        owner: &AccountId,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, NyxdError> {
+        collect_paged!(self, get_unbonded_by_owner_paged, nodes, owner)
+    }
+
+    async fn get_all_unbonded_mixnodes_by_identity(
+        &self,
+        identity_key: IdentityKeyRef<'_>,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, NyxdError> {
+        collect_paged!(self, get_unbonded_by_identity_paged, nodes, identity_key)
+    }
+
+    async fn get_all_gateways(&self) -> Result<Vec<GatewayBond>, NyxdError> {
+        collect_paged!(self, get_gateways_paged, nodes)
+    }
+
+    async fn get_all_single_mixnode_delegations(
+        &self,
+        mix_id: MixId,
+    ) -> Result<Vec<Delegation>, NyxdError> {
+        collect_paged!(self, get_mixnode_delegations_paged, delegations, mix_id)
+    }
+
+    async fn get_all_delegator_delegations(
+        &self,
+        delegation_owner: &AccountId,
+    ) -> Result<Vec<Delegation>, NyxdError> {
+        collect_paged!(
+            self,
+            get_delegator_delegations_paged,
+            delegations,
+            delegation_owner
+        )
+    }
+
+    async fn get_all_network_delegations(&self) -> Result<Vec<Delegation>, NyxdError> {
+        collect_paged!(self, get_all_network_delegations_paged, delegations)
+    }
+
+    async fn get_all_pending_epoch_events(&self) -> Result<Vec<PendingEpochEvent>, NyxdError> {
+        collect_paged!(self, get_pending_epoch_events_paged, events)
+    }
+
+    async fn get_all_pending_interval_events(
+        &self,
+    ) -> Result<Vec<PendingIntervalEvent>, NyxdError> {
+        collect_paged!(self, get_pending_interval_events_paged, events)
+    }
+}
+
+#[async_trait]
+impl<T> PagedMixnetQueryClient for T where T: MixnetQueryClient {}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<C> MixnetQueryClient for C
+where
+    C: CosmWasmClient + NymContractsProvider + Send + Sync,
+{
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NyxdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        let mixnet_contract_address = &self
+            .mixnet_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("mixnet contract"))?;
+        self.query_contract_smart(mixnet_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: MixnetQueryClient + Send + Sync>(
+        client: C,
+        msg: MixnetQueryMsg,
+    ) -> u32 {
+        match msg {
+            MixnetQueryMsg::GetAllFamiliesPaged { limit, start_after } => client
+                .get_all_family_members_paged(start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetAllMembersPaged { limit, start_after } => client
+                .get_all_family_members_paged(start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetFamilyByHead { head } => {
+                client.get_node_family_by_head(head).ignore()
+            }
+            MixnetQueryMsg::GetFamilyByLabel { label } => {
+                client.get_node_family_by_label(label).ignore()
+            }
+            MixnetQueryMsg::GetFamilyMembersByHead { head } => {
+                client.get_family_members_by_head(head).ignore()
+            }
+            MixnetQueryMsg::GetFamilyMembersByLabel { label } => {
+                client.get_family_members_by_label(label).ignore()
+            }
+            MixnetQueryMsg::GetContractVersion {} => client.get_mixnet_contract_version().ignore(),
+            MixnetQueryMsg::GetCW2ContractVersion {} => {
+                client.get_mixnet_contract_cw2_version().ignore()
+            }
+            MixnetQueryMsg::GetRewardingValidatorAddress {} => {
+                client.get_rewarding_validator_address().ignore()
+            }
+            MixnetQueryMsg::GetStateParams {} => client.get_mixnet_contract_state_params().ignore(),
+            MixnetQueryMsg::GetState {} => client.get_mixnet_contract_state().ignore(),
+            MixnetQueryMsg::GetRewardingParams {} => client.get_rewarding_parameters().ignore(),
+            MixnetQueryMsg::GetEpochStatus {} => client.get_current_epoch_status().ignore(),
+            MixnetQueryMsg::GetCurrentIntervalDetails {} => {
+                client.get_current_interval_details().ignore()
+            }
+            MixnetQueryMsg::GetRewardedSet { limit, start_after } => {
+                client.get_rewarded_set_paged(start_after, limit).ignore()
+            }
+            MixnetQueryMsg::GetMixNodeBonds { limit, start_after } => {
+                client.get_mixnode_bonds_paged(start_after, limit).ignore()
+            }
+            MixnetQueryMsg::GetMixNodesDetailed { limit, start_after } => client
+                .get_mixnodes_detailed_paged(start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetUnbondedMixNodes { limit, start_after } => {
+                client.get_unbonded_paged(start_after, limit).ignore()
+            }
+            MixnetQueryMsg::GetUnbondedMixNodesByOwner {
+                owner,
+                limit,
+                start_after,
+            } => client
+                .get_unbonded_by_owner_paged(&owner.parse().unwrap(), start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetUnbondedMixNodesByIdentityKey {
+                identity_key,
+                limit,
+                start_after,
+            } => client
+                .get_unbonded_by_identity_paged(&identity_key, start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetOwnedMixnode { address } => {
+                client.get_owned_mixnode(&address.parse().unwrap()).ignore()
+            }
+            MixnetQueryMsg::GetMixnodeDetails { mix_id } => {
+                client.get_mixnode_details(mix_id).ignore()
+            }
+            MixnetQueryMsg::GetMixnodeRewardingDetails { mix_id } => {
+                client.get_mixnode_rewarding_details(mix_id).ignore()
+            }
+            MixnetQueryMsg::GetStakeSaturation { mix_id } => {
+                client.get_mixnode_stake_saturation(mix_id).ignore()
+            }
+            MixnetQueryMsg::GetUnbondedMixNodeInformation { mix_id } => {
+                client.get_unbonded_mixnode_information(mix_id).ignore()
+            }
+            MixnetQueryMsg::GetBondedMixnodeDetailsByIdentity { mix_identity } => client
+                .get_mixnode_details_by_identity(mix_identity)
+                .ignore(),
+            MixnetQueryMsg::GetLayerDistribution {} => client.get_layer_distribution().ignore(),
+            MixnetQueryMsg::GetGateways { start_after, limit } => {
+                client.get_gateways_paged(start_after, limit).ignore()
+            }
+            MixnetQueryMsg::GetGatewayBond { identity } => {
+                client.get_gateway_bond(identity).ignore()
+            }
+            MixnetQueryMsg::GetOwnedGateway { address } => {
+                client.get_owned_gateway(&address.parse().unwrap()).ignore()
+            }
+            MixnetQueryMsg::GetMixnodeDelegations {
+                mix_id,
+                start_after,
+                limit,
+            } => client
+                .get_mixnode_delegations_paged(mix_id, start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetDelegatorDelegations {
+                delegator,
+                start_after,
+                limit,
+            } => client
+                .get_delegator_delegations_paged(&delegator.parse().unwrap(), start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetDelegationDetails {
+                mix_id,
+                delegator,
+                proxy,
+            } => client
+                .get_delegation_details(mix_id, &delegator.parse().unwrap(), proxy)
+                .ignore(),
+            MixnetQueryMsg::GetAllDelegations { start_after, limit } => client
+                .get_all_network_delegations_paged(start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetPendingOperatorReward { address } => client
+                .get_pending_operator_reward(&address.parse().unwrap())
+                .ignore(),
+            MixnetQueryMsg::GetPendingMixNodeOperatorReward { mix_id } => {
+                client.get_pending_mixnode_operator_reward(mix_id).ignore()
+            }
+            MixnetQueryMsg::GetPendingDelegatorReward {
+                address,
+                mix_id,
+                proxy,
+            } => client
+                .get_pending_delegator_reward(&address.parse().unwrap(), mix_id, proxy)
+                .ignore(),
+            MixnetQueryMsg::GetEstimatedCurrentEpochOperatorReward {
+                mix_id,
+                estimated_performance,
+            } => client
+                .get_estimated_current_epoch_operator_reward(mix_id, estimated_performance)
+                .ignore(),
+            MixnetQueryMsg::GetEstimatedCurrentEpochDelegatorReward {
+                address,
+                mix_id,
+                proxy,
+                estimated_performance,
+            } => client
+                .get_estimated_current_epoch_delegator_reward(
+                    &address.parse().unwrap(),
+                    mix_id,
+                    proxy,
+                    estimated_performance,
+                )
+                .ignore(),
+            MixnetQueryMsg::GetPendingEpochEvents { limit, start_after } => client
+                .get_pending_epoch_events_paged(start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetPendingIntervalEvents { limit, start_after } => client
+                .get_pending_interval_events_paged(start_after, limit)
+                .ignore(),
+            MixnetQueryMsg::GetPendingEpochEvent { event_id } => {
+                client.get_pending_epoch_event(event_id).ignore()
+            }
+            MixnetQueryMsg::GetPendingIntervalEvent { event_id } => {
+                client.get_pending_interval_event(event_id).ignore()
+            }
+            MixnetQueryMsg::GetNumberOfPendingEvents {} => {
+                client.get_number_of_pending_events().ignore()
+            }
+            MixnetQueryMsg::GetSigningNonce { address } => {
+                client.get_signing_nonce(&address.parse().unwrap()).ignore()
+            }
+        }
+    }
+}