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

@@ -98,7 +98,7 @@ 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

.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.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/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

CHANGELOG.md

@@ -6,17 +6,57 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 - 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])
-- Fix contracts and nym-api audit findings ([#3026])
 - Website v2 - deploy infrastructure for strapi and CI ([#2213])
 - add blockstream green to sp list ([#3180])
 - mock-nym-api: fix .storybook lint error ([#3178])
@@ -25,7 +65,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#2979]: https://github.com/nymtech/nym/issues/2979
 [#2332]: https://github.com/nymtech/nym/issues/2332
 [#3168]: https://github.com/nymtech/nym/issues/3168
-[#3026]: https://github.com/nymtech/nym/issues/3026
 [#2213]: https://github.com/nymtech/nym/issues/2213
 [#3180]: https://github.com/nymtech/nym/pull/3180
 [#3178]: https://github.com/nymtech/nym/pull/3178

Cargo.toml

@@ -22,6 +22,7 @@ members = [
     "clients/native/websocket-requests",
     "clients/socks5",
     "common/async-file-watcher",
+    "common/bandwidth-controller",
     "common/bin-common",
     "common/client-core",
     "common/client-libs/gateway-client",
@@ -38,7 +39,6 @@ members = [
     "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",

Makefile

@@ -9,6 +9,10 @@ no-clippy: build cargo-test wasm fmt
 
 happy: fmt clippy-happy test
 
+# Building release binaries is a little manual as we can't just build --release
+# on all workspaces.
+build-release: build-release-main wasm
+
 # -----------------------------------------------------------------------------
 # Define targets for a given workspace
 #  $(1): name
@@ -23,29 +27,37 @@ clippy-happy-$(1):
 clippy-$(1):
 	cargo clippy --manifest-path $(2)/Cargo.toml --workspace $(3) -- -D warnings
 
-clippy-$(1)-examples:
+clippy-examples-$(1):
 	cargo clippy --manifest-path $(2)/Cargo.toml --workspace --examples -- -D warnings
 
+check-$(1):
+	cargo check --manifest-path $(2)/Cargo.toml --workspace $(3)
+
 test-$(1):
 	cargo test --manifest-path $(2)/Cargo.toml --workspace
 
-test-$(1)-expensive:
+test-expensive-$(1):
 	cargo test --manifest-path $(2)/Cargo.toml --workspace -- --ignored
 
 build-$(1):
 	cargo build --manifest-path $(2)/Cargo.toml --workspace $(3)
 
-build-$(1)-examples:
+build-examples-$(1):
 	cargo build --manifest-path $(2)/Cargo.toml --workspace --examples
 
+build-release-$(1):
+	cargo build --manifest-path $(2)/Cargo.toml --workspace --release $(3)
+
 fmt-$(1):
 	cargo fmt --manifest-path $(2)/Cargo.toml --all
 
 clippy-happy: clippy-happy-$(1)
-clippy-all: clippy-$(1) clippy-$(1)-examples
+clippy-all: clippy-$(1) clippy-examples-$(1)
+check: check-$(1)
 cargo-test: test-$(1)
-cargo-test-expensive: test-$(1)-expensive
+cargo-test-expensive: test-expensive-$(1)
 build: build-$(1) build-$(1)-examples
+build-release-all: build-release-$(1)
 fmt: fmt-$(1)
 
 endef
@@ -61,7 +73,7 @@ $(eval $(call add_cargo_workspace,contracts,contracts,--target wasm32-unknown-un
 $(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))
-ifndef NYM_NO_MOBILE
+ifdef NYM_MOBILE
 $(eval $(call add_cargo_workspace,connect-mobile,nym-connect/mobile/src-tauri))
 endif
 
@@ -76,14 +88,27 @@ build-nym-cli:
 	cargo build -p nym-cli --release
 
 # -----------------------------------------------------------------------------
-# Misc
+# Build contracts ready for deploy
 # -----------------------------------------------------------------------------
 
-wasm:
+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
+
+wasm: wasm-build wasm-opt
+
+wasm-build:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
-	wasm-opt --disable-sign-ext -Os contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
-	wasm-opt --disable-sign-ext -Os contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm
-	wasm-opt --disable-sign-ext -Os contracts/target/wasm32-unknown-unknown/release/nym_service_provider_directory.wasm -o contracts/target/wasm32-unknown-unknown/release/nym_service_provider_directory.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

README.md

@@ -21,7 +21,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 
 ### 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 = { workspace = true }
 clap = { version = "4.0", features = ["cargo", "derive"] }
 log = "0.4"
-rand = "0.7.3"
 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
 
-nym-coconut-interface = { path = "../../common/coconut-interface" }
+nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-config = { path = "../../common/config" }
 nym-credentials = { path = "../../common/credentials" }
 nym-credential-storage = { path = "../../common/credential-storage" }
-nym-crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
 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/src/client.rs

@@ -4,11 +4,11 @@
 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, DirectSigningNyxdClient, Fee, NyxdClient};
 
 pub(crate) struct Client {
     nyxd_client: NyxdClient<DirectSigningNyxdClient>,

clients/credential/src/commands.rs

@@ -3,24 +3,13 @@
 
 use clap::{ArgGroup, Args, Subcommand};
 use log::*;
+use nym_bandwidth_controller::acquire::state::State;
 use nym_bin_common::completions::ArgShell;
-use nym_coconut_interface::{Base58, Parameters};
-use nym_credential_storage::storage::Storage;
-use nym_credential_storage::PersistentStorage;
-use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
-use nym_credentials::coconut::utils::obtain_aggregate_signature;
-use nym_crypto::asymmetric::{encryption, identity};
-use nym_network_defaults::VOUCHER_INFO;
-use rand::rngs::OsRng;
-use std::str::FromStr;
-use validator_client::nyxd::traits::DkgQueryClient;
-use validator_client::nyxd::tx::Hash;
-use validator_client::CoconutApiClient;
+use nym_credential_storage::persistent_storage::PersistentStorage;
+use nym_validator_client::nyxd::traits::DkgQueryClient;
 
-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 {
@@ -45,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,
@@ -67,81 +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: DkgQueryClient + Send + Sync>(
-    state: &State,
-    client: &C,
-    shared_storage: PersistentStorage,
-) -> Result<()> {
-    let epoch_id = client.get_current_epoch().await?.epoch_id;
-    let threshold = client
-        .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: 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, 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

@@ -6,10 +6,8 @@ use thiserror::Error;
 
 use nym_credential_storage::error::StorageError;
 use nym_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_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 = nym_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.nyxd, 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.nyxd, &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/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.13"
+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"
@@ -34,21 +34,21 @@ tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
 tokio-tungstenite = "0.14" # websocket
 
 ## internal
+nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
-client-core = { path = "../../common/client-core", features = ["fs-surb-storage"] }
+nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage"] }
 nym-coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
 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]

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,9 +11,9 @@ 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;
@@ -81,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()
     }
 }
@@ -94,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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::config::{Config, Socket};
-use client_core::config::old_config_v1_1_13::OldConfigV1_1_13 as OldBaseConfigV1_1_13;
+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;

clients/native/src/client/mod.rs

@@ -4,28 +4,29 @@
 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 validator_client::Client;
+use nym_validator_client::Client;
 
 pub mod config;
 
@@ -58,10 +59,11 @@ impl SocketClient {
 
     async fn create_bandwidth_controller(
         config: &Config,
-    ) -> BandwidthController<Client<QueryNyxdClient>> {
+    ) -> 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()
@@ -74,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(
-            nym_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

@@ -10,6 +10,7 @@ use crate::{
 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;
@@ -95,7 +96,7 @@ 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,
 }
@@ -103,7 +104,7 @@ pub struct InitResults {
 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(),
         }
@@ -114,7 +115,7 @@ impl Display for InitResults {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         writeln!(f, "{}", self.client_core)?;
         writeln!(f, "Client listening port: {}", self.client_listening_port)?;
-        write!(f, "address of this client: {}", self.client_address)
+        write!(f, "Address of this client: {}", self.client_address)
     }
 }
 
@@ -151,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(),
@@ -168,7 +169,7 @@ 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!("{}", args.output.format(&init_results));
 

clients/native/src/commands/run.rs

@@ -112,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/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"

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.13"
+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"
@@ -20,13 +20,13 @@ url = "2.2"
 
 # internal
 nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
-client-core = { path = "../../common/client-core", features = ["fs-surb-storage"] }
+nym-client-core = { path = "../../common/client-core", features = ["fs-surb-storage"] }
 nym-coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
-mobile-storage = { path = "../../common/mobile-storage", optional = true }
 nym-credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
-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" }
 nym-ordered-buffer = { path = "../../common/socks5/ordered-buffer" }

clients/socks5/src/commands/init.rs

@@ -9,6 +9,7 @@ use crate::{
 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;
@@ -97,7 +98,7 @@ 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,
 }
@@ -105,7 +106,7 @@ pub struct InitResults {
 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),
             socks5_listening_port: config.get_socks5().get_listening_port().to_string(),
             client_address: address.to_string(),
         }
@@ -115,8 +116,8 @@ 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)?;
-        write!(f, "address of this client: {}", self.client_address)
+        writeln!(f, "SOCKS5 listening port: {}", self.socks5_listening_port)?;
+        write!(f, "Address of this client: {}", self.client_address)
     }
 }
 
@@ -157,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(),
@@ -176,11 +177,10 @@ 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!("{}", args.output.format(&init_results));
 
-    eprintln!("\nThe address of this client is: {}\n", address);
     Ok(())
 }
 

clients/socks5/src/commands/run.rs

@@ -122,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/error.rs

@@ -1,4 +1,4 @@
-use client_core::error::ClientCoreError;
+use nym_client_core::error::ClientCoreError;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Socks5ClientError {
@@ -8,6 +8,10 @@ pub enum Socks5ClientError {
     #[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/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 = "../../common/client-core", default-features = false, features = ["wasm"] }
+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

@@ -6,12 +6,13 @@
 // another issue due to #[wasm_bindgen] and `Copy` trait
 #![allow(clippy::drop_copy)]
 
-use client_core::config::{
+use nym_client_core::config::{
     Acknowledgements as ConfigAcknowledgements, CoverTraffic as ConfigCoverTraffic,
-    DebugConfig as ConfigDebug, ExtendedPacketSize, GatewayConnection as ConfigGatewayConnection,
+    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;
@@ -82,7 +83,7 @@ impl From<Traffic> for ConfigTraffic {
     fn from(traffic: Traffic) -> Self {
         let use_extended_packet_size = traffic
             .use_extended_packet_size
-            .then(|| ExtendedPacketSize::Extended32);
+            .then(|| PacketSize::ExtendedPacket32);
 
         ConfigTraffic {
             average_packet_delay: Duration::from_millis(traffic.average_packet_delay_ms),
@@ -91,7 +92,8 @@ impl From<Traffic> for ConfigTraffic {
             ),
             disable_main_poisson_packet_distribution: traffic
                 .disable_main_poisson_packet_distribution,
-            use_extended_packet_size,
+            primary_packet_size: PacketSize::RegularPacket,
+            secondary_packet_size: use_extended_packet_size,
         }
     }
 }
@@ -104,7 +106,7 @@ impl From<ConfigTraffic> for Traffic {
                 as u64,
             disable_main_poisson_packet_distribution: traffic
                 .disable_main_poisson_packet_distribution,
-            use_extended_packet_size: traffic.use_extended_packet_size.is_some(),
+            use_extended_packet_size: traffic.secondary_packet_size.is_some(),
         }
     }
 }
@@ -116,6 +118,10 @@ pub struct CoverTraffic {
     /// 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,
@@ -127,6 +133,7 @@ impl From<CoverTraffic> for 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,
         }
     }
@@ -138,6 +145,7 @@ impl From<ConfigCoverTraffic> for 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,
         }
     }

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::{Client as FakeClient, DirectSigningNyxdClient};
-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<FakeClient<DirectSigningNyxdClient>>>,
+    bandwidth_controller:
+        Option<BandwidthController<FakeClient<DirectSigningNyxdClient>, EphemeralStorage>>,
     disabled_credentials: bool,
 }
 

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/bandwidth-controller/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "nym-bandwidth-controller"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+bip39 = { workspace = true }
+rand = "0.7.3"
+thiserror = "1.0"
+url = "2.2"
+
+nym-coconut-interface = { path = "../coconut-interface" }
+nym-credential-storage = { path = "../credential-storage" }
+nym-credentials = { path = "../credentials" }
+nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
+nym-network-defaults = { path = "../network-defaults" }
+nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
+
+
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
+path = "../client-libs/validator-client"
+features = ["nyxd-client"]

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

@@ -0,0 +1,89 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::error::BandwidthControllerError;
+use nym_coconut_interface::{Base58, Parameters};
+use nym_credential_storage::storage::Storage;
+use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
+use nym_credentials::coconut::utils::obtain_aggregate_signature;
+use nym_crypto::asymmetric::{encryption, identity};
+use nym_network_defaults::VOUCHER_INFO;
+use nym_validator_client::nyxd::traits::CoconutBandwidthSigningClient;
+use nym_validator_client::nyxd::traits::DkgQueryClient;
+use nym_validator_client::nyxd::tx::Hash;
+use nym_validator_client::nyxd::Coin;
+use nym_validator_client::CoconutApiClient;
+use rand::rngs::OsRng;
+use state::{KeyPair, State};
+use std::str::FromStr;
+
+pub mod state;
+
+pub async fn deposit<C>(client: &C, amount: Coin) -> Result<State, BandwidthControllerError>
+where
+    C: CoconutBandwidthSigningClient,
+{
+    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 voucher_value = amount.amount.to_string();
+
+    let tx_hash = client
+        .deposit(
+            amount,
+            String::from(VOUCHER_INFO),
+            signing_keypair.public_key.clone(),
+            encryption_keypair.public_key.clone(),
+            None,
+        )
+        .await?
+        .transaction_hash
+        .to_string();
+
+    let voucher = BandwidthVoucher::new(
+        &params,
+        voucher_value,
+        VOUCHER_INFO.to_string(),
+        Hash::from_str(&tx_hash).map_err(|_| BandwidthControllerError::InvalidTxHash)?,
+        identity::PrivateKey::from_base58_string(&signing_keypair.private_key)?,
+        encryption::PrivateKey::from_base58_string(&encryption_keypair.private_key)?,
+    );
+
+    let state = State { voucher, params };
+
+    Ok(state)
+}
+
+pub async fn get_credential<C: DkgQueryClient + Send + Sync, St: Storage>(
+    state: &State,
+    client: &C,
+    storage: &St,
+) -> Result<(), BandwidthControllerError> {
+    let epoch_id = client.get_current_epoch().await?.epoch_id;
+    let threshold = client
+        .get_current_epoch_threshold()
+        .await?
+        .ok_or(BandwidthControllerError::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?;
+    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(())
+}

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

@@ -1,8 +1,8 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_coconut_interface::Parameters;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 
 use nym_crypto::asymmetric::{encryption, identity};
 
@@ -29,7 +29,16 @@ impl From<encryption::KeyPair> for KeyPair {
     }
 }
 
-pub(crate) struct State {
+pub struct State {
     pub voucher: BandwidthVoucher,
     pub params: Parameters,
 }
+
+impl State {
+    pub fn new(voucher: BandwidthVoucher) -> Self {
+        State {
+            voucher,
+            params: Parameters::new(TOTAL_ATTRIBUTES).unwrap(),
+        }
+    }
+}

common/bandwidth-controller/src/error.rs

@@ -0,0 +1,41 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_coconut_interface::CoconutError;
+use nym_credential_storage::error::StorageError;
+use nym_credentials::error::Error as CredentialsError;
+use nym_crypto::asymmetric::encryption::KeyRecoveryError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_validator_client::error::ValidatorClientError;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum BandwidthControllerError {
+    #[cfg(not(target_arch = "wasm32"))]
+    #[error("Nyxd error: {0}")]
+    Nyxd(#[from] nym_validator_client::nyxd::error::NyxdError),
+
+    #[error("There was a credential storage error - {0}")]
+    CredentialStorageError(#[from] StorageError),
+
+    #[error("Coconut error - {0}")]
+    CoconutError(#[from] CoconutError),
+
+    #[error("Validator client error - {0}")]
+    ValidatorError(#[from] ValidatorClientError),
+
+    #[error("Credential error - {0}")]
+    CredentialError(#[from] CredentialsError),
+
+    #[error("Could not parse Ed25519 data")]
+    Ed25519ParseError(#[from] Ed25519RecoveryError),
+
+    #[error("Could not parse X25519 data")]
+    X25519ParseError(#[from] KeyRecoveryError),
+
+    #[error("The tx hash provided is not valid")]
+    InvalidTxHash,
+
+    #[error("Threshold not set yet")]
+    NoThreshold,
+}

common/bandwidth-controller/src/lib.rs

@@ -1,28 +1,10 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::error::GatewayClientError;
+use crate::error::BandwidthControllerError;
 
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::Storage;
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(not(target_os = "android"))]
-use nym_credential_storage::storage::Storage;
-
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(target_os = "android")]
-use mobile_storage::Storage;
-
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(target_os = "android")]
-use mobile_storage::StorageError;
-
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::StorageError;
-
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(not(target_os = "android"))]
 use nym_credential_storage::error::StorageError;
+use nym_credential_storage::storage::Storage;
 
 use std::str::FromStr;
 use {
@@ -33,40 +15,34 @@ use {
 };
 
 #[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::traits::DkgQueryClient;
-
-// TODO: make it nicer for wasm (I don't want to touch it for this experiment)
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::PersistentStorage;
+use nym_validator_client::nyxd::traits::DkgQueryClient;
 
 #[cfg(target_arch = "wasm32")]
 use crate::wasm_mockups::DkgQueryClient;
 
 #[cfg(not(target_arch = "wasm32"))]
-#[cfg(not(target_os = "android"))]
-use nym_credential_storage::PersistentStorage;
+pub mod acquire;
+pub mod error;
+#[cfg(target_arch = "wasm32")]
+pub mod wasm_mockups;
 
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(target_os = "android")]
-use mobile_storage::PersistentStorage;
-
-#[allow(dead_code)]
-pub struct BandwidthController<C, St: Storage = PersistentStorage> {
+pub struct BandwidthController<C, St: Storage> {
     storage: St,
     client: C,
 }
 
-impl<C, St> BandwidthController<C, St>
-where
-    St: Storage + 'static,
-{
+impl<C, St: Storage> BandwidthController<C, St> {
     pub fn new(storage: St, client: C) -> Self {
         BandwidthController { storage, client }
     }
 
+    pub fn storage(&self) -> &St {
+        &self.storage
+    }
+
     pub async fn prepare_coconut_credential(
         &self,
-    ) -> Result<(nym_coconut_interface::Credential, i64), GatewayClientError>
+    ) -> Result<(nym_coconut_interface::Credential, i64), BandwidthControllerError>
     where
         C: DkgQueryClient + Sync + Send,
     {
@@ -85,9 +61,8 @@ where
 
         #[cfg(not(target_arch = "wasm32"))]
         let coconut_api_clients =
-            validator_client::CoconutApiClient::all_coconut_api_clients(&self.client, epoch_id)
-                .await
-                .expect("Could not query api clients");
+            nym_validator_client::CoconutApiClient::all_coconut_api_clients(&self.client, epoch_id)
+                .await?;
         #[cfg(target_arch = "wasm32")]
         let coconut_api_clients = vec![];
         let verification_key = obtain_aggregate_verification_key(&coconut_api_clients).await?;
@@ -107,7 +82,7 @@ where
         ))
     }
 
-    pub async fn consume_credential(&self, id: i64) -> Result<(), GatewayClientError> {
+    pub async fn consume_credential(&self, id: i64) -> Result<(), BandwidthControllerError> {
         // JS: shouldn't we send some contract/validator/gateway message here to actually, you know,
         // consume it?
         Ok(self.storage.consume_coconut_credential(id).await?)

common/bandwidth-controller/src/wasm_mockups.rs

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

common/bin-common/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-bin-common"
-version = "0.3.0"
+version = "0.5.0"
 description = "Common code for nym binaries"
 edition = { workspace = true }
 authors = { workspace = true }
@@ -12,17 +12,29 @@ atty = "0.2"
 clap = { version = "4.0", features = ["derive"] }
 clap_complete = "4.0"
 clap_complete_fig = "4.0"
-filetime = "0.2.20"
 log = { workspace = true }
 pretty_env_logger = "0.4.0"
 semver = "0.11"
 serde = { workspace = true, features = ["derive"], optional = true }
 serde_json = { workspace = true, optional = true }
-walkdir = "2.3.3"
+
+## tracing
+tracing-appender = { version = "0.2.2", optional = true }
+tracing-subscriber = { version = "0.3.16", features = [
+    "env-filter",
+], optional = true }
+tracing-tree = { version = "0.2.2", optional = true }
+
 
 [build-dependencies]
-vergen = { version = "=7.4.3", default-features = false, features = ["build", "git", "rustc", "cargo"] }
+vergen = { version = "=7.4.3", default-features = false, features = [
+    "build",
+    "git",
+    "rustc",
+    "cargo",
+] }
 
 [features]
 default = []
 output_format = ["serde", "serde_json"]
+tracing = ["tracing-appender", "tracing-subscriber", "tracing-tree"]

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

@@ -1,54 +0,0 @@
-use std::{
-    collections::HashMap,
-    io,
-    path::{Path, PathBuf},
-};
-
-use filetime::FileTime;
-use walkdir::WalkDir;
-
-/// Keeps the most recently accessed directories in the given directory.
-pub fn keep_recently_accessed_dirs<P: AsRef<Path>>(dir: P, num_to_keep: usize) -> io::Result<()> {
-    let mut dir_access_times: HashMap<PathBuf, FileTime> = HashMap::new();
-
-    for entry in std::fs::read_dir(dir)?.flatten() {
-        if entry.file_type().map(|e| e.is_dir()).unwrap_or(false) {
-            // For each sub directory, keep track of the most recently accessed time of any
-            // file inside that sub directory.
-            let sub_dir = entry.path();
-            let mut most_recent_access_time: Option<FileTime> = None;
-
-            for file_entry in WalkDir::new(&sub_dir)
-                .into_iter()
-                .filter_map(|e| e.ok())
-                .filter(|e| e.file_type().is_file())
-            {
-                let metadata = file_entry.metadata().unwrap();
-                let accessed_time = FileTime::from_last_access_time(&metadata);
-
-                if most_recent_access_time.map_or(true, |current| accessed_time > current) {
-                    most_recent_access_time = Some(accessed_time);
-                }
-            }
-
-            if let Some(access_time) = most_recent_access_time {
-                dir_access_times.insert(sub_dir, access_time);
-            }
-        }
-    }
-
-    let mut sorted_dir_access_times: Vec<(PathBuf, FileTime)> =
-        dir_access_times.into_iter().collect();
-    sorted_dir_access_times.sort_unstable_by_key(|(_, accessed_time)| *accessed_time);
-    sorted_dir_access_times.reverse();
-    let dirs_to_remove = sorted_dir_access_times.split_off(num_to_keep);
-
-    for (path, _) in dirs_to_remove {
-        println!("Removing: {:?}", path);
-        if let Err(err) = std::fs::remove_dir_all(path.clone()) {
-            println!("Failed to remove {:?} due to: {:?}", path, err);
-        }
-    }
-
-    Ok(())
-}

common/bin-common/src/lib.rs

@@ -3,7 +3,6 @@
 
 pub mod build_information;
 pub mod completions;
-pub mod file_handling;
 pub mod logging;
 pub mod output_format;
 pub mod version_checker;

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

@@ -1,5 +1,16 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
+// use tracing_subscriber::{
+//     fmt::Layer, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Registry,
+// };
+// use tracing_tree::HierarchicalLayer;
+
+#[cfg(feature = "tracing")]
+pub use tracing_appender;
+#[cfg(feature = "tracing")]
+pub use tracing_subscriber;
+#[cfg(feature = "tracing")]
+pub use tracing_tree;
 
 // I'd argue we should start transitioning from `log` to `tracing`
 pub fn setup_logging() {
@@ -24,6 +35,34 @@ pub fn setup_logging() {
         .init();
 }
 
+// TODO: This has to be a macro, running it as a function does not work for the file_appender for some reason
+#[cfg(feature = "tracing")]
+#[macro_export]
+macro_rules! setup_tracing {
+    ($file_name: expr) => {
+        use nym_bin_common::logging::tracing_subscriber::layer::SubscriberExt;
+        use nym_bin_common::logging::tracing_subscriber::util::SubscriberInitExt;
+
+        let file_appender =
+            nym_bin_common::logging::tracing_appender::rolling::hourly($file_name, "log");
+        let (non_blocking, _guard) =
+            nym_bin_common::logging::tracing_appender::non_blocking(file_appender);
+        let appender_layer = nym_bin_common::logging::tracing_subscriber::fmt::Layer::new()
+            .with_ansi(false)
+            .with_writer(non_blocking);
+
+        nym_bin_common::logging::tracing_subscriber::Registry::default()
+            .with(nym_bin_common::logging::tracing_subscriber::EnvFilter::from_default_env())
+            .with(appender_layer)
+            .with(
+                nym_bin_common::logging::tracing_tree::HierarchicalLayer::new(4)
+                    .with_targets(true)
+                    .with_bracketed_fields(true),
+            )
+            .init();
+    };
+}
+
 pub fn banner(crate_name: &str, crate_version: &str) -> String {
     format!(
         r#"

common/client-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "client-core"
-version = "1.1.13"
+name = "nym-client-core"
+version = "1.1.14"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -25,19 +25,21 @@ tokio = { version = "1.24.1", features = ["macros"]}
 time = "0.3.17"
 
 # internal
+nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
 nym-crypto = { path = "../crypto" }
-gateway-client = { path = "../client-libs/gateway-client" }
+nym-gateway-client = { path = "../client-libs/gateway-client" }
 #gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
-gateway-requests = { path = "../../gateway/gateway-requests" }
+nym-gateway-requests = { path = "../../gateway/gateway-requests" }
 nym-nonexhaustive-delayqueue = { path = "../nonexhaustive-delayqueue" }
 nym-sphinx = { path = "../nymsphinx" }
 nym-pemstore = { path = "../pemstore" }
 nym-topology = { path = "../topology" }
-validator-client = { path = "../client-libs/validator-client", default-features = false }
+nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 nym-task = { path = "../task" }
+nym-credential-storage = { path = "../credential-storage" }
 
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.validator-client]
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-validator-client]
 path = "../client-libs/validator-client"
 features = ["nyxd-client"]
 
@@ -89,5 +91,5 @@ sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macro
 [features]
 default = []
 fs-surb-storage = ["sqlx"]
-wasm = ["gateway-client/wasm"]
+wasm = ["nym-gateway-client/wasm"]
 

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

@@ -24,13 +24,13 @@ use crate::config::{Config, DebugConfig, GatewayEndpointConfig};
 use crate::error::ClientCoreError;
 use crate::spawn_future;
 use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
-use gateway_client::{
+use log::{debug, info};
+use nym_bandwidth_controller::BandwidthController;
+use nym_crypto::asymmetric::{encryption, identity};
+use nym_gateway_client::{
     AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
     MixnetMessageSender,
 };
-use log::{debug, info};
-use nym_crypto::asymmetric::{encryption, identity};
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::addressing::nodes::NodeIdentity;
@@ -43,11 +43,12 @@ use std::time::Duration;
 use tap::TapFallible;
 use url::Url;
 
+use nym_credential_storage::storage::Storage;
 #[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::traits::DkgQueryClient;
+use nym_validator_client::nyxd::traits::DkgQueryClient;
 
 #[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::DkgQueryClient;
+use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
 
 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
 pub mod non_wasm_helpers;
@@ -151,7 +152,7 @@ impl From<bool> for CredentialsToggle {
     }
 }
 
-pub struct BaseClientBuilder<'a, B, C> {
+pub struct BaseClientBuilder<'a, B, C, St: Storage> {
     // due to wasm limitations I had to split it like this : (
     gateway_config: &'a GatewayEndpointConfig,
     debug_config: &'a DebugConfig,
@@ -160,21 +161,22 @@ pub struct BaseClientBuilder<'a, B, C> {
     reply_storage_backend: B,
 
     custom_topology_provider: Option<Box<dyn TopologyProvider>>,
-    bandwidth_controller: Option<BandwidthController<C>>,
+    bandwidth_controller: Option<BandwidthController<C, St>>,
     key_manager: KeyManager,
 }
 
-impl<'a, B, C> BaseClientBuilder<'a, B, C>
+impl<'a, B, C, St> BaseClientBuilder<'a, B, C, St>
 where
     B: ReplyStorageBackend + Send + Sync + 'static,
     C: DkgQueryClient + Sync + Send + 'static,
+    St: Storage + 'static,
 {
     pub fn new_from_base_config<T>(
         base_config: &'a Config<T>,
         key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C>>,
+        bandwidth_controller: Option<BandwidthController<C, St>>,
         reply_storage_backend: B,
-    ) -> BaseClientBuilder<'a, B, C> {
+    ) -> BaseClientBuilder<'a, B, C, St> {
         BaseClientBuilder {
             gateway_config: base_config.get_gateway_endpoint_config(),
             debug_config: base_config.get_debug_config(),
@@ -191,11 +193,11 @@ where
         gateway_config: &'a GatewayEndpointConfig,
         debug_config: &'a DebugConfig,
         key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C>>,
+        bandwidth_controller: Option<BandwidthController<C, St>>,
         reply_storage_backend: B,
         credentials_toggle: CredentialsToggle,
         nym_api_endpoints: Vec<Url>,
-    ) -> BaseClientBuilder<'a, B, C> {
+    ) -> BaseClientBuilder<'a, B, C, St> {
         BaseClientBuilder {
             gateway_config,
             debug_config,
@@ -235,21 +237,16 @@ where
     ) {
         info!("Starting loop cover traffic stream...");
 
-        let mut stream = LoopCoverTrafficStream::new(
+        let stream = LoopCoverTrafficStream::new(
             ack_key,
             debug_config.acknowledgements.average_ack_delay,
-            debug_config.traffic.average_packet_delay,
-            debug_config.cover_traffic.loop_cover_traffic_average_delay,
             mix_tx,
             self_address,
             topology_accessor,
+            debug_config.traffic,
+            debug_config.cover_traffic,
         );
 
-        if let Some(size) = debug_config.traffic.use_extended_packet_size {
-            log::debug!("Setting extended packet size: {:?}", size);
-            stream.set_custom_packet_size(size.into());
-        }
-
         stream.start_with_shutdown(shutdown);
     }
 
@@ -311,7 +308,7 @@ where
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         shutdown: TaskClient,
-    ) -> Result<GatewayClient<C>, ClientCoreError> {
+    ) -> Result<GatewayClient<C, St>, ClientCoreError> {
         let gateway_id = self.gateway_config.gateway_id.clone();
         if gateway_id.is_empty() {
             return Err(ClientCoreError::GatewayIdUnknown);
@@ -408,7 +405,7 @@ where
     // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
     // requests?
     fn start_mix_traffic_controller(
-        gateway_client: GatewayClient<C>,
+        gateway_client: GatewayClient<C, St>,
         shutdown: TaskClient,
     ) -> BatchMixMessageSender {
         info!("Starting mix traffic controller...");
@@ -533,17 +530,12 @@ where
         // primarily to throttle incoming connections (e.g socks5 for attached network-requesters)
         let shared_lane_queue_lengths = LaneQueueLengths::new();
 
-        let mut controller_config = real_messages_control::Config::new(
+        let controller_config = real_messages_control::Config::new(
             self.debug_config,
             self.key_manager.ack_key(),
             self_address,
         );
 
-        if let Some(size) = self.debug_config.traffic.use_extended_packet_size {
-            log::debug!("Setting extended packet size: {:?}", size);
-            controller_config.set_custom_packet_size(size.into());
-        }
-
         Self::start_real_traffic_controller(
             controller_config,
             shared_topology_accessor.clone(),

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

@@ -3,7 +3,7 @@
 
 use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::topology_control::TopologyAccessor;
-use crate::spawn_future;
+use crate::{config, spawn_future};
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
@@ -34,11 +34,8 @@ where
     /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
     average_ack_delay: Duration,
 
-    /// Average delay a data packet is going to get delay at a single mixnode.
-    average_packet_delay: Duration,
-
-    /// Average delay between sending subsequent cover packets.
-    average_cover_message_sending_delay: Duration,
+    /// Defines configuration options related to cover traffic.
+    cover_traffic: config::CoverTraffic,
 
     /// Internal state, determined by `average_message_sending_delay`,
     /// used to keep track of when a next packet should be sent out.
@@ -61,8 +58,11 @@ where
     /// Accessor to the common instance of network topology.
     topology_access: TopologyAccessor,
 
-    /// Predefined packet size used for the loop cover messages.
-    packet_size: PacketSize,
+    /// Primary predefined packet size used for the loop cover messages.
+    primary_packet_size: PacketSize,
+
+    /// Optional secondary predefined packet size used for the loop cover messages.
+    secondary_packet_size: Option<PacketSize>,
 }
 
 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -83,7 +83,7 @@ where
 
         // we know it's time to send a message, so let's prepare delay for the next one
         // Get the `now` by looking at the current `delay` deadline
-        let avg_delay = self.average_cover_message_sending_delay;
+        let avg_delay = self.cover_traffic.loop_cover_traffic_average_delay;
         let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
 
         // The next interval value is `next_poisson_delay` after the one that just
@@ -107,15 +107,14 @@ where
 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 impl LoopCoverTrafficStream<OsRng> {
-    #[allow(clippy::too_many_arguments)]
     pub fn new(
         ack_key: Arc<AckKey>,
         average_ack_delay: Duration,
-        average_packet_delay: Duration,
-        average_cover_message_sending_delay: Duration,
         mix_tx: BatchMixMessageSender,
         our_full_destination: Recipient,
         topology_access: TopologyAccessor,
+        traffic_config: config::Traffic,
+        cover_config: config::CoverTraffic,
     ) -> Self {
         let rng = OsRng;
 
@@ -128,21 +127,17 @@ impl LoopCoverTrafficStream<OsRng> {
         LoopCoverTrafficStream {
             ack_key,
             average_ack_delay,
-            average_packet_delay,
-            average_cover_message_sending_delay,
+            cover_traffic: cover_config,
             next_delay,
             mix_tx,
             our_full_destination,
             rng,
             topology_access,
-            packet_size: Default::default(),
+            primary_packet_size: traffic_config.primary_packet_size,
+            secondary_packet_size: traffic_config.secondary_packet_size,
         }
     }
 
-    pub fn set_custom_packet_size(&mut self, packet_size: PacketSize) {
-        self.packet_size = packet_size;
-    }
-
     fn set_next_delay(&mut self, amount: Duration) {
         #[cfg(not(target_arch = "wasm32"))]
         let next_delay = Box::pin(time::sleep(amount));
@@ -153,9 +148,28 @@ impl LoopCoverTrafficStream<OsRng> {
         self.next_delay = next_delay;
     }
 
+    fn loop_cover_message_size(&mut self) -> PacketSize {
+        let Some(secondary_packet_size) = self.secondary_packet_size else {
+            return self.primary_packet_size
+        };
+
+        let use_primary = self
+            .rng
+            .gen_bool(self.cover_traffic.cover_traffic_primary_size_ratio);
+
+        if use_primary {
+            self.primary_packet_size
+        } else {
+            secondary_packet_size
+        }
+    }
+
     async fn on_new_message(&mut self) {
         trace!("next cover message!");
 
+        let cover_traffic_packet_size = self.loop_cover_message_size();
+        trace!("the next loop cover message will be put in a {cover_traffic_packet_size} packet");
+
         // TODO for way down the line: in very rare cases (during topology update) we might have
         // to wait a really tiny bit before actually obtaining the permit hence messing with our
         // poisson delay, but is it really a problem?
@@ -178,8 +192,8 @@ impl LoopCoverTrafficStream<OsRng> {
             &self.ack_key,
             &self.our_full_destination,
             self.average_ack_delay,
-            self.average_packet_delay,
-            self.packet_size,
+            self.cover_traffic.loop_cover_traffic_average_delay,
+            cover_traffic_packet_size,
         )
         .expect("Somehow failed to generate a loop cover message with a valid topology");
 
@@ -189,10 +203,6 @@ impl LoopCoverTrafficStream<OsRng> {
                     // This isn't a problem, if the channel is full means we're already sending the
                     // max amount of messages downstream can handle.
                     log::debug!("Failed to send cover message - channel full");
-                    // However it's still useful to alert the user that the gateway or the link to
-                    // the gateway can't keep up. Either due to insufficient bandwidth on the
-                    // client side, or that the gateway is overloaded.
-                    log::warn!("Failed to send sphinx packet - gateway or connection to gateway can't keep up");
                 }
                 TrySendError::Closed(_) => {
                     log::warn!("Failed to send cover message - channel closed");
@@ -214,9 +224,17 @@ impl LoopCoverTrafficStream<OsRng> {
     }
 
     pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
+        if self.cover_traffic.disable_loop_cover_traffic_stream {
+            // we should have never got here in the first place - the task should have never been created to begin with
+            // so panic and review the code that lead to this branch
+            panic!("attempted to start LoopCoverTrafficStream while config explicitly disabled it.")
+        }
+
         // we should set initial delay only when we actually start the stream
-        let sampled =
-            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
+        let sampled = sample_poisson_duration(
+            &mut self.rng,
+            self.cover_traffic.loop_cover_traffic_average_delay,
+        );
         self.set_next_delay(sampled);
 
         spawn_future(async move {

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

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::config::persistence::key_pathfinder::ClientKeyPathfinder;
-use gateway_requests::registration::handshake::SharedKeys;
 use log::*;
 use nym_crypto::asymmetric::{encryption, identity};
+use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_sphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
 use std::io;

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

@@ -2,15 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::spawn_future;
-use gateway_client::GatewayClient;
 use log::*;
+use nym_gateway_client::GatewayClient;
 use nym_sphinx::forwarding::packet::MixPacket;
 
+use nym_credential_storage::storage::Storage;
 #[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::traits::DkgQueryClient;
+use nym_validator_client::nyxd::traits::DkgQueryClient;
 
 #[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::DkgQueryClient;
+use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
 
 pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
 pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
@@ -19,10 +20,10 @@ pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
 pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
 const MAX_FAILURE_COUNT: usize = 100;
 
-pub struct MixTrafficController<C> {
+pub struct MixTrafficController<C, St: Storage> {
     // TODO: most likely to be replaced by some higher level construct as
     // later on gateway_client will need to be accessible by other entities
-    gateway_client: GatewayClient<C>,
+    gateway_client: GatewayClient<C, St>,
     mix_rx: BatchMixMessageReceiver,
 
     // TODO: this is temporary work-around.
@@ -30,13 +31,14 @@ pub struct MixTrafficController<C> {
     consecutive_gateway_failure_count: usize,
 }
 
-impl<C> MixTrafficController<C>
+impl<C, St> MixTrafficController<C, St>
 where
     C: DkgQueryClient + Sync + Send + 'static,
+    St: Storage + 'static,
 {
     pub fn new(
-        gateway_client: GatewayClient<C>,
-    ) -> (MixTrafficController<C>, BatchMixMessageSender) {
+        gateway_client: GatewayClient<C, St>,
+    ) -> (MixTrafficController<C, St>, BatchMixMessageSender) {
         let (sphinx_message_sender, sphinx_message_receiver) =
             tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
         (

common/client-core/src/client/real_messages_control/acknowledgement_control/acknowledgement_listener.rs

@@ -3,8 +3,8 @@
 
 use super::action_controller::{AckActionSender, Action};
 use futures::StreamExt;
-use gateway_client::AcknowledgementReceiver;
 use log::*;
+use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::{
     acknowledgements::{identifier::recover_identifier, AckKey},
     chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},

common/client-core/src/client/real_messages_control/acknowledgement_control/mod.rs

@@ -13,8 +13,8 @@ use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::spawn_future;
 use action_controller::AckActionReceiver;
 use futures::channel::mpsc;
-use gateway_client::AcknowledgementReceiver;
 use log::*;
+use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::params::PacketSize;
 use nym_sphinx::{

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

@@ -101,8 +101,11 @@ pub(crate) struct Config {
     /// Note that it does not include gateway hops.
     num_mix_hops: u8,
 
-    /// Predefined packet size used for the encapsulated messages.
-    packet_size: PacketSize,
+    /// Primary predefined packet size used for the encapsulated messages.
+    primary_packet_size: PacketSize,
+
+    /// Optional secondary predefined packet size used for the encapsulated messages.
+    secondary_packet_size: Option<PacketSize>,
 }
 
 impl Config {
@@ -118,7 +121,8 @@ impl Config {
             average_packet_delay,
             average_ack_delay,
             num_mix_hops: DEFAULT_NUM_MIX_HOPS,
-            packet_size: PacketSize::default(),
+            primary_packet_size: PacketSize::default(),
+            secondary_packet_size: None,
         }
     }
 
@@ -130,8 +134,14 @@ impl Config {
     }
 
     /// Allows setting non-default size of the sphinx packets sent out.
-    pub fn with_custom_packet_size(mut self, packet_size: PacketSize) -> Self {
-        self.packet_size = packet_size;
+    pub fn with_custom_primary_packet_size(mut self, packet_size: PacketSize) -> Self {
+        self.primary_packet_size = packet_size;
+        self
+    }
+
+    /// Allows setting non-default size of the sphinx packets sent out.
+    pub fn with_custom_secondary_packet_size(mut self, packet_size: Option<PacketSize>) -> Self {
+        self.secondary_packet_size = packet_size;
         self
     }
 }
@@ -170,7 +180,6 @@ where
             config.average_packet_delay,
             config.average_ack_delay,
         )
-        .with_custom_real_message_packet_size(config.packet_size)
         .with_mix_hops(config.num_mix_hops);
 
         MessageHandler {
@@ -211,6 +220,28 @@ where
         }
     }
 
+    fn optimal_packet_size(&self, msg: &NymMessage) -> PacketSize {
+        // if secondary packet was never set, then it's obvious we have to use the primary packet
+        let Some(secondary_packet) = self.config.secondary_packet_size else {
+            trace!("only primary packet size is available");
+            return self.config.primary_packet_size
+        };
+
+        let primary_count =
+            msg.required_packets(self.config.primary_packet_size, self.config.num_mix_hops);
+        let secondary_count = msg.required_packets(secondary_packet, self.config.num_mix_hops);
+
+        trace!("This message would require: {primary_count} primary packets or {secondary_count} secondary packets...");
+        // if there would be no benefit in using the secondary packet - use the primary (duh)
+        if primary_count <= secondary_count {
+            trace!("so choosing primary for this message");
+            self.config.primary_packet_size
+        } else {
+            trace!("so choosing secondary for this message");
+            secondary_packet
+        }
+    }
+
     async fn generate_reply_surbs_with_keys(
         &mut self,
         amount: usize,
@@ -237,9 +268,13 @@ where
         reply_surb: ReplySurb,
         is_extra_surb_request: bool,
     ) -> Result<(), SurbWrappedPreparationError> {
+        let msg = NymMessage::new_reply(message);
+        let packet_size = self.optimal_packet_size(&msg);
+        debug!("Using {packet_size} packets for {msg}");
+
         let mut fragment = self
             .message_preparer
-            .pad_and_split_message(NymMessage::new_reply(message));
+            .pad_and_split_message(msg, packet_size);
         if fragment.len() > 1 {
             // well, it's not a single surb message
             return Err(SurbWrappedPreparationError {
@@ -289,10 +324,12 @@ where
 
     // // TODO: this will require additional argument to make it use different variant of `ReplyMessage`
     pub(crate) fn split_reply_message(&mut self, message: Vec<u8>) -> Vec<Fragment> {
+        let msg = NymMessage::new_reply(ReplyMessage::new_data_message(message));
+        let packet_size = self.optimal_packet_size(&msg);
+        debug!("Using {packet_size} packets for {msg}");
+
         self.message_preparer
-            .pad_and_split_message(NymMessage::new_reply(ReplyMessage::new_data_message(
-                message,
-            )))
+            .pad_and_split_message(msg, packet_size)
     }
 
     pub(crate) async fn send_retransmission_reply_chunks(
@@ -388,7 +425,11 @@ where
         let topology_permit = self.topology_access.get_read_permit().await;
         let topology = self.get_topology(&topology_permit)?;
 
-        let fragments = self.message_preparer.pad_and_split_message(message);
+        let packet_size = self.optimal_packet_size(&message);
+        debug!("Using {packet_size} packets for {message}");
+        let fragments = self
+            .message_preparer
+            .pad_and_split_message(message, packet_size);
 
         let mut pending_acks = Vec::with_capacity(fragments.len());
         let mut real_messages = Vec::with_capacity(fragments.len());

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

@@ -1,4 +1,4 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 // INPUT: InputMessage from user
@@ -22,15 +22,13 @@ use crate::{
     spawn_future,
 };
 use futures::channel::mpsc;
-use gateway_client::AcknowledgementReceiver;
 use log::*;
+use nym_gateway_client::AcknowledgementReceiver;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::PacketSize;
 use nym_task::connections::{ConnectionCommandReceiver, LaneQueueLengths};
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
-use std::time::Duration;
 
 use crate::client::replies::reply_controller;
 use crate::config;
@@ -45,61 +43,29 @@ pub struct Config {
     /// Key used to decrypt contents of received SURBAcks
     ack_key: Arc<AckKey>,
 
-    /// Given ack timeout in the form a * BASE_DELAY + b, it specifies the additive part `b`
-    ack_wait_addition: Duration,
-
-    /// Given ack timeout in the form a * BASE_DELAY + b, it specifies the multiplier `a`
-    ack_wait_multiplier: f64,
-
     /// Address of `this` client.
     self_recipient: Recipient,
 
-    /// Average delay between sending subsequent packets from this client.
-    average_message_sending_delay: Duration,
+    /// Specifies all traffic related configuration options.
+    traffic: config::Traffic,
 
-    /// Average delay a data packet is going to get delayed at a single mixnode.
-    average_packet_delay_duration: Duration,
+    /// Specifies all cover traffic related configuration options.
+    cover_traffic: config::CoverTraffic,
 
-    /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
-    average_ack_delay_duration: Duration,
+    /// Specifies all acknowledgements related configuration options.
+    acks: config::Acknowledgements,
 
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    disable_main_poisson_packet_distribution: bool,
-
-    /// Predefined packet size used for the encapsulated messages.
-    packet_size: PacketSize,
-
-    /// Defines the minimum number of reply surbs the client would request.
-    minimum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs the client would request.
-    maximum_reply_surb_request_size: u32,
-
-    /// Defines the maximum number of reply surbs a remote party is allowed to request from this client at once.
-    maximum_allowed_reply_surb_request_size: u32,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before explicitly asking
-    /// for more even though in theory they wouldn't need to.
-    maximum_reply_surb_rerequest_waiting_period: Duration,
-
-    /// Defines maximum amount of time the client is going to wait for reply surbs before
-    /// deciding it's never going to get them and would drop all pending messages
-    maximum_reply_surb_drop_waiting_period: Duration,
-
-    /// Defines maximum amount of time given reply surb is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    maximum_reply_surb_age: Duration,
-
-    /// Defines maximum amount of time given reply key is going to be valid for.
-    /// This is going to be superseded by key rotation once implemented.
-    maximum_reply_key_age: Duration,
+    /// Specifies all reply SURBs related configuration options.
+    reply_surbs: config::ReplySurbs,
 }
 
 impl<'a> From<&'a Config> for acknowledgement_control::Config {
     fn from(cfg: &'a Config) -> Self {
-        acknowledgement_control::Config::new(cfg.ack_wait_addition, cfg.ack_wait_multiplier)
-            .with_custom_packet_size(cfg.packet_size)
+        acknowledgement_control::Config::new(
+            cfg.acks.ack_wait_addition,
+            cfg.acks.ack_wait_multiplier,
+        )
+        .with_custom_packet_size(cfg.traffic.primary_packet_size)
     }
 }
 
@@ -108,26 +74,16 @@ impl<'a> From<&'a Config> for real_traffic_stream::Config {
         real_traffic_stream::Config::new(
             Arc::clone(&cfg.ack_key),
             cfg.self_recipient,
-            cfg.average_ack_delay_duration,
-            cfg.average_packet_delay_duration,
-            cfg.average_message_sending_delay,
-            cfg.disable_main_poisson_packet_distribution,
+            cfg.acks.average_ack_delay,
+            cfg.traffic,
+            cfg.cover_traffic.cover_traffic_primary_size_ratio,
         )
-        .with_custom_cover_packet_size(cfg.packet_size)
     }
 }
 
 impl<'a> From<&'a Config> for reply_controller::Config {
     fn from(cfg: &'a Config) -> Self {
-        reply_controller::Config::new(
-            cfg.minimum_reply_surb_request_size,
-            cfg.maximum_reply_surb_request_size,
-            cfg.maximum_allowed_reply_surb_request_size,
-            cfg.maximum_reply_surb_rerequest_waiting_period,
-            cfg.maximum_reply_surb_drop_waiting_period,
-            cfg.maximum_reply_surb_age,
-            cfg.maximum_reply_key_age,
-        )
+        reply_controller::Config::new(cfg.reply_surbs)
     }
 }
 
@@ -136,10 +92,11 @@ impl<'a> From<&'a Config> for message_handler::Config {
         message_handler::Config::new(
             Arc::clone(&cfg.ack_key),
             cfg.self_recipient,
-            cfg.average_packet_delay_duration,
-            cfg.average_ack_delay_duration,
+            cfg.traffic.average_packet_delay,
+            cfg.acks.average_ack_delay,
         )
-        .with_custom_packet_size(cfg.packet_size)
+        .with_custom_primary_packet_size(cfg.traffic.primary_packet_size)
+        .with_custom_secondary_packet_size(cfg.traffic.secondary_packet_size)
     }
 }
 
@@ -152,42 +109,12 @@ impl Config {
         Config {
             ack_key,
             self_recipient,
-            packet_size: Default::default(),
-            ack_wait_addition: base_client_debug_config.acknowledgements.ack_wait_addition,
-            ack_wait_multiplier: base_client_debug_config
-                .acknowledgements
-                .ack_wait_multiplier,
-            average_message_sending_delay: base_client_debug_config
-                .traffic
-                .message_sending_average_delay,
-            average_packet_delay_duration: base_client_debug_config.traffic.average_packet_delay,
-            average_ack_delay_duration: base_client_debug_config.acknowledgements.average_ack_delay,
-            disable_main_poisson_packet_distribution: base_client_debug_config
-                .traffic
-                .disable_main_poisson_packet_distribution,
-            minimum_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
-                .minimum_reply_surb_request_size,
-            maximum_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
-                .maximum_reply_surb_request_size,
-            maximum_allowed_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
-                .maximum_allowed_reply_surb_request_size,
-            maximum_reply_surb_rerequest_waiting_period: base_client_debug_config
-                .reply_surbs
-                .maximum_reply_surb_rerequest_waiting_period,
-            maximum_reply_surb_drop_waiting_period: base_client_debug_config
-                .reply_surbs
-                .maximum_reply_surb_drop_waiting_period,
-            maximum_reply_surb_age: base_client_debug_config.reply_surbs.maximum_reply_surb_age,
-            maximum_reply_key_age: base_client_debug_config.reply_surbs.maximum_reply_key_age,
+            traffic: base_client_debug_config.traffic,
+            cover_traffic: base_client_debug_config.cover_traffic,
+            acks: base_client_debug_config.acknowledgements,
+            reply_surbs: base_client_debug_config.reply_surbs,
         }
     }
-
-    pub fn set_custom_packet_size(&mut self, packet_size: PacketSize) {
-        self.packet_size = packet_size;
-    }
 }
 
 pub(crate) struct RealMessagesController<R>

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

@@ -6,6 +6,7 @@ use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
 use crate::client::transmission_buffer::TransmissionBuffer;
+use crate::config;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
@@ -27,7 +28,6 @@ use std::time::Duration;
 
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
-
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;
 
@@ -44,18 +44,12 @@ pub(crate) struct Config {
     /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
     average_ack_delay: Duration,
 
-    /// Average delay a data packet is going to get delay at a single mixnode.
-    average_packet_delay: Duration,
+    /// Defines all configuration options related to this traffic stream.
+    traffic: config::Traffic,
 
-    /// Average delay between sending subsequent packets.
-    average_message_sending_delay: Duration,
-
-    /// Controls whether the stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    disable_poisson_packet_distribution: bool,
-
-    /// Predefined packet size used for the loop cover messages.
-    cover_packet_size: PacketSize,
+    /// Specifies the ratio of `primary_packet_size` to `secondary_packet_size` used in cover traffic.
+    /// Only applicable if `secondary_packet_size` is enabled.
+    cover_traffic_primary_size_ratio: f64,
 }
 
 impl Config {
@@ -63,25 +57,17 @@ impl Config {
         ack_key: Arc<AckKey>,
         our_full_destination: Recipient,
         average_ack_delay: Duration,
-        average_packet_delay: Duration,
-        average_message_sending_delay: Duration,
-        disable_poisson_packet_distribution: bool,
+        traffic: config::Traffic,
+        cover_traffic_primary_size_ratio: f64,
     ) -> Self {
         Config {
             ack_key,
             our_full_destination,
             average_ack_delay,
-            average_packet_delay,
-            average_message_sending_delay,
-            disable_poisson_packet_distribution,
-            cover_packet_size: Default::default(),
+            traffic,
+            cover_traffic_primary_size_ratio,
         }
     }
-
-    pub fn with_custom_cover_packet_size(mut self, packet_size: PacketSize) -> Self {
-        self.cover_packet_size = packet_size;
-        self
-    }
 }
 
 pub(crate) struct OutQueueControl<R>
@@ -212,11 +198,30 @@ where
         self.sent_notifier.unbounded_send(frag_id).unwrap();
     }
 
+    fn loop_cover_message_size(&mut self) -> PacketSize {
+        let Some(secondary_packet_size) = self.config.traffic.secondary_packet_size else {
+            return self.config.traffic.primary_packet_size
+        };
+
+        let use_primary = self
+            .rng
+            .gen_bool(self.config.cover_traffic_primary_size_ratio);
+
+        if use_primary {
+            self.config.traffic.primary_packet_size
+        } else {
+            secondary_packet_size
+        }
+    }
+
     async fn on_message(&mut self, next_message: StreamMessage) {
         trace!("created new message");
 
         let (next_message, fragment_id) = match next_message {
             StreamMessage::Cover => {
+                let cover_traffic_packet_size = self.loop_cover_message_size();
+                trace!("the next loop cover message will be put in a {cover_traffic_packet_size} packet");
+
                 // TODO for way down the line: in very rare cases (during topology update) we might have
                 // to wait a really tiny bit before actually obtaining the permit hence messing with our
                 // poisson delay, but is it really a problem?
@@ -240,8 +245,8 @@ where
                         &self.config.ack_key,
                         &self.config.our_full_destination,
                         self.config.average_ack_delay,
-                        self.config.average_packet_delay,
-                        self.config.cover_packet_size,
+                        self.config.traffic.average_packet_delay,
+                        cover_traffic_packet_size,
                     )
                     .expect(
                         "Somehow failed to generate a loop cover message with a valid topology",
@@ -286,7 +291,7 @@ where
     }
 
     fn current_average_message_sending_delay(&self) -> Duration {
-        self.config.average_message_sending_delay
+        self.config.traffic.message_sending_average_delay
             * self.sending_delay_controller.current_multiplier()
     }
 
@@ -297,24 +302,34 @@ where
             self.sending_delay_controller.current_multiplier()
         );
 
-        // Even just a single used slot is enough to signal backpressure
-        if used_slots > 0 {
+        if self
+            .sending_delay_controller
+            .is_backpressure_currently_detected(used_slots)
+        {
             log::trace!("Backpressure detected");
             self.sending_delay_controller.record_backpressure_detected();
         }
 
-        // If the buffer is running out, slow down the sending rate
+        // If the buffer is running out, slow down the sending rate by increasing the delay
+        // multiplier.
         if self.mix_tx.capacity() == 0
             && self.sending_delay_controller.not_increased_delay_recently()
         {
             self.sending_delay_controller.increase_delay_multiplier();
         }
 
-        // Very carefully step up the sending rate in case it seems like we can solidly handle the
-        // current rate.
-        if self.sending_delay_controller.is_sending_reliable() {
+        // If it looks like we are sending reliably, increase the sending rate by decreasing the
+        // sending delay multiplier.
+        if !self
+            .sending_delay_controller
+            .was_backpressure_detected_recently()
+            && self.sending_delay_controller.not_decreased_delay_recently()
+        {
             self.sending_delay_controller.decrease_delay_multiplier();
         }
+
+        // Keep track of multiplier changes, and log if necessary.
+        self.sending_delay_controller.record_delay_multiplier();
     }
 
     fn pop_next_message(&mut self) -> Option<RealMessage> {
@@ -400,8 +415,10 @@ where
             // we never set an initial delay - let's do it now
             cx.waker().wake_by_ref();
 
-            let sampled =
-                sample_poisson_duration(&mut self.rng, self.config.average_message_sending_delay);
+            let sampled = sample_poisson_duration(
+                &mut self.rng,
+                self.config.traffic.message_sending_average_delay,
+            );
 
             #[cfg(not(target_arch = "wasm32"))]
             let next_delay = Box::pin(time::sleep(sampled));
@@ -452,7 +469,7 @@ where
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
     ) -> Poll<Option<StreamMessage>> {
-        if self.config.disable_poisson_packet_distribution {
+        if self.config.traffic.disable_main_poisson_packet_distribution {
             self.poll_immediate(cx)
         } else {
             self.poll_poisson(cx)
@@ -468,7 +485,7 @@ where
         let lanes = self.transmission_buffer.num_lanes();
         let mult = self.sending_delay_controller.current_multiplier();
         let delay = self.current_average_message_sending_delay().as_millis();
-        let status_str = if self.config.disable_poisson_packet_distribution {
+        let status_str = if self.config.traffic.disable_main_poisson_packet_distribution {
             format!("Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), no delay")
         } else {
             format!(
@@ -491,23 +508,12 @@ where
         }
     }
 
-    #[cfg(not(target_arch = "wasm32"))]
-    fn log_status_infrequent(&self) {
-        if self.sending_delay_controller.current_multiplier() > 1 {
-            log::warn!(
-                "Unable to send packets at the default rate - rate reduced by setting the delay multiplier set to: {}",
-                self.sending_delay_controller.current_multiplier()
-            );
-        }
-    }
-
     pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
         debug!("Started OutQueueControl with graceful shutdown support");
 
         #[cfg(not(target_arch = "wasm32"))]
         {
             let mut status_timer = tokio::time::interval(Duration::from_secs(5));
-            let mut infrequent_status_timer = tokio::time::interval(Duration::from_secs(60));
 
             while !shutdown.is_shutdown() {
                 tokio::select! {
@@ -518,9 +524,6 @@ where
                     _ = status_timer.tick() => {
                         self.log_status(&mut shutdown);
                     }
-                    _ = infrequent_status_timer.tick() => {
-                        self.log_status_infrequent();
-                    }
                     next_message = self.next() => if let Some(next_message) = next_message {
                         self.on_message(next_message).await;
                     } else {

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

@@ -11,15 +11,20 @@ const INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 1;
 // The minimum time between decreasing the average delay between packets. We don't want to change
 // to quickly to keep things somewhat stable. Also there are buffers downstreams meaning we need to
 // wait a little to see the effect before we decrease further.
-const DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 30;
+const DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 2;
+// The queue length that is required for us to register that backpressure occured. If there are
+// more than this many packets waiting to be sent, we consider the channel to be under
+// backpressure.
+const BACKPRESSURE_THRESHOLD: usize = 10;
 // If we enough time passes without any sign of backpressure in the channel, we can consider
-// lowering the average delay. The goal is to keep somewhat stable, rather than maxing out
-// bandwidth at all times.
-const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 30;
+// lowering the average delay.
+const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 2;
 // The maximum multiplier we apply to the base average Poisson delay.
 const MAX_DELAY_MULTIPLIER: u32 = 6;
 // The minium multiplier we apply to the base average Poisson delay.
 const MIN_DELAY_MULTIPLIER: u32 = 1;
+// If the multipler increases we log it, but we don't want to log about it too often.
+const INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS: u64 = 60;
 
 pub(crate) struct SendingDelayController {
     /// Multiply the average sending delay.
@@ -33,6 +38,14 @@ pub(crate) struct SendingDelayController {
     /// Minimum delay multiplier
     lower_bound: u32,
 
+    /// We counter the number of times the multiplier has been elevated. If it is elevated for long
+    /// enough we need to log about it.
+    multiplier_elevated_counter: u32,
+
+    /// We can't log about the elevated multiplier too often, so we keep track of the last time we
+    /// did,
+    time_when_logged_about_elevated_multiplier: Instant,
+
     /// To make sure we don't change the multiplier to fast, we limit a change to some duration
     time_when_changed: Instant,
 
@@ -55,6 +68,9 @@ impl SendingDelayController {
             current_multiplier: MIN_DELAY_MULTIPLIER,
             upper_bound,
             lower_bound,
+            multiplier_elevated_counter: 0,
+            time_when_logged_about_elevated_multiplier: now
+                - Duration::from_secs(INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS),
             time_when_changed: now,
             time_when_backpressure_detected: now,
         }
@@ -79,7 +95,7 @@ impl SendingDelayController {
             self.current_multiplier =
                 (self.current_multiplier + 1).clamp(self.lower_bound, self.upper_bound);
             self.time_when_changed = get_time_now();
-            log::warn!(
+            log::debug!(
                 "Increasing sending delay multiplier to: {}",
                 self.current_multiplier
             );
@@ -100,22 +116,58 @@ impl SendingDelayController {
         }
     }
 
-    pub(crate) fn record_backpressure_detected(&mut self) {
-        self.time_when_backpressure_detected = get_time_now();
-    }
-
     pub(crate) fn not_increased_delay_recently(&self) -> bool {
         get_time_now()
             > self.time_when_changed + Duration::from_secs(INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
     }
 
-    pub(crate) fn is_sending_reliable(&self) -> bool {
-        let now = get_time_now();
-        let delay_change_interval = Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS);
-        let acceptable_time_without_backpressure =
-            Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS);
+    pub(crate) fn not_decreased_delay_recently(&self) -> bool {
+        get_time_now()
+            > self.time_when_changed + Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
+    }
 
-        now > self.time_when_backpressure_detected + acceptable_time_without_backpressure
-            && now > self.time_when_changed + delay_change_interval
+    pub(crate) fn is_backpressure_currently_detected(&self, queue_length: usize) -> bool {
+        queue_length > BACKPRESSURE_THRESHOLD
+    }
+
+    pub(crate) fn record_backpressure_detected(&mut self) {
+        self.time_when_backpressure_detected = get_time_now();
+    }
+
+    pub(crate) fn was_backpressure_detected_recently(&self) -> bool {
+        get_time_now()
+            < self.time_when_backpressure_detected
+                + Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS)
+    }
+
+    pub(crate) fn record_delay_multiplier(&mut self) {
+        // Count the number of times the multiplier has been elevated.
+        let multiplier_elevated = self.current_multiplier - self.lower_bound;
+        if multiplier_elevated == 0 {
+            self.multiplier_elevated_counter = 0;
+        } else {
+            self.multiplier_elevated_counter += 1;
+        }
+
+        // If needed, log about the elevated multiplier.
+        let now = get_time_now();
+        if self.multiplier_elevated_counter > 20
+            && now
+                > self.time_when_logged_about_elevated_multiplier
+                    + Duration::from_secs(INTERVAL_BETWEEN_WARNING_ABOUT_ELEVATED_MULTIPLIER_SECS)
+        {
+            let status_str = format!(
+                "Poisson delay currently scaled by: {}",
+                self.current_multiplier()
+            );
+            if self.current_multiplier() > 0 {
+                log::debug!("{}", status_str);
+            } else if self.current_multiplier() > 1 {
+                log::info!("{}", status_str);
+            } else if self.current_multiplier() > 2 {
+                log::warn!("{}", status_str);
+            }
+            self.time_when_logged_about_elevated_multiplier = now;
+        }
     }
 }

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

@@ -7,10 +7,10 @@ use crate::spawn_future;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
 use futures::StreamExt;
-use gateway_client::MixnetMessageReceiver;
 use log::*;
 use nym_crypto::asymmetric::encryption;
 use nym_crypto::Digest;
+use nym_gateway_client::MixnetMessageReceiver;
 use nym_sphinx::anonymous_replies::requests::{
     RepliableMessage, RepliableMessageContent, ReplyMessage, ReplyMessageContent,
 };

common/client-core/src/client/replies/reply_controller/mod.rs

@@ -22,38 +22,21 @@ use time::OffsetDateTime;
 
 use crate::client::helpers::new_interval_stream;
 use crate::client::transmission_buffer::TransmissionBuffer;
+use crate::config;
 pub(crate) use requests::{ReplyControllerMessage, ReplyControllerReceiver, ReplyControllerSender};
 
 pub mod requests;
 
+// this is still left as a separate config so I wouldn't need to replace it everywhere
+// plus its not unreasonable to think that we might need something outside config::ReplySurbs struct
 pub struct Config {
-    min_surb_request_size: u32,
-    max_surb_request_size: u32,
-    maximum_allowed_reply_surb_request_size: u32,
-    max_surb_rerequest_waiting_period: Duration,
-    max_surb_drop_waiting_period: Duration,
-    max_reply_surb_age: Duration,
-    max_reply_key_age: Duration,
+    reply_surbs: config::ReplySurbs,
 }
 
 impl Config {
-    pub(crate) fn new(
-        min_surb_request_size: u32,
-        max_surb_request_size: u32,
-        maximum_allowed_reply_surb_request_size: u32,
-        max_surb_rerequest_waiting_period: Duration,
-        max_surb_drop_waiting_period: Duration,
-        max_reply_surb_age: Duration,
-        max_reply_key_age: Duration,
-    ) -> Self {
+    pub(crate) fn new(reply_surbs_cfg: config::ReplySurbs) -> Self {
         Self {
-            min_surb_request_size,
-            max_surb_request_size,
-            maximum_allowed_reply_surb_request_size,
-            max_surb_rerequest_waiting_period,
-            max_surb_drop_waiting_period,
-            max_reply_surb_age,
-            max_reply_key_age,
+            reply_surbs: reply_surbs_cfg,
         }
     }
 }
@@ -509,9 +492,17 @@ where
         }
 
         // 2. check whether the requested amount is within sane range
-        if amount > self.config.maximum_allowed_reply_surb_request_size {
-            warn!("The requested reply surb amount is larger than our maximum allowed ({amount} > {}). Lowering it to a more sane value...", self.config.maximum_allowed_reply_surb_request_size);
-            amount = self.config.maximum_allowed_reply_surb_request_size;
+        if amount
+            > self
+                .config
+                .reply_surbs
+                .maximum_allowed_reply_surb_request_size
+        {
+            warn!("The requested reply surb amount is larger than our maximum allowed ({amount} > {}). Lowering it to a more sane value...", self.config.reply_surbs.maximum_allowed_reply_surb_request_size);
+            amount = self
+                .config
+                .reply_surbs
+                .maximum_allowed_reply_surb_request_size;
         }
 
         // 3. construct and send the surbs away
@@ -707,8 +698,11 @@ where
         }
 
         let request_size = min(
-            self.config.max_surb_request_size,
-            max(total_queue, self.config.min_surb_request_size),
+            self.config.reply_surbs.maximum_reply_surb_request_size,
+            max(
+                total_queue,
+                self.config.reply_surbs.minimum_reply_surb_request_size,
+            ),
         );
 
         if let Err(err) = self
@@ -744,9 +738,17 @@ where
             };
 
             let diff = now - last_received_time;
+            let max_rerequest_wait = self
+                .config
+                .reply_surbs
+                .maximum_reply_surb_rerequest_waiting_period;
+            let max_drop_wait = self
+                .config
+                .reply_surbs
+                .maximum_reply_surb_drop_waiting_period;
 
-            if diff > self.config.max_surb_rerequest_waiting_period {
-                if diff > self.config.max_surb_drop_waiting_period {
+            if diff > max_rerequest_wait {
+                if diff > max_drop_wait {
                     to_remove.push(*pending_reply_target)
                 } else {
                     debug!("We haven't received any surbs in {:?} from {pending_reply_target}. Going to explicitly ask for more", diff);
@@ -793,7 +795,7 @@ where
             };
             let diff = now - last_received_time;
 
-            if diff > self.config.max_reply_surb_age {
+            if diff > self.config.reply_surbs.maximum_reply_surb_age {
                 info!("it's been {diff:?} since we last received any reply surb from {sender}. Going to remove all stored entries...");
 
                 to_remove_surbs.push(*sender);
@@ -813,7 +815,7 @@ where
 
             let diff = now - sent_at;
 
-            if diff > self.config.max_reply_key_age {
+            if diff > self.config.reply_surbs.maximum_reply_key_age {
                 debug!("it's been {diff:?} since we created this reply key. it's probably never going to get used, so we're going to purge it...");
                 to_remove_keys.push(*digest);
             }
@@ -842,7 +844,8 @@ where
         let mut stale_inspection = new_interval_stream(polling_rate);
 
         // this is in the order of hours/days so we don't have to poll it that often
-        let polling_rate = Duration::from_secs(self.config.max_reply_surb_age.as_secs() / 10);
+        let polling_rate =
+            Duration::from_secs(self.config.reply_surbs.maximum_reply_surb_age.as_secs() / 10);
         let mut invalidation_inspection = new_interval_stream(polling_rate);
 
         while !shutdown.is_shutdown() {

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

@@ -10,7 +10,7 @@ use rand::thread_rng;
 use url::Url;
 
 pub(crate) struct NymApiTopologyProvider {
-    validator_client: validator_client::client::NymApiClient,
+    validator_client: nym_validator_client::client::NymApiClient,
     nym_api_urls: Vec<Url>,
 
     client_version: String,
@@ -22,7 +22,9 @@ impl NymApiTopologyProvider {
         nym_api_urls.shuffle(&mut thread_rng());
 
         NymApiTopologyProvider {
-            validator_client: validator_client::client::NymApiClient::new(nym_api_urls[0].clone()),
+            validator_client: nym_validator_client::client::NymApiClient::new(
+                nym_api_urls[0].clone(),
+            ),
             nym_api_urls,
             client_version,
             currently_used_api: 0,

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

@@ -171,8 +171,6 @@ impl<T> TransmissionBuffer<T> {
         &mut self,
         n: usize,
     ) -> Option<Vec<(TransmissionLane, T)>> {
-        // let start = Instant::now();
-
         if self.buffer.is_empty() {
             return None;
         }
@@ -187,8 +185,6 @@ impl<T> TransmissionBuffer<T> {
             items.push(next)
         }
 
-        // todo!("time time taken");
-
         Some(items)
     }
 

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

@@ -32,6 +32,8 @@ const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_00
 // bandwidth bridging protocol, we can come back to a smaller timeout value
 const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_secs(5 * 60);
 
+const DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO: f64 = 0.70;
+
 // reply-surbs related:
 
 // define when to request
@@ -90,6 +92,11 @@ impl<T> Config<T> {
         Config::default().with_id(id)
     }
 
+    pub fn validate(&self) -> bool {
+        // no other sections have explicit requirements (yet)
+        self.debug.validate()
+    }
+
     #[must_use]
     pub fn with_id<S: Into<String>>(mut self, id: S) -> Self
     where
@@ -356,10 +363,6 @@ impl<T> Config<T> {
         self.debug.traffic.disable_main_poisson_packet_distribution
     }
 
-    pub fn get_use_extended_packet_size(&self) -> Option<ExtendedPacketSize> {
-        self.debug.traffic.use_extended_packet_size
-    }
-
     pub fn get_minimum_reply_surb_storage_threshold(&self) -> usize {
         self.debug.reply_surbs.minimum_reply_surb_storage_threshold
     }
@@ -596,7 +599,7 @@ impl<T: NymConfig> Client<T> {
 pub struct Logging {}
 
 #[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
+#[serde(default)]
 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.
@@ -616,8 +619,27 @@ pub struct Traffic {
     /// poisson distribution.
     pub disable_main_poisson_packet_distribution: bool,
 
-    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
-    pub use_extended_packet_size: Option<ExtendedPacketSize>,
+    /// Specifies the packet size used for sent messages.
+    /// Do not override it unless you understand the consequences of that change.
+    pub primary_packet_size: PacketSize,
+
+    /// Specifies the optional auxiliary packet size for optimizing message streams.
+    /// Note that its use decreases overall anonymity.
+    /// Do not set it it unless you understand the consequences of that change.
+    pub secondary_packet_size: Option<PacketSize>,
+}
+
+impl Traffic {
+    pub fn validate(&self) -> bool {
+        if let Some(secondary_packet_size) = self.secondary_packet_size {
+            if secondary_packet_size == PacketSize::AckPacket
+                || secondary_packet_size == self.primary_packet_size
+            {
+                return false;
+            }
+        }
+        true
+    }
 }
 
 impl Default for Traffic {
@@ -626,7 +648,8 @@ impl Default for Traffic {
             average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
             message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
             disable_main_poisson_packet_distribution: false,
-            use_extended_packet_size: None,
+            primary_packet_size: PacketSize::RegularPacket,
+            secondary_packet_size: None,
         }
     }
 }
@@ -639,6 +662,10 @@ pub struct CoverTraffic {
     #[serde(with = "humantime_serde")]
     pub loop_cover_traffic_average_delay: Duration,
 
+    /// 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,
@@ -648,6 +675,7 @@ impl Default for CoverTraffic {
     fn default() -> Self {
         CoverTraffic {
             loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
+            cover_traffic_primary_size_ratio: DEFAULT_COVER_TRAFFIC_PRIMARY_SIZE_RATIO,
             disable_loop_cover_traffic_stream: false,
         }
     }
@@ -805,12 +833,11 @@ pub struct DebugConfig {
     pub reply_surbs: ReplySurbs,
 }
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum ExtendedPacketSize {
-    Extended8,
-    Extended16,
-    Extended32,
+impl DebugConfig {
+    pub fn validate(&self) -> bool {
+        // no other sections have explicit requirements (yet)
+        self.traffic.validate()
+    }
 }
 
 // it could be derived, sure, but I'd rather have an explicit implementation in case we had to change
@@ -828,13 +855,3 @@ impl Default for DebugConfig {
         }
     }
 }
-
-impl From<ExtendedPacketSize> for PacketSize {
-    fn from(size: ExtendedPacketSize) -> PacketSize {
-        match size {
-            ExtendedPacketSize::Extended8 => PacketSize::ExtendedPacket8,
-            ExtendedPacketSize::Extended16 => PacketSize::ExtendedPacket16,
-            ExtendedPacketSize::Extended32 => PacketSize::ExtendedPacket32,
-        }
-    }
-}

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

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::config::{
-    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, ExtendedPacketSize,
-    GatewayConnection, Logging, ReplySurbs, Topology, Traffic, DEFAULT_ACK_WAIT_ADDITION,
-    DEFAULT_ACK_WAIT_MULTIPLIER, DEFAULT_AVERAGE_PACKET_DELAY, DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
+    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, GatewayConnection, Logging,
+    ReplySurbs, Topology, Traffic, DEFAULT_ACK_WAIT_ADDITION, DEFAULT_ACK_WAIT_MULTIPLIER,
+    DEFAULT_AVERAGE_PACKET_DELAY, DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
     DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY, DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
     DEFAULT_MAXIMUM_REPLY_KEY_AGE, DEFAULT_MAXIMUM_REPLY_SURB_AGE,
     DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD, DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -14,10 +14,29 @@ use crate::config::{
     DEFAULT_TOPOLOGY_REFRESH_RATE, DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
 };
 use nym_config::NymConfig;
+use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::time::Duration;
 
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ExtendedPacketSize {
+    Extended8,
+    Extended16,
+    Extended32,
+}
+
+impl From<ExtendedPacketSize> for PacketSize {
+    fn from(size: ExtendedPacketSize) -> PacketSize {
+        match size {
+            ExtendedPacketSize::Extended8 => PacketSize::ExtendedPacket8,
+            ExtendedPacketSize::Extended16 => PacketSize::ExtendedPacket16,
+            ExtendedPacketSize::Extended32 => PacketSize::ExtendedPacket32,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct OldConfigV1_1_13<T> {
@@ -104,11 +123,13 @@ impl From<OldDebugConfigV1_1_13> for DebugConfig {
                 message_sending_average_delay: value.message_sending_average_delay,
                 disable_main_poisson_packet_distribution: value
                     .disable_main_poisson_packet_distribution,
-                use_extended_packet_size: value.use_extended_packet_size,
+                primary_packet_size: PacketSize::RegularPacket,
+                secondary_packet_size: value.use_extended_packet_size.map(Into::into),
             },
             cover_traffic: CoverTraffic {
                 loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
                 disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
+                ..CoverTraffic::default()
             },
             gateway_connection: GatewayConnection {
                 gateway_response_timeout: value.gateway_response_timeout,

common/client-core/src/error.rs

@@ -1,11 +1,11 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use gateway_client::error::GatewayClientError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_gateway_client::error::GatewayClientError;
 use nym_topology::gateway::GatewayConversionError;
 use nym_topology::NymTopologyError;
-use validator_client::ValidatorClientError;
+use nym_validator_client::ValidatorClientError;
 
 #[derive(thiserror::Error, Debug)]
 pub enum ClientCoreError {

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

@@ -7,11 +7,11 @@ use crate::{
     error::ClientCoreError,
 };
 use futures::{SinkExt, StreamExt};
-use gateway_client::GatewayClient;
-use gateway_requests::registration::handshake::SharedKeys;
 use log::{debug, info, trace, warn};
 use nym_config::NymConfig;
 use nym_crypto::asymmetric::identity;
+use nym_gateway_client::GatewayClient;
+use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_topology::{filter::VersionFilterable, gateway};
 use rand::{seq::SliceRandom, thread_rng, Rng};
 use std::{sync::Arc, time::Duration};
@@ -19,6 +19,8 @@ use tap::TapFallible;
 use tungstenite::Message;
 use url::Url;
 
+#[cfg(not(target_arch = "wasm32"))]
+use nym_validator_client::nyxd::DirectSigningNyxdClient;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::net::TcpStream;
 #[cfg(not(target_arch = "wasm32"))]
@@ -27,14 +29,13 @@ use tokio::time::Instant;
 use tokio_tungstenite::connect_async;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
-#[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::DirectSigningNyxdClient;
 
 #[cfg(not(target_arch = "wasm32"))]
 type WsConn = WebSocketStream<MaybeTlsStream<TcpStream>>;
+use nym_credential_storage::storage::Storage;
 
 #[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::DirectSigningNyxdClient;
+use nym_bandwidth_controller::wasm_mockups::DirectSigningNyxdClient;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer::Instant;
 #[cfg(target_arch = "wasm32")]
@@ -67,7 +68,7 @@ async fn current_gateways<R: Rng>(
     let nym_api = nym_apis
         .choose(rng)
         .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-    let client = validator_client::client::NymApiClient::new(nym_api.clone());
+    let client = nym_validator_client::client::NymApiClient::new(nym_api.clone());
 
     log::trace!("Fetching list of gateways from: {}", nym_api);
 
@@ -223,12 +224,12 @@ pub(super) async fn query_gateway_details(
     }
 }
 
-pub(super) async fn register_with_gateway(
+pub(super) async fn register_with_gateway<St: Storage>(
     gateway: &gateway::Node,
     our_identity: Arc<identity::KeyPair>,
 ) -> Result<Arc<SharedKeys>, ClientCoreError> {
     let timeout = Duration::from_millis(1500);
-    let mut gateway_client: GatewayClient<DirectSigningNyxdClient> = GatewayClient::new_init(
+    let mut gateway_client: GatewayClient<DirectSigningNyxdClient, St> = GatewayClient::new_init(
         gateway.clients_address(),
         gateway.identity_key,
         our_identity.clone(),

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

@@ -11,6 +11,7 @@ use serde::Serialize;
 use tap::TapFallible;
 
 use nym_config::NymConfig;
+use nym_credential_storage::storage::Storage;
 use nym_crypto::asymmetric::{encryption, identity};
 use url::Url;
 
@@ -73,7 +74,7 @@ pub fn new_client_keys() -> KeyManager {
 /// Either pick one at random by querying the available gateways from the nym-api, or use the
 /// chosen one if it's among the available ones.
 /// The shared key is added to the supplied `KeyManager` and the endpoint details are returned.
-pub async fn register_with_gateway(
+pub async fn register_with_gateway<St: Storage>(
     key_manager: &mut KeyManager,
     nym_api_endpoints: Vec<Url>,
     chosen_gateway_id: Option<identity::PublicKey>,
@@ -87,7 +88,7 @@ pub async fn register_with_gateway(
     let our_identity = key_manager.identity_keypair();
 
     // Establish connection, authenticate and generate keys for talking with the gateway
-    let shared_keys = helpers::register_with_gateway(&gateway, our_identity).await?;
+    let shared_keys = helpers::register_with_gateway::<St>(&gateway, our_identity).await?;
     key_manager.insert_gateway_shared_key(shared_keys);
 
     Ok(gateway.into())
@@ -100,7 +101,7 @@ pub async fn register_with_gateway(
 /// b. Create a new gateway configuration but keep existing keys. This assumes that the caller
 ///    knows what they are doing and that the keys match the requested gateway.
 /// c. Create a new gateway configuration with a newly registered gateway and keys.
-pub async fn setup_gateway_from_config<C, T>(
+pub async fn setup_gateway_from_config<C, T, St>(
     register_gateway: bool,
     user_chosen_gateway_id: Option<identity::PublicKey>,
     config: &Config<T>,
@@ -109,6 +110,7 @@ pub async fn setup_gateway_from_config<C, T>(
 where
     C: NymConfig + ClientCoreConfigTrait,
     T: NymConfig,
+    St: Storage,
 {
     let id = config.get_id();
 
@@ -141,7 +143,7 @@ where
 
     // Establish connection, authenticate and generate keys for talking with the gateway
     eprintln!("Registering with new gateway");
-    let shared_keys = helpers::register_with_gateway(&gateway, our_identity).await?;
+    let shared_keys = helpers::register_with_gateway::<St>(&gateway, our_identity).await?;
     key_manager.insert_gateway_shared_key(shared_keys);
 
     // Write all keys to storage and just return the gateway endpoint config. It is assumed that we

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

@@ -1,5 +1,5 @@
 [package]
-name = "gateway-client"
+name = "nym-gateway-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
@@ -14,21 +14,20 @@ log = { workspace = true }
 thiserror = "1.0"
 url = "2.2"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-async-trait = { workspace = true }
 tokio = { version = "1.24.1", features = ["macros"] }
 
 # internal
+nym-bandwidth-controller = { path = "../../bandwidth-controller" }
 nym-coconut-interface = { path = "../../coconut-interface" }
-nym-credentials = { path = "../../credentials" }
+nym-credential-storage = { path = "../../credential-storage" }
 nym-crypto = { path = "../../crypto" }
-gateway-requests = { path = "../../../gateway/gateway-requests" }
+nym-gateway-requests = { path = "../../../gateway/gateway-requests" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-sphinx = { path = "../../nymsphinx" }
 nym-pemstore = { path = "../../pemstore" }
-validator-client = { path = "../validator-client" }
+nym-validator-client = { path = "../validator-client" }
 nym-task = { path = "../../task" }
 serde = { workspace = true, features = ["derive"] }
-mobile-storage = { path = "../../mobile-storage" }
 
 
 [dependencies.tungstenite]
@@ -47,9 +46,6 @@ features = ["net", "sync", "time"]
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 version = "0.14"
 
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.nym-credential-storage]
-path = "../../credential-storage"
-
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2"

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

@@ -1,7 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::bandwidth::BandwidthController;
 use crate::error::GatewayClientError;
 use crate::packet_router::PacketRouter;
 pub use crate::packet_router::{
@@ -10,13 +9,14 @@ pub use crate::packet_router::{
 use crate::socket_state::{PartiallyDelegated, SocketState};
 use crate::{cleanup_socket_message, try_decrypt_binary_message};
 use futures::{SinkExt, StreamExt};
-use gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
-use gateway_requests::iv::IV;
-use gateway_requests::registration::handshake::{client_handshake, SharedKeys};
-use gateway_requests::{BinaryRequest, ClientControlRequest, ServerResponse, PROTOCOL_VERSION};
 use log::*;
+use nym_bandwidth_controller::BandwidthController;
 use nym_coconut_interface::Credential;
 use nym_crypto::asymmetric::identity;
+use nym_gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
+use nym_gateway_requests::iv::IV;
+use nym_gateway_requests::registration::handshake::{client_handshake, SharedKeys};
+use nym_gateway_requests::{BinaryRequest, ClientControlRequest, ServerResponse, PROTOCOL_VERSION};
 use nym_network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_task::TaskClient;
@@ -26,24 +26,14 @@ use std::sync::Arc;
 use std::time::Duration;
 use tungstenite::protocol::Message;
 
+use nym_credential_storage::storage::Storage;
 #[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::traits::DkgQueryClient;
-
+use nym_validator_client::nyxd::traits::DkgQueryClient;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio_tungstenite::connect_async;
 
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(not(target_os = "android"))]
-use nym_credential_storage::PersistentStorage;
-
-#[cfg(not(target_arch = "wasm32"))]
-#[cfg(target_os = "android")]
-use mobile_storage::PersistentStorage;
-
 #[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::DkgQueryClient;
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::PersistentStorage;
+use nym_bandwidth_controller::wasm_mockups::DkgQueryClient;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;
 #[cfg(target_arch = "wasm32")]
@@ -52,7 +42,7 @@ use wasm_utils::websocket::JSWebsocket;
 const DEFAULT_RECONNECTION_ATTEMPTS: usize = 10;
 const DEFAULT_RECONNECTION_BACKOFF: Duration = Duration::from_secs(5);
 
-pub struct GatewayClient<C> {
+pub struct GatewayClient<C, St: Storage> {
     authenticated: bool,
     disabled_credentials_mode: bool,
     bandwidth_remaining: i64,
@@ -63,7 +53,7 @@ pub struct GatewayClient<C> {
     connection: SocketState,
     packet_router: PacketRouter,
     response_timeout_duration: Duration,
-    bandwidth_controller: Option<BandwidthController<C, PersistentStorage>>,
+    bandwidth_controller: Option<BandwidthController<C, St>>,
 
     // reconnection related variables
     /// Specifies whether client should try to reconnect to gateway on connection failure.
@@ -78,9 +68,10 @@ pub struct GatewayClient<C> {
     shutdown: TaskClient,
 }
 
-impl<C> GatewayClient<C>
+impl<C, St> GatewayClient<C, St>
 where
     C: Sync + Send,
+    St: Storage,
 {
     // TODO: put it all in a Config struct
     #[allow(clippy::too_many_arguments)]
@@ -92,7 +83,7 @@ where
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         response_timeout_duration: Duration,
-        bandwidth_controller: Option<BandwidthController<C, PersistentStorage>>,
+        bandwidth_controller: Option<BandwidthController<C, St>>,
         shutdown: TaskClient,
     ) -> Self {
         GatewayClient {
@@ -146,7 +137,7 @@ where
         let shutdown = TaskClient::dummy();
         let packet_router = PacketRouter::new(ack_tx, mix_tx, shutdown.clone());
 
-        GatewayClient::<C> {
+        GatewayClient::<C, St> {
             authenticated: false,
             disabled_credentials_mode: true,
             bandwidth_remaining: 0,

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

@@ -1,15 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::StorageError;
-use gateway_requests::registration::handshake::error::HandshakeError;
-#[cfg(target_os = "android")]
-#[cfg(not(target_arch = "wasm32"))]
-use mobile_storage::StorageError;
-#[cfg(not(target_os = "android"))]
-#[cfg(not(target_arch = "wasm32"))]
-use nym_credential_storage::error::StorageError;
+use nym_gateway_requests::registration::handshake::error::HandshakeError;
 use std::io;
 use thiserror::Error;
 use tungstenite::Error as WsError;
@@ -27,12 +19,6 @@ pub enum GatewayClientError {
     #[error("There was a network error - {0}")]
     NetworkError(#[from] WsError),
 
-    #[error("There was a credential storage error - {0}")]
-    CredentialStorageError(#[from] StorageError),
-
-    #[error("Coconut error - {0}")]
-    CoconutError(#[from] nym_coconut_interface::CoconutError),
-
     // TODO: see if `JsValue` is a reasonable type for this
     #[cfg(target_arch = "wasm32")]
     #[error("There was a network error")]
@@ -47,8 +33,8 @@ pub enum GatewayClientError {
     #[error("No bandwidth controller provided")]
     NoBandwidthControllerAvailable,
 
-    #[error("Credential error - {0}")]
-    CredentialError(#[from] nym_credentials::error::Error),
+    #[error("Bandwidth controller error - {0}")]
+    BandwidthControllerError(#[from] nym_bandwidth_controller::error::BandwidthControllerError),
 
     #[error("Connection was abruptly closed")]
     ConnectionAbruptlyClosed,

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

@@ -3,21 +3,18 @@
 
 use crate::error::GatewayClientError;
 pub use client::GatewayClient;
-use gateway_requests::registration::handshake::SharedKeys;
-use gateway_requests::BinaryResponse;
 use log::warn;
+use nym_gateway_requests::registration::handshake::SharedKeys;
+use nym_gateway_requests::BinaryResponse;
 pub use packet_router::{
     AcknowledgementReceiver, AcknowledgementSender, MixnetMessageReceiver, MixnetMessageSender,
 };
 use tungstenite::{protocol::Message, Error as WsError};
 
-pub mod bandwidth;
 pub mod client;
 pub mod error;
 pub mod packet_router;
 pub mod socket_state;
-#[cfg(target_arch = "wasm32")]
-pub mod wasm_mockups;
 
 /// Helper method for reading from websocket stream. Helps to flatten the structure.
 pub(crate) fn cleanup_socket_message(

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

@@ -7,8 +7,8 @@ use crate::{cleanup_socket_messages, try_decrypt_binary_message};
 use futures::channel::oneshot;
 use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
-use gateway_requests::registration::handshake::SharedKeys;
 use log::*;
+use nym_gateway_requests::registration::handshake::SharedKeys;
 use nym_task::TaskClient;
 use std::sync::Arc;
 use tungstenite::Message;

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

@@ -1,80 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use async_trait::async_trait;
-use std::marker::PhantomData;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum StorageError {
-    #[error("Wasm client is not yet supported")]
-    WasmNotSupported,
-
-    #[allow(dead_code)]
-    #[error("Code shouldn't reach this point")]
-    InconsistentData,
-}
-
-pub struct DirectSigningNyxdClient {}
-
-pub trait DkgQueryClient {}
-
-// impl CosmWasmClient for DirectSigningNyxdClient {}
-
-#[derive(Clone)]
-pub struct Client<C> {
-    _phantom: PhantomData<C>,
-}
-
-impl<C> DkgQueryClient for Client<C> {}
-
-#[derive(Clone)]
-pub struct PersistentStorage {}
-
-pub struct CoconutCredential {
-    pub id: i64,
-    pub voucher_value: String,
-    pub voucher_info: String,
-    pub serial_number: String,
-    pub binding_number: String,
-    pub signature: String,
-    pub epoch_id: String,
-}
-
-#[async_trait]
-pub trait Storage: Send + Sync {
-    async fn insert_coconut_credential(
-        &self,
-        voucher_value: String,
-        voucher_info: String,
-        serial_number: String,
-        binding_number: String,
-        signature: String,
-    ) -> Result<(), StorageError>;
-
-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError>;
-
-    async fn consume_coconut_credential(&self, id: i64) -> Result<(), StorageError>;
-}
-
-#[async_trait]
-impl Storage for PersistentStorage {
-    async fn insert_coconut_credential(
-        &self,
-        _voucher_value: String,
-        _voucher_info: String,
-        _serial_number: String,
-        _binding_number: String,
-        _signature: String,
-    ) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn consume_coconut_credential(&self, _id: i64) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-}

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

@@ -1,5 +1,5 @@
 [package]
-name = "mixnet-client"
+name = "nym-mixnet-client"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"

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

@@ -1,5 +1,5 @@
 [package]
-name = "validator-client"
+name = "nym-validator-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"

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

@@ -5,10 +5,10 @@ use cosmrs::bank::MsgSend;
 use cosmrs::rpc::{self, HttpClient};
 use cosmrs::tx::Msg;
 use cosmrs::{tx, AccountId, Coin, Denom};
-use validator_client::nyxd::CosmWasmClient;
-use validator_client::signing::direct_wallet::DirectSecp256k1HdWallet;
-use validator_client::signing::tx_signer::TxSigner;
-use validator_client::signing::SignerData;
+use nym_validator_client::nyxd::CosmWasmClient;
+use nym_validator_client::signing::direct_wallet::DirectSecp256k1HdWallet;
+use nym_validator_client::signing::tx_signer::TxSigner;
+use nym_validator_client::signing::SignerData;
 
 // run with: cargo run --example offline_signing --features=nyxd-client
 #[tokio::main]

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

@@ -4,7 +4,7 @@
 pub mod client;
 #[cfg(feature = "nyxd-client")]
 pub mod connection_tester;
-mod error;
+pub mod error;
 pub mod nym_api;
 #[cfg(feature = "nyxd-client")]
 pub mod nyxd;

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

@@ -24,8 +24,9 @@ use nym_mixnet_contract_common::{
     MixOwnershipResponse, MixnodeDetailsResponse, NumberOfPendingEventsResponse,
     PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse, PagedFamiliesResponse,
     PagedGatewayResponse, PagedMembersResponse, PagedMixNodeDelegationsResponse,
-    PagedMixnodeBondsResponse, PagedRewardedSetResponse, PendingEpochEventsResponse,
-    PendingIntervalEventsResponse, QueryMsg as MixnetQueryMsg,
+    PagedMixnodeBondsResponse, PagedRewardedSetResponse, PendingEpochEventResponse,
+    PendingEpochEventsResponse, PendingIntervalEventResponse, PendingIntervalEventsResponse,
+    QueryMsg as MixnetQueryMsg,
 };
 use serde::Deserialize;
 
@@ -174,6 +175,16 @@ pub trait MixnetQueryClient {
             .await
     }
 
+    async fn get_mixnode_details_by_identity(
+        &self,
+        mix_identity: IdentityKey,
+    ) -> Result<Option<MixNodeDetails>, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetBondedMixnodeDetailsByIdentity {
+            mix_identity,
+        })
+        .await
+    }
+
     async fn get_mixnode_rewarding_details(
         &self,
         mix_id: MixId,
@@ -374,14 +385,20 @@ pub trait MixnetQueryClient {
             .await
     }
 
-    async fn get_mixnode_details_by_identity(
+    async fn get_pending_epoch_event(
         &self,
-        mix_identity: IdentityKey,
-    ) -> Result<Option<MixNodeDetails>, NyxdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetBondedMixnodeDetailsByIdentity {
-            mix_identity,
-        })
-        .await
+        event_id: EpochEventId,
+    ) -> Result<PendingEpochEventResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingEpochEvent { event_id })
+            .await
+    }
+
+    async fn get_pending_interval_event(
+        &self,
+        event_id: IntervalEventId,
+    ) -> Result<PendingIntervalEventResponse, NyxdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingIntervalEvent { event_id })
+            .await
     }
 
     async fn get_number_of_pending_events(

common/client-libs/validator-client/src/nyxd/traits/mixnet_signing_client.rs

@@ -331,6 +331,38 @@ pub trait MixnetSigningClient {
         .await
     }
 
+    async fn decrease_pledge(
+        &self,
+        decrease_by: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::DecreasePledge {
+                decrease_by: decrease_by.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn decrease_pledge_on_behalf(
+        &self,
+        owner: AccountId,
+        decrease_by: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::DecreasePledgeOnBehalf {
+                owner: owner.to_string(),
+                decrease_by: decrease_by.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+
     async fn unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
         self.execute_mixnet_contract(fee, MixnetExecuteMsg::UnbondMixnode {}, vec![])
             .await

common/client-libs/validator-client/src/nyxd/traits/vesting_signing_client.rs

@@ -91,6 +91,21 @@ pub trait VestingSigningClient {
         .await
     }
 
+    async fn vesting_decrease_pledge(
+        &self,
+        decrease_by: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NyxdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::DecreasePledge {
+                amount: decrease_by.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+
     async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError>;
 
     async fn vesting_track_unbond_mixnode(

common/coconut-interface/Cargo.toml

@@ -10,4 +10,4 @@ getset = "0.1.1"
 serde = { workspace = true, features = ["derive"] }
 thiserror = "1"
 
-nymcoconut = {path = "../nymcoconut" }
+nym-coconut = {path = "../nymcoconut" }

common/coconut-interface/src/error.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nymcoconut::CoconutError;
+use nym_coconut::CoconutError;
 use thiserror::Error;
 
 #[derive(Debug, Error)]

common/coconut-interface/src/lib.rs

@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 
 use error::CoconutInterfaceError;
 
-pub use nymcoconut::*;
+pub use nym_coconut::*;
 
 #[derive(Debug, Serialize, Deserialize, Getters, CopyGetters, Clone, PartialEq, Eq)]
 pub struct Credential {
@@ -64,7 +64,7 @@ impl Credential {
         .iter()
         .map(hash_to_scalar)
         .collect::<Vec<Attribute>>();
-        nymcoconut::verify_credential(&params, verification_key, &self.theta, &public_attributes)
+        nym_coconut::verify_credential(&params, verification_key, &self.theta, &public_attributes)
     }
 
     pub fn as_bytes(&self) -> Vec<u8> {

common/commands/Cargo.toml

@@ -28,7 +28,7 @@ tap = "1"
 cosmrs = { git = "https://github.com/neacsu/cosmos-rust", branch = "neacsu/feegrant_support" }
 cosmwasm-std = { workspace = true }
 
-validator-client = { path = "../client-libs/validator-client", features = ["nyxd-client"] }
+nym-validator-client = { path = "../client-libs/validator-client", features = ["nyxd-client"] }
 nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
 nym-crypto = { path = "../../common/crypto", features = ["asymmetric"] }
 nym-network-defaults = { path = "../network-defaults" }