added note that operators can decrease self bond via wallet

* ci: don't fail fast for contracts

* contracts: fix clippy in tests

.github/dependabot.yml

@@ -0,0 +1,16 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "daily"
+    commit-message:
+        prefix: build
+        prefix-development: chore
+        include: scope

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

@@ -80,7 +80,7 @@ jobs:
           components: rustfmt, clippy
 
       - name: Install wasm-opt
-        run: cargo install wasm-opt
+        run: cargo install --version 0.112.0 wasm-opt
 
       - name: Build release contracts
         run: make wasm
@@ -98,10 +98,15 @@ jobs:
           cp target/release/nym-network-requester $OUTPUT_DIR
           cp target/release/nym-network-statistics $OUTPUT_DIR
           cp target/release/nym-cli $OUTPUT_DIR
-          cp target/release/credential $OUTPUT_DIR
+          cp target/release/nym-credential-client $OUTPUT_DIR
+          cp target/release/explorer-api $OUTPUT_DIR
           
           cp contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_bandwidth.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_dkg.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
 
       - name: Deploy branch to CI www
         continue-on-error: true

.github/workflows/cd-dev.yml

@@ -0,0 +1,76 @@
+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: "16"
+      - 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

@@ -0,0 +1,82 @@
+name: CD docs
+
+on:
+  push:
+    branches: master
+    paths:
+      - 'documentation/docs/**'
+
+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: "16"
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --release --all
+      - 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 && \
+            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
+      - 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/"
+          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/"
+      - 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/docs/book/"
+          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/"
+      - name: Matrix - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Matrix - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: cd-docs
+          NYM_PROJECT_NAME: "Docs 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_DOCS }}"
+          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-dev.yml

@@ -0,0 +1,66 @@
+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: "16"
+      - 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

@@ -0,0 +1,72 @@
+name: CI docs
+
+on:
+  push:
+    branches-ignore: master
+    paths:
+      - 'documentation/docs/**'
+
+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: "16"
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --release --all
+      - 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 && \
+            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
+      - 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/"
+          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/"
+      - name: Matrix - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Matrix - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: ci-docs
+          NYM_PROJECT_NAME: "Docs CI"
+          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+          NYM_CI_WWW_LOCATION: "docs-${{ 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_DOCS }}"
+          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/contracts-build.yml

@@ -20,7 +20,7 @@ jobs:
           components: rustfmt, clippy
 
       - name: Install wasm-opt
-        run: cargo install wasm-opt
+        run: cargo install --version 0.112.0 wasm-opt
 
       - name: Build release contracts
         run: make wasm

.github/workflows/contracts.yml

@@ -30,6 +30,7 @@ jobs:
     continue-on-error: ${{ matrix.rust == 'nightly' }}
     needs: matrix_prep
     strategy:
+      fail-fast: false
       matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
     steps:
       - uses: actions/checkout@v2
@@ -63,4 +64,4 @@ jobs:
         if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
-          args: --manifest-path contracts/Cargo.toml --workspace -- -D warnings
+          args: --manifest-path contracts/Cargo.toml --workspace --all-targets -- -D warnings

.github/workflows/greetings.yml

@@ -0,0 +1,13 @@
+name: Greetings
+
+on: [pull_request_target, issues]
+
+jobs:
+  greeting:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/first-interaction@v1
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        issue-message: 'Thank you for raising this issue'
+        pr-message: 'Thank you for making this first PR'

.github/workflows/support-files/cd-dev/index.js

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

.github/workflows/support-files/cd-dev/templates/failure

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

.github/workflows/support-files/cd-dev/templates/success

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

.github/workflows/support-files/cd-docs/index.js

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

.github/workflows/support-files/cd-docs/templates/failure

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

.github/workflows/support-files/cd-docs/templates/success

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

.github/workflows/support-files/ci-dev/index.js

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

.github/workflows/support-files/ci-dev/templates/failure

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

.github/workflows/support-files/ci-dev/templates/success

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

.github/workflows/support-files/ci-docs/index.js

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

.github/workflows/support-files/ci-docs/templates/failure

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

.github/workflows/support-files/ci-docs/templates/success

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

.github/workflows/support-files/notifications/send_message.js

@@ -3,7 +3,7 @@ require('dotenv').config();
 const { sendMatrixMessage } = require('./send_message_to_matrix');
 
 let context = {
-  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect','security'],
+  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect','security','ci-docs','cd-docs','ci-dev','cd-dev'],
 };
 
 /**

.github/workflows/support-files/package.json

@@ -22,6 +22,6 @@
     "unified": "^9.2.2"
   },
   "devDependencies": {
-    "prettier": "2.3.2"
+    "prettier": "^2.8.7"
   }
 }

.github/workflows/wallet.yml

@@ -64,4 +64,4 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: clippy
-          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-features -- -D warnings
+          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-features --all-targets -- -D warnings

.gitignore

@@ -39,7 +39,6 @@ validator-api-config.toml
 dist
 storybook-static
 envs/qwerty.env
-Cargo.lock
-nym-connect/Cargo.lock
 .parcel-cache
 **/.DS_Store
+cpu-cycles/libcpucycles/build

CHANGELOG.md

@@ -4,6 +4,72 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
+- nym-network-statistics properly handles signals ([#3209])
+- add socks5 support for Rust SDK ([#3226], [#3255])
+- add coconut bandwidth credential support for Rust SDK ([#3273]) 
+
+[#3209]: https://github.com/nymtech/nym/issues/3209
+[#3226]: https://github.com/nymtech/nym/pull/3226
+[#3255]: https://github.com/nymtech/nym/pull/3255
+[#3273]: https://github.com/nymtech/nym/pull/3273
+
+## [v1.1.15] (2023-04-18)
+
+- Fix verloc being stuck waiting for shutdown signal ([#3250])
+- Introduce `--output json` flag to `sign` command to allow to more easily capture the output ([#3249])
+- Explorer - Dont fetch Service Provider list on Testnet ([#3245])
+- When determining active set, rather than weighting the nodes by just the `stake`, use `stake * performance` ([#3234])
+- Introduce dual packet sizes to our clients (as in use two packet sizes at the same time depending on message size) ([#3189])
+- Experiment with offline signing in our validator client ([#3174])
+- Modify network requester binary to reload `allowed.list` periodically to pull in any changes made upstream without having to restart the service ([#3149])
+- Standardise all `--output json` on binary inits, we pass the output json at different points for different binaries. ([#3080])
+- Service provider directory contract: initial version ([#2759])
+- Fix issue where network-requester run failed on fresh init due to missing allow file ([#3316])
+
+[#3250]: https://github.com/nymtech/nym/issues/3250
+[#3249]: https://github.com/nymtech/nym/issues/3249
+[#3245]: https://github.com/nymtech/nym/issues/3245
+[#3234]: https://github.com/nymtech/nym/issues/3234
+[#3189]: https://github.com/nymtech/nym/issues/3189
+[#3174]: https://github.com/nymtech/nym/issues/3174
+[#3149]: https://github.com/nymtech/nym/issues/3149
+[#3080]: https://github.com/nymtech/nym/issues/3080
+[#2759]: https://github.com/nymtech/nym/issues/2759
+[#3316]: https://github.com/nymtech/nym/pull/3316
+
+## [v1.1.14] (2023-04-04)
+
+- Investigate cause of qwerty validator being in invalid rewarding state ([#3224])
+- Fix NR config due to changes in #3199 ([#3223])
+- [Issue] Mixnodes and gateway do not close connections properly  ([#3187])
+- disable sign-ext when using wasm-opt + update wasm-opt ([#3203])
+- chore: tidy up client `Debug` config section ([#3199])
+
+[#3224]: https://github.com/nymtech/nym/issues/3224
+[#3223]: https://github.com/nymtech/nym/issues/3223
+[#3187]: https://github.com/nymtech/nym/issues/3187
+[#3203]: https://github.com/nymtech/nym/pull/3203
+[#3199]: https://github.com/nymtech/nym/pull/3199
+>>>>>>> master
+
+## [v1.1.13] (2023-03-15)
+
+- NE - instead of throwing a "Mixnode/Gateway not found" error for blacklisted nodes due to bad performance, show their history but tag them as "Having poor performance" ([#2979])
+- NE - Upgrade Sandbox and make below changes:  ([#2332])
+- Explorer - Updates ([#3168])
+- Website v2 - deploy infrastructure for strapi and CI ([#2213])
+- add blockstream green to sp list ([#3180])
+- mock-nym-api: fix .storybook lint error ([#3178])
+- Validating new interval config parameters to prevent division by zero ([#3153])
+
+[#2979]: https://github.com/nymtech/nym/issues/2979
+[#2332]: https://github.com/nymtech/nym/issues/2332
+[#3168]: https://github.com/nymtech/nym/issues/3168
+[#2213]: https://github.com/nymtech/nym/issues/2213
+[#3180]: https://github.com/nymtech/nym/pull/3180
+[#3178]: https://github.com/nymtech/nym/pull/3178
+[#3153]: https://github.com/nymtech/nym/pull/3153
+
 ## [v1.1.12] (2023-03-07)
 
 - Fix generated docs for mixnet and vesting contract on docs.rs ([#3093])

Cargo.toml

@@ -17,13 +17,14 @@ opt-level = 3
 
 resolver = "2"
 members = [
-    "clients/client-core",
     "clients/credential",
     "clients/native",
     "clients/native/websocket-requests",
     "clients/socks5",
-    "common/bandwidth-claim-contract",
+    "common/async-file-watcher",
+    "common/bandwidth-controller",
     "common/bin-common",
+    "common/client-core",
     "common/client-libs/gateway-client",
     "common/client-libs/mixnet-client",
     "common/client-libs/validator-client",
@@ -36,8 +37,8 @@ members = [
     "common/cosmwasm-smart-contracts/group-contract",
     "common/cosmwasm-smart-contracts/mixnet-contract",
     "common/cosmwasm-smart-contracts/multisig-contract",
+    "common/cosmwasm-smart-contracts/service-provider-directory",
     "common/cosmwasm-smart-contracts/vesting-contract",
-    "common/mobile-storage",
     "common/credential-storage",
     "common/credentials",
     "common/crypto",
@@ -60,6 +61,7 @@ members = [
     "common/nymsphinx/params",
     "common/nymsphinx/types",
     "common/pemstore",
+    "common/socks5-client-core",
     "common/socks5/proxy-helpers",
     "common/socks5/requests",
     "common/statistics",
@@ -94,7 +96,7 @@ default-members = [
     "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop"]
+exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "cpu-cycles"]
 
 [workspace.package]
 authors = ["Nym Technologies SA"]
@@ -106,8 +108,19 @@ license = "Apache-2.0"
 
 [workspace.dependencies]
 async-trait = "0.1.64"
+bip39 = { version = "2.0.0", features = ["zeroize"] }
 cfg-if = "1.0.0"
-dotenv = "0.15.0"
+cosmwasm-derive = "=1.0.0"
+cosmwasm-schema = "=1.0.0"
+cosmwasm-std = "=1.0.0"
+cosmwasm-storage = "=1.0.0"
+cw-utils = "=0.13.4"
+cw-storage-plus = "=0.13.4"
+cw2 = { version = "=0.13.4" }
+cw3 = { version = "=0.13.4" }
+cw3-fixed-multisig = { version = "=0.13.4" }
+cw4 = { version = "=0.13.4" }
+dotenvy = "0.15.6"
 lazy_static = "1.4.0"
 log = "0.4"
 once_cell = "1.7.2"

Makefile

@@ -1,134 +1,116 @@
+# Default target
+all: test
+
 test: clippy-all cargo-test wasm fmt
+
 test-all: test cargo-test-expensive
+
 no-clippy: build cargo-test wasm fmt
+
 happy: fmt clippy-happy test
-clippy-all: clippy-main clippy-main-examples clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-connect-mobile clippy-all-wasm-client
-clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect clippy-happy-connect-mobile
-cargo-test: test-main test-contracts test-wallet test-connect test-connect-mobile
-cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
-build: build-contracts build-wallet build-main build-main-examples build-connect build-connect-mobile build-wasm-client
-fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-connect-mobile fmt-wasm-client
 
-clippy-happy-main:
-	cargo clippy
+# Building release binaries is a little manual as we can't just build --release
+# on all workspaces.
+build-release: build-release-main wasm
 
-clippy-happy-contracts:
-	cargo clippy --manifest-path contracts/Cargo.toml --target wasm32-unknown-unknown
+# -----------------------------------------------------------------------------
+# Define targets for a given workspace
+#  $(1): name
+#  $(2): path to workspace
+#  $(3): extra arguments to cargo
+# -----------------------------------------------------------------------------
+define add_cargo_workspace
 
-clippy-happy-wallet:
-	cargo clippy --manifest-path nym-wallet/Cargo.toml
+clippy-happy-$(1):
+	cargo clippy --manifest-path $(2)/Cargo.toml $(3)
 
-clippy-happy-connect:
-	cargo clippy --manifest-path nym-connect/desktop/Cargo.toml
+clippy-$(1):
+	cargo clippy --manifest-path $(2)/Cargo.toml --workspace $(3) -- -D warnings
 
-clippy-happy-connect-mobile:
-	cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml
+clippy-examples-$(1):
+	cargo clippy --manifest-path $(2)/Cargo.toml --workspace --examples -- -D warnings
 
-clippy-main:
-	cargo clippy --workspace -- -D warnings
+check-$(1):
+	cargo check --manifest-path $(2)/Cargo.toml --workspace $(3)
 
-clippy-main-examples:
-	cargo clippy --workspace --examples -- -D warnings
+test-$(1):
+	cargo test --manifest-path $(2)/Cargo.toml --workspace
 
-clippy-wasm:
-	cargo clippy --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --workspace -- -D warnings
+test-expensive-$(1):
+	cargo test --manifest-path $(2)/Cargo.toml --workspace -- --ignored
 
+build-$(1):
+	cargo build --manifest-path $(2)/Cargo.toml --workspace $(3)
 
-clippy-all-contracts:
-	cargo clippy --workspace --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
+build-examples-$(1):
+	cargo build --manifest-path $(2)/Cargo.toml --workspace --examples
 
-clippy-all-wallet:
-	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings
+build-release-$(1):
+	cargo build --manifest-path $(2)/Cargo.toml --workspace --release $(3)
 
-clippy-all-connect:
-	cargo clippy --workspace --manifest-path nym-connect/desktop/Cargo.toml --all-features -- -D warnings
+fmt-$(1):
+	cargo fmt --manifest-path $(2)/Cargo.toml --all
 
-clippy-all-connect-mobile:
-	cargo clippy --workspace --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- -D warnings
+clippy-happy: clippy-happy-$(1)
+clippy-all: clippy-$(1) clippy-examples-$(1)
+check: check-$(1)
+cargo-test: test-$(1)
+cargo-test-expensive: test-expensive-$(1)
+build: build-$(1) build-$(1)-examples
+build-release-all: build-release-$(1)
+fmt: fmt-$(1)
 
-clippy-all-wasm-client:
-	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
+endef
 
-test-main:
-	cargo test --workspace
+# -----------------------------------------------------------------------------
+# Rust workspaces
+# -----------------------------------------------------------------------------
 
-test-main-expensive:
-	cargo test --workspace -- --ignored
+# Generate targets for the various cargo workspaces
 
-test-contracts:
-	cargo test --manifest-path contracts/Cargo.toml --all-features
+$(eval $(call add_cargo_workspace,main,.))
+$(eval $(call add_cargo_workspace,contracts,contracts,--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))
+ifdef NYM_MOBILE
+$(eval $(call add_cargo_workspace,connect-mobile,nym-connect/mobile/src-tauri))
+endif
 
-test-contracts-expensive:
-	cargo test --manifest-path contracts/Cargo.toml --all-features -- --ignored
-
-test-wallet:
-	cargo test --manifest-path nym-wallet/Cargo.toml --all-features
-
-test-wallet-expensive:
-	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored
-
-test-connect:
-	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features
-
-test-connect-expensive:
-	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features -- --ignored
-
-test-connect-mobile:
-	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features
-
-test-connect-mobile-expensive:
-	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- --ignored
-
-build-main:
-	cargo build --workspace
-
-build-main-examples:
-	cargo build --workspace --examples
-
-build-contracts:
-	cargo build --manifest-path contracts/Cargo.toml --workspace
-
-build-wallet:
-	cargo build --manifest-path nym-wallet/Cargo.toml --workspace
-
-build-connect:
-	cargo build --manifest-path nym-connect/desktop/Cargo.toml --workspace
-
-build-connect-mobile:
-	cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --workspace
+# -----------------------------------------------------------------------------
+# Convenience targets for crates that are already part of the main workspace
+# -----------------------------------------------------------------------------
 
 build-explorer-api:
-	cargo build --manifest-path explorer-api/Cargo.toml --workspace
-
-build-wasm-client:
-	cargo build --manifest-path clients/webassembly/Cargo.toml --workspace --target wasm32-unknown-unknown
+	cargo build -p explorer-api
 
 build-nym-cli:
-	cargo build --release --manifest-path tools/nym-cli/Cargo.toml
+	cargo build -p nym-cli --release
 
-fmt-main:
-	cargo fmt --all
+# -----------------------------------------------------------------------------
+# Build contracts ready for deploy
+# -----------------------------------------------------------------------------
 
-fmt-contracts:
-	cargo fmt --manifest-path contracts/Cargo.toml --all
+CONTRACTS_OUT_DIR=contracts/target/wasm32-unknown-unknown/release
+VESTING_CONTRACT=$(CONTRACTS_OUT_DIR)/vesting_contract.wasm
+MIXNET_CONTRACT=$(CONTRACTS_OUT_DIR)/mixnet_contract.wasm
+SERVICE_PROVIDER_DIRECTORY_CONTRACT=$(CONTRACTS_OUT_DIR)/nym_service_provider_directory.wasm
 
-fmt-wallet:
-	cargo fmt --manifest-path nym-wallet/Cargo.toml --all
+wasm: wasm-build wasm-opt
 
-fmt-connect:
-	cargo fmt --manifest-path nym-connect/desktop/Cargo.toml --all
-
-fmt-connect-mobile:
-	cargo fmt --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all
-
-fmt-wasm-client:
-	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all
-
-wasm:
+wasm-build:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
-	wasm-opt -Os contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
-	wasm-opt -Os contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm
 
+wasm-opt:
+	wasm-opt --disable-sign-ext -Os $(VESTING_CONTRACT) -o $(VESTING_CONTRACT)
+	wasm-opt --disable-sign-ext -Os $(MIXNET_CONTRACT) -o $(MIXNET_CONTRACT)
+	wasm-opt --disable-sign-ext -Os $(SERVICE_PROVIDER_DIRECTORY_CONTRACT) -o $(SERVICE_PROVIDER_DIRECTORY_CONTRACT)
+
+# -----------------------------------------------------------------------------
+# Misc
+# -----------------------------------------------------------------------------
+
+# NOTE: this seems deprecated an not needed anymore?
 mixnet-opt: wasm
 	cd contracts/mixnet && make opt
 

README.md

@@ -16,12 +16,12 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
-[![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/nymtech/nym/build.yml?branch=develop&style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
 
 
 ### Building
 
-Platform build instructions are available on [our docs site](https://nymtech.net/docs/stable/run-nym-nodes/build-nym).
+Platform build instructions are available on [our docs site](https://nymtech.net/docs/binaries/building-nym.html).
 Wallet build instructions are also available on [our docs site](https://nymtech.net/docs/stable/nym-apps/wallet#for-developers).
 
 ### Developing

SECURITY.md

@@ -3,8 +3,8 @@ Critical bug or security issue 💥
 If you're here because you're trying to figure out how to notify us of a security issue, go to Discord, and alert the core engineers:
 
     Dave Hrycyszyn futurechimp#5430
-    Drazen Urch drazen#4873
     Jedrzej Stuczynski "Jedrzej | Nym#5666"
+    Fran Arbanas | franarbanas#0995
+    Mark Sinclair | marknym#8088 
 
-
-Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.
+Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.

clients/credential/Cargo.toml

@@ -1,27 +1,23 @@
 [package]
-name = "credential"
+name = "nym-credential-client"
 version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bip39 = "1.0.1"
 clap = { version = "4.0", features = ["cargo", "derive"] }
 log = "0.4"
-rand = "0.7.3"
-serde = { version = "1.0", features = ["derive"] }
+serde = { workspace = true, features = ["derive"] }
 thiserror = "1.0"
-url = "2.2"
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
 
-coconut-interface = { path = "../../common/coconut-interface" }
+nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-config = { path = "../../common/config" }
-credentials = { path = "../../common/credentials" }
-credential-storage = { path = "../../common/credential-storage" }
-nym-crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
+nym-credentials = { path = "../../common/credentials" }
+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" }
-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
 

clients/credential/README.md

@@ -0,0 +1,32 @@
+<!--
+Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+SPDX-License-Identifier: Apache-2.0
+-->
+
+## Credential binary
+
+The credential binary is used to acquire coconut bandwidth credentials in exchange for nym tokens. Those credentials are stored in the client's `data` directory, so that they can be used as the client sees fit.
+
+### Warning
+
+The credential binary is still experimental software. The infrastructure for using it is not yet deployed to mainnet and it's still in the process of being deployed to sandbox.
+
+### Building
+
+From the project's root directory, run:
+```
+cargo build -p credential
+```
+which generates the `credential` binary in `target/debug/credential`.
+
+
+### Running
+
+For example, you can get a credential worth 3 nym (3000000 unym) in a socks5 client that was already initialized like so:
+
+```
+./target/debug/credential --config-env-file envs/sandbox.env --client-home-directory  ~/.nym/socks5-clients/cred_client  --nyxd-url  https://sandbox-validator1.nymtech.net --mnemonic $MNEMONIC  --recovery-dir /tmp/recovery --amount 3000000
+```
+
+More information regarding how to run the binary can be found by running it with the `--help` argument.
+

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 std::str::FromStr;
 use url::Url;
-use validator_client::nyxd;
-use validator_client::nyxd::traits::CoconutBandwidthSigningClient;
-use validator_client::nyxd::{Coin, Fee, NyxdClient, SigningNyxdClient};
 
 pub(crate) struct Client {
-    nyxd_client: NyxdClient<SigningNyxdClient>,
+    nyxd_client: NyxdClient<DirectSigningNyxdClient>,
     mix_denom_base: String,
 }
 

clients/credential/src/commands.rs

@@ -3,26 +3,13 @@
 
 use clap::{ArgGroup, Args, Subcommand};
 use log::*;
+use nym_bandwidth_controller::acquire::state::State;
 use nym_bin_common::completions::ArgShell;
-use rand::rngs::OsRng;
-use std::str::FromStr;
+use nym_credential_storage::persistent_storage::PersistentStorage;
+use nym_validator_client::nyxd::traits::DkgQueryClient;
 
-use coconut_interface::{Base58, Parameters};
-use credential_storage::storage::Storage;
-use credential_storage::PersistentStorage;
-use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
-use credentials::coconut::utils::obtain_aggregate_signature;
-use nym_crypto::asymmetric::{encryption, identity};
-use nym_network_defaults::VOUCHER_INFO;
-use validator_client::nyxd::traits::DkgQueryClient;
-use validator_client::nyxd::tx::Hash;
-use validator_client::nyxd::CosmWasmClient;
-use validator_client::CoconutApiClient;
-
-use crate::client::Client;
-use crate::error::{CredentialClientError, Result};
+use crate::error::Result;
 use crate::recovery_storage::RecoveryStorage;
-use crate::state::{KeyPair, State};
 
 #[derive(Subcommand)]
 pub(crate) enum Command {
@@ -47,10 +34,6 @@ pub(crate) struct Run {
     #[clap(long)]
     pub(crate) client_home_directory: std::path::PathBuf,
 
-    /// The nyxd URL that should be used
-    #[clap(long)]
-    pub(crate) nyxd_url: String,
-
     /// A mnemonic for the account that buys the credential
     #[clap(long)]
     pub(crate) mnemonic: String,
@@ -69,82 +52,16 @@ pub(crate) struct Run {
     pub(crate) recovery_mode: bool,
 }
 
-pub(crate) async fn deposit(nyxd_url: &str, mnemonic: &str, amount: u64) -> Result<State> {
-    let mut rng = OsRng;
-    let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
-    let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-
-    let client = Client::new(nyxd_url, mnemonic);
-    let tx_hash = client
-        .deposit(
-            amount,
-            signing_keypair.public_key.clone(),
-            encryption_keypair.public_key.clone(),
-            None,
-        )
-        .await?;
-
-    let voucher = BandwidthVoucher::new(
-        &params,
-        amount.to_string(),
-        VOUCHER_INFO.to_string(),
-        Hash::from_str(&tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
-        identity::PrivateKey::from_base58_string(&signing_keypair.private_key)?,
-        encryption::PrivateKey::from_base58_string(&encryption_keypair.private_key)?,
-    );
-
-    let state = State { voucher, params };
-
-    Ok(state)
-}
-
-pub(crate) async fn get_credential<C: Clone + CosmWasmClient + Send + Sync>(
-    state: &State,
-    client: validator_client::Client<C>,
-    shared_storage: PersistentStorage,
-) -> Result<()> {
-    let epoch_id = client.nyxd.get_current_epoch().await?.epoch_id;
-    let threshold = client
-        .nyxd
-        .get_current_epoch_threshold()
-        .await?
-        .ok_or(CredentialClientError::NoThreshold)?;
-    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client, epoch_id).await?;
-
-    let signature = obtain_aggregate_signature(
-        &state.params,
-        &state.voucher,
-        &coconut_api_clients,
-        threshold,
-    )
-    .await?;
-    info!("Signature: {:?}", signature.to_bs58());
-    shared_storage
-        .insert_coconut_credential(
-            state.voucher.get_voucher_value(),
-            VOUCHER_INFO.to_string(),
-            state.voucher.get_private_attributes()[0].to_bs58(),
-            state.voucher.get_private_attributes()[1].to_bs58(),
-            signature.to_bs58(),
-            epoch_id.to_string(),
-        )
-        .await?;
-
-    Ok(())
-}
-
-pub(crate) async fn recover_credentials<C: Clone + CosmWasmClient + Send + Sync>(
-    client: validator_client::Client<C>,
+pub(crate) async fn recover_credentials<C: DkgQueryClient + Send + Sync>(
+    client: &C,
     recovery_storage: &RecoveryStorage,
-    shared_storage: PersistentStorage,
+    shared_storage: &PersistentStorage,
 ) -> Result<()> {
     for voucher in recovery_storage.unconsumed_vouchers()? {
-        let state = State {
-            voucher,
-            params: Parameters::new(TOTAL_ATTRIBUTES).unwrap(),
-        };
-        if let Err(e) = get_credential(&state, client.clone(), shared_storage.clone()).await {
+        let state = State::new(voucher);
+        if let Err(e) =
+            nym_bandwidth_controller::acquire::get_credential(&state, client, shared_storage).await
+        {
             error!(
                 "Could not recover deposit {} due to {:?}, try again later",
                 state.voucher.tx_hash(),

clients/credential/src/error.rs

@@ -4,12 +4,10 @@
 use std::time::SystemTimeError;
 use thiserror::Error;
 
-use credential_storage::error::StorageError;
-use credentials::error::Error as CredentialError;
-use nym_crypto::asymmetric::encryption::KeyRecoveryError;
-use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
-use validator_client::nyxd::error::NyxdError;
-use validator_client::ValidatorClientError;
+use nym_credential_storage::error::StorageError;
+use nym_credentials::error::Error as CredentialError;
+use nym_validator_client::nyxd::error::NyxdError;
+use nym_validator_client::ValidatorClientError;
 
 pub type Result<T> = std::result::Result<T, CredentialClientError>;
 
@@ -18,6 +16,9 @@ pub enum CredentialClientError {
     #[error("IO error: {0}")]
     IOError(#[from] std::io::Error),
 
+    #[error("Bandwidth controller error: {0}")]
+    BandwidthControllerError(#[from] nym_bandwidth_controller::error::BandwidthControllerError),
+
     #[error("Nyxd error: {0}")]
     Nyxd(#[from] NyxdError),
 
@@ -27,21 +28,9 @@ pub enum CredentialClientError {
     #[error("Credential error: {0}")]
     Credential(#[from] CredentialError),
 
-    #[error("The tx hash provided is not valid")]
-    InvalidTxHash,
-
-    #[error("Could not parse Ed25519 data")]
-    Ed25519ParseError(#[from] Ed25519RecoveryError),
-
-    #[error("Could not parse X25519 data")]
-    X25519ParseError(#[from] KeyRecoveryError),
-
     #[error("Could not use shared storage")]
     SharedStorageError(#[from] StorageError),
 
     #[error("Could not get system time")]
     SysTimeError(#[from] SystemTimeError),
-
-    #[error("Threshold not set yet")]
-    NoThreshold,
 }

clients/credential/src/main.rs

@@ -1,11 +1,9 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-mod client;
 mod commands;
 mod error;
 mod recovery_storage;
-mod state;
 
 use commands::*;
 use error::Result;
@@ -18,9 +16,9 @@ use std::time::{Duration, SystemTime};
 
 use clap::{CommandFactory, Parser};
 use nym_bin_common::logging::setup_logging;
-use validator_client::nyxd::traits::DkgQueryClient;
-use validator_client::nyxd::CosmWasmClient;
-use validator_client::Config;
+use nym_validator_client::nyxd::traits::DkgQueryClient;
+use nym_validator_client::nyxd::{Coin, CosmWasmClient};
+use nym_validator_client::Config;
 
 const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute
 
@@ -35,8 +33,8 @@ struct Cli {
     pub(crate) command: Command,
 }
 
-async fn block_until_coconut_is_available<C: Clone + CosmWasmClient + Send + Sync>(
-    client: &validator_client::Client<C>,
+async fn block_until_coconut_is_available<C: CosmWasmClient + Send + Sync>(
+    client: &nym_validator_client::Client<C>,
 ) -> Result<()> {
     loop {
         let epoch = client.nyxd.get_current_epoch().await?;
@@ -77,21 +75,34 @@ async fn main() -> Result<()> {
                 .client_home_directory
                 .join(DATA_DIR)
                 .join(CRED_DB_FILE_NAME);
-            let shared_storage = credential_storage::initialise_storage(db_path).await;
+            let shared_storage =
+                nym_credential_storage::initialise_persistent_storage(db_path).await;
             let recovery_storage = recovery_storage::RecoveryStorage::new(r.recovery_dir)?;
 
             let network_details = NymNetworkDetails::new_from_env();
-            let config = Config::try_from_nym_network_details(&network_details)?;
-            let client = validator_client::Client::new_query(config)?;
+            let config = Config::try_from_nym_network_details(&network_details).expect(
+                "failed to construct valid validator client config with the provided network",
+            );
+            let amount = Coin::new(
+                r.amount as u128,
+                network_details.chain_details.mix_denom.base,
+            );
+            let client =
+                nym_validator_client::Client::new_signing(config, 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 = deposit(&r.nyxd_url, &r.mnemonic, r.amount).await?;
-                if get_credential(&state, client, shared_storage)
-                    .await
-                    .is_err()
+                let state =
+                    nym_bandwidth_controller::acquire::deposit(&client.nyxd, amount).await?;
+                if nym_bandwidth_controller::acquire::get_credential(
+                    &state,
+                    &client,
+                    &shared_storage,
+                )
+                .await
+                .is_err()
                 {
                     warn!("Failed to obtain credential. Dumping recovery data.",);
                     match recovery_storage.insert_voucher(&state.voucher) {
@@ -104,11 +115,11 @@ async fn main() -> Result<()> {
                     }
                 }
             } else {
-                recover_credentials(client, &recovery_storage, shared_storage).await?;
+                recover_credentials(&client.nyxd, &recovery_storage, &shared_storage).await?;
             }
         }
-        Command::Completions(c) => c.generate(&mut crate::Cli::command(), bin_name),
-        Command::GenerateFigSpec => fig_generate(&mut crate::Cli::command(), bin_name),
+        Command::Completions(c) => c.generate(&mut Cli::command(), bin_name),
+        Command::GenerateFigSpec => fig_generate(&mut Cli::command(), bin_name),
     }
 
     Ok(())

clients/credential/src/recovery_storage.rs

@@ -1,7 +1,7 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use credentials::coconut::bandwidth::BandwidthVoucher;
+use nym_credentials::coconut::bandwidth::BandwidthVoucher;
 use std::fs::{create_dir_all, read_dir, File};
 use std::io::{Read, Write};
 use std::path::PathBuf;

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.12"
+version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -26,30 +26,29 @@ lazy_static = "1.4.0"
 log = { workspace = true } # self explanatory
 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 = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
-serde_json = "1.0"
+serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
+serde_json = { workspace = true }
 thiserror = "1.0.34"
 tap = "1.0.1"
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket
 
 ## internal
-nym-bin-common = { path = "../../common/bin-common" }
-client-core = { path = "../client-core", features = ["fs-surb-storage"] }
-coconut-interface = { path = "../../common/coconut-interface" }
+nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
+nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
+nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage"] }
+nym-coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
-credential-storage = { path = "../../common/credential-storage" }
-credentials = { path = "../../common/credentials" }
+nym-credential-storage = { path = "../../common/credential-storage" }
+nym-credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
-gateway-client = { path = "../../common/client-libs/gateway-client" }
-gateway-requests = { path = "../../gateway/gateway-requests" }
+nym-gateway-requests = { path = "../../gateway/gateway-requests" }
 nym-network-defaults = { path = "../../common/network-defaults" }
 nym-sphinx = { path = "../../common/nymsphinx" }
 nym-pemstore = { path = "../../common/pemstore" }
 nym-task = { path = "../../common/task" }
 nym-topology = { path = "../../common/topology" }
-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
-websocket-requests = { path = "websocket-requests" }
+nym-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+nym-client-websocket-requests = { path = "websocket-requests" }
 
 [dev-dependencies]
-serde_json = "1.0" # for the "textsend" example

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

@@ -13,7 +13,7 @@
       },
       "devDependencies": {
         "clean-webpack-plugin": "^4.0.0",
-        "webpack": "^5.70.0",
+        "webpack": "^5.76.0",
         "webpack-cli": "^4.9.2",
         "webpack-dev-server": "^4.7.4"
       }
@@ -490,9 +490,9 @@
       }
     },
     "node_modules/acorn": {
-      "version": "8.7.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.0.tgz",
-      "integrity": "sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ==",
+      "version": "8.8.2",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz",
+      "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==",
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -1327,9 +1327,9 @@
       }
     },
     "node_modules/enhanced-resolve": {
-      "version": "5.9.2",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.9.2.tgz",
-      "integrity": "sha512-GIm3fQfwLJ8YZx2smuHpBKkXC1yOk+OBEmKckVyL0i/ea8mqDEykK3ld5dgH1QYPNyT/lIllxV2LULnxCHaHkA==",
+      "version": "5.12.0",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.12.0.tgz",
+      "integrity": "sha512-QHTXI/sZQmko1cbDoNAa3mJ5qhWUUNAq3vR0/YiD379fWQrcfuoX1+HW2S0MTt7XmoPLapdaDKUtelUSPic7hQ==",
       "dependencies": {
         "graceful-fs": "^4.2.4",
         "tapable": "^2.2.0"
@@ -2380,10 +2380,10 @@
         "node": ">= 10.13.0"
       }
     },
-    "node_modules/json-parse-better-errors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
-      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw=="
+    "node_modules/json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
     },
     "node_modules/json-schema-traverse": {
       "version": "0.4.1",
@@ -3824,9 +3824,9 @@
       }
     },
     "node_modules/watchpack": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.3.1.tgz",
-      "integrity": "sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==",
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz",
+      "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==",
       "dependencies": {
         "glob-to-regexp": "^0.4.1",
         "graceful-fs": "^4.1.2"
@@ -3845,33 +3845,33 @@
       }
     },
     "node_modules/webpack": {
-      "version": "5.70.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.70.0.tgz",
-      "integrity": "sha512-ZMWWy8CeuTTjCxbeaQI21xSswseF2oNOwc70QSKNePvmxE7XW36i7vpBMYZFAUHPwQiEbNGCEYIOOlyRbdGmxw==",
+      "version": "5.76.0",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.76.0.tgz",
+      "integrity": "sha512-l5sOdYBDunyf72HW8dF23rFtWq/7Zgvt/9ftMof71E/yUb1YLOBmTgA2K4vQthB3kotMrSj609txVE0dnr2fjA==",
       "dependencies": {
         "@types/eslint-scope": "^3.7.3",
         "@types/estree": "^0.0.51",
         "@webassemblyjs/ast": "1.11.1",
         "@webassemblyjs/wasm-edit": "1.11.1",
         "@webassemblyjs/wasm-parser": "1.11.1",
-        "acorn": "^8.4.1",
+        "acorn": "^8.7.1",
         "acorn-import-assertions": "^1.7.6",
         "browserslist": "^4.14.5",
         "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.9.2",
+        "enhanced-resolve": "^5.10.0",
         "es-module-lexer": "^0.9.0",
         "eslint-scope": "5.1.1",
         "events": "^3.2.0",
         "glob-to-regexp": "^0.4.1",
         "graceful-fs": "^4.2.9",
-        "json-parse-better-errors": "^1.0.2",
+        "json-parse-even-better-errors": "^2.3.1",
         "loader-runner": "^4.2.0",
         "mime-types": "^2.1.27",
         "neo-async": "^2.6.2",
         "schema-utils": "^3.1.0",
         "tapable": "^2.1.1",
         "terser-webpack-plugin": "^5.1.3",
-        "watchpack": "^2.3.1",
+        "watchpack": "^2.4.0",
         "webpack-sources": "^3.2.3"
       },
       "bin": {
@@ -4894,9 +4894,9 @@
       }
     },
     "acorn": {
-      "version": "8.7.0",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.7.0.tgz",
-      "integrity": "sha512-V/LGr1APy+PXIwKebEWrkZPwoeoF+w1jiOBUmuxuiUIaOHtob8Qc9BTrYo7VuI5fR8tqsy+buA2WFooR5olqvQ=="
+      "version": "8.8.2",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz",
+      "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw=="
     },
     "acorn-import-assertions": {
       "version": "1.8.0",
@@ -5527,9 +5527,9 @@
       "dev": true
     },
     "enhanced-resolve": {
-      "version": "5.9.2",
-      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.9.2.tgz",
-      "integrity": "sha512-GIm3fQfwLJ8YZx2smuHpBKkXC1yOk+OBEmKckVyL0i/ea8mqDEykK3ld5dgH1QYPNyT/lIllxV2LULnxCHaHkA==",
+      "version": "5.12.0",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.12.0.tgz",
+      "integrity": "sha512-QHTXI/sZQmko1cbDoNAa3mJ5qhWUUNAq3vR0/YiD379fWQrcfuoX1+HW2S0MTt7XmoPLapdaDKUtelUSPic7hQ==",
       "requires": {
         "graceful-fs": "^4.2.4",
         "tapable": "^2.2.0"
@@ -6305,10 +6305,10 @@
         "supports-color": "^8.0.0"
       }
     },
-    "json-parse-better-errors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz",
-      "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw=="
+    "json-parse-even-better-errors": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+      "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="
     },
     "json-schema-traverse": {
       "version": "0.4.1",
@@ -7396,9 +7396,9 @@
       "dev": true
     },
     "watchpack": {
-      "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.3.1.tgz",
-      "integrity": "sha512-x0t0JuydIo8qCNctdDrn1OzH/qDzk2+rdCOC3YzumZ42fiMqmQ7T3xQurykYMhYfHaPHTp4ZxAx2NfUo1K6QaA==",
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.0.tgz",
+      "integrity": "sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==",
       "requires": {
         "glob-to-regexp": "^0.4.1",
         "graceful-fs": "^4.1.2"
@@ -7414,33 +7414,33 @@
       }
     },
     "webpack": {
-      "version": "5.70.0",
-      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.70.0.tgz",
-      "integrity": "sha512-ZMWWy8CeuTTjCxbeaQI21xSswseF2oNOwc70QSKNePvmxE7XW36i7vpBMYZFAUHPwQiEbNGCEYIOOlyRbdGmxw==",
+      "version": "5.76.0",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.76.0.tgz",
+      "integrity": "sha512-l5sOdYBDunyf72HW8dF23rFtWq/7Zgvt/9ftMof71E/yUb1YLOBmTgA2K4vQthB3kotMrSj609txVE0dnr2fjA==",
       "requires": {
         "@types/eslint-scope": "^3.7.3",
         "@types/estree": "^0.0.51",
         "@webassemblyjs/ast": "1.11.1",
         "@webassemblyjs/wasm-edit": "1.11.1",
         "@webassemblyjs/wasm-parser": "1.11.1",
-        "acorn": "^8.4.1",
+        "acorn": "^8.7.1",
         "acorn-import-assertions": "^1.7.6",
         "browserslist": "^4.14.5",
         "chrome-trace-event": "^1.0.2",
-        "enhanced-resolve": "^5.9.2",
+        "enhanced-resolve": "^5.10.0",
         "es-module-lexer": "^0.9.0",
         "eslint-scope": "5.1.1",
         "events": "^3.2.0",
         "glob-to-regexp": "^0.4.1",
         "graceful-fs": "^4.2.9",
-        "json-parse-better-errors": "^1.0.2",
+        "json-parse-even-better-errors": "^2.3.1",
         "loader-runner": "^4.2.0",
         "mime-types": "^2.1.27",
         "neo-async": "^2.6.2",
         "schema-utils": "^3.1.0",
         "tapable": "^2.1.1",
         "terser-webpack-plugin": "^5.1.3",
-        "watchpack": "^2.3.1",
+        "watchpack": "^2.4.0",
         "webpack-sources": "^3.2.3"
       }
     },

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

@@ -19,7 +19,7 @@
   "license": "Apache-2.0",
   "devDependencies": {
     "clean-webpack-plugin": "^4.0.0",
-    "webpack": "^5.70.0",
+    "webpack": "^5.76.0",
     "webpack-cli": "^4.9.2",
     "webpack-dev-server": "^4.7.4"
   },

clients/native/examples/websocket_binarysend.rs

@@ -1,10 +1,10 @@
 use futures::{SinkExt, StreamExt};
+use nym_client_websocket_requests::{requests::ClientRequest, responses::ServerResponse};
 use nym_sphinx::addressing::clients::Recipient;
 use tokio::net::TcpStream;
 use tokio_tungstenite::{
     connect_async, tungstenite::protocol::Message, MaybeTlsStream, WebSocketStream,
 };
-use websocket_requests::{requests::ClientRequest, responses::ServerResponse};
 
 // just helpers functions that work in this very particular context because we are sending to ourselves
 // and hence will always get a response back (i.e. the message we sent)

clients/native/src/client/config/mod.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::config::template::config_template;
-use client_core::config::ClientCoreConfigTrait;
+use nym_client_core::config::ClientCoreConfigTrait;
 use nym_config::defaults::DEFAULT_WEBSOCKET_LISTENING_PORT;
 use nym_config::{NymConfig, OptionalSet};
 use serde::{Deserialize, Serialize};
@@ -11,10 +11,11 @@ use std::net::{IpAddr, Ipv4Addr};
 use std::path::PathBuf;
 use std::str::FromStr;
 
-pub use client_core::config::Config as BaseConfig;
-pub use client_core::config::MISSING_VALUE;
-pub use client_core::config::{DebugConfig, GatewayEndpointConfig};
+pub use nym_client_core::config::Config as BaseConfig;
+pub use nym_client_core::config::MISSING_VALUE;
+pub use nym_client_core::config::{DebugConfig, GatewayEndpointConfig};
 
+pub mod old_config_v1_1_13;
 mod template;
 
 #[derive(Debug, Deserialize, PartialEq, Eq, Serialize, Clone, Copy)]
@@ -80,7 +81,7 @@ impl NymConfig for Config {
 }
 
 impl ClientCoreConfigTrait for Config {
-    fn get_gateway_endpoint(&self) -> &client_core::config::GatewayEndpointConfig {
+    fn get_gateway_endpoint(&self) -> &nym_client_core::config::GatewayEndpointConfig {
         self.base.get_gateway_endpoint()
     }
 }
@@ -93,6 +94,11 @@ impl Config {
         }
     }
 
+    pub fn validate(&self) -> bool {
+        // no other sections have explicit requirements (yet)
+        self.base.validate()
+    }
+
     pub fn with_socket(mut self, socket_type: SocketType) -> Self {
         self.socket.socket_type = socket_type;
         self

clients/native/src/client/config/old_config_v1_1_13.rs

@@ -0,0 +1,60 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::client::config::{Config, Socket};
+use nym_client_core::config::old_config_v1_1_13::OldConfigV1_1_13 as OldBaseConfigV1_1_13;
+use nym_config::NymConfig;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct OldConfigV1_1_13 {
+    #[serde(flatten)]
+    base: OldBaseConfigV1_1_13<OldConfigV1_1_13>,
+
+    socket: Socket,
+}
+
+impl NymConfig for OldConfigV1_1_13 {
+    fn template() -> &'static str {
+        // not intended to be used
+        unimplemented!()
+    }
+
+    fn default_root_directory() -> PathBuf {
+        dirs::home_dir()
+            .expect("Failed to evaluate $HOME value")
+            .join(".nym")
+            .join("clients")
+    }
+
+    fn try_default_root_directory() -> Option<PathBuf> {
+        dirs::home_dir().map(|path| path.join(".nym").join("clients"))
+    }
+
+    fn root_directory(&self) -> PathBuf {
+        self.base.client.nym_root_directory.clone()
+    }
+
+    fn config_directory(&self) -> PathBuf {
+        self.root_directory()
+            .join(&self.base.client.id)
+            .join("config")
+    }
+
+    fn data_directory(&self) -> PathBuf {
+        self.root_directory()
+            .join(&self.base.client.id)
+            .join("data")
+    }
+}
+
+impl From<OldConfigV1_1_13> for Config {
+    fn from(value: OldConfigV1_1_13) -> Self {
+        Config {
+            base: value.base.into(),
+            socket: value.socket,
+        }
+    }
+}

clients/native/src/client/config/template.rs

@@ -110,10 +110,15 @@ host = '{{ socket.host }}'
 
 [debug]
 
-average_packet_delay = '{{ debug.average_packet_delay }}'
-average_ack_delay = '{{ debug.average_ack_delay }}'
-loop_cover_traffic_average_delay = '{{ debug.loop_cover_traffic_average_delay }}'
-message_sending_average_delay = '{{ debug.message_sending_average_delay }}'
+[debug.traffic]
+average_packet_delay = '{{ debug.traffic.average_packet_delay }}'
+message_sending_average_delay = '{{ debug.traffic.message_sending_average_delay }}'
+
+[debug.acknowledgements]
+average_ack_delay = '{{ debug.acknowledgements.average_ack_delay }}'
+
+[debug.cover_traffic]
+loop_cover_traffic_average_delay = '{{ debug.cover_traffic.loop_cover_traffic_average_delay }}'
 
 "#
 }

clients/native/src/client/mod.rs

@@ -1,31 +1,33 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use std::error::Error;
-
 use crate::client::config::Config;
 use crate::error::ClientError;
 use crate::websocket;
-use client_core::client::base_client::{
+use futures::channel::mpsc;
+use log::*;
+use nym_bandwidth_controller::BandwidthController;
+use nym_client_core::client::base_client::{
     non_wasm_helpers, BaseClientBuilder, ClientInput, ClientOutput, ClientState,
 };
-use client_core::client::inbound_messages::InputMessage;
-use client_core::client::received_buffer::{
+use nym_client_core::client::inbound_messages::InputMessage;
+use nym_client_core::client::received_buffer::{
     ReceivedBufferMessage, ReceivedBufferRequestSender, ReconstructedMessagesReceiver,
 };
-use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
-use log::*;
+use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_task::connections::TransmissionLane;
 use nym_task::TaskManager;
+use nym_validator_client::nyxd::QueryNyxdClient;
+use std::error::Error;
 use tokio::sync::watch::error::SendError;
-use validator_client::nyxd::QueryNyxdClient;
 
-pub use client_core::client::key_manager::KeyManager;
+pub use nym_client_core::client::key_manager::KeyManager;
+use nym_credential_storage::persistent_storage::PersistentStorage;
 pub use nym_sphinx::addressing::clients::Recipient;
 pub use nym_sphinx::receiver::ReconstructedMessage;
+use nym_validator_client::Client;
+
 pub mod config;
 
 pub struct SocketClient {
@@ -55,10 +57,13 @@ impl SocketClient {
         }
     }
 
-    async fn create_bandwidth_controller(config: &Config) -> BandwidthController<QueryNyxdClient> {
+    async fn create_bandwidth_controller(
+        config: &Config,
+    ) -> BandwidthController<Client<QueryNyxdClient>, PersistentStorage> {
         let details = nym_network_defaults::NymNetworkDetails::new_from_env();
-        let mut client_config = validator_client::Config::try_from_nym_network_details(&details)
-            .expect("failed to construct validator client config");
+        let mut client_config =
+            nym_validator_client::Config::try_from_nym_network_details(&details)
+                .expect("failed to construct validator client config");
         let nyxd_url = config
             .get_base()
             .get_validator_endpoints()
@@ -71,10 +76,13 @@ impl SocketClient {
             .expect("No validator api endpoint provided");
         // overwrite env configuration with config URLs
         client_config = client_config.with_urls(nyxd_url, api_url);
-        let client = validator_client::Client::new_query(client_config)
+        let client = nym_validator_client::Client::new_query(client_config)
             .expect("Could not construct query client");
         BandwidthController::new(
-            credential_storage::initialise_storage(config.get_base().get_database_path()).await,
+            nym_credential_storage::initialise_persistent_storage(
+                config.get_base().get_database_path(),
+            )
+            .await,
             client,
         )
     }

clients/native/src/commands/init.rs

@@ -1,13 +1,16 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
     client::config::Config,
     commands::{override_config, OverrideConfig},
     error::ClientError,
 };
 use clap::Args;
+use nym_bin_common::output_format::OutputFormat;
 use nym_config::NymConfig;
+use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_crypto::asymmetric::identity;
 use nym_sphinx::addressing::clients::Recipient;
 use serde::Serialize;
@@ -70,9 +73,8 @@ pub(crate) struct Init {
     #[clap(long, hide = true)]
     enabled_credentials_mode: Option<bool>,
 
-    /// Save a summary of the initialization to a json file
-    #[clap(long)]
-    output_json: bool,
+    #[clap(short, long, default_value_t = OutputFormat::default())]
+    output: OutputFormat,
 }
 
 impl From<Init> for OverrideConfig {
@@ -94,15 +96,17 @@ impl From<Init> for OverrideConfig {
 #[derive(Debug, Serialize)]
 pub struct InitResults {
     #[serde(flatten)]
-    client_core: client_core::init::InitResults,
+    client_core: nym_client_core::init::InitResults,
     client_listening_port: String,
+    client_address: String,
 }
 
 impl InitResults {
     fn new(config: &Config, address: &Recipient) -> Self {
         Self {
-            client_core: client_core::init::InitResults::new(config.get_base(), address),
+            client_core: nym_client_core::init::InitResults::new(config.get_base(), address),
             client_listening_port: config.get_listening_port().to_string(),
+            client_address: address.to_string(),
         }
     }
 }
@@ -110,25 +114,29 @@ impl InitResults {
 impl Display for InitResults {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "{}", self.client_core)?;
-        write!(f, "Client listening port: {}", self.client_listening_port)
+        writeln!(f, "Client listening port: {}", self.client_listening_port)?;
+        write!(f, "Address of this client: {}", self.client_address)
     }
 }
 
 pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
-    println!("Initialising client...");
+    eprintln!("Initialising client...");
 
     let id = &args.id;
 
     let already_init = Config::default_config_file_path(id).exists();
     if already_init {
-        println!("Client \"{id}\" was already initialised before");
+        // in case we're using old config, try to upgrade it
+        // (if we're using the current version, it's a no-op)
+        try_upgrade_v1_1_13_config(id)?;
+        eprintln!("Client \"{id}\" was already initialised before");
     }
 
     // Usually you only register with the gateway on the first init, however you can force
     // re-registering if wanted.
     let user_wants_force_register = args.force_register_gateway;
     if user_wants_force_register {
-        println!("Instructed to force registering gateway. This might overwrite keys!");
+        eprintln!("Instructed to force registering gateway. This might overwrite keys!");
     }
 
     // If the client was already initialized, don't generate new keys and don't re-register with
@@ -144,7 +152,7 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
 
     // Setup gateway by either registering a new one, or creating a new config from the selected
     // one but with keys kept, or reusing the gateway configuration.
-    let gateway = client_core::init::setup_gateway_from_config::<Config, _>(
+    let gateway = nym_client_core::init::setup_gateway_from_config::<Config, _, PersistentStorage>(
         register_gateway,
         user_chosen_gateway_id,
         config.get_base(),
@@ -161,28 +169,22 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
 
     print_saved_config(&config);
 
-    let address = client_core::init::get_client_address_from_stored_keys(config.get_base())?;
+    let address = nym_client_core::init::get_client_address_from_stored_keys(config.get_base())?;
     let init_results = InitResults::new(&config, &address);
-    println!("{init_results}");
+    println!("{}", args.output.format(&init_results));
 
-    // Output summary to a json file, if specified
-    if args.output_json {
-        client_core::init::output_to_json(&init_results, "client_init_results.json");
-    }
-
-    println!("\nThe address of this client is: {address}\n");
     Ok(())
 }
 
 fn print_saved_config(config: &Config) {
     let config_save_location = config.get_config_file_save_location();
-    println!("Saved configuration file to {config_save_location:?}");
-    println!("Using gateway: {}", config.get_base().get_gateway_id());
+    eprintln!("Saved configuration file to {config_save_location:?}");
+    eprintln!("Using gateway: {}", config.get_base().get_gateway_id());
     log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
     log::debug!("Gateway owner: {}", config.get_base().get_gateway_owner());
     log::debug!(
         "Gateway listener: {}",
         config.get_base().get_gateway_listener()
     );
-    println!("Client configuration completed.\n");
+    eprintln!("Client configuration completed.\n");
 }

clients/native/src/commands/mod.rs

@@ -1,13 +1,15 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::client::config::old_config_v1_1_13::OldConfigV1_1_13;
 use crate::client::config::{BaseConfig, Config};
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use lazy_static::lazy_static;
+use log::info;
 use nym_bin_common::build_information::BinaryBuildInformation;
 use nym_bin_common::completions::{fig_generate, ArgShell};
-use nym_config::OptionalSet;
+use nym_config::{NymConfig, OptionalSet};
 use std::error::Error;
 use std::net::IpAddr;
 
@@ -102,6 +104,20 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
         )
 }
 
+fn try_upgrade_v1_1_13_config(id: &str) -> std::io::Result<()> {
+    // explicitly load it as v1.1.13 (which is incompatible with the current, i.e. 1.1.14+)
+    let Ok(old_config) = OldConfigV1_1_13::load_from_file(id) else {
+        // if we failed to load it, there might have been nothing to upgrade
+        // or maybe it was an even older file. in either way. just ignore it and carry on with our day
+        return Ok(());
+    };
+    info!("It seems the client is using <= v1.1.13 config template.");
+    info!("It is going to get updated to the current specification.");
+
+    let updated: Config = old_config.into();
+    updated.save_to_file(None)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

clients/native/src/commands/run.rs

@@ -4,12 +4,12 @@
 use std::error::Error;
 use std::net::IpAddr;
 
+use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
     client::{config::Config, SocketClient},
     commands::{override_config, OverrideConfig},
     error::ClientError,
 };
-
 use clap::Args;
 use log::*;
 use nym_bin_common::version_checker::is_minor_version_compatible;
@@ -100,6 +100,10 @@ fn version_check(cfg: &Config) -> bool {
 pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn Error + Send + Sync>> {
     let id = &args.id;
 
+    // in case we're using old config, try to upgrade it
+    // (if we're using the current version, it's a no-op)
+    try_upgrade_v1_1_13_config(id)?;
+
     let mut config = match Config::load_from_file(id) {
         Ok(cfg) => cfg,
         Err(err) => {
@@ -108,6 +112,10 @@ pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn Error + Send + Syn
         }
     };
 
+    if !config.validate() {
+        return Err(Box::new(ClientError::ConfigValidationFailure));
+    }
+
     let override_config_fields = OverrideConfig::from(args.clone());
     config = override_config(config, override_config_fields);
 

clients/native/src/error.rs

@@ -1,4 +1,4 @@
-use client_core::error::ClientCoreError;
+use nym_client_core::error::ClientCoreError;
 
 #[derive(thiserror::Error, Debug)]
 pub enum ClientError {
@@ -11,6 +11,10 @@ pub enum ClientError {
     #[error("Failed to load config for: {0}")]
     FailedToLoadConfig(String),
 
+    // TODO: add more details here
+    #[error("Failed to validate the loaded config")]
+    ConfigValidationFailure,
+
     #[error("Failed local version check, client and config mismatch")]
     FailedLocalVersionCheck,
 

clients/native/src/main.rs

@@ -4,7 +4,7 @@
 use std::error::Error;
 
 use clap::{crate_name, crate_version, Parser};
-use nym_bin_common::logging::{banner, setup_logging};
+use nym_bin_common::logging::{maybe_print_banner, setup_logging};
 use nym_network_defaults::setup_env;
 
 pub mod client;
@@ -15,7 +15,7 @@ pub mod websocket;
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     setup_logging();
-    println!("{}", banner(crate_name!(), crate_version!()));
+    maybe_print_banner(crate_name!(), crate_version!());
 
     let args = commands::Cli::parse();
     setup_env(args.config_env_file.as_ref());

clients/native/src/websocket/handler.rs

@@ -1,16 +1,17 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use client_core::client::replies::reply_controller::requests::ReplyControllerSender;
-use client_core::client::{
+use futures::channel::mpsc;
+use futures::{SinkExt, StreamExt};
+use log::*;
+use nym_client_core::client::replies::reply_controller::requests::ReplyControllerSender;
+use nym_client_core::client::{
     inbound_messages::{InputMessage, InputMessageSender},
     received_buffer::{
         ReceivedBufferMessage, ReceivedBufferRequestSender, ReconstructedMessagesReceiver,
     },
 };
-use futures::channel::mpsc;
-use futures::{SinkExt, StreamExt};
-use log::*;
+use nym_client_websocket_requests::{requests::ClientRequest, responses::ServerResponse};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::receiver::ReconstructedMessage;
@@ -25,7 +26,6 @@ use tokio_tungstenite::{
     tungstenite::{protocol::Message as WsMessage, Error as WsError},
     WebSocketStream,
 };
-use websocket_requests::{requests::ClientRequest, responses::ServerResponse};
 
 #[derive(Default)]
 enum ReceivedResponseType {

clients/native/websocket-requests/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "websocket-requests"
+name = "nym-client-websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
@@ -7,7 +7,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
 
 nym-sphinx = { path = "../../../common/nymsphinx" }

clients/socks5/Cargo.toml

@@ -1,24 +1,16 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.12"
+version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
 rust-version = "1.56"
 
-[lib]
-name = "nym_socks5"
-path = "src/lib.rs"
-
 [dependencies]
 clap = { version = "4.0", features = ["cargo", "derive"] }
-dirs = "4.0"
-futures = "0.3"
 lazy_static = "1.4.0"
 log = { workspace = true }
-pin-project = "1.0"
 pretty_env_logger = "0.4"
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
 serde_json = { workspace = true }
 tap = "1.0.1"
@@ -27,28 +19,21 @@ tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
 url = "2.2"
 
 # internal
-nym-bin-common = { path = "../../common/bin-common" }
-client-core = { path = "../client-core", features = ["fs-surb-storage"] }
-coconut-interface = { path = "../../common/coconut-interface" }
+nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
+nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage"] }
+nym-coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
-credential-storage = { path = "../../common/credential-storage", optional = true }
-mobile-storage = { path = "../../common/mobile-storage", optional = true }
-credentials = { path = "../../common/credentials" }
+nym-credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
-gateway-client = { path = "../../common/client-libs/gateway-client" }
-gateway-requests = { path = "../../gateway/gateway-requests" }
+nym-gateway-requests = { path = "../../gateway/gateway-requests" }
+nym-credential-storage = { path = "../../common/credential-storage" }
 nym-network-defaults = { path = "../../common/network-defaults" }
 nym-sphinx = { path = "../../common/nymsphinx" }
-ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
+nym-ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
 nym-pemstore = { path = "../../common/pemstore" }
-proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
-service-providers-common = { path = "../../service-providers/common" }
-socks5-requests = { path = "../../common/socks5/requests" }
-nym-task = { path = "../../common/task" }
 nym-topology = { path = "../../common/topology" }
-validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }
+nym-socks5-client-core = { path = "../../common/socks5-client-core" }
 
 [features]
-default = ["credential-storage"]
+default = []
 eth = []
-mobile = ["mobile-storage", "gateway-client/mobile"]

clients/socks5/src/commands/init.rs

@@ -1,14 +1,17 @@
-// 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::commands::try_upgrade_v1_1_13_config;
 use crate::{
-    client::config::Config,
     commands::{override_config, OverrideConfig},
     error::Socks5ClientError,
 };
 use clap::Args;
+use nym_bin_common::output_format::OutputFormat;
 use nym_config::NymConfig;
+use nym_credential_storage::persistent_storage::PersistentStorage;
 use nym_crypto::asymmetric::identity;
+use nym_socks5_client_core::config::Config;
 use nym_sphinx::addressing::clients::Recipient;
 use serde::Serialize;
 use std::fmt::Display;
@@ -74,9 +77,8 @@ pub(crate) struct Init {
     #[clap(long, hide = true)]
     enabled_credentials_mode: Option<bool>,
 
-    /// Save a summary of the initialization to a json file
-    #[clap(long)]
-    output_json: bool,
+    #[clap(short, long, default_value_t = OutputFormat::default())]
+    output: OutputFormat,
 }
 
 impl From<Init> for OverrideConfig {
@@ -96,15 +98,17 @@ impl From<Init> for OverrideConfig {
 #[derive(Debug, Serialize)]
 pub struct InitResults {
     #[serde(flatten)]
-    client_core: client_core::init::InitResults,
+    client_core: nym_client_core::init::InitResults,
     socks5_listening_port: String,
+    client_address: String,
 }
 
 impl InitResults {
     fn new(config: &Config, address: &Recipient) -> Self {
         Self {
-            client_core: client_core::init::InitResults::new(config.get_base(), address),
-            socks5_listening_port: config.get_listening_port().to_string(),
+            client_core: nym_client_core::init::InitResults::new(config.get_base(), address),
+            socks5_listening_port: config.get_socks5().get_listening_port().to_string(),
+            client_address: address.to_string(),
         }
     }
 }
@@ -112,26 +116,30 @@ impl InitResults {
 impl Display for InitResults {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "{}", self.client_core)?;
-        write!(f, "SOCKS5 listening port: {}", self.socks5_listening_port)
+        writeln!(f, "SOCKS5 listening port: {}", self.socks5_listening_port)?;
+        write!(f, "Address of this client: {}", self.client_address)
     }
 }
 
 pub(crate) async fn execute(args: &Init) -> Result<(), Socks5ClientError> {
-    println!("Initialising client...");
+    eprintln!("Initialising client...");
 
     let id = &args.id;
     let provider_address = &args.provider;
 
     let already_init = Config::default_config_file_path(id).exists();
     if already_init {
-        println!("SOCKS5 client \"{id}\" was already initialised before");
+        // in case we're using old config, try to upgrade it
+        // (if we're using the current version, it's a no-op)
+        try_upgrade_v1_1_13_config(id)?;
+        eprintln!("SOCKS5 client \"{id}\" was already initialised before");
     }
 
     // Usually you only register with the gateway on the first init, however you can force
     // re-registering if wanted.
     let user_wants_force_register = args.force_register_gateway;
     if user_wants_force_register {
-        println!("Instructed to force registering gateway. This might overwrite keys!");
+        eprintln!("Instructed to force registering gateway. This might overwrite keys!");
     }
 
     // If the client was already initialized, don't generate new keys and don't re-register with
@@ -150,7 +158,7 @@ pub(crate) async fn execute(args: &Init) -> Result<(), Socks5ClientError> {
 
     // Setup gateway by either registering a new one, or creating a new config from the selected
     // one but with keys kept, or reusing the gateway configuration.
-    let gateway = client_core::init::setup_gateway_from_config::<Config, _>(
+    let gateway = nym_client_core::init::setup_gateway_from_config::<Config, _, PersistentStorage>(
         register_gateway,
         user_chosen_gateway_id,
         config.get_base(),
@@ -169,28 +177,22 @@ pub(crate) async fn execute(args: &Init) -> Result<(), Socks5ClientError> {
 
     print_saved_config(&config);
 
-    let address = client_core::init::get_client_address_from_stored_keys(config.get_base())?;
+    let address = nym_client_core::init::get_client_address_from_stored_keys(config.get_base())?;
     let init_results = InitResults::new(&config, &address);
-    println!("{}", init_results);
+    println!("{}", args.output.format(&init_results));
 
-    // Output summary to a json file, if specified
-    if args.output_json {
-        client_core::init::output_to_json(&init_results, "socks5_client_init_results.json");
-    }
-
-    println!("\nThe address of this client is: {}\n", address);
     Ok(())
 }
 
 fn print_saved_config(config: &Config) {
     let config_save_location = config.get_config_file_save_location();
-    println!("Saved configuration file to {:?}", config_save_location);
-    println!("Using gateway: {}", config.get_base().get_gateway_id());
+    eprintln!("Saved configuration file to {:?}", config_save_location);
+    eprintln!("Using gateway: {}", config.get_base().get_gateway_id());
     log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
     log::debug!("Gateway owner: {}", config.get_base().get_gateway_owner());
     log::debug!(
         "Gateway listener: {}",
         config.get_base().get_gateway_listener()
     );
-    println!("Client configuration completed.\n");
+    eprintln!("Client configuration completed.\n");
 }

clients/socks5/src/commands/mod.rs

@@ -1,13 +1,15 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::config::{BaseConfig, Config};
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use lazy_static::lazy_static;
+use log::info;
 use nym_bin_common::build_information::BinaryBuildInformation;
 use nym_bin_common::completions::{fig_generate, ArgShell};
-use nym_config::OptionalSet;
+use nym_config::{NymConfig, OptionalSet};
+use nym_socks5_client_core::config::old_config_v1_1_13::OldConfigV1_1_13;
+use nym_socks5_client_core::config::{BaseConfig, Config};
 use std::error::Error;
 
 pub mod init;
@@ -101,6 +103,20 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
         )
 }
 
+fn try_upgrade_v1_1_13_config(id: &str) -> std::io::Result<()> {
+    // explicitly load it as v1.1.13 (which is incompatible with the current, i.e. 1.1.14+)
+    let Ok(old_config) = OldConfigV1_1_13::load_from_file(id) else {
+        // if we failed to load it, there might have been nothing to upgrade
+        // or maybe it was an even older file. in either way. just ignore it and carry on with our day
+        return Ok(());
+    };
+    info!("It seems the client is using <= v1.1.13 config template.");
+    info!("It is going to get updated to the current specification.");
+
+    let updated: Config = old_config.into();
+    updated.save_to_file(None)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

clients/socks5/src/commands/run.rs

@@ -1,17 +1,17 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
-    client::{config::Config, NymClient},
     commands::{override_config, OverrideConfig},
     error::Socks5ClientError,
 };
-
 use clap::Args;
 use log::*;
 use nym_bin_common::version_checker::is_minor_version_compatible;
 use nym_config::NymConfig;
 use nym_crypto::asymmetric::identity;
+use nym_socks5_client_core::{config::Config, NymClient};
 use nym_sphinx::addressing::clients::Recipient;
 
 #[derive(Args, Clone)]
@@ -108,6 +108,10 @@ fn version_check(cfg: &Config) -> bool {
 pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     let id = &args.id;
 
+    // in case we're using old config, try to upgrade it
+    // (if we're using the current version, it's a no-op)
+    try_upgrade_v1_1_13_config(id)?;
+
     let mut config = match Config::load_from_file(id) {
         Ok(cfg) => cfg,
         Err(err) => {
@@ -118,6 +122,10 @@ pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error
         }
     };
 
+    if !config.validate() {
+        return Err(Box::new(Socks5ClientError::ConfigValidationFailure));
+    }
+
     let override_config_fields = OverrideConfig::from(args.clone());
     config = override_config(config, override_config_fields);
 

clients/socks5/src/commands/upgrade.rs

@@ -1,10 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::config::{Config, MISSING_VALUE};
-
 use nym_bin_common::version_checker::Version;
 use nym_config::NymConfig;
+use nym_socks5_client_core::config::{Config, MISSING_VALUE};
 
 use clap::Args;
 use std::{fmt::Display, process};

clients/socks5/src/error.rs

@@ -1,39 +1,23 @@
-use crate::socks::types::SocksProxyError;
-use client_core::error::ClientCoreError;
-use socks5_requests::{ConnectionError, ConnectionId};
+use nym_client_core::error::ClientCoreError;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Socks5ClientError {
     #[error("I/O error: {0}")]
     IoError(#[from] std::io::Error),
 
-    #[error("client-core error: {0}")]
-    ClientCoreError(#[from] ClientCoreError),
-
-    #[error("SOCKS proxy error")]
-    SocksProxyError(SocksProxyError),
-
     #[error("Failed to load config for: {0}")]
     FailedToLoadConfig(String),
 
+    // TODO: add more details here
+    #[error("Failed to validate the loaded config")]
+    ConfigValidationFailure,
+
     #[error("Failed local version check, client and config mismatch")]
     FailedLocalVersionCheck,
 
     #[error("Fail to bind address")]
     FailToBindAddress,
 
-    #[error("Network requester: connection id {connection_id}: {error}")]
-    NetworkRequesterError {
-        connection_id: ConnectionId,
-        error: String,
-    },
-}
-
-impl From<ConnectionError> for Socks5ClientError {
-    fn from(value: ConnectionError) -> Self {
-        Socks5ClientError::NetworkRequesterError {
-            connection_id: value.connection_id,
-            error: value.network_requester_error,
-        }
-    }
+    #[error("client-core error: {0}")]
+    ClientCoreError(#[from] ClientCoreError),
 }

clients/socks5/src/lib.rs

@@ -1,6 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod client;
-pub mod error;
-pub mod socks;

clients/socks5/src/main.rs

@@ -4,18 +4,16 @@
 use std::error::Error;
 
 use clap::{crate_name, crate_version, Parser};
-use nym_bin_common::logging::{banner, setup_logging};
+use nym_bin_common::logging::{maybe_print_banner, setup_logging};
 use nym_network_defaults::setup_env;
 
-pub mod client;
 mod commands;
 pub mod error;
-pub mod socks;
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     setup_logging();
-    println!("{}", banner(crate_name!(), crate_version!()));
+    maybe_print_banner(crate_name!(), crate_version!());
 
     let args = commands::Cli::parse();
     setup_env(args.config_env_file.as_ref());

clients/validator/.eslintrc.json

@@ -1,83 +1,71 @@
 {
-    "root": true,
-    "env": {
-        "browser": true,
-        "es6": true,
-        "node": true
-    },
-    "parserOptions": {
-        "ecmaVersion": 2019,
-        "sourceType": "module"
-    },
-    "globals": {
-        "Atomics": "readonly",
-        "SharedArrayBuffer": "readonly"
-    },
-    "plugins": ["prettier", "mocha"],
-    "extends": [
-        "airbnb-base",
-        "airbnb-typescript/base",
-        "prettier"],
-    "rules": {
-        "prettier/prettier": "error",
-        "import/prefer-default-export": "off",
-        "import/no-extraneous-dependencies": [
-            "error",
-            {
-                "devDependencies": [
-                    "**/*.test.[jt]s",
-                    "**/*.spec.[jt]s"
-                ]
-            }
-        ],
-        "import/extensions": [
-            "error",
-            "ignorePackages",
-            {
-                "ts": "never",
-                "js": "never"
-            }
-        ]
-    },
-    "overrides": [
-        {
-            "files": "**/*.ts",
-            "parser": "@typescript-eslint/parser",
-            "parserOptions": {
-                "project": "./tsconfig.json"
-            },
-            "plugins": ["@typescript-eslint/eslint-plugin"],
-            "extends": [
-                "plugin:@typescript-eslint/eslint-recommended",
-                "plugin:@typescript-eslint/recommended",
-                "prettier"
-            ],
-            "rules": {
-                "@typescript-eslint/explicit-function-return-type": "off",
-                "@typescript-eslint/no-explicit-any": "off",
-                "@typescript-eslint/no-var-requires": "off",
-                "no-use-before-define": [0],
-                "@typescript-eslint/no-use-before-define": [1],
-                "import/no-unresolved": 0,
-                "import/no-extraneous-dependencies": [
-                    "error",
-                    {
-                        "devDependencies": [
-                            "**/*.test.ts",
-                            "**/*.spec.ts"
-                        ]
-                    }
-                ],
-                "quotes": "off",
-                "@typescript-eslint/quotes": [
-                    2,
-                    "single",
-                    {
-                        "avoidEscape": true
-                    }
-                ],
-                "@typescript-eslint/no-unused-vars": [2, { "argsIgnorePattern": "^_" }]
-            }
-        }
+  "root": true,
+  "env": {
+    "browser": true,
+    "es6": true,
+    "node": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2019,
+    "sourceType": "module"
+  },
+  "globals": {
+    "Atomics": "readonly",
+    "SharedArrayBuffer": "readonly"
+  },
+  "plugins": ["prettier", "mocha"],
+  "extends": ["airbnb-base", "airbnb-typescript/base", "prettier"],
+  "rules": {
+    "prettier/prettier": "error",
+    "import/prefer-default-export": "off",
+    "import/no-extraneous-dependencies": [
+      "error",
+      {
+        "devDependencies": ["**/*.test.[jt]s", "**/*.spec.[jt]s"]
+      }
+    ],
+    "import/extensions": [
+      "error",
+      "ignorePackages",
+      {
+        "ts": "never",
+        "js": "never"
+      }
     ]
+  },
+  "overrides": [
+    {
+      "files": "**/*.ts",
+      "parser": "@typescript-eslint/parser",
+      "parserOptions": {
+        "project": "./tsconfig.json"
+      },
+      "plugins": ["@typescript-eslint/eslint-plugin"],
+      "extends": ["plugin:@typescript-eslint/eslint-recommended", "plugin:@typescript-eslint/recommended", "prettier"],
+      "rules": {
+        "@typescript-eslint/explicit-function-return-type": "off",
+        "@typescript-eslint/no-explicit-any": "off",
+        "@typescript-eslint/no-var-requires": "off",
+        "no-use-before-define": [0],
+        "@typescript-eslint/no-use-before-define": [1],
+        "import/no-unresolved": 0,
+        "import/no-extraneous-dependencies": [
+          "error",
+          {
+            "devDependencies": ["**/*.test.ts", "**/*.spec.ts"]
+          }
+        ],
+        "quotes": "off",
+        "@typescript-eslint/quotes": [
+          2,
+          "single",
+          {
+            "avoidEscape": true
+          }
+        ],
+        "@typescript-eslint/no-unused-vars": [2, { "argsIgnorePattern": "^_" }]
+      }
+    }
+  ],
+  "ignorePatterns": ["tsconfig.json", "*.d.ts", "dist/**/*", "dist", "node_modules"]
 }

clients/validator/.gitignore

@@ -4,4 +4,5 @@ coverage
 dist
 docs
 examples/accounts
-node_modules
+node_modules
+.env

clients/validator/.npmignore

@@ -1,3 +1,5 @@
 coverage
 node_modules
-tests
+tests
+src
+type

clients/validator/README.md

@@ -1,40 +1,39 @@
-Nym Validator Client
-====================
+# Nym Validator Client (Typescript)
 
-A TypeScript client for interacting with CosmWasm smart contracts in Nym validators. 
+A TypeScript client for interacting with CosmWasm smart contracts in Nym validators.
 
-Running examples
------------------
-
-With the code checked out, `cd examples`. This folder contains runnable example code that will set up a blockchain and allow you to interact with it through the client. 
-
-Running tests
--------------
+Include the Nym Validator in your project:
 
 ```
-npm test
+yarn add @nymproject/nym-validator-client
 ```
 
-You can also trigger test execution with a test watcher. I don't have the centuries of life left to me that are needed to fight through the arcana of wiring up a working TypeScript mocha triggered execution setup, so for now my Cargo-based hack is:
-
+Connect to validator and make queries
 
 ```
-cargo watch -s "cd clients/validator && npm test"
+import Validator from '@nymproject/nym-validator-client'
+
+const main = async () => {
+
+ const client = await Validator.connectForQuery(rpcAddress, validatorAddress, prefix, mixnetContractAddress, vestingContractAddress, denom)
+
+ client.getBalance(address)
+
+}
+
 ```
 
-It's ugly but works fine if you have Cargo installed. TypeScript setup help happily accepted here. 
+Connect to validator for performing actions
 
-Generating Documentation
-------------------------
+```
+import Validator from '@nymproject/nym-validator-client'
 
-You can generate docs by running `npm run docs`. Generated output will appear in the `docs` directory. 
+const main = async () => {
 
-Packaging
-------------------------
+ const client = await Validator.connect(mnemonic, rpcAddress, validatorAddress, prefix, mixnetContractAddress, vestingContractAddress, denom)
 
-If you're a Nym platform developer who's made changes to the client and wants to re-publish the package to NPM, here's how you do it: 
+ const res = await client.send(address, [{ amount: '10000000', denom: 'unym' }]);
 
-1. Bump the version number (use SemVer)
-1. `npm run build`
-1. `npm login` (if you haven't already)
-1. `npm publish`
+}
+
+```

clients/validator/package.json

@@ -4,15 +4,23 @@
   "description": "A TypeScript client for interacting with smart contracts in Nym validators",
   "repository": "https://github.com/nymtech/nym",
   "main": "./dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
-    "test": "ts-mocha tests/**/*.test.ts",
+    "build": "rollup -c ./rollup.config.mjs",
+    "build:types": "rollup-type-bundler --dist ./dist/nym-validator-client",
+    "build:prod": "sh ./scripts/build-prod.sh",
+    "test": "ts-mocha -p ./tsconfig.test.json ./src/tests/**/*.test.ts",
+    "testmock": "ts-mocha -p ./tsconfig.test.json ./src/tests/mock/*.test.ts",
     "coverage": "nyc npm test",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
+    "clean": "rm -rf ./dist",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "lint:tsc": "tsc --noEmit",
     "docs": "typedoc --out docs src/index.ts"
   },
+  "files": [
+    "./dist/*"
+  ],
   "keywords": [],
   "author": "Nym Technologies SA (https://nymtech.net)",
   "contributors": [
@@ -21,6 +29,14 @@
   ],
   "license": "Apache-2.0",
   "devDependencies": {
+    "@favware/rollup-type-bundler": "^2.0.0",
+    "@nymproject/types": "^1.0.0",
+    "@rollup/plugin-commonjs": "^24.0.1",
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "rollup": "^3.17.2",
+    "rollup-plugin-dts": "^5.2.0",
     "@typescript-eslint/eslint-plugin": "^5.7.0",
     "@typescript-eslint/parser": "^5.7.0",
     "eslint": "^7.18.0",
@@ -31,21 +47,21 @@
     "eslint-plugin-import": "^2.25.4",
     "eslint-plugin-mocha": "^10.0.3",
     "eslint-plugin-prettier": "^4.0.0",
-    "expect": "^28.1.3",
     "mocha": "^10.0.0",
-    "prettier": "^2.5.1",
-    "typedoc": "^0.22.13",
+    "prettier": "^2.8.7",
     "ts-mocha": "^10.0.0",
-    "typescript": "^4.6.2"
-  },
-  "dependencies": {
-    "@cosmjs/cosmwasm-stargate": "^0.28.0",
-    "@cosmjs/crypto": "^0.28.0",
-    "@cosmjs/math": "^0.28.0",
-    "@cosmjs/proto-signing": "^0.28.0",
-    "@cosmjs/stargate": "^0.28.0",
-    "@cosmjs/tendermint-rpc": "^0.28.0",
-    "axios": "^0.26.1",
-    "cosmjs-types": "^0.4.1"
+    "typedoc": "^0.22.13",
+    "typescript": "^4.6.2",
+    "cosmjs-types": "^0.4.1",
+    "dotenv": "^16.0.3",
+    "expect": "^28.1.3",
+    "moq.ts": "^7.3.4",
+    "@cosmjs/cosmwasm-stargate": "^0.29.5",
+    "@cosmjs/crypto": "^0.29.5",
+    "@cosmjs/math": "^0.29.5",
+    "@cosmjs/proto-signing": "^0.29.5",
+    "@cosmjs/stargate": "^0.29.5",
+    "@cosmjs/tendermint-rpc": "^0.29.5",
+    "axios": "^1.3.3"
   }
 }

clients/validator/rollup.config.mjs

@@ -0,0 +1,15 @@
+import typescript from '@rollup/plugin-typescript';
+import resolve from '@rollup/plugin-node-resolve';
+import json from '@rollup/plugin-json';
+import commonjs from '@rollup/plugin-commonjs';
+
+export default [
+  {
+    input: './src/index.ts',
+    output: {
+      dir: 'dist/nym-validator-client',
+      format: 'cjs',
+    },
+    plugins: [resolve(), typescript(), commonjs(), json()],
+  },
+];

clients/validator/scripts/build-prod.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+set -o errexit
+set -o nounset
+
+rm -rf ./dist || true
+rm -rf ../../dist || true
+
+
+# Bundle application
+
+yarn build
+
+# Bundle types
+
+yarn build:types
+
+# Build package.json for bundle
+
+node ./scripts/buildPackageJson.mjs
+
+# Copy README
+
+cp README.md dist/nym-validator-client
+
+# move the output outside of the yarn/npm workspaces
+
+mv ./dist ../../
+
+echo "Output can be found in:"
+realpath ../../dist

clients/validator/scripts/buildPackageJson.mjs

@@ -0,0 +1,20 @@
+import * as fs from 'fs';
+
+// parse the package.json from the SDK, so we can keep fields like the name and version
+const json = JSON.parse(fs.readFileSync('./package.json').toString());
+
+// defaults (NB: these are in the output file locations)
+const main = 'index.js';
+const types = 'index.d.ts';
+
+// make a package.json for the bundle
+const packageJson = {
+  name: json.name,
+  version: json.version,
+  license: json.license,
+  author: json.author,
+  main,
+  types,
+};
+
+fs.writeFileSync('./dist/nym-validator-client/package.json', JSON.stringify(packageJson, null, 2));

clients/validator/src/currency.ts

@@ -1,5 +1,6 @@
 import { Decimal } from '@cosmjs/math';
 import { Coin } from '@cosmjs/stargate';
+import { CoinMap } from './types/shared';
 
 // NARROW NO-BREAK SPACE (U+202F)
 const thinSpace = '\u202F';
@@ -34,15 +35,6 @@ export function nativeToPrintable(nativeValue: string): string {
   return Decimal.fromAtomics(nativeValue, 6).toString();
 }
 
-export interface MappedCoin {
-  readonly denom: string;
-  readonly fractionalDigits: number;
-}
-
-export interface CoinMap {
-  readonly [key: string]: MappedCoin;
-}
-
 export function nativeCoinToDisplay(coin: Coin, coinMap: CoinMap): Coin {
   if (!coinMap) return coin;
 

clients/validator/src/index.ts

@@ -1,6 +1,3 @@
-import { Bip39, Random } from '@cosmjs/crypto';
-import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing';
-import { coin as cosmosCoin, Coin, DeliverTxResponse, isDeliverTxFailure, StdFee } from '@cosmjs/stargate';
 import {
   ExecuteResult,
   InstantiateOptions,
@@ -8,45 +5,40 @@ import {
   MigrateResult,
   UploadResult,
 } from '@cosmjs/cosmwasm-stargate';
-import SigningClient, { ISigningClient } from './signing-client';
+import { Bip39, Random } from '@cosmjs/crypto';
+import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing';
+import { Coin, coin as cosmosCoin, DeliverTxResponse, isDeliverTxFailure, StdFee } from '@cosmjs/stargate';
 import {
   ContractStateParams,
   Delegation,
   Gateway,
   GatewayBond,
+  GatewayOwnershipResponse,
+  LayerDistribution,
   MixnetContractVersion,
   MixNode,
   MixNodeBond,
+  MixNodeCostParams,
+  MixNodeDetails,
+  MixNodeRewarding,
+  MixOwnershipResponse,
+  OriginalVestingResponse,
   PagedAllDelegationsResponse,
   PagedDelegatorDelegationsResponse,
   PagedGatewayResponse,
   PagedMixDelegationsResponse,
-  PagedMixnodeResponse,
-} from './types';
-import {
-  CoinMap,
-  displayAmountToNative,
-  MappedCoin,
-  nativeCoinToDisplay,
-  nativeToPrintable,
-  printableBalance,
-  printableCoin,
-} from './currency';
+  PagedMixNodeBondResponse,
+  PagedMixNodeDetailsResponse,
+  PagedUnbondedMixnodesResponse,
+  RewardingParams,
+  StakeSaturationResponse,
+  UnbondedMixnodeResponse,
+  VestingAccountInfo,
+  ContractState, VestingAccountsCoinPaged, VestingAccountsPaged, DelegationTimes, Delegations, Period, VestingAccountNode, DelegationBlock
+} from '@nymproject/types';
 import QueryClient from './query-client';
-import { nymGasPrice } from './stargate-helper';
-
-export { coins, coin } from '@cosmjs/stargate';
-export { Coin };
-export {
-  displayAmountToNative,
-  nativeCoinToDisplay,
-  printableCoin,
-  printableBalance,
-  nativeToPrintable,
-  MappedCoin,
-  CoinMap,
-};
-export { nymGasPrice };
+import SigningClient, { ISigningClient } from './signing-client';
+// import { DelegationBlock } from './types/shared';
 
 export interface INymClient {
   readonly mixnetContract: string;
@@ -147,7 +139,7 @@ export default class ValidatorClient implements INymClient {
     return DirectSecp256k1HdWallet.fromMnemonic(mnemonic, signerOptions);
   }
 
-  getBalance(address: string): Promise<Coin> {
+  async getBalance(address: string): Promise<Coin> {
     return this.client.getBalance(address, this.denom);
   }
 
@@ -159,15 +151,39 @@ export default class ValidatorClient implements INymClient {
     return this.client.getCachedMixnodes();
   }
 
-  async getActiveMixnodes(): Promise<MixNodeBond[]> {
+  async getStakeSaturation(mixId: number): Promise<StakeSaturationResponse> {
+    return this.client.getStakeSaturation(this.mixnetContract, mixId);
+  }
+
+  async getActiveMixnodes(): Promise<MixNodeDetails[]> {
     return this.client.getActiveMixnodes();
   }
 
+  async getUnbondedMixNodeInformation(mixId: number): Promise<UnbondedMixnodeResponse> {
+    return this.client.getUnbondedMixNodeInformation(this.mixnetContract, mixId);
+  }
+
   async getRewardedMixnodes(): Promise<MixNodeBond[]> {
     return this.client.getRewardedMixnodes();
   }
 
-  public async getMixnetContractSettings(): Promise<ContractStateParams> {
+  async getMixnodeRewardingDetails(mixId: number): Promise<MixNodeRewarding> {
+    return this.client.getMixnodeRewardingDetails(this.mixnetContract, mixId);
+  }
+
+  async getOwnedMixnode(address: string): Promise<MixOwnershipResponse> {
+    return this.client.getOwnedMixnode(this.mixnetContract, address);
+  }
+
+  async ownsGateway(address: string): Promise<GatewayOwnershipResponse> {
+    return this.client.ownsGateway(this.mixnetContract, address);
+  }
+
+  async getLayerDistribution(): Promise<LayerDistribution> {
+    return this.client.getLayerDistribution(this.mixnetContract);
+  }
+
+  public async getMixnetContractSettings(): Promise<ContractState> {
     return this.client.getStateParams(this.mixnetContract);
   }
 
@@ -175,29 +191,74 @@ export default class ValidatorClient implements INymClient {
     return this.client.getContractVersion(this.mixnetContract);
   }
 
-  public async getRewardPool(): Promise<string> {
-    return this.client.getRewardPool(this.mixnetContract);
+  public async getVestingContractVersion(): Promise<MixnetContractVersion> {
+    return this.client.getContractVersion(this.vestingContract);
   }
 
-  public async getCirculatingSupply(): Promise<string> {
-    return this.client.getCirculatingSupply(this.mixnetContract);
+  public async getSpendableCoins(vestingAccountAddress: string): Promise<MixnetContractVersion> {
+    return this.client.getSpendableCoins(this.vestingContract, vestingAccountAddress);
   }
 
-  public async getSybilResistancePercent(): Promise<number> {
-    return this.client.getSybilResistancePercent(this.mixnetContract);
+  public async getRewardParams(): Promise<RewardingParams> {
+    return this.client.getRewardParams(this.mixnetContract);
   }
 
-  public async getIntervalRewardPercent(): Promise<number> {
-    return this.client.getIntervalRewardPercent(this.mixnetContract);
+  async getUnbondedMixNodes(): Promise<UnbondedMixnodeResponse[]> {
+    let mixNodes: UnbondedMixnodeResponse[] = [];
+    const limit = 50;
+    let startAfter;
+    for (; ;) {
+      // eslint-disable-next-line no-await-in-loop
+      const pagedResponse: PagedUnbondedMixnodesResponse = await this.client.getUnbondedMixNodes(
+        this.mixnetContract,
+        limit,
+        startAfter,
+      );
+
+      mixNodes = mixNodes.concat(pagedResponse.nodes);
+      startAfter = pagedResponse.start_next_after;
+      // if `start_next_after` is not set, we're done
+      if (!startAfter) {
+        break;
+      }
+    }
+
+    return mixNodes;
   }
 
-  public async getAllNyxdMixnodes(): Promise<MixNodeBond[]> {
+  public async getMixNodeBonds(): Promise<MixNodeBond[]> {
     let mixNodes: MixNodeBond[] = [];
     const limit = 50;
     let startAfter;
     for (; ;) {
       // eslint-disable-next-line no-await-in-loop
-      const pagedResponse: PagedMixnodeResponse = await this.client.getMixNodesPaged(this.mixnetContract, limit);
+      const pagedResponse: PagedMixNodeBondResponse = await this.client.getMixNodeBonds(
+        this.mixnetContract,
+        limit,
+        startAfter,
+      );
+      mixNodes = mixNodes.concat(pagedResponse.nodes);
+      startAfter = pagedResponse.start_next_after;
+      // if `start_next_after` is not set, we're done
+      if (!startAfter) {
+        break;
+      }
+    }
+
+    return mixNodes;
+  }
+
+  public async getMixNodesDetailed(): Promise<MixNodeDetails[]> {
+    let mixNodes: MixNodeDetails[] = [];
+    const limit = 50;
+    let startAfter;
+    for (; ;) {
+      // eslint-disable-next-line no-await-in-loop
+      const pagedResponse: PagedMixNodeDetailsResponse = await this.client.getMixNodesDetailed(
+        this.mixnetContract,
+        limit,
+        startAfter,
+      );
       mixNodes = mixNodes.concat(pagedResponse.nodes);
       startAfter = pagedResponse.start_next_after;
       // if `start_next_after` is not set, we're done
@@ -210,29 +271,16 @@ export default class ValidatorClient implements INymClient {
   }
 
   public async getAllNyxdGateways(): Promise<GatewayBond[]> {
-    let gateways: GatewayBond[] = [];
-    const limit = 50;
-    let startAfter;
-    for (; ;) {
-      // eslint-disable-next-line no-await-in-loop
-      const pagedResponse: PagedGatewayResponse = await this.client.getGatewaysPaged(this.mixnetContract, limit);
-      gateways = gateways.concat(pagedResponse.nodes);
-      startAfter = pagedResponse.start_next_after;
-      // if `start_next_after` is not set, we're done
-      if (!startAfter) {
-        break;
-      }
-    }
-
-    return gateways;
+    const pagedResponse: PagedGatewayResponse = await this.client.getGatewaysPaged(this.mixnetContract);
+    return pagedResponse.nodes;
   }
 
   /**
    * Gets list of all delegations towards particular mixnode.
    *
-   * @param mixIdentity identity of the node to which the delegation was sent
+   * @param mix_id identity of the node to which the delegation was sent
    */
-  public async getAllNyxdSingleMixnodeDelegations(mixIdentity: string): Promise<Delegation[]> {
+  public async getAllNyxdSingleMixnodeDelegations(mix_id: number): Promise<Delegation[]> {
     let delegations: Delegation[] = [];
     const limit = 250;
     let startAfter;
@@ -240,7 +288,7 @@ export default class ValidatorClient implements INymClient {
       // eslint-disable-next-line no-await-in-loop
       const pagedResponse: PagedMixDelegationsResponse = await this.client.getMixNodeDelegationsPaged(
         this.mixnetContract,
-        mixIdentity,
+        mix_id,
         limit,
         startAfter,
       );
@@ -278,13 +326,13 @@ export default class ValidatorClient implements INymClient {
     return delegations;
   }
 
-  public async getAllNyxdNetworkDelegations(): Promise<Delegation[]> {
+  public async getAllNyxdDelegations(): Promise<Delegation[]> {
     let delegations: Delegation[] = [];
     const limit = 250;
     let startAfter;
     for (; ;) {
       // eslint-disable-next-line no-await-in-loop
-      const pagedResponse: PagedAllDelegationsResponse = await this.client.getAllNetworkDelegationsPaged(
+      const pagedResponse: PagedAllDelegationsResponse = await this.client.getAllDelegationsPaged(
         this.mixnetContract,
         limit,
         startAfter,
@@ -300,6 +348,10 @@ export default class ValidatorClient implements INymClient {
     return delegations;
   }
 
+  public async getDelegationDetails(mix_id: number, delegator: string): Promise<Delegation> {
+    return this.client.getDelegationDetails(this.mixnetContract, mix_id, delegator);
+  }
+
   /**
    * Generate a minimum gateway bond required to create a fresh mixnode.
    *
@@ -308,7 +360,7 @@ export default class ValidatorClient implements INymClient {
   public async minimumMixnodePledge(): Promise<Coin> {
     const stateParams = await this.getMixnetContractSettings();
     // we trust the contract to return a valid number
-    return cosmosCoin(stateParams.minimum_mixnode_pledge, this.prefix);
+    return cosmosCoin(stateParams.params.minimum_mixnode_pledge, this.prefix);
   }
 
   /**
@@ -319,7 +371,7 @@ export default class ValidatorClient implements INymClient {
   public async minimumGatewayPledge(): Promise<Coin> {
     const stateParams = await this.getMixnetContractSettings();
     // we trust the contract to return a valid number
-    return cosmosCoin(stateParams.minimum_gateway_pledge, this.prefix);
+    return cosmosCoin(stateParams.params.minimum_gateway_pledge, this.prefix);
   }
 
   public async send(
@@ -393,12 +445,21 @@ export default class ValidatorClient implements INymClient {
   public async bondMixNode(
     mixNode: MixNode,
     ownerSignature: string,
+    costParams: MixNodeCostParams,
     pledge: Coin,
     fee?: StdFee | 'auto' | number,
     memo?: string,
   ): Promise<ExecuteResult> {
     this.assertSigning();
-    return (this.client as ISigningClient).bondMixNode(this.mixnetContract, mixNode, ownerSignature, pledge, fee, memo);
+    return (this.client as ISigningClient).bondMixNode(
+      this.mixnetContract,
+      mixNode,
+      costParams,
+      ownerSignature,
+      pledge,
+      fee,
+      memo,
+    );
   }
 
   public async unbondMixNode(fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult> {
@@ -423,29 +484,29 @@ export default class ValidatorClient implements INymClient {
   }
 
   public async delegateToMixNode(
-    mixIdentity: string,
+    mixId: number,
     amount: Coin,
     fee?: StdFee | 'auto' | number,
     memo?: string,
   ): Promise<ExecuteResult> {
     this.assertSigning();
-    return (this.client as ISigningClient).delegateToMixNode(this.mixnetContract, mixIdentity, amount, fee, memo);
+    return (this.client as ISigningClient).delegateToMixNode(this.mixnetContract, mixId, amount, fee, memo);
   }
 
   public async undelegateFromMixNode(
-    mixIdentity: string,
+    mixId: number,
     fee?: StdFee | 'auto' | number,
     memo?: string,
   ): Promise<ExecuteResult> {
-    return (this.client as ISigningClient).undelegateFromMixNode(this.mixnetContract, mixIdentity, fee, memo);
+    return (this.client as ISigningClient).undelegateFromMixNode(this.mixnetContract, mixId, fee, memo);
   }
 
   public async updateMixnodeConfig(
-    mixIdentity: string,
+    mixId: number,
     fee: StdFee | 'auto' | number,
     profitPercentage: number,
   ): Promise<ExecuteResult> {
-    return (this.client as ISigningClient).updateMixnodeConfig(this.mixnetContract, mixIdentity, profitPercentage, fee);
+    return (this.client as ISigningClient).updateMixnodeConfig(this.mixnetContract, mixId, profitPercentage, fee);
   }
 
   public async updateContractStateParams(
@@ -456,4 +517,105 @@ export default class ValidatorClient implements INymClient {
     this.assertSigning();
     return (this.client as ISigningClient).updateContractStateParams(this.mixnetContract, newParams, fee, memo);
   }
+
+
+  // VESTING 
+  // TODO - MOVE TO A DIFFERENT FILE
+
+
+  public async getVestingAccountsPaged(): Promise<VestingAccountsPaged> {
+    return this.client.getVestingAccountsPaged(this.vestingContract);
+  }
+
+  public async getVestingAmountsAccountsPaged(): Promise<VestingAccountsCoinPaged> {
+    return this.client.getVestingAmountsAccountsPaged(this.vestingContract);
+  }
+
+  public async getLockedTokens(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getLockedTokens(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getSpendableTokens(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getSpendableTokens(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getVestedTokens(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getVestedTokens(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getVestingTokens(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getVestingTokens(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getSpendableVestedTokens(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getSpendableVestedTokens(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getSpendableRewards(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getSpendableRewards(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getDelegatedCoins(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getDelegatedCoins(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getPledgedCoins(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getPledgedCoins(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getStakedCoins(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getStakedCoins(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getWithdrawnCoins(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getWithdrawnCoins(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getStartTime(vestingAccountAddress: string): Promise<string> {
+    return this.client.getStartTime(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getEndTime(vestingAccountAddress: string): Promise<string> {
+    return this.client.getEndTime(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getOriginalVestingDetails(vestingAccountAddress: string): Promise<OriginalVestingResponse> {
+    return this.client.getOriginalVestingDetails(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getHistoricStakingRewards(vestingAccountAddress: string): Promise<Coin> {
+    return this.client.getHistoricStakingRewards(this.vestingContract, vestingAccountAddress);
+  }
+
+  public async getAccountDetails(address: string): Promise<VestingAccountInfo> {
+    return this.client.getAccountDetails(this.vestingContract, address);
+  }
+
+  public async getMixnode(address: string): Promise<VestingAccountNode> {
+    return this.client.getMixnode(this.vestingContract, address);
+  }
+
+  public async getGateway(address: string): Promise<VestingAccountNode> {
+    return this.client.getGateway(this.vestingContract, address);
+  }
+
+  public async getDelegationTimes(mix_id: number, delegatorAddress: string): Promise<DelegationTimes> {
+    return this.client.getDelegationTimes(this.vestingContract, mix_id, delegatorAddress);
+  }
+
+  public async getAllDelegations(): Promise<Delegations> {
+    return this.client.getAllDelegations(this.vestingContract);
+  }
+
+  public async getDelegation(address: string, mix_id: number): Promise<DelegationBlock> {
+    return this.client.getDelegation(this.vestingContract, address, mix_id );
+  }
+ 
+  public async getTotalDelegationAmount(address: string, mix_id: number, block_timestamp_sec: number): Promise<Coin> {
+    return this.client.getTotalDelegationAmount(this.vestingContract, address, mix_id, block_timestamp_sec);
+  }
+
+  public async getCurrentVestingPeriod(address: string): Promise<Period> {
+    return this.client.getCurrentVestingPeriod(this.vestingContract, address);
+  }
 }

clients/validator/src/nym-api-querier.ts

@@ -2,9 +2,8 @@
  * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
  * SPDX-License-Identifier: Apache-2.0
  */
-
 import axios from 'axios';
-import { GatewayBond, MixNodeBond } from './types';
+import { GatewayBond, MixNodeBond, MixNodeDetails } from '@nymproject/types';
 
 export const NYM_API_VERSION = '/v1';
 export const NYM_API_GATEWAYS_PATH = `${NYM_API_VERSION}/gateways`;
@@ -17,7 +16,7 @@ export interface INymApiQuery {
 
   getCachedGateways(): Promise<GatewayBond[]>;
 
-  getActiveMixnodes(): Promise<MixNodeBond[]>;
+  getActiveMixnodes(): Promise<MixNodeDetails[]>;
 
   getRewardedMixnodes(): Promise<MixNodeBond[]>;
 }
@@ -51,7 +50,7 @@ export default class NymApiQuerier implements INymApiQuery {
     throw new Error('None of the provided validator APIs seem to be alive');
   }
 
-  async getActiveMixnodes(): Promise<MixNodeBond[]> {
+  async getActiveMixnodes(): Promise<MixNodeDetails[]> {
     const url = new URL(this.nymApiUrl);
     url.pathname += NYM_API_ACTIVE_MIXNODES_PATH;
 

clients/validator/src/nyxd-querier.ts

@@ -2,28 +2,26 @@
  * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
  * SPDX-License-Identifier: Apache-2.0
  */
-
-import { JsonObject } from '@cosmjs/cosmwasm-stargate';
 // eslint-disable-next-line import/no-cycle
 import { INyxdQuery } from './query-client';
 import {
-  ContractStateParams,
-  Delegation,
+  Delegation, OriginalVestingResponse, RewardingParams, StakeSaturationResponse, VestingAccountInfo,
+  UnbondedMixnodeResponse,
   GatewayOwnershipResponse,
-  LayerDistribution,
   MixnetContractVersion,
   MixOwnershipResponse,
   PagedAllDelegationsResponse,
   PagedDelegatorDelegationsResponse,
   PagedGatewayResponse,
   PagedMixDelegationsResponse,
-  PagedMixnodeResponse,
-  RewardingStatus,
-} from './types';
-
-interface SmartContractQuery {
-  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
-}
+  PagedMixNodeBondResponse,
+  PagedMixNodeDetailsResponse,
+  PagedUnbondedMixnodesResponse,
+  LayerDistribution,
+  ContractState, VestingAccountsCoinPaged, VestingAccountsPaged, DelegationTimes, Delegations, Period, VestingAccountNode, DelegationBlock
+} from '@nymproject/types';
+import { SmartContractQuery } from './types/shared';
+import { Coin } from 'cosmjs-types/cosmos/base/v1beta1/coin';
 
 export default class NyxdQuerier implements INyxdQuery {
   client: SmartContractQuery;
@@ -38,15 +36,44 @@ export default class NyxdQuerier implements INyxdQuery {
     });
   }
 
-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+  getMixNodeBonds(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeBondResponse> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      get_mix_nodes: {
+      get_mix_node_bonds: {
         limit,
         start_after: startAfter,
       },
     });
   }
 
+  getMixNodesDetailed(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeDetailsResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_mix_nodes_detailed: {
+        limit,
+        start_after: startAfter,
+      },
+    });
+  }
+
+  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_stake_saturation: { mix_id: mixId },
+    });
+  }
+
+  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<any> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_mixnode_rewarding_details: { mix_id: mixId },
+    });
+  }
+
   getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
     return this.client.queryContractSmart(mixnetContractAddress, {
       get_gateways: {
@@ -56,35 +83,51 @@ export default class NyxdQuerier implements INyxdQuery {
     });
   }
 
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      owns_mixnode: {
+      get_owned_mixnode: {
         address,
       },
     });
   }
 
+  getUnbondedMixNodes(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedUnbondedMixnodesResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_unbonded_mix_nodes: { limit, start_after: startAfter },
+    });
+  }
+
+  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_unbonded_mix_node_information: { mix_id: mixId },
+    });
+  }
+
   ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      owns_gateway: {
+      get_owned_gateway: {
         address,
       },
     });
   }
 
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+  getStateParams(mixnetContractAddress: string): Promise<ContractState> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      state_params: {},
+      get_state: {},
     });
   }
 
-  getAllNetworkDelegationsPaged(
+  getAllDelegationsPaged(
     mixnetContractAddress: string,
     limit?: number,
     startAfter?: [string, string],
   ): Promise<PagedAllDelegationsResponse> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      get_all_network_delegations: {
+      get_all_delegations: {
         start_after: startAfter,
         limit,
       },
@@ -93,13 +136,13 @@ export default class NyxdQuerier implements INyxdQuery {
 
   getMixNodeDelegationsPaged(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mix_id: number,
     limit?: number,
     startAfter?: string,
   ): Promise<PagedMixDelegationsResponse> {
     return this.client.queryContractSmart(mixnetContractAddress, {
       get_mixnode_delegations: {
-        mix_identity: mixIdentity,
+        mix_id: mix_id,
         start_after: startAfter,
         limit,
       },
@@ -121,10 +164,10 @@ export default class NyxdQuerier implements INyxdQuery {
     });
   }
 
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation> {
     return this.client.queryContractSmart(mixnetContractAddress, {
       get_delegation_details: {
-        mix_identity: mixIdentity,
+        mix_id: mix_id,
         delegator,
       },
     });
@@ -132,44 +175,163 @@ export default class NyxdQuerier implements INyxdQuery {
 
   getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      layer_distribution: {},
+      get_layer_distribution: {},
     });
   }
 
-  getRewardPool(mixnetContractAddress: string): Promise<string> {
+  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams> {
     return this.client.queryContractSmart(mixnetContractAddress, {
-      get_reward_pool: {},
+      get_rewarding_params: {},
     });
   }
 
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_circulating_supply: {},
+  getSpendableCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<any> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      vesting_account_address: vestingAccountAddress,
     });
   }
 
-  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_interval_reward_percent: {},
+  getVestingAccountsPaged(vestingContractAddress: string): Promise<VestingAccountsPaged> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_accounts_paged: {}
     });
   }
 
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_sybil_resistance_percent: {},
+  getVestingAmountsAccountsPaged(vestingContractAddress: string): Promise<VestingAccountsCoinPaged> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_accounts_vesting_coins_paged: {}
     });
   }
 
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_rewarding_status: {
-        mix_identity: mixIdentity,
-        rewarding_interval_nonce: rewardingIntervalNonce,
-      },
+  getLockedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      locked_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getSpendableTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      spendable_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getVestedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_vested_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getVestingTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_vesting_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getSpendableVestedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_spendable_vested_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getSpendableRewards(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_spendable_reward_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getDelegatedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_delegated_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getPledgedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_pledged_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getStakedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_staked_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getWithdrawnCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_withdrawn_coins: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getStartTime(vestingContractAddress: string, vestingAccountAddress: string): Promise<string> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_start_time: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getEndTime(vestingContractAddress: string, vestingAccountAddress: string): Promise<string> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_end_time: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getOriginalVestingDetails(vestingContractAddress: string, vestingAccountAddress: string): Promise<OriginalVestingResponse> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_original_vesting: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getHistoricStakingRewards(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_historical_vesting_staking_reward: { vesting_account_address: vestingAccountAddress }
+    });
+  }
+
+  getAccountDetails(vestingContractAddress: string, address: string): Promise<VestingAccountInfo> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_account: { address: address }
+    });
+  }
+
+  getMixnode(vestingContractAddress: string, address: string): Promise<VestingAccountNode> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_mixnode: { address: address }
+    });
+  }
+
+  getGateway(vestingContractAddress: string, address: string): Promise<VestingAccountNode> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_gateway: { address: address }
+    });
+  }
+
+  getDelegationTimes(vestingContractAddress: string, mix_id: number, address: string): Promise<DelegationTimes> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_delegation_times: { mix_id: mix_id, address: address }
+    });
+  }
+
+  getAllDelegations(vestingContractAddress: string): Promise<Delegations> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_all_delegations: {}
+    });
+  }
+
+  getDelegation(vestingContractAddress: string, address: string, mix_id: number): Promise<DelegationBlock> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_all_delegations: {address: address, mix_id: mix_id}
+    });
+  }
+
+  getTotalDelegationAmount(vestingContractAddress: string, address: string, mix_id: number, block_timestamp_sec: number): Promise<Coin> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_all_delegations: {address: address, mix_id: mix_id, block_timestamp_sec: block_timestamp_sec}
+    });
+  }
+
+  getCurrentVestingPeriod(vestingContractAddress: string, address: string): Promise<Period> {
+    return this.client.queryContractSmart(vestingContractAddress, {
+      get_current_vesting_period: { address: address }
     });
   }
 }

clients/validator/src/query-client.ts

@@ -1,75 +1,60 @@
-import { CosmWasmClient, JsonObject } from '@cosmjs/cosmwasm-stargate';
-import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
-import {
-  Account,
-  Block,
-  Coin,
-  DeliverTxResponse,
-  IndexedTx,
-  SearchTxFilter,
-  SearchTxQuery,
-  SequenceResponse,
-} from '@cosmjs/stargate';
-import { Code, CodeDetails, Contract, ContractCodeHistoryEntry } from '@cosmjs/cosmwasm-stargate/build/cosmwasmclient';
+import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
 // eslint-disable-next-line import/no-cycle
 import NyxdQuerier from './nyxd-querier';
 import {
-  ContractStateParams,
   Delegation,
   GatewayBond,
   GatewayOwnershipResponse,
   LayerDistribution,
   MixnetContractVersion,
-  MixNodeBond,
+  MixNodeDetails,
   MixOwnershipResponse,
   PagedAllDelegationsResponse,
   PagedDelegatorDelegationsResponse,
   PagedGatewayResponse,
   PagedMixDelegationsResponse,
-  PagedMixnodeResponse,
-  RewardingStatus,
-} from './types';
-import NymApiQuerier, { INymApiQuery as INymApiQuery } from './nym-api-querier';
-
-export interface ICosmWasmQuery {
-  // methods exposed by `CosmWasmClient`
-  getChainId(): Promise<string>;
-  getHeight(): Promise<number>;
-  getAccount(searchAddress: string): Promise<Account | null>;
-  getSequence(address: string): Promise<SequenceResponse>;
-  getBlock(height?: number): Promise<Block>;
-  getBalance(address: string, searchDenom: string): Promise<Coin>;
-  getTx(id: string): Promise<IndexedTx | null>;
-  searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise<readonly IndexedTx[]>;
-  disconnect(): void;
-  broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
-  getCodes(): Promise<readonly Code[]>;
-  getCodeDetails(codeId: number): Promise<CodeDetails>;
-  getContracts(codeId: number): Promise<readonly string[]>;
-  getContract(address: string): Promise<Contract>;
-  getContractCodeHistory(address: string): Promise<readonly ContractCodeHistoryEntry[]>;
-  queryContractRaw(address: string, key: Uint8Array): Promise<Uint8Array | null>;
-  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
-}
+  PagedMixNodeBondResponse,
+  PagedMixNodeDetailsResponse,
+  PagedUnbondedMixnodesResponse,
+  StakeSaturationResponse,
+  UnbondedMixnodeResponse,
+  MixNodeBond,
+  MixNodeRewarding,
+  OriginalVestingResponse,
+  VestingAccountInfo,
+  ContractState, VestingAccountsCoinPaged, VestingAccountsPaged, DelegationTimes, Delegations, Period, VestingAccountNode, DelegationBlock
+} from '@nymproject/types';
+import NymApiQuerier, { INymApiQuery } from './nym-api-querier';
+import { ICosmWasmQuery } from './types/shared';
+import { RewardingParams } from '@nymproject/types';
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+import { Coin } from 'cosmjs-types/cosmos/base/v1beta1/coin';
 
 export interface INyxdQuery {
   // nym-specific implemented inside NymQuerier
   getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
-
-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse>;
+  getMixNodeBonds(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeBondResponse>;
+  getMixNodesDetailed(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeDetailsResponse>;
   getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse>;
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
+  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
   ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams>;
-
-  getAllNetworkDelegationsPaged(
+  getStateParams(mixnetContractAddress: string): Promise<ContractState>;
+  getAllDelegationsPaged(
     mixnetContractAddress: string,
     limit?: number,
     startAfter?: [string, string],
   ): Promise<PagedAllDelegationsResponse>;
   getMixNodeDelegationsPaged(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mix_id: number,
     limit?: number,
     startAfter?: string,
   ): Promise<PagedMixDelegationsResponse>;
@@ -79,18 +64,12 @@ export interface INyxdQuery {
     limit?: number,
     startAfter?: string,
   ): Promise<PagedDelegatorDelegationsResponse>;
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation>;
-
+  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation>;
   getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
-  getRewardPool(mixnetContractAddress: string): Promise<string>;
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string>;
-  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number>;
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number>;
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus>;
+  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams>;
+  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse>;
+  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse>;
+  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding>;
 }
 
 export interface IQueryClient extends ICosmWasmQuery, INyxdQuery, INymApiQuery { }
@@ -115,41 +94,73 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
     return this.nyxdQuerier.getContractVersion(mixnetContractAddress);
   }
 
-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
-    return this.nyxdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
+  getMixNodeBonds(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeBondResponse> {
+    return this.nyxdQuerier.getMixNodeBonds(mixnetContractAddress, limit, startAfter);
+  }
+
+  getMixNodesDetailed(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeDetailsResponse> {
+    return this.nyxdQuerier.getMixNodesDetailed(mixnetContractAddress, limit, startAfter);
+  }
+
+  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse> {
+    return this.nyxdQuerier.getStakeSaturation(mixnetContractAddress, mixId);
+  }
+
+  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding> {
+    return this.nyxdQuerier.getMixnodeRewardingDetails(mixnetContractAddress, mixId);
   }
 
   getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
     return this.nyxdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
   }
 
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
-    return this.nyxdQuerier.ownsMixNode(mixnetContractAddress, address);
+  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nyxdQuerier.getOwnedMixnode(mixnetContractAddress, address);
   }
 
   ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
     return this.nyxdQuerier.ownsGateway(mixnetContractAddress, address);
   }
 
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+  getUnbondedMixNodes(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedUnbondedMixnodesResponse> {
+    return this.nyxdQuerier.getUnbondedMixNodes(mixnetContractAddress, limit, startAfter);
+  }
+
+  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse> {
+    return this.nyxdQuerier.getUnbondedMixNodeInformation(mixnetContractAddress, mixId);
+  }
+
+  getStateParams(mixnetContractAddress: string): Promise<ContractState> {
     return this.nyxdQuerier.getStateParams(mixnetContractAddress);
   }
 
-  getAllNetworkDelegationsPaged(
+  getAllDelegationsPaged(
     mixnetContractAddress: string,
     limit?: number,
     startAfter?: [string, string],
   ): Promise<PagedAllDelegationsResponse> {
-    return this.nyxdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
+    return this.nyxdQuerier.getAllDelegationsPaged(mixnetContractAddress, limit, startAfter);
   }
 
   getMixNodeDelegationsPaged(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mix_id: number,
     limit?: number,
     startAfter?: string,
   ): Promise<PagedMixDelegationsResponse> {
-    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
+    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mix_id, limit, startAfter);
   }
 
   getDelegatorDelegationsPaged(
@@ -161,36 +172,16 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
     return this.nyxdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
   }
 
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
-    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
+  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation> {
+    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mix_id, delegator);
   }
 
   getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
     return this.nyxdQuerier.getLayerDistribution(mixnetContractAddress);
   }
 
-  getRewardPool(mixnetContractAddress: string): Promise<string> {
-    return this.nyxdQuerier.getRewardPool(mixnetContractAddress);
-  }
-
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
-    return this.nyxdQuerier.getCirculatingSupply(mixnetContractAddress);
-  }
-
-  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nyxdQuerier.getIntervalRewardPercent(mixnetContractAddress);
-  }
-
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
-    return this.nyxdQuerier.getSybilResistancePercent(mixnetContractAddress);
-  }
-
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus> {
-    return this.nyxdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
+  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams> {
+    return this.nyxdQuerier.getRewardParams(mixnetContractAddress);
   }
 
   getCachedGateways(): Promise<GatewayBond[]> {
@@ -201,11 +192,111 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
     return this.nymApiQuerier.getCachedMixnodes();
   }
 
-  getActiveMixnodes(): Promise<MixNodeBond[]> {
+  getActiveMixnodes(): Promise<MixNodeDetails[]> {
     return this.nymApiQuerier.getActiveMixnodes();
   }
 
   getRewardedMixnodes(): Promise<MixNodeBond[]> {
     return this.nymApiQuerier.getRewardedMixnodes();
   }
+
+  getSpendableCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<any> {
+    return this.nyxdQuerier.getSpendableCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getVestingAccountsPaged(vestingContractAddress: string): Promise<VestingAccountsPaged> {
+    return this.nyxdQuerier.getVestingAccountsPaged(vestingContractAddress);
+  }
+
+  getVestingAmountsAccountsPaged(vestingContractAddress: string): Promise<VestingAccountsCoinPaged> {
+    return this.nyxdQuerier.getVestingAmountsAccountsPaged(vestingContractAddress);
+  }
+
+  getLockedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getLockedTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getSpendableTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getSpendableTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getVestedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getVestedTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getVestingTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getVestingTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getSpendableVestedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getSpendableVestedTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getSpendableRewards(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getSpendableRewards(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getDelegatedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getDelegatedCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getPledgedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getPledgedCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getStakedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getStakedCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getWithdrawnCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getWithdrawnCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getStartTime(vestingContractAddress: string, vestingAccountAddress: string): Promise<string> {
+    return this.nyxdQuerier.getStartTime(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getEndTime(vestingContractAddress: string, vestingAccountAddress: string): Promise<string> {
+    return this.nyxdQuerier.getEndTime(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getOriginalVestingDetails(vestingContractAddress: string, vestingAccountAddress: string): Promise<OriginalVestingResponse> {
+    return this.nyxdQuerier.getOriginalVestingDetails(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getHistoricStakingRewards(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getHistoricStakingRewards(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getAccountDetails(vestingContractAddress: string, address: string): Promise<VestingAccountInfo> {
+    return this.nyxdQuerier.getAccountDetails(vestingContractAddress, address);
+  }
+
+  getMixnode(vestingContractAddress: string, address: string): Promise<VestingAccountNode> {
+    return this.nyxdQuerier.getMixnode(vestingContractAddress, address);
+  }
+
+  getGateway(vestingContractAddress: string, address: string): Promise<VestingAccountNode> {
+    return this.nyxdQuerier.getGateway(vestingContractAddress, address);
+  }
+
+  getDelegationTimes(vestingContractAddress: string, mix_id: number, delegatorAddress: string): Promise<DelegationTimes> {
+    return this.nyxdQuerier.getDelegationTimes(vestingContractAddress, mix_id, delegatorAddress);
+  }
+
+  getAllDelegations(vestingContractAddress: string): Promise<Delegations> {
+    return this.nyxdQuerier.getAllDelegations(vestingContractAddress);
+  }
+
+  getDelegation(vestingContractAddress: string, vestingAccountAddress: string, mix_id: number): Promise<DelegationBlock> {
+    return this.nyxdQuerier.getDelegation(vestingContractAddress, vestingAccountAddress, mix_id);
+  }
+
+  getTotalDelegationAmount(vestingContractAddress: string, vestingAccountAddress: string, mix_id: number, block_timestamp_sec: number): Promise<Coin> {
+    return this.nyxdQuerier.getTotalDelegationAmount(vestingContractAddress, vestingAccountAddress, mix_id, block_timestamp_sec);
+  }
+
+  getCurrentVestingPeriod(vestingContractAddress: string, address: string): Promise<Period> {
+    return this.nyxdQuerier.getCurrentVestingPeriod(vestingContractAddress, address);
+  }
 }

clients/validator/src/signing-client.ts

@@ -25,14 +25,23 @@ import {
   MixnetContractVersion,
   MixNode,
   MixNodeBond,
+  MixNodeCostParams,
+  MixNodeDetails,
+  MixNodeRewarding,
   MixOwnershipResponse,
+  OriginalVestingResponse,
   PagedAllDelegationsResponse,
   PagedDelegatorDelegationsResponse,
   PagedGatewayResponse,
   PagedMixDelegationsResponse,
-  PagedMixnodeResponse,
-  RewardingStatus,
-} from './types';
+  PagedMixNodeBondResponse,
+  PagedMixNodeDetailsResponse,
+  PagedUnbondedMixnodesResponse,
+  RewardingParams,
+  UnbondedMixnodeResponse,
+  VestingAccountInfo,
+  ContractState, VestingAccountsCoinPaged, VestingAccountsPaged, DelegationTimes, Delegations, Period, VestingAccountNode, DelegationBlock
+} from '@nymproject/types';
 import NymApiQuerier from './nym-api-querier';
 
 // methods exposed by `SigningCosmWasmClient`
@@ -143,6 +152,7 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign
   bondMixNode(
     mixnetContractAddress: string,
     mixNode: MixNode,
+    costParams: MixNodeCostParams,
     ownerSignature: string,
     pledge: Coin,
     fee?: StdFee | 'auto' | number,
@@ -164,7 +174,7 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign
 
   delegateToMixNode(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mixId: number,
     amount: Coin,
     fee?: StdFee | 'auto' | number,
     memo?: string,
@@ -172,14 +182,14 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign
 
   undelegateFromMixNode(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mixId: number,
     fee?: StdFee | 'auto' | number,
     memo?: string,
   ): Promise<ExecuteResult>;
 
   updateMixnodeConfig(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mixId: number,
     profitMarginPercent: number,
     fee: StdFee | 'auto' | number,
   ): Promise<ExecuteResult>;
@@ -238,41 +248,73 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
     return this.nyxdQuerier.getContractVersion(mixnetContractAddress);
   }
 
-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
-    return this.nyxdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
+  getMixNodeBonds(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeBondResponse> {
+    return this.nyxdQuerier.getMixNodeBonds(mixnetContractAddress, limit, startAfter);
+  }
+
+  getMixNodesDetailed(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeDetailsResponse> {
+    return this.nyxdQuerier.getMixNodesDetailed(mixnetContractAddress, limit, startAfter);
+  }
+
+  getStakeSaturation(mixnetContractAddress: string, mixId: number) {
+    return this.nyxdQuerier.getStakeSaturation(mixnetContractAddress, mixId);
+  }
+
+  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse> {
+    return this.nyxdQuerier.getUnbondedMixNodeInformation(mixnetContractAddress, mixId);
+  }
+
+  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding> {
+    return this.nyxdQuerier.getMixnodeRewardingDetails(mixnetContractAddress, mixId);
   }
 
   getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
     return this.nyxdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
   }
 
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
-    return this.nyxdQuerier.ownsMixNode(mixnetContractAddress, address);
+  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nyxdQuerier.getOwnedMixnode(mixnetContractAddress, address);
   }
 
   ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
     return this.nyxdQuerier.ownsGateway(mixnetContractAddress, address);
   }
 
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
+  getStateParams(mixnetContractAddress: string): Promise<ContractState> {
     return this.nyxdQuerier.getStateParams(mixnetContractAddress);
   }
 
-  getAllNetworkDelegationsPaged(
+  getAllDelegationsPaged(
     mixnetContractAddress: string,
     limit?: number,
     startAfter?: [string, string],
   ): Promise<PagedAllDelegationsResponse> {
-    return this.nyxdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
+    return this.getAllDelegationsPaged(mixnetContractAddress, limit, startAfter);
+  }
+
+  getUnbondedMixNodes(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedUnbondedMixnodesResponse> {
+    return this.nyxdQuerier.getUnbondedMixNodes(mixnetContractAddress, limit, startAfter);
   }
 
   getMixNodeDelegationsPaged(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mix_id: number,
     limit?: number,
     startAfter?: string,
   ): Promise<PagedMixDelegationsResponse> {
-    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
+    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mix_id, limit, startAfter);
   }
 
   getDelegatorDelegationsPaged(
@@ -284,36 +326,16 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
     return this.nyxdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
   }
 
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
-    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
+  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation> {
+    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mix_id, delegator);
   }
 
   getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
     return this.nyxdQuerier.getLayerDistribution(mixnetContractAddress);
   }
 
-  getRewardPool(mixnetContractAddress: string): Promise<string> {
-    return this.nyxdQuerier.getRewardPool(mixnetContractAddress);
-  }
-
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
-    return this.nyxdQuerier.getCirculatingSupply(mixnetContractAddress);
-  }
-
-  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nyxdQuerier.getIntervalRewardPercent(mixnetContractAddress);
-  }
-
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
-    return this.nyxdQuerier.getSybilResistancePercent(mixnetContractAddress);
-  }
-
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus> {
-    return this.nyxdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
+  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams> {
+    return this.nyxdQuerier.getRewardParams(mixnetContractAddress);
   }
 
   getCachedGateways(): Promise<GatewayBond[]> {
@@ -324,7 +346,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
     return this.nymApiQuerier.getCachedMixnodes();
   }
 
-  getActiveMixnodes(): Promise<MixNodeBond[]> {
+  getActiveMixnodes(): Promise<MixNodeDetails[]> {
     return this.nymApiQuerier.getActiveMixnodes();
   }
 
@@ -332,11 +354,16 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
     return this.nymApiQuerier.getRewardedMixnodes();
   }
 
+  getSpendableCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<any> {
+    return this.nyxdQuerier.getSpendableCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
   // signing related:
 
   bondMixNode(
     mixnetContractAddress: string,
     mixNode: MixNode,
+    costParams: MixNodeCostParams,
     ownerSignature: string,
     pledge: Coin,
     fee: StdFee | 'auto' | number = 'auto',
@@ -348,6 +375,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
       {
         bond_mixnode: {
           mix_node: mixNode,
+          cost_params: costParams,
           owner_signature: ownerSignature,
         },
       },
@@ -414,7 +442,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
 
   delegateToMixNode(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mixId: number,
     amount: Coin,
     fee: StdFee | 'auto' | number = 'auto',
     memo = 'Default MixNode Delegation from Typescript',
@@ -424,7 +452,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
       mixnetContractAddress,
       {
         delegate_to_mixnode: {
-          mix_identity: mixIdentity,
+          mix_id: mixId,
         },
       },
       fee,
@@ -435,7 +463,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
 
   undelegateFromMixNode(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mixId: number,
     fee: StdFee | 'auto' | number = 'auto',
     memo = 'Default MixNode Undelegation from Typescript',
   ): Promise<ExecuteResult> {
@@ -444,7 +472,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
       mixnetContractAddress,
       {
         undelegate_from_mixnode: {
-          mix_identity: mixIdentity,
+          mix_id: mixId,
         },
       },
       fee,
@@ -454,14 +482,14 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
 
   updateMixnodeConfig(
     mixnetContractAddress: string,
-    mixIdentity: string,
+    mixId: number,
     profitMarginPercent: number,
     fee: StdFee | 'auto' | number,
   ): Promise<ExecuteResult> {
     return this.execute(
       this.clientAddress,
       mixnetContractAddress,
-      { update_mixnode_config: { profit_margin_percent: profitMarginPercent, mix_identity: mixIdentity } },
+      { update_mixnode_config: { profit_margin_percent: profitMarginPercent, mix_id: mixId } },
       fee,
     );
   }
@@ -482,4 +510,102 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
       memo,
     );
   }
+
+  // vesting related 
+
+  getVestingAccountsPaged(vestingContractAddress: string): Promise<VestingAccountsPaged> {
+    return this.nyxdQuerier.getVestingAccountsPaged(vestingContractAddress);
+  };
+
+  getVestingAmountsAccountsPaged(vestingContractAddress: string): Promise<VestingAccountsCoinPaged> {
+    return this.nyxdQuerier.getVestingAmountsAccountsPaged(vestingContractAddress);
+  }
+
+  getLockedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getLockedTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getSpendableTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getSpendableTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getVestedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getVestedTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getVestingTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getVestingTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getSpendableVestedTokens(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getSpendableVestedTokens(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getSpendableRewards(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getSpendableRewards(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getDelegatedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getDelegatedCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getPledgedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getPledgedCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getStakedCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getStakedCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getWithdrawnCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getWithdrawnCoins(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getStartTime(vestingContractAddress: string, vestingAccountAddress: string): Promise<string> {
+    return this.nyxdQuerier.getStartTime(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getEndTime(vestingContractAddress: string, vestingAccountAddress: string): Promise<string> {
+    return this.nyxdQuerier.getEndTime(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getOriginalVestingDetails(vestingContractAddress: string, vestingAccountAddress: string): Promise<OriginalVestingResponse> {
+    return this.nyxdQuerier.getOriginalVestingDetails(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getHistoricStakingRewards(vestingContractAddress: string, vestingAccountAddress: string): Promise<Coin> {
+    return this.nyxdQuerier.getHistoricStakingRewards(vestingContractAddress, vestingAccountAddress);
+  }
+
+  getAccountDetails(vestingContractAddress: string, address: string): Promise<VestingAccountInfo> {
+    return this.nyxdQuerier.getAccountDetails(vestingContractAddress, address);
+  }
+
+  getMixnode(vestingContractAddress: string, address: string): Promise<VestingAccountNode> {
+    return this.nyxdQuerier.getMixnode(vestingContractAddress, address);
+  }
+
+  getGateway(vestingContractAddress: string, address: string): Promise<VestingAccountNode> {
+    return this.nyxdQuerier.getGateway(vestingContractAddress, address);
+  }
+
+  getDelegationTimes(vestingContractAddress: string, mix_id: number, delegatorAddress: string): Promise<DelegationTimes> {
+    return this.nyxdQuerier.getDelegationTimes(vestingContractAddress, mix_id, delegatorAddress);
+  }
+
+  getAllDelegations(vestingContractAddress: string): Promise<Delegations> {
+    return this.nyxdQuerier.getAllDelegations(vestingContractAddress);
+  }
+
+  getDelegation(vestingContractAddress: string, vestingAccountAddress: string, mix_id: number): Promise<DelegationBlock> {
+    return this.nyxdQuerier.getDelegation(vestingContractAddress, vestingAccountAddress, mix_id);
+  }
+
+  getTotalDelegationAmount(vestingContractAddress: string, vestingAccountAddress: string, mix_id: number, block_timestamp_sec: number): Promise<Coin> {
+    return this.nyxdQuerier.getTotalDelegationAmount(vestingContractAddress, vestingAccountAddress, mix_id, block_timestamp_sec);
+  }
+
+  getCurrentVestingPeriod(vestingContractAddress: string, address: string): Promise<Period> {
+    return this.nyxdQuerier.getCurrentVestingPeriod(vestingContractAddress, address);
+  }
 }

clients/validator/src/tests/expectedResponses.ts

@@ -0,0 +1,254 @@
+import { Coin } from 'cosmjs-types/cosmos/base/v1beta1/coin';
+import expect from 'expect';
+
+export const amountDemon = {
+    denom: expect.any(String),
+    amount: expect.any(String)
+}
+
+export const delegation = {
+    owner: expect.any(String),
+    mix_id: expect.any(Number),
+    cumulative_reward_ratio: expect.any(String),
+    amount: amountDemon,
+    height: expect.any(Number || BigInt),
+    proxy: expect.any(String || null)
+}
+
+export const detailedDelegation = {
+    delegation: delegation,
+    mixnode_still_bonded: expect.any(Boolean)
+}
+
+export const gateway = {
+    pledge_amount: amountDemon,
+    owner: expect.any(String),
+    block_height: expect.any(Number || BigInt),
+    gateway: {
+        host: expect.any(String),
+        mix_port: expect.any(Number),
+        clients_port: expect.any(Number),
+        location: expect.any(String),
+        sphinx_key: expect.any(String),
+        identity_key: expect.any(String),
+        version: expect.any(String),
+    },
+    proxy: expect.any(String || null)
+}
+
+export const pagedGateway = {
+    nodes: gateway,
+    per_page: expect.any(Number),
+    start_next_after: expect.any(Number)
+}
+
+export const ownGateway = {
+    address: expect.any(String),
+    gateway: gateway
+}
+
+export const rewardingdetails = {
+    cost_params: {
+        profit_margin_percent: expect.any(String),
+        interval_operating_cost: {
+            denom: expect.any(String),
+            amount: expect.any(String)
+        }
+    },
+    operator: expect.any(String),
+    delegates: expect.any(String),
+    total_unit_reward: expect.any(String),
+    unit_delegation: expect.any(String),
+    last_rewarded_epoch: expect.any(Number),
+    unique_delegations: expect.any(Number)
+}
+
+export const mix_node = {
+    host: expect.any(String),
+    mix_port: expect.any(Number),
+    verloc_port: expect.any(Number),
+    http_api_port: expect.any(Number),
+    sphinx_key: expect.any(String),
+    identity_key: expect.any(String),
+    version: expect.any(String)
+}
+
+export const mixnodebond = {
+    mix_id: expect.any(Number),
+    owner: expect.any(String),
+    original_pledge: {
+        denom: expect.any(String),
+        amount: expect.any(String)
+    },
+    layer: expect.any(String),
+    mix_node: mix_node,
+    proxy: expect.any(String) || null,
+    bonding_height: expect.any(Number || BigInt),
+    is_unbonding: expect.any(Boolean)
+}
+
+export const mixnode = {
+    bond_information: mixnodebond,
+    rewarding_details: rewardingdetails
+}
+
+export const ownedNode = {
+    address: expect.any(String),
+    mixnode_details: {
+        bond_information: mixnodebond,
+        rewarding_details: rewardingdetails
+    }
+}
+
+export const saturation = {
+    mix_id: expect.any(Number),
+    current_saturation: expect.any(String),
+    uncapped_saturation: expect.any(String)
+}
+
+export const contractVersion = {
+    build_timestamp: expect.any(String),
+    build_version: expect.any(String),
+    commit_sha: expect.any(String),
+    commit_timestamp: expect.any(String),
+    commit_branch: expect.any(String),
+    rustc_version: expect.any(String)
+};
+
+export const stateParams = {
+    minimum_gateway_pledge: amountDemon,
+    minimum_mixnode_pledge: expect.any(String),
+    mixnode_rewarded_set_size: expect.any(Number),
+    mixnode_active_set_size: expect.any(Number)
+}
+
+export const contract = {
+    owner: expect.any(Number),
+    rewarding_validator_address: expect.any(Number),
+    vesting_contract_address: expect.any(Number),
+    rewarding_denom: expect.any(String),
+    params: stateParams
+}
+
+export const rewardingnode = {
+    mix_id: expect.any(Number),
+    rewarding_details: rewardingdetails
+}
+
+export const unbondednode = {
+    mix_id: expect.any(Number),
+    unbonded_info: {
+        identity_key: expect.any(String),
+        owner: expect.any(String),
+        proxy: expect.any(String) || null,
+        unbonding_height: expect.any(Number)
+    }
+}
+
+export const allunbondednodes = [
+    expect.any(Number), {
+        identity_key: expect.any(String),
+        owner: expect.any(String),
+        proxy: expect.any(String) || null,
+        unbonding_height: expect.any(Number)
+    }
+]
+
+export const layerDistribution = {
+    layer1: expect.any(Number),
+    layer2: expect.any(Number),
+    layer3: expect.any(Number)
+}
+
+export const intervalRewardParams = {
+    reward_pool: expect.any(Number),
+    staking_supply: expect.any(Number),
+    staking_supply_scale_factor: expect.any(Number),
+    epoch_reward_budget: expect.any(Number),
+    stake_saturation_point: expect.any(Number),
+    sybil_resistance: expect.any(Number),
+    active_set_work_factor: expect.any(Number),
+    interval_pool_emission: expect.any(Number)
+}
+
+export const rewardingParams = {
+    interval: intervalRewardParams,
+    rewarded_set_size: expect.any(Number),
+    active_set_size: expect.any(Number)
+}
+
+export const VestAccounts = [{
+    account_id: expect.any(String),
+    owner: expect.any(String)
+}]
+
+export const VestAccountCoin = [{
+    account_id: expect.any(String),
+    owner: expect.any(String),
+    still_vesting: Coin
+}]
+
+export const vestingAccountsPaged = {
+    accounts: VestAccounts,
+    start_next_after: expect.any(String)
+}
+
+export const VestingCoinAccounts = {
+    accounts: VestAccountCoin,
+    start_next_after: expect.any(String)
+}
+
+export const OriginalVestingDetails = {
+    amount: Coin,
+    number_of_periods: expect.any(Number),
+    period_duration: expect.any(Number)
+}
+
+export const PledgeCap = {
+    percent: expect.any(String) || null,
+};
+
+export const Periods = [{
+    period_seconds: expect.any(Number),
+    start_time: expect.any(Number),
+}]
+
+export const VestingAccountDetails = {
+    owner_address: expect.any(String),
+    staking_address: expect.any(String) || null,
+    start_time: expect.any(String),
+    periods: Periods,
+    coin: Coin,
+    storage_key: expect.any(Number),
+    pledge_cap: PledgeCap
+}
+
+export const Node = {
+    amount: Coin,
+    block_time: expect.any(String)
+}
+
+export type VestingPeriod = 'Before' | { In: number } | 'After';
+
+export const DelegationTimestamps = [
+    expect.any(Number)
+]
+
+export const DelegatorTimes = {
+    owner: expect.any(String),
+    account_id: expect.any(Number),
+    mix_id: expect.any(Number),
+    delegation_timestamps: DelegationTimestamps
+}
+
+export const DelegationBlock = [{
+    account_id: expect.any(Number),
+    amount: expect.any(String),
+    block_timestamp: expect.any(Number),
+    mix_id: expect.any(Number)
+}]
+
+export const Delegations = {
+    delegations: DelegationBlock,
+    start_next_after: expect.any(String) || null
+}

clients/validator/src/tests/mock/client.ts

@@ -0,0 +1,19 @@
+import { Mock, Times } from 'moq.ts';
+import expect from 'expect';
+import { INyxdQuery } from '../../query-client';
+
+export class TestHelper {
+  buildMethod = async <T>(methodName: string, args: any[], expectedResult: any): Promise<T> => {
+    const client = new Mock<INyxdQuery>()
+      .setup((nym) => nym[methodName](...args))
+      .returns(Promise.resolve(expectedResult));
+    const obj = client.object();
+    const actualDetails = await obj[methodName](...args);
+
+    client.verify((nym) => nym[methodName](...args), Times.Exactly(1));
+    expect(Object.keys([actualDetails])).toEqual(Object.keys(expectedResult));
+    expect(actualDetails).toBeDefined();
+
+    return actualDetails;
+  };
+}

clients/validator/src/tests/mock/delegation.mock.test.ts

@@ -0,0 +1,40 @@
+import expect from 'expect';
+import { Delegation } from '@nymproject/types';
+import { PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse } from '../../types/shared-types';
+import { TestHelper } from './client';
+import { mixnet, mixnodeowneraddress, mix_id } from './testData';
+
+describe('Delegation mock tests', () => {
+  const testHelper = new TestHelper();
+
+  it('get Delegation Details', () => {
+    const execute = testHelper.buildMethod('getDelegationDetails', [mixnet, mix_id, mixnodeowneraddress], <Delegation>{
+      owner: mixnodeowneraddress,
+      mix_id: 0,
+      cumulative_reward_ratio: '',
+      amount: {
+        denom: 'nym',
+        amount: '10',
+      },
+      height: 1314134144132n,
+      proxy: 'null',
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get All Delegations Paged', () => {
+    const execute = testHelper.buildMethod('getAllDelegationsPaged', [mixnet], <PagedAllDelegationsResponse>{
+      delegations: [],
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Delegator Delegations Paged', () => {
+    const execute = testHelper.buildMethod('getDelegatorDelegationsPaged', [mixnet, mixnodeowneraddress], <
+      PagedDelegatorDelegationsResponse
+    >{
+      delegations: [],
+    });
+    expect(execute).toBeTruthy();
+  });
+});

clients/validator/src/tests/mock/gateway.mock.test.ts

@@ -0,0 +1,24 @@
+import expect from 'expect';
+import { GatewayOwnershipResponse, PagedGatewayResponse } from '../../types/shared-types';
+import { TestHelper } from './client';
+import { gatewayowneraddress, mixnet } from './testData';
+
+describe('Gateway mock tests', () => {
+  const testHelper = new TestHelper();
+
+  it('get Gateways Paged', () => {
+    const execute = testHelper.buildMethod('getGatewaysPaged', [mixnet], <PagedGatewayResponse>{
+      nodes: [],
+      per_page: 25,
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('owns Gateway', () => {
+    const execute = testHelper.buildMethod('ownsGateway', [mixnet, gatewayowneraddress], <GatewayOwnershipResponse>{
+      address: gatewayowneraddress,
+      gateway: {},
+    });
+    expect(execute).toBeTruthy();
+  });
+});

clients/validator/src/tests/mock/mixnet.mock.test.ts

@@ -0,0 +1,65 @@
+import expect from 'expect';
+import { LayerDistribution, MixnetContractVersion, StakeSaturationResponse } from '@nymproject/types';
+import { TestHelper } from './client';
+import { mixnet, mix_id } from './testData';
+import { RewardingParams } from '@nymproject/types';
+import { ContractState } from '../../types/shared';
+
+describe('Mixnet mock tests', () => {
+  const testHelper = new TestHelper();
+
+  it('get Layer Distribution', () => {
+    const execute = testHelper.buildMethod('getLayerDistribution', [mixnet], <LayerDistribution>{
+      layer1: 2,
+      layer2: 2,
+      layer3: 5,
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Reward Params', () => {
+    const execute = testHelper.buildMethod('getRewardParams', [mixnet], <RewardingParams>{
+      interval: {},
+      rewarded_set_size: 0,
+      active_set_size: 0,
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Stake Saturation', () => {
+    const execute = testHelper.buildMethod('getStakeSaturation', [mixnet, mix_id], <StakeSaturationResponse>{
+      mix_id: 0,
+      current_saturation: '',
+      uncapped_saturation: '',
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get State Params', () => {
+    const execute = testHelper.buildMethod('getStateParams', [mixnet], <ContractState>{
+      owner: '',
+      rewarding_validator_address: '',
+      vesting_contract_address: '',
+      rewarding_denom: 'unym',
+      params: {
+        minimum_mixnode_pledge: '',
+        minimum_gateway_pledge: '',
+        mixnode_rewarded_set_size: 240,
+        mixnode_active_set_size: 240,
+      },
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Contract Version', () => {
+    const execute = testHelper.buildMethod('getContractVersion', [mixnet], <MixnetContractVersion>{
+      build_timestamp: 'test',
+      commit_branch: 'test',
+      build_version: 'test',
+      rustc_version: 'test',
+      commit_sha: 'test',
+      commit_timestamp: 'test',
+    });
+    expect(execute).toBeTruthy();
+  });
+});

clients/validator/src/tests/mock/mixnode.mock.test.ts

@@ -0,0 +1,71 @@
+import expect from 'expect';
+import {
+  MixNodeRewarding,
+  MixOwnershipResponse,
+  PagedMixDelegationsResponse,
+  PagedMixNodeBondResponse,
+  PagedMixNodeDetailsResponse,
+  UnbondedMixnodeResponse,
+} from '@nymproject/types';
+import { TestHelper } from './client';
+import { mixnet, mixnodeowneraddress, mix_id } from './testData';
+
+describe('Mixnode mock tests', () => {
+  const testHelper = new TestHelper();
+
+  it('get Mixnode Bonds', () => {
+    const execute = testHelper.buildMethod('getMixNodeBonds', [mixnet], <PagedMixNodeBondResponse>{
+      nodes: [],
+      per_page: 25,
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Mixnode Delegations Paged', () => {
+    const execute = testHelper.buildMethod('getMixNodeDelegationsPaged', [mixnet, mix_id], <
+      PagedMixDelegationsResponse
+    >{
+      delegations: [],
+      per_page: 25,
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Mixnodes Detailed', () => {
+    const execute = testHelper.buildMethod('getMixNodesDetailed', [mixnet], <PagedMixNodeDetailsResponse>{
+      nodes: [],
+      per_page: 25,
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Mixnode Rewarding Details', () => {
+    const execute = testHelper.buildMethod('getMixnodeRewardingDetails', [mixnet, mix_id], <MixNodeRewarding>{
+      cost_params: {},
+      operator: '',
+      delegates: '',
+      total_unit_reward: '',
+      unit_delegation: '',
+      last_rewarded_epoch: 1,
+      unique_delegations: 1,
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Owned Mixnode', () => {
+    const execute = testHelper.buildMethod('getOwnedMixnode', [mixnet, mixnodeowneraddress], <MixOwnershipResponse>{
+      address: '',
+      mixnode: {},
+    });
+    expect(execute).toBeTruthy();
+  });
+
+  it('get Unbonded Mixnode Information', () => {
+    const execute = testHelper.buildMethod(
+      'getUnbondedMixNodeInformation',
+      [mixnet, mix_id],
+      <UnbondedMixnodeResponse>{},
+    );
+    expect(execute).toBeTruthy();
+  });
+});

clients/validator/src/tests/mock/testData.ts

@@ -0,0 +1,8 @@
+export const mixnet = 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g';
+export const gatewayowneraddress = 'n16evnn8glr0sham3matj8rg2s24m6x56ayk87ts';
+// export const mixId = 436207616;
+export const mix_id = 26;
+export const nodeIdentityKey = 'ATmVJknZarDF6Yj53M7h8NS9LLCUvWuToXpk3pDvYUH1';
+export const mixnodeowneraddress = 'n1fzv4jc7fanl9s0qj02ge2ezk3kts545kjtek47';
+export const delegatorAddress = 'n1lemst75va9700tsrxq58adzujrh6h9s5x60h9h';
+export const rewardingIntervalNonce = 1;

clients/validator/src/tests/query/mixnetQueries.test.ts

@@ -0,0 +1,180 @@
+import expect from 'expect';
+import ValidatorClient from '../../index';
+
+import {
+  allunbondednodes,
+  contract,
+  delegation,
+  gateway,
+  layerDistribution,
+  mixnode,
+  mixnodebond,
+  ownedNode,
+  ownGateway,
+  rewardingnode,
+  saturation,
+  unbondednode,
+} from '../expectedResponses';
+import { delegatorAddress, gatewayowneraddress } from '../mock/testData';
+
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+describe('Mixnet queries', () => {
+  let client: ValidatorClient;
+
+  beforeEach(async () => {
+    client = await ValidatorClient.connectForQuery(
+      process.env.rpcAddress || '',
+      process.env.validatorAddress || '',
+      process.env.prefix || '',
+      process.env.mixnetContractAddress || '',
+      process.env.vestingContractAddress || '',
+      process.env.denom || '',
+    );
+  });
+
+  //
+  // CONTRACT
+  //
+
+  it('can query for an account balance', async () => {
+    const balance = await client.getBalance('n1ptg680vnmef2cd8l0s9uyc4f0hgf3x8sed6w77');
+    expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
+  });
+
+  it('can query for stake saturation', async () => {
+    const stakeSaturation = await client.getStakeSaturation(7);
+    expect(Object.keys(stakeSaturation)).toEqual(Object.keys(saturation));
+    expect(stakeSaturation).toBeTruthy();
+    expect(stakeSaturation?.current_saturation).toBeTruthy();
+  });
+
+  it('can query for contract version', async () => {
+    const contractV = await client.getMixnetContractVersion();
+    expect(contractV).toBeTruthy();
+  });
+
+  it('can query for mixnet contract settings', async () => {
+    const settings = await client.getMixnetContractSettings();
+    expect(Object.keys(settings)).toEqual(Object.keys(contract));
+    expect(settings).toBeTruthy();
+  });
+
+  it('can query for reward pool', async () => {
+    const rewardPool = await client.getRewardParams();
+    // TODO add velidation here
+    expect(rewardPool).toBeTruthy();
+  });
+
+  it('can query for layer distribution', async () => {
+    const layer = await client.getLayerDistribution();
+    expect(Object.keys(layer)).toEqual(Object.keys(layerDistribution));
+    expect(layer).toBeTruthy();
+  });
+
+  //
+  // MIXNODES
+  //
+
+  it('can query for unbonded mixnodes', async () => {
+    const unbondedNodes = await client.getUnbondedMixNodes();
+    for (let i = 0; i < unbondedNodes.length; i++) {
+      expect(Object.keys(unbondedNodes[0])).toEqual(Object.keys(allunbondednodes));
+      expect(unbondedNodes).toBeTruthy();
+    }
+  });
+
+  it('can query for unbonded mixnode information', async () => {
+    const unbondedMixnodeInfo = await client.getUnbondedMixNodeInformation(1);
+    expect(Object.keys(unbondedMixnodeInfo)).toEqual(Object.keys(unbondednode));
+    expect(unbondedMixnodeInfo).toBeTruthy();
+  });
+
+  it('can query for mixnode rewarding details', async () => {
+    const rewardingDetails = await client.getMixnodeRewardingDetails(1);
+    expect(Object.keys(rewardingDetails)).toEqual(Object.keys(rewardingnode));
+    expect(rewardingDetails).toBeTruthy();
+  });
+
+  it('can query for owned mixnode', async () => {
+    const ownedMixnode = await client.getOwnedMixnode('n1ptg680vnmef2cd8l0s9uyc4f0hgf3x8sed6w77');
+    expect(Object.keys(ownedMixnode)).toEqual(Object.keys(ownedNode));
+    expect(ownedMixnode).toBeTruthy();
+  });
+
+  it('can query for all mixnode bonds', async () => {
+    const mixnodeBonds = await client.getMixNodeBonds();
+    expect(Object.keys(mixnodeBonds[0])).toEqual(Object.keys(mixnodebond));
+    expect(mixnodeBonds).toBeTruthy();
+    expect(Array.isArray(mixnodeBonds)).toBeTruthy();
+  });
+
+  it('can query for all mixnode details', async () => {
+    const mixnodeDetails = await client.getMixNodesDetailed();
+    expect(Object.keys(mixnodeDetails[0])).toEqual(Object.keys(mixnode));
+    expect(mixnodeDetails).toBeTruthy();
+    expect(Array.isArray(mixnodeDetails)).toBeTruthy();
+  });
+
+  it('can query for all active mixnodes', async () => {
+    const activeNodes = await client.getActiveMixnodes();
+    expect(Object.keys(activeNodes[0])).toEqual(Object.keys(mixnode));
+    expect(activeNodes).toBeTruthy();
+    expect(Array.isArray(activeNodes)).toBeTruthy();
+  });
+
+  it('can query for rewarded mixnodes', async () => {
+    const rewardNodes = await client.getRewardedMixnodes();
+    expect(Object.keys(rewardNodes[0])).toEqual(Object.keys(mixnode));
+    expect(rewardNodes).toBeTruthy();
+  });
+
+  //
+  // DELEGATIONS
+  //
+
+  it('can query for account delegations', async () => {
+    const delegations = await client.getAllNyxdDelegatorDelegations('n1fzv4jc7fanl9s0qj02ge2ezk3kts545kjtek47');
+    expect(Object.keys(delegations[0])).toEqual(Object.keys(delegation));
+    expect(delegations).toBeTruthy();
+    expect(Array.isArray(delegations)).toBeTruthy();
+  });
+
+  it('can query for all delegations', async () => {
+    const allDelegations = await client.getAllNyxdDelegations();
+    expect(Object.keys(allDelegations[0])).toEqual(Object.keys(delegation));
+    expect(allDelegations).toBeTruthy();
+    expect(Array.isArray(allDelegations)).toBeTruthy();
+  });
+
+  it('can query for all delegations on a node', async () => {
+    const mixnodeDelegations = await client.getAllNyxdSingleMixnodeDelegations(1);
+    expect(Object.keys(mixnodeDelegations[0])).toEqual(Object.keys(delegation));
+    expect(mixnodeDelegations).toBeTruthy();
+  });
+
+  it('can query for detailed delegations', async () => {
+    const detailedDelegation = await client.getDelegationDetails(7, delegatorAddress);
+    expect(Object.keys(detailedDelegation)).toEqual(Object.keys(detailedDelegation));
+    expect(detailedDelegation).toBeTruthy();
+  });
+
+  //
+  // GATEWAYS
+  //
+
+  it('can query for all gateways', async () => {
+    const gateways = await client.getAllNyxdGateways();
+    expect(Object.keys(gateways[0])).toEqual(Object.keys(gateway));
+    expect(gateways).toBeTruthy();
+    expect(Array.isArray(gateways)).toBeTruthy();
+  }).timeout(10000);
+
+  it('can query for owned gateway', async () => {
+    const gateway = await client.ownsGateway(gatewayowneraddress);
+    expect(Object.keys(gateway)).toEqual(Object.keys(ownGateway));
+    expect(gateway).toBeTruthy();
+  }).timeout(10000);
+});

clients/validator/src/tests/query/vestingQueries.test.ts

@@ -0,0 +1,168 @@
+import expect from 'expect';
+import ValidatorClient from '../../index';
+import { amountDemon, Delegations, DelegatorTimes, Node, OriginalVestingDetails, VestingAccountDetails, vestingAccountsPaged, VestingCoinAccounts, VestingPeriod } from '../expectedResponses';
+
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+describe('Vesting queries', () => {
+  let client: ValidatorClient;
+
+  beforeEach(async () => {
+    client = await ValidatorClient.connectForQuery(
+      process.env.rpcAddress || '',
+      process.env.validatorAddress || '',
+      process.env.prefix || '',
+      process.env.mixnetContractAddress || '',
+      process.env.vestingContractAddress || '',
+      process.env.denom || '',
+    );
+  });
+
+  const vesting_account_address = 'n14juvj7llvx8eppypnqj6xlrgwss9wfrcuy0nkv';
+  const mixnodeowner = 'n1z93z44vf8ssvdhujjvxcj4rd5e3lz0l60wdk70';
+  const gatewayowner = 'n1un9cuvw9e3xqratmde4j55ucksev0dkeruq800';
+  const mix_id = 79;
+
+  it('can query for contract version', async () => {
+    const contract = await client.getVestingContractVersion();
+    expect(contract).toBeTruthy();
+  });
+
+  // TODO see if we can use AccountEntry type here instead
+  it('can get all accounts paged', async () => {
+    const accounts = await client.getVestingAccountsPaged();
+    expect(Object.keys(accounts)).toEqual(Object.keys(vestingAccountsPaged));
+    expect(accounts).toBeTruthy();
+  });
+
+  it('can get coins for all accounts paged', async () => {
+    const accounts = await client.getVestingAmountsAccountsPaged();
+    expect(Object.keys(accounts)).toEqual(Object.keys(VestingCoinAccounts));
+    expect(accounts).toBeTruthy();
+  });
+
+  it('can get locked tokens for an account', async () => {
+    const locked = await client.getLockedTokens(vesting_account_address);
+    expect(Object.keys(locked)).toEqual(Object.keys(amountDemon));
+    expect(locked).toBeTruthy();
+  });
+
+  it('can get spendable tokens for an account', async () => {
+    const spendable = await client.getSpendableTokens(vesting_account_address);
+    expect(Object.keys(spendable)).toEqual(Object.keys(amountDemon));
+    expect(spendable).toBeTruthy();
+  });
+
+  it('can get vested tokens for an account', async () => {
+    const vested = await client.getVestedTokens(vesting_account_address);
+    expect(Object.keys(vested)).toEqual(Object.keys(amountDemon));
+    expect(vested).toBeTruthy();
+  });
+
+  it('can get vesting tokens for an account', async () => {
+    const vesting = await client.getVestingTokens(vesting_account_address);
+    expect(Object.keys(vesting)).toEqual(Object.keys(amountDemon));
+    expect(vesting).toBeTruthy();
+  });
+
+  it('can get spendable vested tokens for an account', async () => {
+    const spendable = await client.getSpendableVestedTokens(vesting_account_address);
+    expect(Object.keys(spendable)).toEqual(Object.keys(amountDemon));
+    expect(spendable).toBeTruthy();
+  });
+
+  it('can get spendable rewards for an account', async () => {
+    const rewards = await client.getSpendableRewards(vesting_account_address);
+    expect(Object.keys(rewards)).toEqual(Object.keys(amountDemon));
+    expect(rewards).toBeTruthy();
+  });
+
+  it('can get delegated coins', async () => {
+    const delegated = await client.getDelegatedCoins(vesting_account_address);
+    expect(Object.keys(delegated)).toEqual(Object.keys(amountDemon));
+    expect(delegated).toBeTruthy();
+  });
+
+  it('can get pledged coins', async () => {
+    const pledged = await client.getPledgedCoins(vesting_account_address);
+    expect(Object.keys(pledged)).toEqual(Object.keys(amountDemon));
+    expect(pledged).toBeTruthy();
+  });
+
+  it('can get staked coins', async () => {
+    const staked = await client.getStakedCoins(vesting_account_address);
+    expect(Object.keys(staked)).toEqual(Object.keys(amountDemon));
+    expect(staked).toBeTruthy();
+  });
+
+  it('can get withdrawn coins', async () => {
+    const withdrawn = await client.getWithdrawnCoins(vesting_account_address);
+    expect(Object.keys(withdrawn)).toEqual(Object.keys(amountDemon));
+    expect(withdrawn).toBeTruthy();
+  });
+
+  it('can get start time of an account', async () => {
+    const time = await client.getStartTime(vesting_account_address);
+    expect(typeof time).toBe("string");
+    expect(time).toBeTruthy();
+  });
+
+  it('can get end time of an account', async () => {
+    const time = await client.getEndTime(vesting_account_address);
+    expect(typeof time).toBe("string");
+    expect(time).toBeTruthy();
+  });
+
+  it('can get account original vesting details', async () => {
+    const original = await client.getOriginalVestingDetails(vesting_account_address);
+    expect(Object.keys(original)).toEqual(Object.keys(OriginalVestingDetails));
+    expect(original).toBeTruthy();
+  });
+
+  it('can get historic vesting staking rewards', async () => {
+    const rewards = await client.getHistoricStakingRewards(vesting_account_address);
+    expect(Object.keys(rewards)).toEqual(Object.keys(amountDemon));
+    expect(rewards).toBeTruthy();
+  });
+
+  // TODO see if we can use "VestingAccountInfo" type here instead
+  it('can get account details', async () => {
+    const account = await client.getAccountDetails(vesting_account_address);
+    expect(Object.keys(account)).toEqual(Object.keys(VestingAccountDetails));
+    expect(account).toBeTruthy();
+  });
+
+  // TODO add option for if account has no mixnode and expected is null 
+  it('can get mixnode', async () => {
+    const mixnode = await client.getMixnode(mixnodeowner);
+    expect(Object.keys(mixnode)).toEqual(Object.keys(Node));
+    expect(mixnode).toBeTruthy();
+  });
+
+  // TODO add option for if account has no gateway and expected is null 
+  it.skip('can get gateway', async () => {
+    const gateway = await client.getGateway(gatewayowner);
+    expect(Object.keys(gateway)).toEqual(Object.keys(Node));
+    expect(gateway).toBeTruthy();
+  });
+
+  it('can get delegations times', async () => {
+    const delegation = await client.getDelegationTimes(mix_id, mixnodeowner);
+    expect(Object.keys(delegation)).toEqual(Object.keys(DelegatorTimes));
+    expect(delegation).toBeTruthy();
+  });
+
+  it('can get all delegations', async () => {
+    const delegation = await client.getAllDelegations();
+    expect(Object.keys(delegation)).toEqual(Object.keys(Delegations));
+    expect(delegation).toBeTruthy();
+  });
+
+  it('can get current vesting period', async () => {
+    const period = await client.getCurrentVestingPeriod(gatewayowner);
+    expect(period).toEqual(expect.anything() as unknown as VestingPeriod);
+    expect(period).toBeTruthy();
+  });
+});

clients/validator/src/tests/sign/mixnetActions.test.ts

@@ -0,0 +1,107 @@
+import expect from 'expect';
+import ValidatorClient from '../../';
+
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+// TODO: implement for QA with .env for mnemonics
+describe('Mixnet actions', () => {
+  let client: ValidatorClient;
+
+  beforeEach(async () => {
+    client = await ValidatorClient.connect(
+      process.env.mnemonic || '',
+      process.env.rpcAddress || '',
+      process.env.validatorAddress || '',
+      process.env.prefix || '',
+      process.env.mixnetContractAddress || '',
+      process.env.vestingContractAddress || '',
+      process.env.denom || '',
+    );
+  });
+
+  it('can send tokens', async () => {
+    const res = await client.send(client.address, [{ amount: '10000000', denom: 'unym' }]);
+    expect(res.transactionHash).toBeDefined();
+  }).timeout(10000);
+
+  it.skip('can delegate tokens', async () => {
+    const [_, secondMixnode] = await client.getActiveMixnodes();
+
+    if (secondMixnode) {
+      const res = await client.delegateToMixNode(
+        secondMixnode.bond_information.mix_id,
+        {
+          amount: '15000000',
+          denom: 'unym',
+        },
+        { gas: '1000000', amount: [{ amount: '100000', denom: 'unym' }] },
+      );
+      expect(res.transactionHash).toBeDefined();
+    }
+  }).timeout(10000);
+
+  // Need to provide a mix id that can be undelegated from
+  it.skip('can undelegate from a mixnode', async () => {
+    const mixId = 8;
+    const res = await client.undelegateFromMixNode(mixId);
+    expect(res.transactionHash).toBeDefined();
+  });
+
+  it.skip('Can unbond a mixnode', async () => {
+    const res = await client.unbondMixNode();
+    expect(res.transactionHash).toBeDefined();
+  }).timeout(10000);
+
+  it.skip('Can bond a mixnode', async () => {
+    const res = await client.bondMixNode(
+      {
+        identity_key: '3P6pAcF2p3pYMqWdpHqhbavu3ifyaBs5Qw5UmmCGwimx',
+        sphinx_key: 'GQMQKwUThaggatA6oZteSWTsCQoUfmLtamJ7o9YkP9aE',
+        host: '109.74.195.67',
+        mix_port: 1789,
+        verloc_port: 1790,
+        http_api_port: 8000,
+        version: '1.1.4',
+      },
+      '3rXWCQBUj5JQB3UBUkZcXhCk9Zh3cjduMF8aFHPTG7KTkkhZzDJTNmE2p2Ph1g6iQW5vRGTpQzjXF33WDwvhzHk6',
+      { profit_margin_percent: '0.1', interval_operating_cost: { amount: '40', denom: 'nym' } },
+      { amount: '100_000_000', denom: 'unym' },
+      { gas: '1000000', amount: [{ amount: '100000', denom: 'unym' }] },
+    );
+    expect(res.transactionHash).toBeDefined();
+  }).timeout(10000);
+
+  it.skip('can unbond a gateway', async () => {
+    const res = await client.unbondGateway();
+    expect(res.transactionHash).toBeDefined();
+  });
+
+  it.skip('can bond a gateway', async () => {
+    const res = await client.bondGateway(
+      {
+        identity_key: '36vfvEyBzo5cWEFbnP7fqgY39kFw9PQhvwzbispeNaxL',
+        sphinx_key: 'G65Fwc2JNAotuHQFqmDKhQNQL5rn3r9pupUdmxMygNUZ',
+        host: '151.236.220.82',
+        version: '1.1.4',
+        mix_port: 1789,
+        clients_port: 9000,
+        location: 'Cuba',
+      },
+      '3ipSJksWHehZm1YfuH5Ahtg7b22NnrP9hEs6iEDXfUS5uiUhpWmCjGR3b3NDHuxeGjpZYJNYJ52D8WCPK5ZR7Szj',
+      { amount: '100_000_000', denom: 'unym' },
+    );
+    expect(res.transactionHash).toBeDefined();
+  });
+
+  it.skip('can update contract state params', async () => {
+    const res = await client.updateContractStateParams({
+      minimum_mixnode_pledge: '',
+      minimum_gateway_pledge: '',
+      mixnode_rewarded_set_size: 2,
+      mixnode_active_set_size: 2,
+    });
+    expect(res.transactionHash).toBeDefined();
+  });
+});

clients/validator/src/tsconfig.json

@@ -1,15 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "es6",
-        "module": "commonjs",
-        "esModuleInterop": true,
-        "strict": true,
-        "declaration": true,
-        "outDir": "./dist"
-    },
-    "exclude": [
-        "tests",
-        "dist",
-        "node_modules"
-    ]
-}

clients/validator/src/types.ts

@@ -1,157 +0,0 @@
-import { Coin } from '@cosmjs/stargate';
-
-// TODO: ideally we'd have re-exported those using that fancy crate that builds ts types from rust
-
-export type MixnetContractVersion = {
-  build_timestamp: string;
-  build_version: string;
-  commit_sha: string;
-  commit_timestamp: string;
-  commit_branch: string;
-  rustc_version: string;
-};
-
-export type PagedMixnodeResponse = {
-  nodes: MixNodeBond[];
-  per_page: number;
-  start_next_after?: string;
-};
-
-export type PagedGatewayResponse = {
-  nodes: GatewayBond[];
-  per_page: number;
-  start_next_after?: string;
-};
-
-export type MixOwnershipResponse = {
-  address: string;
-  mixnode?: MixNodeBond;
-};
-
-export type GatewayOwnershipResponse = {
-  address: string;
-  gateway?: GatewayBond;
-};
-
-export type ContractStateParams = {
-  // ideally I'd want to define those as `number` rather than `string`, but
-  // rust-side they are defined as Uint128 and that don't have
-  // native javascript representations and therefore are interpreted as strings after deserialization
-  minimum_mixnode_pledge: string;
-  minimum_gateway_pledge: string;
-  mixnode_rewarded_set_size: number;
-  mixnode_active_set_size: number;
-};
-
-export type LayerDistribution = {
-  gateways: number;
-  layer1: number;
-  layer2: number;
-  layer3: number;
-};
-
-export type Delegation = {
-  owner: string;
-  node_identity: string;
-  amount: Coin;
-  block_height: number;
-  proxy?: string;
-};
-
-export type PagedMixDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: string;
-};
-
-export type PagedDelegatorDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: string;
-};
-
-export type PagedAllDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: [string, string];
-};
-
-export type RewardingResult = {
-  operator_reward: string;
-  total_delegator_reward: string;
-};
-
-export type NodeRewardParams = {
-  period_reward_pool: string;
-  k: string;
-  reward_blockstamp: number;
-  circulating_supply: string;
-  uptime: string;
-  sybil_resistance_percent: number;
-};
-
-export type DelegatorRewardParams = {
-  node_reward_params: NodeRewardParams;
-  sigma: number;
-  profit_margin: number;
-  node_profit: number;
-};
-
-export type PendingDelegatorRewarding = {
-  running_results: RewardingResult;
-  next_start: string;
-  rewarding_params: DelegatorRewardParams;
-};
-
-export type RewardingStatus = { Complete: RewardingResult } | { PendingNextDelegatorPage: PendingDelegatorRewarding };
-
-export type MixnodeRewardingStatusResponse = {
-  status?: RewardingStatus;
-};
-
-export enum Layer {
-  Gateway,
-  One,
-  Two,
-  Three,
-}
-
-export type MixNodeBond = {
-  owner: string;
-  mix_node: MixNode;
-  layer: Layer;
-  bond_amount: Coin;
-  total_delegation: Coin;
-};
-
-export type MixNode = {
-  host: string;
-  mix_port: number;
-  verloc_port: number;
-  http_api_port: number;
-  sphinx_key: string;
-  identity_key: string;
-  version: string;
-  profit_margin_percent: number;
-};
-
-export type GatewayBond = {
-  owner: string;
-  gateway: Gateway;
-
-  bond_amount: Coin;
-  total_delegation: Coin;
-};
-
-export type Gateway = {
-  host: string;
-  mix_port: number;
-  clients_port: number;
-  location: string;
-  sphinx_key: string;
-  identity_key: string;
-  version: string;
-};
-
-export type SendRequest = {
-  senderAddress: string;
-  recipientAddress: string;
-  transferAmount: readonly Coin[];
-};

clients/validator/src/types/global.d.ts

@@ -0,0 +1,11 @@
+declare namespace NodeJS {
+  interface ProcessEnv {
+    rpcAddress: string;
+    validatorAddress: string;
+    prefix: string;
+    mixnetContractAddress: string;
+    vestingContractAddress: string;
+    denom: string;
+    mnemonic: string;
+  }
+}

clients/validator/src/types/shared.ts

@@ -0,0 +1,259 @@
+import { JsonObject } from '@cosmjs/cosmwasm-stargate';
+import { Code, CodeDetails, Contract, ContractCodeHistoryEntry } from '@cosmjs/cosmwasm-stargate/build/cosmwasmclient';
+import {
+  Account,
+  Block,
+  Coin,
+  DeliverTxResponse,
+  IndexedTx,
+  SearchTxFilter,
+  SearchTxQuery,
+  SequenceResponse,
+} from '@cosmjs/stargate';
+import {
+  MixNodeRewarding,
+  PagedMixNodeBondResponse,
+  PagedMixNodeDetailsResponse,
+  StakeSaturationResponse,
+  UnbondedMixnodeResponse,
+} from '@nymproject/types';
+
+export type MixnetContractVersion = {
+  build_timestamp: string;
+  build_version: string;
+  commit_sha: string;
+  commit_timestamp: string;
+  commit_branch: string;
+  rustc_version: string;
+};
+
+export type PagedMixnodeResponse = {
+  nodes: MixNodeBond[];
+  per_page: number;
+  start_next_after?: string;
+};
+
+export type PagedGatewayResponse = {
+  nodes: GatewayBond[];
+  per_page: number;
+  start_next_after?: string;
+};
+
+export type MixOwnershipResponse = {
+  address: string;
+  mixnode?: MixNodeBond;
+};
+
+export type GatewayOwnershipResponse = {
+  address: string;
+  gateway?: GatewayBond;
+};
+
+export type ContractStateParams = {
+  // ideally I'd want to define those as `number` rather than `string`, but
+  // rust-side they are defined as Uint128 and that don't have
+  // native javascript representations and therefore are interpreted as strings after deserialization
+  minimum_mixnode_pledge: string;
+  minimum_gateway_pledge: string;
+  mixnode_rewarded_set_size: number;
+  mixnode_active_set_size: number;
+};
+
+export type LayerDistribution = {
+  gateways: number;
+  layer1: number;
+  layer2: number;
+  layer3: number;
+};
+
+export type Delegation = {
+  owner: string;
+  node_identity: string;
+  amount: Coin;
+  block_height: number;
+  proxy?: string;
+};
+
+export type PagedMixDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: string;
+};
+
+export type PagedDelegatorDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: string;
+};
+
+export type PagedAllDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: [string, string];
+};
+
+export type RewardingResult = {
+  operator_reward: string;
+  total_delegator_reward: string;
+};
+
+export type NodeRewardParams = {
+  period_reward_pool: string;
+  k: string;
+  reward_blockstamp: number;
+  circulating_supply: string;
+  uptime: string;
+  sybil_resistance_percent: number;
+};
+
+export type DelegatorRewardParams = {
+  node_reward_params: NodeRewardParams;
+  sigma: number;
+  profit_margin: number;
+  node_profit: number;
+};
+
+export type PendingDelegatorRewarding = {
+  running_results: RewardingResult;
+  next_start: string;
+  rewarding_params: DelegatorRewardParams;
+};
+
+export type RewardingStatus = { Complete: RewardingResult } | { PendingNextDelegatorPage: PendingDelegatorRewarding };
+
+export type MixnodeRewardingStatusResponse = {
+  status?: RewardingStatus;
+};
+
+export enum Layer {
+  Gateway,
+  One,
+  Two,
+  Three,
+}
+
+export type MixNodeBond = {
+  owner: string;
+  mix_node: MixNode;
+  layer: Layer;
+  bond_amount: Coin;
+  total_delegation: Coin;
+};
+
+export type MixNode = {
+  host: string;
+  mix_port: number;
+  verloc_port: number;
+  http_api_port: number;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+  profit_margin_percent: number;
+};
+
+export type GatewayBond = {
+  owner: string;
+  gateway: Gateway;
+
+  bond_amount: Coin;
+  total_delegation: Coin;
+};
+
+export type Gateway = {
+  host: string;
+  mix_port: number;
+  clients_port: number;
+  location: string;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+};
+
+export type SendRequest = {
+  senderAddress: string;
+  recipientAddress: string;
+  transferAmount: readonly Coin[];
+};
+
+export interface SmartContractQuery {
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
+}
+export interface ICosmWasmQuery {
+  // methods exposed by `CosmWasmClient`
+  getChainId(): Promise<string>;
+  getHeight(): Promise<number>;
+  getAccount(searchAddress: string): Promise<Account | null>;
+  getSequence(address: string): Promise<SequenceResponse>;
+  getBlock(height?: number): Promise<Block>;
+  getBalance(address: string, searchDenom: string): Promise<Coin>;
+  getTx(id: string): Promise<IndexedTx | null>;
+  searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise<readonly IndexedTx[]>;
+  disconnect(): void;
+  broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
+  getCodes(): Promise<readonly Code[]>;
+  getCodeDetails(codeId: number): Promise<CodeDetails>;
+  getContracts(codeId: number): Promise<readonly string[]>;
+  getContract(address: string): Promise<Contract>;
+  getContractCodeHistory(address: string): Promise<readonly ContractCodeHistoryEntry[]>;
+  queryContractRaw(address: string, key: Uint8Array): Promise<Uint8Array | null>;
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
+}
+
+export interface INymdQuery {
+  // nym-specific implemented inside NymQuerier
+  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
+  getMixNodeBonds(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeBondResponse>;
+  getMixNodesDetailed(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixNodeDetailsResponse>;
+  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse>;
+  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
+  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
+  getStateParams(mixnetContractAddress: string): Promise<ContractState>;
+  getAllNetworkDelegationsPaged(
+    mixnetContractAddress: string,
+    limit?: number,
+    startAfter?: [string, string],
+  ): Promise<PagedAllDelegationsResponse>;
+  getMixNodeDelegationsPaged(
+    mixnetContractAddress: string,
+    mix_id: number,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedMixDelegationsResponse>;
+  getDelegatorDelegationsPaged(
+    mixnetContractAddress: string,
+    delegator: string,
+    limit?: number,
+    startAfter?: string,
+  ): Promise<PagedDelegatorDelegationsResponse>;
+  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation>;
+  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
+  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse>;
+  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse>;
+  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding>;
+}
+
+export interface IVestingQuerier {
+  getVestingContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
+}
+
+export interface MappedCoin {
+  readonly denom: string;
+  readonly fractionalDigits: number;
+}
+
+export interface CoinMap {
+  readonly [key: string]: MappedCoin;
+}
+
+export interface ContractState {
+  owner: string;
+  rewarding_validator_address: string;
+  vesting_contract_address: string;
+  rewarding_denom: string;
+  params: ContractStateParams;
+}

clients/validator/tests/query/balance.test.ts

@@ -1,11 +0,0 @@
-import ValidatorClient from '../../validator/index';
-import expect from 'expect';
-
-describe('Query: balances', () => {
-  it('can query for an account balance', async () => {
-    const client = await ValidatorClient.connectForQuery(
-      'https://rpc.nymtech.net/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
-    const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
-    expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
-  }).timeout(5000);
-})

clients/validator/tests/sign/send.test.ts

@@ -1,14 +0,0 @@
-import ValidatorClient from '../../dist';
-import expect from 'expect';
-
-// TODO: implement for QA with .env for mnemonics
-// describe('Sign: send', () => {
-//   it('can send tokens', async () => {
-//     const client = await ValidatorClient.connect(
-//       '<ADD MNEMONIC HERE>',
-//       'https://rpc.nyx.nodes.guru/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
-//     await client.send('<ADD ADDRESS HERE>')
-//     const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
-//     expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
-//   }).timeout(5000);
-// })

clients/validator/tsconfig.json

@@ -1,23 +1,22 @@
 {
-    "compilerOptions": {
-        "target": "es6",
-        "module": "commonjs",
-        "esModuleInterop": true,
-        "strict": true,
-        "declaration": true,
-        "outDir": "./dist",
-        "skipLibCheck": true
-    },
-    "typedocOptions": {
-        "entryPoints": [
-            "src/index.ts"
-        ],
-        "out": "docs"
-    },
-    "exclude": [
-        "dist",
-        "examples",
-        "tests",
-        "node_modules"
-    ]
-}
+  "compilerOptions": {
+    "outDir": "./dist/nym-validator-client",
+    "module": "ES2020",
+    "target": "es2021",
+    "allowJs": false,
+    "strict": true,
+    "lib": ["es2021", "dom", "dom.iterable", "esnext"],
+    "moduleResolution": "node",
+    "skipDefaultLibCheck": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "noImplicitAny": true,
+    "typeRoots": ["./src/types/global.d.ts"]
+  },
+  "typedocOptions": {
+    "entryPoints": ["./src/index.ts"],
+    "out": "docs"
+  },
+  "exclude": ["dist", "./src/tests/**/*", "node_module"]
+}

clients/validator/tsconfig.test.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS"
+  }
+}

clients/webassembly/Cargo.toml

@@ -30,13 +30,14 @@ wasm-bindgen = { version = "=0.2.83", features = ["serde-serialize"]  }
 wasm-bindgen-futures = "0.4"
 
 # internal
-client-core = { path = "../client-core", default-features = false, features = ["wasm"] }
-coconut-interface = { path = "../../common/coconut-interface" }
-credentials = { path = "../../common/credentials" }
+nym-client-core = { path = "../../common/client-core", default-features = false, features = ["wasm"] }
+nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
+nym-coconut-interface = { path = "../../common/coconut-interface" }
+nym-credentials = { path = "../../common/credentials" }
+nym-credential-storage = { path = "../../common/credential-storage" }
 nym-crypto = { path = "../../common/crypto" }
 nym-sphinx = { path = "../../common/nymsphinx" }
-gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm"] }
-validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
+nym-validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 wasm-utils = { path = "../../common/wasm-utils" }
 nym-task = { path = "../../common/task" }
 # The `console_error_panic_hook` crate provides better debugging of panics by

clients/webassembly/src/client/config.rs

@@ -3,8 +3,16 @@
 
 // due to expansion of #[wasm_bindgen] macro on `Debug` Config struct
 #![allow(clippy::drop_non_drop)]
+// another issue due to #[wasm_bindgen] and `Copy` trait
+#![allow(clippy::drop_copy)]
 
-use client_core::config::{DebugConfig as ConfigDebug, ExtendedPacketSize, GatewayEndpointConfig};
+use nym_client_core::config::{
+    Acknowledgements as ConfigAcknowledgements, CoverTraffic as ConfigCoverTraffic,
+    DebugConfig as ConfigDebug, GatewayConnection as ConfigGatewayConnection,
+    GatewayEndpointConfig, ReplySurbs as ConfigReplySurbs, Topology as ConfigTopology,
+    Traffic as ConfigTraffic,
+};
+use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -48,15 +56,131 @@ impl Config {
     }
 }
 
-// just a helper structure to more easily pass through the JS boundary
 #[wasm_bindgen]
-pub struct Debug {
+#[derive(Debug, Copy, Clone)]
+pub struct Traffic {
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent packet is going to be delayed at any given mix node.
     /// So for a packet going through three mix nodes, on average, it will take three times this value
     /// until the packet reaches its destination.
     pub average_packet_delay_ms: u64,
 
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take another 'real traffic stream' message to be sent.
+    /// If no real packets are available and cover traffic is enabled,
+    /// a loop cover message is sent instead in order to preserve the rate.
+    pub message_sending_average_delay_ms: u64,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size.
+    pub use_extended_packet_size: bool,
+}
+
+impl From<Traffic> for ConfigTraffic {
+    fn from(traffic: Traffic) -> Self {
+        let use_extended_packet_size = traffic
+            .use_extended_packet_size
+            .then(|| PacketSize::ExtendedPacket32);
+
+        ConfigTraffic {
+            average_packet_delay: Duration::from_millis(traffic.average_packet_delay_ms),
+            message_sending_average_delay: Duration::from_millis(
+                traffic.message_sending_average_delay_ms,
+            ),
+            disable_main_poisson_packet_distribution: traffic
+                .disable_main_poisson_packet_distribution,
+            primary_packet_size: PacketSize::RegularPacket,
+            secondary_packet_size: use_extended_packet_size,
+        }
+    }
+}
+
+impl From<ConfigTraffic> for Traffic {
+    fn from(traffic: ConfigTraffic) -> Self {
+        Traffic {
+            average_packet_delay_ms: traffic.average_packet_delay.as_millis() as u64,
+            message_sending_average_delay_ms: traffic.message_sending_average_delay.as_millis()
+                as u64,
+            disable_main_poisson_packet_distribution: traffic
+                .disable_main_poisson_packet_distribution,
+            use_extended_packet_size: traffic.secondary_packet_size.is_some(),
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone)]
+pub struct CoverTraffic {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take for another loop cover traffic message to be sent.
+    pub loop_cover_traffic_average_delay_ms: u64,
+
+    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
+    /// Only applicable if `secondary_packet_size` is enabled.
+    pub cover_traffic_primary_size_ratio: f64,
+
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
+    pub disable_loop_cover_traffic_stream: bool,
+}
+
+impl From<CoverTraffic> for ConfigCoverTraffic {
+    fn from(cover_traffic: CoverTraffic) -> Self {
+        ConfigCoverTraffic {
+            loop_cover_traffic_average_delay: Duration::from_millis(
+                cover_traffic.loop_cover_traffic_average_delay_ms,
+            ),
+            cover_traffic_primary_size_ratio: cover_traffic.cover_traffic_primary_size_ratio,
+            disable_loop_cover_traffic_stream: cover_traffic.disable_loop_cover_traffic_stream,
+        }
+    }
+}
+
+impl From<ConfigCoverTraffic> for CoverTraffic {
+    fn from(cover_traffic: ConfigCoverTraffic) -> Self {
+        CoverTraffic {
+            loop_cover_traffic_average_delay_ms: cover_traffic
+                .loop_cover_traffic_average_delay
+                .as_millis() as u64,
+            cover_traffic_primary_size_ratio: cover_traffic.cover_traffic_primary_size_ratio,
+            disable_loop_cover_traffic_stream: cover_traffic.disable_loop_cover_traffic_stream,
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone)]
+pub struct GatewayConnection {
+    /// How long we're willing to wait for a response to a message sent to the gateway,
+    /// before giving up on it.
+    pub gateway_response_timeout_ms: u64,
+}
+
+impl From<GatewayConnection> for ConfigGatewayConnection {
+    fn from(gateway_connection: GatewayConnection) -> Self {
+        ConfigGatewayConnection {
+            gateway_response_timeout: Duration::from_millis(
+                gateway_connection.gateway_response_timeout_ms,
+            ),
+        }
+    }
+}
+
+impl From<ConfigGatewayConnection> for GatewayConnection {
+    fn from(gateway_connection: ConfigGatewayConnection) -> Self {
+        GatewayConnection {
+            gateway_response_timeout_ms: gateway_connection.gateway_response_timeout.as_millis()
+                as u64,
+        }
+    }
+}
+
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone)]
+pub struct Acknowledgements {
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent acknowledgement is going to be delayed at any given mix node.
     /// So for an ack going through three mix nodes, on average, it will take three times this value
@@ -72,21 +196,31 @@ pub struct Debug {
     /// it is assumed it was lost and retransmission of the data packet happens.
     /// In an ideal network with 0 latency, this value would have been 0.
     pub ack_wait_addition_ms: u64,
+}
 
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take for another loop cover traffic message to be sent.
-    pub loop_cover_traffic_average_delay_ms: u64,
+impl From<Acknowledgements> for ConfigAcknowledgements {
+    fn from(acknowledgements: Acknowledgements) -> Self {
+        ConfigAcknowledgements {
+            average_ack_delay: Duration::from_millis(acknowledgements.average_ack_delay_ms),
+            ack_wait_multiplier: acknowledgements.ack_wait_multiplier,
+            ack_wait_addition: Duration::from_millis(acknowledgements.ack_wait_addition_ms),
+        }
+    }
+}
 
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take another 'real traffic stream' message to be sent.
-    /// If no real packets are available and cover traffic is enabled,
-    /// a loop cover message is sent instead in order to preserve the rate.
-    pub message_sending_average_delay_ms: u64,
-
-    /// How long we're willing to wait for a response to a message sent to the gateway,
-    /// before giving up on it.
-    pub gateway_response_timeout_ms: u64,
+impl From<ConfigAcknowledgements> for Acknowledgements {
+    fn from(acknowledgements: ConfigAcknowledgements) -> Self {
+        Acknowledgements {
+            average_ack_delay_ms: acknowledgements.average_ack_delay.as_millis() as u64,
+            ack_wait_multiplier: acknowledgements.ack_wait_multiplier,
+            ack_wait_addition_ms: acknowledgements.ack_wait_addition.as_millis() as u64,
+        }
+    }
+}
 
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone)]
+pub struct Topology {
     /// The uniform delay every which clients are querying the directory server
     /// to try to obtain a compatible network topology to send sphinx packets through.
     pub topology_refresh_rate_ms: u64,
@@ -95,18 +229,31 @@ pub struct Debug {
     /// path. This timeout determines waiting period until it is decided that the packet
     /// did not reach its destination.
     pub topology_resolution_timeout_ms: u64,
+}
 
-    /// Controls whether the dedicated loop cover traffic stream should be enabled.
-    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay_ms])
-    pub disable_loop_cover_traffic_stream: bool,
+impl From<Topology> for ConfigTopology {
+    fn from(topology: Topology) -> Self {
+        ConfigTopology {
+            topology_refresh_rate: Duration::from_millis(topology.topology_refresh_rate_ms),
+            topology_resolution_timeout: Duration::from_millis(
+                topology.topology_resolution_timeout_ms,
+            ),
+        }
+    }
+}
 
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    pub disable_main_poisson_packet_distribution: bool,
-
-    /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size.
-    pub use_extended_packet_size: bool,
+impl From<ConfigTopology> for Topology {
+    fn from(topology: ConfigTopology) -> Self {
+        Topology {
+            topology_refresh_rate_ms: topology.topology_refresh_rate.as_millis() as u64,
+            topology_resolution_timeout_ms: topology.topology_resolution_timeout.as_millis() as u64,
+        }
+    }
+}
 
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone)]
+pub struct ReplySurbs {
     /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
     /// It can only allow to go below that value if its to request additional reply surbs.
     pub minimum_reply_surb_storage_threshold: usize,
@@ -140,46 +287,80 @@ pub struct Debug {
     pub maximum_reply_key_age_ms: u64,
 }
 
-impl From<Debug> for ConfigDebug {
-    fn from(debug: Debug) -> Self {
-        // For now we just always use the (older) 32kb extended size
-        let use_extended_packet_size = debug
-            .use_extended_packet_size
-            .then(|| ExtendedPacketSize::Extended32);
-
-        ConfigDebug {
-            average_packet_delay: Duration::from_millis(debug.average_packet_delay_ms),
-            average_ack_delay: Duration::from_millis(debug.average_ack_delay_ms),
-            ack_wait_multiplier: debug.ack_wait_multiplier,
-            ack_wait_addition: Duration::from_millis(debug.ack_wait_addition_ms),
-            loop_cover_traffic_average_delay: Duration::from_millis(
-                debug.loop_cover_traffic_average_delay_ms,
-            ),
-            message_sending_average_delay: Duration::from_millis(
-                debug.message_sending_average_delay_ms,
-            ),
-            gateway_response_timeout: Duration::from_millis(debug.gateway_response_timeout_ms),
-            topology_refresh_rate: Duration::from_millis(debug.topology_refresh_rate_ms),
-            topology_resolution_timeout: Duration::from_millis(
-                debug.topology_resolution_timeout_ms,
-            ),
-            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
-            disable_main_poisson_packet_distribution: debug
-                .disable_main_poisson_packet_distribution,
-            use_extended_packet_size,
-            minimum_reply_surb_storage_threshold: debug.minimum_reply_surb_storage_threshold,
-            maximum_reply_surb_storage_threshold: debug.maximum_reply_surb_storage_threshold,
-            minimum_reply_surb_request_size: debug.minimum_reply_surb_request_size,
-            maximum_reply_surb_request_size: debug.maximum_reply_surb_request_size,
-            maximum_allowed_reply_surb_request_size: debug.maximum_allowed_reply_surb_request_size,
+impl From<ReplySurbs> for ConfigReplySurbs {
+    fn from(reply_surbs: ReplySurbs) -> Self {
+        ConfigReplySurbs {
+            minimum_reply_surb_storage_threshold: reply_surbs.minimum_reply_surb_storage_threshold,
+            maximum_reply_surb_storage_threshold: reply_surbs.maximum_reply_surb_storage_threshold,
+            minimum_reply_surb_request_size: reply_surbs.minimum_reply_surb_request_size,
+            maximum_reply_surb_request_size: reply_surbs.maximum_reply_surb_request_size,
+            maximum_allowed_reply_surb_request_size: reply_surbs
+                .maximum_allowed_reply_surb_request_size,
             maximum_reply_surb_rerequest_waiting_period: Duration::from_millis(
-                debug.maximum_reply_surb_rerequest_waiting_period_ms,
+                reply_surbs.maximum_reply_surb_rerequest_waiting_period_ms,
             ),
             maximum_reply_surb_drop_waiting_period: Duration::from_millis(
-                debug.maximum_reply_surb_drop_waiting_period_ms,
+                reply_surbs.maximum_reply_surb_drop_waiting_period_ms,
             ),
-            maximum_reply_surb_age: Duration::from_millis(debug.maximum_reply_surb_age_ms),
-            maximum_reply_key_age: Duration::from_millis(debug.maximum_reply_key_age_ms),
+            maximum_reply_surb_age: Duration::from_millis(reply_surbs.maximum_reply_surb_age_ms),
+            maximum_reply_key_age: Duration::from_millis(reply_surbs.maximum_reply_key_age_ms),
+        }
+    }
+}
+
+impl From<ConfigReplySurbs> for ReplySurbs {
+    fn from(reply_surbs: ConfigReplySurbs) -> Self {
+        ReplySurbs {
+            minimum_reply_surb_storage_threshold: reply_surbs.minimum_reply_surb_storage_threshold,
+            maximum_reply_surb_storage_threshold: reply_surbs.maximum_reply_surb_storage_threshold,
+            minimum_reply_surb_request_size: reply_surbs.minimum_reply_surb_request_size,
+            maximum_reply_surb_request_size: reply_surbs.maximum_reply_surb_request_size,
+            maximum_allowed_reply_surb_request_size: reply_surbs
+                .maximum_allowed_reply_surb_request_size,
+            maximum_reply_surb_rerequest_waiting_period_ms: reply_surbs
+                .maximum_reply_surb_rerequest_waiting_period
+                .as_millis() as u64,
+            maximum_reply_surb_drop_waiting_period_ms: reply_surbs
+                .maximum_reply_surb_drop_waiting_period
+                .as_millis() as u64,
+            maximum_reply_surb_age_ms: reply_surbs.maximum_reply_surb_age.as_millis() as u64,
+            maximum_reply_key_age_ms: reply_surbs.maximum_reply_key_age.as_millis() as u64,
+        }
+    }
+}
+
+// just a helper structure to more easily pass through the JS boundary
+#[wasm_bindgen]
+#[derive(Debug, Copy, Clone)]
+pub struct Debug {
+    /// Defines all configuration options related to traffic streams.
+    pub traffic: Traffic,
+
+    /// Defines all configuration options related to cover traffic stream(s).
+    pub cover_traffic: CoverTraffic,
+
+    /// Defines all configuration options related to the gateway connection.
+    pub gateway_connection: GatewayConnection,
+
+    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
+    pub acknowledgements: Acknowledgements,
+
+    /// Defines all configuration options related topology, such as refresh rates or timeouts.
+    pub topology: Topology,
+
+    /// Defines all configuration options related to reply SURBs.
+    pub reply_surbs: ReplySurbs,
+}
+
+impl From<Debug> for ConfigDebug {
+    fn from(debug: Debug) -> Self {
+        ConfigDebug {
+            traffic: debug.traffic.into(),
+            cover_traffic: debug.cover_traffic.into(),
+            gateway_connection: debug.gateway_connection.into(),
+            acknowledgements: debug.acknowledgements.into(),
+            topology: debug.topology.into(),
+            reply_surbs: debug.reply_surbs.into(),
         }
     }
 }
@@ -187,34 +368,12 @@ impl From<Debug> for ConfigDebug {
 impl From<ConfigDebug> for Debug {
     fn from(debug: ConfigDebug) -> Self {
         Debug {
-            average_packet_delay_ms: debug.average_packet_delay.as_millis() as u64,
-            average_ack_delay_ms: debug.average_ack_delay.as_millis() as u64,
-            ack_wait_multiplier: debug.ack_wait_multiplier,
-            ack_wait_addition_ms: debug.ack_wait_addition.as_millis() as u64,
-            loop_cover_traffic_average_delay_ms: debug.loop_cover_traffic_average_delay.as_millis()
-                as u64,
-            message_sending_average_delay_ms: debug.message_sending_average_delay.as_millis()
-                as u64,
-            gateway_response_timeout_ms: debug.gateway_response_timeout.as_millis() as u64,
-            topology_refresh_rate_ms: debug.topology_refresh_rate.as_millis() as u64,
-            topology_resolution_timeout_ms: debug.topology_resolution_timeout.as_millis() as u64,
-            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
-            disable_main_poisson_packet_distribution: debug
-                .disable_main_poisson_packet_distribution,
-            use_extended_packet_size: debug.use_extended_packet_size.is_some(),
-            minimum_reply_surb_storage_threshold: debug.minimum_reply_surb_storage_threshold,
-            maximum_reply_surb_storage_threshold: debug.maximum_reply_surb_storage_threshold,
-            minimum_reply_surb_request_size: debug.minimum_reply_surb_request_size,
-            maximum_reply_surb_request_size: debug.maximum_reply_surb_request_size,
-            maximum_allowed_reply_surb_request_size: debug.maximum_allowed_reply_surb_request_size,
-            maximum_reply_surb_rerequest_waiting_period_ms: debug
-                .maximum_reply_surb_rerequest_waiting_period
-                .as_millis() as u64,
-            maximum_reply_surb_drop_waiting_period_ms: debug
-                .maximum_reply_surb_drop_waiting_period
-                .as_millis() as u64,
-            maximum_reply_surb_age_ms: debug.maximum_reply_surb_age.as_millis() as u64,
-            maximum_reply_key_age_ms: debug.maximum_reply_key_age.as_millis() as u64,
+            traffic: debug.traffic.into(),
+            cover_traffic: debug.cover_traffic.into(),
+            gateway_connection: debug.gateway_connection.into(),
+            acknowledgements: debug.acknowledgements.into(),
+            topology: debug.topology.into(),
+            reply_surbs: debug.reply_surbs.into(),
         }
     }
 }

clients/webassembly/src/client/helpers.rs

@@ -1,9 +1,9 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use client_core::client::base_client::ClientInput;
-use client_core::client::inbound_messages::InputMessage;
 use js_sys::Promise;
+use nym_client_core::client::base_client::ClientInput;
+use nym_client_core::client::inbound_messages::InputMessage;
 use std::sync::Arc;
 use wasm_bindgen::JsValue;
 use wasm_bindgen_futures::future_to_promise;

clients/webassembly/src/client/mod.rs

@@ -4,14 +4,15 @@
 use self::config::Config;
 use crate::client::helpers::InputSender;
 use crate::client::response_pusher::ResponsePusher;
-use client_core::client::base_client::{
+use js_sys::Promise;
+use nym_bandwidth_controller::wasm_mockups::{Client as FakeClient, DirectSigningNyxdClient};
+use nym_bandwidth_controller::BandwidthController;
+use nym_client_core::client::base_client::{
     BaseClientBuilder, ClientInput, ClientOutput, CredentialsToggle,
 };
-use client_core::client::replies::reply_storage::browser_backend;
-use client_core::client::{inbound_messages::InputMessage, key_manager::KeyManager};
-use gateway_client::bandwidth::BandwidthController;
-use gateway_client::wasm_mockups::SigningNyxdClient;
-use js_sys::Promise;
+use nym_client_core::client::replies::reply_storage::browser_backend;
+use nym_client_core::client::{inbound_messages::InputMessage, key_manager::KeyManager};
+use nym_credential_storage::ephemeral_storage::EphemeralStorage;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_task::connections::TransmissionLane;
@@ -48,7 +49,8 @@ pub struct NymClientBuilder {
     on_message: js_sys::Function,
 
     // unimplemented:
-    bandwidth_controller: Option<BandwidthController<SigningNyxdClient>>,
+    bandwidth_controller:
+        Option<BandwidthController<FakeClient<DirectSigningNyxdClient>, EphemeralStorage>>,
     disabled_credentials: bool,
 }
 
@@ -82,8 +84,14 @@ impl NymClientBuilder {
     // with no persistence
     fn setup_reply_surb_storage_backend(config: &Config) -> browser_backend::Backend {
         browser_backend::Backend::new(
-            config.debug.minimum_reply_surb_storage_threshold,
-            config.debug.maximum_reply_surb_storage_threshold,
+            config
+                .debug
+                .reply_surbs
+                .minimum_reply_surb_storage_threshold,
+            config
+                .debug
+                .reply_surbs
+                .maximum_reply_surb_storage_threshold,
         )
     }
 

clients/webassembly/src/client/response_pusher.rs

@@ -1,11 +1,13 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use client_core::client::base_client::ClientOutput;
-use client_core::client::received_buffer::{ReceivedBufferMessage, ReconstructedMessagesReceiver};
 use futures::channel::mpsc;
 use futures::StreamExt;
 use js_sys::Uint8Array;
+use nym_client_core::client::base_client::ClientOutput;
+use nym_client_core::client::received_buffer::{
+    ReceivedBufferMessage, ReconstructedMessagesReceiver,
+};
 use wasm_bindgen::JsValue;
 use wasm_bindgen_futures::spawn_local;
 use wasm_utils::console_error;

clients/webassembly/src/gateway_selector.rs

@@ -1,12 +1,13 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use client_core::config::GatewayEndpointConfig;
+use nym_client_core::config::GatewayEndpointConfig;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub async fn get_gateway(api_server: String, preferred: Option<String>) -> GatewayEndpointConfig {
-    let validator_client = validator_client::client::NymApiClient::new(api_server.parse().unwrap());
+    let validator_client =
+        nym_validator_client::client::NymApiClient::new(api_server.parse().unwrap());
 
     let gateways = match validator_client.get_cached_gateways().await {
         Err(err) => panic!("failed to obtain list of all gateways - {err}"),

common/async-file-watcher/Cargo.toml

@@ -1,10 +1,12 @@
 [package]
-name = "bandwidth-claim-contract"
+name = "async-file-watcher"
 version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-schemars = "0.8"
-serde = { version = "1.0.103", default-features = false, features = ["derive"] }
+log = "0.4"
+tokio = { workspace = true, features = ["time"] }
+futures = "0.3"
+notify = "5.1.0"