Add timeouts

getting lane queue lengths in place
WIP
2022-11-22 23:25:06 +01:00 · 2022-11-22 23:07:00 +01:00 · 2022-11-22 21:55:33 +01:00 · 2022-11-22 13:58:53 +01:00 · 2022-11-22 11:49:35 +01:00 · 2022-11-22 11:13:38 +01:00
318 changed files with 4003 additions and 9111 deletions
@@ -5,7 +5,7 @@ on:
    - cron: '5 9 * * *'
 jobs:
  cargo-deny:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository code
        uses: actions/checkout@v2
@@ -26,7 +26,7 @@ jobs:
          path: .github/workflows/support-files/notifications/deny.message
  notification:
    needs: cargo-deny
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - name: Check out repository code
        uses: actions/checkout@v2
@@ -1,6 +1,6 @@
 [
  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"stable",
    "runOnEvent":"always"
  },
@@ -1,21 +1,16 @@
 name: Build release of Nym smart contracts
 on:
  workflow_dispatch:
-  release:
-    types: [created]
+
+defaults:
+  run:
+    working-directory: contracts

 jobs:
  build:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      
-      - name: Check the release tag starts with `nym-contracts-`
-        if: startsWith(github.ref, 'refs/tags/nym-contracts-') == false && github.event_name != 'workflow_dispatch'
-        uses: actions/github-script@v3
-        with:
-          script: |
-            core.setFailed('Release tag did not start with nym-contracts-...')      

      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
@@ -26,7 +21,7 @@ jobs:
          components: rustfmt, clippy

      - name: Build release contracts
-        run: make wasm
+        run: RUSTFLAGS='-C link-arg=-s' cargo build --release --target wasm32-unknown-unknown

      - name: Upload Mixnet Contract Artifact
        uses: actions/upload-artifact@v3
@@ -41,11 +36,3 @@ jobs:
          name: vesting_contract.wasm
          path: contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
          retention-days: 5
-
-      - name: Upload to release based on tag name
-        uses: softprops/action-gh-release@v1
-        if: github.event_name == 'release'
-        with:
-          files: |
-            contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
-            contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm
@@ -10,7 +10,7 @@ on:

 jobs:
  matrix_prep:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -24,7 +24,7 @@ jobs:
  contracts:
    # since it's going to be compiled into wasm, there's absolutely
    # no point in running CI on different OS-es
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    continue-on-error: ${{ matrix.rust == 'nightly' }}
    needs: matrix_prep
    strategy:
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -5,7 +5,7 @@ on:
    - cron: '14 1 * * *'
 jobs:
  matrix_prep:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -25,7 +25,7 @@ jobs:
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-latest'

      - name: Check out repository code
        uses: actions/checkout@v2
@@ -96,7 +96,7 @@ jobs:

      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
        with:
          command: clean

@@ -160,7 +160,7 @@ jobs:

  notification:
    needs: build
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
@@ -1,6 +1,6 @@
 [
  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"stable",
    "runOnEvent":"schedule"
  },
@@ -17,7 +17,7 @@
  },

  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"beta",
    "runOnEvent":"schedule"
  },
@@ -33,7 +33,7 @@
  },

  {
-    "os":"ubuntu-20.04",
+    "os":"ubuntu-latest",
    "rust":"nightly",
    "runOnEvent":"schedule"
  },
@@ -5,19 +5,19 @@ on:
    - cron: '14 2 * * *'
 jobs:
  matrix_prep:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
-      # creates the matrix strategy from nightly_build_matrix_includes.json
+      # creates the matrix strategy from nightly_build_release_matrix.json
      - uses: actions/checkout@v3
      - id: set-matrix
        uses: JoshuaTheMiller/conditional-build-matrix@main
        with:
-          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
+          inputFile: '.github/workflows/nightly_build_release_matrix.json'
          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
  get_release:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    needs: matrix_prep
    outputs:
      output1: ${{ steps.step2.outputs.latest_release }}
@@ -38,7 +38,7 @@ jobs:
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-latest'

      - name: Check out latest release branch
        uses: actions/checkout@v3
@@ -111,7 +111,7 @@ jobs:

      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
        with:
          command: clean

@@ -174,8 +174,8 @@ jobs:
          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-targets -- -D warnings

  notification:
-    needs: [build,get_release]
-    runs-on: ubuntu-20.04
+    needs: build
+    runs-on: ubuntu-latest
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
@@ -192,7 +192,7 @@ jobs:
          NYM_PROJECT_NAME: "Nym nightly build on latest release"
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "https://github.com/nymtech/nym/tree/${{needs.get_release.outputs.output1}}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
@@ -1,203 +0,0 @@
-name: Nightly builds on second latest release
-
-on:
-  schedule:
-    - cron: '24 2 * * *'
-jobs:
-  matrix_prep:
-    runs-on: ubuntu-20.04
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      # creates the matrix strategy from nightly_build_matrix_includes.json
-      - uses: actions/checkout@v3
-      - id: set-matrix
-        uses: JoshuaTheMiller/conditional-build-matrix@main
-        with:
-          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
-          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
-  get_release:
-    runs-on: ubuntu-20.04
-    needs: matrix_prep
-    outputs:
-      output1: ${{ steps.step2.outputs.latest_release }}
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: Fetch all branches
-        run: git fetch --all
-      - name: Set output variable to latest release branch
-        id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+' | tail -n 2 | head -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
-  build:
-    needs: [get_release,matrix_prep]
-    strategy:
-      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
-    steps:
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
-
-      - name: Check out latest release branch
-        uses: actions/checkout@v3
-        with:
-          ref: ${{needs.get_release.outputs.output1}}
-
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
-          components: rustfmt, clippy
-
-      - name: Build all binaries
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run all tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run expensive tests
-        if: github.ref == 'refs/heads/develop' || github.event.pull_request.base.ref == 'develop' || github.event.pull_request.base.ref == 'master'
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace --all-features -- --ignored
-
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - uses: actions-rs/clippy-check@v1
-        name: Clippy checks
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
-
-      - name: Run clippy
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --workspace --all-targets -- -D warnings
-
-      - name: Reclaim some disk space
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
-        with:
-          command: clean
-
-      # COCONUT stuff
-      - name: Build all binaries with coconut enabled
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --features=coconut
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run all tests with coconut enabled
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --workspace --features=coconut
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
-      - name: Run clippy with coconut enabled
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --workspace --all-targets --features=coconut -- -D warnings
-
-      # nym-wallet (the rust part)
-      - name: Build nym-wallet rust code
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path nym-wallet/Cargo.toml --workspace
-
-      - name: Run nym-wallet tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --manifest-path nym-wallet/Cargo.toml --workspace
-
-      - name: Check nym-wallet formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --manifest-path nym-wallet/Cargo.toml --all -- --check
-
-      - name: Run clippy for nym-wallet
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.rust != 'nightly' }}
-        with:
-          command: clippy
-          args: --manifest-path nym-wallet/Cargo.toml --workspace --all-targets -- -D warnings
-
-  notification:
-    needs: [build,get_release]
-    runs-on: ubuntu-20.04
-    steps:
-      - name: Collect jobs status
-        uses: technote-space/workflow-conclusion-action@v2
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: Keybase - Node Install
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Keybase - Send Notification
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        env:
-          NYM_NOTIFICATION_KIND: nightly
-          NYM_PROJECT_NAME: "Nym nightly build on latest release"
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "https://github.com/nymtech/nym/tree/${{needs.get_release.outputs.output1}}"
-          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
-          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "ci-nightly-release"
-          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -0,0 +1,50 @@
+[
+  {
+    "os":"ubuntu-latest",
+    "rust":"stable",
+    "runOnEvent":"workflow_dispatch"
+  },
+
+  {
+    "os":"windows-latest",
+    "rust":"stable",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"stable",
+    "runOnEvent":"workflow_dispatch"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"beta",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"beta",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"beta",
+    "runOnEvent":"workflow_dispatch"
+  },
+
+  {
+    "os":"ubuntu-latest",
+    "rust":"nightly",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"windows-latest",
+    "rust":"nightly",
+    "runOnEvent":"workflow_dispatch"
+  },
+  {
+    "os":"macos-latest",
+    "rust":"nightly",
+    "runOnEvent":"workflow_dispatch"
+  }
+]
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04, windows-latest, macos-latest]
+        platform: [ubuntu-latest, windows-latest, macos-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -41,19 +41,19 @@ jobs:
    - name: Keybase - Node Install
      run: npm install
      working-directory: .github/workflows/support-files
-    - name: Keybase - Send Notification
-      env:
-        NYM_NOTIFICATION_KIND: nym-connect
-        NYM_PROJECT_NAME: "nym-connect"
-        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-        NYM_CI_WWW_LOCATION: "nym-connect-${{ env.GITHUB_REF_SLUG }}"
-        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-        GIT_BRANCH: "${GITHUB_REF##*/}"
-        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
-        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-        KEYBASE_NYM_CHANNEL: "ci-nym-connect"
-        IS_SUCCESS: "${{ job.status == 'success' }}"
-      uses: docker://keybaseio/client:stable-node
-      with:
-        args: .github/workflows/support-files/notifications/entry_point.sh
+#    - name: Keybase - Send Notification
+#      env:
+#        NYM_NOTIFICATION_KIND: nym-connect
+#        NYM_PROJECT_NAME: "nym-connect"
+#        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+#        NYM_CI_WWW_LOCATION: "nym-connect-${{ env.GITHUB_REF_SLUG }}"
+#        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+#        GIT_BRANCH: "${GITHUB_REF##*/}"
+#        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+#        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+#        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+#        KEYBASE_NYM_CHANNEL: "ci-nym-connect"
+#        IS_SUCCESS: "${{ job.status == 'success' }}"
+#      uses: docker://keybaseio/client:stable-node
+#      with:
+#        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -19,7 +19,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -12,7 +12,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -12,7 +12,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-20.04]
+        platform: [ubuntu-latest]
    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v2
@@ -12,7 +12,7 @@ defaults:
 jobs:
  test:
    name: wallet tests
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

@@ -85,7 +85,7 @@ async function getMessageBody(context) {
            ...
          ],
          check_run_url: 'https://api.github.com/repos/nymtech/nym/check-runs/5182940024',
-          labels: [ 'ubuntu-20.04' ],
+          labels: [ 'ubuntu-latest' ],
          runner_id: 1,
          runner_name: 'Hosted Agent',
          runner_group_id: 2,
@@ -7,7 +7,7 @@ on:

 jobs:
  wasm:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2

@@ -2,47 +2,20 @@

 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

-## [v1.1.2]
-
-### Changed
-
- gateway: Renamed flag from `enabled/disabled_credentials_mode` to `only-coconut-credentials`
- "Family" feature for node families + layers
- Initial coconut functionality including credentials and distributed key generation 
-
-## [v1.1.1](https://github.com/nymtech/nym/tree/v1.1.1) (2022-11-29)
+## Unreleased

 ### Added

 - binaries: add `-c` shortform for `--config-env-file`
 - websocket-requests: add server response signalling current packet queue length in the client
- contracts: DKG contract that handles coconut key generation ([#1678][#1708][#1747])
- validator-api: generate coconut keys interactively, using DKG and multisig contracts ([#1678][#1708][#1747])

 ### Changed

 - clients: add concept of transmission lanes to better handle multiple data streams ([#1720])
- clients,validator-api: take coconut signers from the chain instead of specifying them via CLI ([#1747])
- multisig contract: add DKG contract to the list of addresses that can create proposals ([#1747])
 - socks5-client: wait closing inbound connection until data is sent, and throttle incoming data in general ([#1783])
- nym-cli: improve error reporting/handling and changed `vesting-schedule` queries to use query client instead of signing client

-### Fixed
-
- gateway-client: fix decrypting stored messages on reconnect ([#1786])
-
-### Fixed
-
- gateway-client: fix decrypting stored messages on reconnect ([#1786])
- socks5-client: fix shutting down all tasks if anyone of them panics or errors out ([#1805])
-
-[#1678]: https://github.com/nymtech/nym/pull/1678
-[#1708]: https://github.com/nymtech/nym/pull/1708
 [#1720]: https://github.com/nymtech/nym/pull/1720
-[#1747]: https://github.com/nymtech/nym/pull/1747
 [#1783]: https://github.com/nymtech/nym/pull/1783
-[#1786]: https://github.com/nymtech/nym/pull/1786
-[#1805]: https://github.com/nymtech/nym/pull/1805


 ## [v1.1.0](https://github.com/nymtech/nym/tree/v1.1.0) (2022-11-09)
@@ -586,7 +586,7 @@ dependencies = [

 [[package]]
 name = "client-core"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "client-connections",
 "config",
@@ -642,8 +642,6 @@ version = "0.1.0"
 dependencies = [
 "contracts-common",
 "cosmwasm-std",
- "cw-utils",
- "multisig-contract-common",
 "schemars",
 "serde",
 ]
@@ -923,6 +921,7 @@ dependencies = [
 name = "credential"
 version = "0.1.0"
 dependencies = [
+ "async-trait",
 "bip39",
 "cfg-if 0.1.10",
 "clap 3.2.8",
@@ -934,6 +933,7 @@ dependencies = [
 "crypto",
 "network-defaults",
 "pemstore",
+ "pickledb",
 "rand 0.7.3",
 "serde",
 "thiserror",
@@ -963,6 +963,7 @@ dependencies = [
 "crypto",
 "rand 0.7.3",
 "thiserror",
+ "url",
 "validator-api-requests",
 "validator-client",
 ]
@@ -1241,9 +1242,9 @@ dependencies = [

 [[package]]
 name = "cw-utils"
-version = "0.13.4"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dbaecb78c8e8abfd6b4258c7f4fbeb5c49a5e45ee4d910d3240ee8e1d714e1b"
+checksum = "babd2c090f39d07ce5bf2556962305e795daa048ce20a93709eb591476e4a29e"
 dependencies = [
 "cosmwasm-std",
 "schemars",
@@ -1251,23 +1252,11 @@ dependencies = [
 "thiserror",
 ]

-[[package]]
-name = "cw2"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04cf4639517490dd36b333bbd6c4fbd92e325fd0acf4683b41753bc5eb63bfc1"
-dependencies = [
- "cosmwasm-std",
- "cw-storage-plus",
- "schemars",
- "serde",
-]
-
 [[package]]
 name = "cw3"
-version = "0.13.4"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe19462a7f644ba60c19d3443cb90d00c50d9b6b3b0a3a7fca93df8261af979b"
+checksum = "f871854338a54c7bb094d16ffe17212b93b146d9659dbce4c9402a9b77e240ef"
 dependencies = [
 "cosmwasm-std",
 "cw-utils",
@@ -1275,27 +1264,11 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "cw3-fixed-multisig"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df54aa54c13f405ec4ab36b6217538bc957d439eee58f89312db05a79caf6706"
-dependencies = [
- "cosmwasm-std",
- "cw-storage-plus",
- "cw-utils",
- "cw2",
- "cw3",
- "schemars",
- "serde",
- "thiserror",
-]
-
 [[package]]
 name = "cw4"
-version = "0.13.4"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0acc3549d5ce11c6901b3a676f2e2628684722197054d97cd0101ea174ed5cbd"
+checksum = "c4476d6a7c13c46ed9ff260bd0e1cf648dc37b13f483822e1ff2a431f0f6ee52"
 dependencies = [
 "cosmwasm-std",
 "cw-storage-plus",
@@ -1631,7 +1604,7 @@ dependencies = [

 [[package]]
 name = "explorer-api"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "chrono",
 "clap 3.2.8",
@@ -2743,6 +2716,12 @@ dependencies = [
 "vcpkg",
 ]

+[[package]]
+name = "linked-hash-map"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"
+
 [[package]]
 name = "lioness"
 version = "0.1.2"
@@ -2973,7 +2952,6 @@ dependencies = [
 "cosmwasm-std",
 "cw-utils",
 "cw3",
- "cw3-fixed-multisig",
 "cw4",
 "schemars",
 "serde",
@@ -3131,7 +3109,6 @@ dependencies = [
 "pretty_env_logger",
 "serde",
 "serde_json",
- "tap",
 "tokio",
 "validator-client",
 ]
@@ -3157,7 +3134,6 @@ dependencies = [
 "rand 0.6.5",
 "serde",
 "serde_json",
- "tap",
 "thiserror",
 "time 0.3.14",
 "toml",
@@ -3168,7 +3144,7 @@ dependencies = [

 [[package]]
 name = "nym-client"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "clap 3.2.8",
 "client-connections",
@@ -3208,7 +3184,7 @@ dependencies = [

 [[package]]
 name = "nym-gateway"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3255,7 +3231,7 @@ dependencies = [

 [[package]]
 name = "nym-mixnode"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "anyhow",
 "bs58",
@@ -3297,7 +3273,7 @@ dependencies = [

 [[package]]
 name = "nym-network-requester"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "async-trait",
 "clap 3.2.8",
@@ -3345,7 +3321,7 @@ dependencies = [

 [[package]]
 name = "nym-socks5-client"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "clap 3.2.8",
 "client-connections",
@@ -3412,7 +3388,7 @@ dependencies = [

 [[package]]
 name = "nym-validator-api"
-version = "1.1.1"
+version = "1.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3509,7 +3485,6 @@ dependencies = [
 "getrandom 0.2.6",
 "group 0.11.0",
 "itertools",
- "pemstore",
 "rand 0.8.5",
 "rand_chacha 0.3.1",
 "serde",
@@ -3926,6 +3901,19 @@ dependencies = [
 "indexmap",
 ]

+[[package]]
+name = "pickledb"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9161694d67f6c5163519d42be942ae36bbdb55f439460144f105bc4f9f7d1d61"
+dependencies = [
+ "bincode",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+ "serde_yaml",
+]
+
 [[package]]
 name = "pin-project"
 version = "1.0.10"
@@ -5036,6 +5024,18 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "serde_yaml"
+version = "0.8.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a521f2940385c165a24ee286aa8599633d162077a54bdcae2a6fd5a7bfa7a0"
+dependencies = [
+ "indexmap",
+ "ryu",
+ "serde",
+ "yaml-rust",
+]
+
 [[package]]
 name = "sha-1"
 version = "0.8.2"
@@ -5662,9 +5662,7 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 name = "task"
 version = "0.1.0"
 dependencies = [
- "futures",
 "log",
- "thiserror",
 "tokio",
 ]

@@ -5804,18 +5802,18 @@ checksum = "b1141d4d61095b28419e22cb0bbf02755f5e54e0526f97f1e3d1d160e60885fb"

 [[package]]
 name = "thiserror"
-version = "1.0.37"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
+checksum = "c53f98874615aea268107765aa1ed8f6116782501d18e53d08b471733bea6c85"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.37"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
+checksum = "f8b463991b4eab2d801e724172285ec4195c650e8ec79b149e6c2a8e6dd3f783"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -6905,6 +6903,15 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
+
 [[package]]
 name = "yansi"
 version = "0.5.1"
@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.2"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"

@@ -228,9 +228,7 @@ impl LoopCoverTrafficStream<OsRng> {
                    }
                }
            }
-            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-                .await
-                .expect("Task stopped without shutdown called");
+            assert!(shutdown.is_shutdown_poll());
            log::debug!("LoopCoverTrafficStream: Exiting");
        })
    }
@@ -69,8 +69,6 @@ impl MixTrafficController {

    #[cfg(not(target_arch = "wasm32"))]
    pub fn start_with_shutdown(mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        spawn_future(async move {
            debug!("Started MixTrafficController with graceful shutdown support");

@@ -90,9 +88,7 @@ impl MixTrafficController {
                    }
                }
            }
-            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-                .await
-                .expect("Task stopped without shutdown called");
+            assert!(shutdown.is_shutdown_poll());
            log::debug!("MixTrafficController: Exiting");
        })
    }
@@ -1,3 +1,5 @@
+use std::sync::atomic::AtomicBool;
+
 pub mod cover_traffic_stream;
 pub mod inbound_messages;
 pub mod key_manager;
@@ -7,3 +9,10 @@ pub mod received_buffer;
 #[cfg(feature = "reply-surb")]
 pub mod reply_key_storage;
 pub mod topology_control;
+
+// This is *NOT* used to signal shutdown.
+// It's critical that we don't have any tasks finishing early, this is an additional safety check
+// that tasks exiting are doing so because shutdown has been signalled, and no other reason.
+// In particular for tasks that rely on their associated channel being closed to signal shutdown,
+// and don't have access to a shutdown listener channel.
+pub static SHUTDOWN_HAS_BEEN_SIGNALLED: AtomicBool = AtomicBool::new(false);
@@ -72,8 +72,6 @@ impl AcknowledgementListener {

    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started AcknowledgementListener with graceful shutdown support");

        while !shutdown.is_shutdown() {
@@ -90,9 +88,7 @@ impl AcknowledgementListener {
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("AcknowledgementListener: Exiting");
    }

@@ -272,9 +272,7 @@ impl ActionController {
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("ActionController: Exiting");
    }

@@ -187,17 +187,19 @@ where
        // there's no point in trying to send nothing
        if let Some(real_messages) = real_messages {
            // tells real message sender (with the poisson timer) to send this to the mix network
-            self.real_message_sender
+            if self
+                .real_message_sender
                .send((real_messages, lane))
                .await
-                .expect("BatchRealMessageReceiver has stopped receiving!");
+                .is_err()
+            {
+                panic!();
+            }
        }
    }

    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started InputMessageListener with graceful shutdown support");

        while !shutdown.is_shutdown() {
@@ -216,9 +218,7 @@ where
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("InputMessageListener: Exiting");
    }

@@ -116,19 +116,21 @@ where
            .unwrap();

        // send to `OutQueueControl` to eventually send to the mix network
-        self.real_message_sender
+        if self
+            .real_message_sender
            .send((
                vec![RealMessage::new(prepared_fragment.mix_packet, frag_id)],
                TransmissionLane::Retransmission,
            ))
            .await
-            .expect("BatchRealMessageReceiver has stopped receiving!");
+            .is_err()
+        {
+            panic!();
+        }
    }

    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started RetransmissionRequestListener with graceful shutdown support");

        while !shutdown.is_shutdown() {
@@ -145,9 +147,7 @@ where
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("RetransmissionRequestListener: Exiting");
    }

@@ -16,7 +16,7 @@ use crate::{
    },
    spawn_future,
 };
-use client_connections::{ConnectionCommandReceiver, LaneQueueLengths};
+use client_connections::{ClosedConnectionReceiver, LaneQueueLengths};
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
@@ -115,7 +115,7 @@ impl RealMessagesController<OsRng> {
        topology_access: TopologyAccessor,
        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
        lane_queue_lengths: LaneQueueLengths,
-        client_connection_rx: ConnectionCommandReceiver,
+        closed_connection_rx: ClosedConnectionReceiver,
    ) -> Self {
        let rng = OsRng;

@@ -166,7 +166,7 @@ impl RealMessagesController<OsRng> {
            config.self_recipient,
            topology_access,
            lane_queue_lengths,
-            client_connection_rx,
+            closed_connection_rx,
        );

        RealMessagesController {
@@ -5,7 +5,7 @@ use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
 use client_connections::{
-    ConnectionCommand, ConnectionCommandReceiver, ConnectionId, LaneQueueLengths, TransmissionLane,
+    ClosedConnectionReceiver, ConnectionCommand, ConnectionId, LaneQueueLengths, TransmissionLane,
 };
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
@@ -134,13 +134,12 @@ where

    /// Incoming channel for being notified of closed connections, so that we can close lanes
    /// corresponding to connections. To avoid sending traffic unnecessary
-    client_connection_rx: ConnectionCommandReceiver,
+    closed_connection_rx: ClosedConnectionReceiver,

    /// Report queue lengths so that upstream can backoff sending data, and keep connections open.
    lane_queue_lengths: LaneQueueLengths,
 }

-#[derive(Debug)]
 pub(crate) struct RealMessage {
    mix_packet: MixPacket,
    fragment_id: FragmentIdentifier,
@@ -183,7 +182,7 @@ where
        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
        lane_queue_lengths: LaneQueueLengths,
-        client_connection_rx: ConnectionCommandReceiver,
+        closed_connection_rx: ClosedConnectionReceiver,
    ) -> Self {
        OutQueueControl {
            config,
@@ -197,7 +196,7 @@ where
            rng,
            topology_access,
            transmission_buffer: Default::default(),
-            client_connection_rx,
+            closed_connection_rx,
            lane_queue_lengths,
        }
    }
@@ -254,7 +253,7 @@ where
        };

        if let Err(err) = self.mix_tx.send(vec![next_message]).await {
-            log::error!("Failed to send: {}", err);
+            log::error!("Failed to send - channel closed: {}", err);
        }

        // notify ack controller about sending our message only after we actually managed to push it
@@ -263,7 +262,7 @@ where
            self.sent_notify(fragment_id);
        }

-        // In addition to closing connections on receiving messages throught client_connection_rx,
+        // In addition to closing connections on receiving messages throught closed_connection_rx,
        // also close connections when sufficiently stale.
        self.transmission_buffer.prune_stale_connections();

@@ -336,7 +335,7 @@ where
        // Start by checking if we have any incoming messages about closed connections
        // NOTE: this feels a bit iffy, the `OutQueueControl` is getting ripe for a rewrite to
        // something simpler.
-        if let Poll::Ready(Some(id)) = Pin::new(&mut self.client_connection_rx).poll_next(cx) {
+        if let Poll::Ready(Some(id)) = Pin::new(&mut self.closed_connection_rx).poll_next(cx) {
            match id {
                ConnectionCommand::Close(id) => self.on_close_connection(id),
                ConnectionCommand::ActiveConnections(_) => panic!(),
@@ -415,7 +414,7 @@ where

    fn poll_immediate(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
        // Start by checking if we have any incoming messages about closed connections
-        if let Poll::Ready(Some(id)) = Pin::new(&mut self.client_connection_rx).poll_next(cx) {
+        if let Poll::Ready(Some(id)) = Pin::new(&mut self.closed_connection_rx).poll_next(cx) {
            match id {
                ConnectionCommand::Close(id) => self.on_close_connection(id),
                ConnectionCommand::ActiveConnections(_) => panic!(),
@@ -465,32 +464,16 @@ 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 {
-            format!(
+        if self.config.disable_poisson_packet_distribution {
+            log::info!(
                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), no delay",
                backlog
-            )
+            );
        } else {
-            format!(
+            log::info!(
                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), avg delay: {}ms ({mult})",
-                backlog, delay
-            )
-        };
-        if packets > 1000 {
-            log::warn!("{status_str}");
-        } else if packets > 0 {
-            log::info!("{status_str}");
-        } else {
-            log::debug!("{status_str}");
-        }
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn log_status_infrequent(&self) {
-        if self.sending_delay_controller.current_multiplier() > 1 {
-            log::warn!(
-                "Unable to send packets fast enough - sending delay multiplier set to: {}",
-                self.sending_delay_controller.current_multiplier()
+                backlog,
+                delay
            );
        }
    }
@@ -499,8 +482,7 @@ where
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
        debug!("Started OutQueueControl with graceful shutdown support");

-        let mut status_timer = tokio::time::interval(Duration::from_secs(5));
-        let mut infrequent_status_timer = tokio::time::interval(Duration::from_secs(60));
+        let mut status_timer = tokio::time::interval(Duration::from_secs(1));

        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -511,9 +493,6 @@ where
                _ = status_timer.tick() => {
                    self.log_status();
                }
-                _ = 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 {
@@ -522,9 +501,7 @@ where
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("OutQueueControl: Exiting");
    }

@@ -82,7 +82,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
            );
@@ -322,8 +322,6 @@ impl RequestReceiver {

    #[cfg(not(target_arch = "wasm32"))]
    async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started RequestReceiver with graceful shutdown support");
        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -342,9 +340,7 @@ impl RequestReceiver {
                },
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("RequestReceiver: Exiting");
    }

@@ -376,8 +372,6 @@ impl FragmentedMessageReceiver {

    #[cfg(not(target_arch = "wasm32"))]
    async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started FragmentedMessageReceiver with graceful shutdown support");
        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -395,9 +389,7 @@ impl FragmentedMessageReceiver {
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(shutdown.is_shutdown_poll());
        log::debug!("FragmentedMessageReceiver: Exiting");
    }

@@ -138,7 +138,7 @@ impl TopologyRefresherConfig {
 }

 pub struct TopologyRefresher {
-    validator_client: validator_client::client::ApiClient,
+    validator_client: validator_client::ApiClient,
    client_version: String,

    validator_api_urls: Vec<Url>,
@@ -154,9 +154,7 @@ impl TopologyRefresher {
        cfg.validator_api_urls.shuffle(&mut thread_rng());

        TopologyRefresher {
-            validator_client: validator_client::client::ApiClient::new(
-                cfg.validator_api_urls[0].clone(),
-            ),
+            validator_client: validator_client::ApiClient::new(cfg.validator_api_urls[0].clone()),
            client_version: cfg.client_version,
            validator_api_urls: cfg.validator_api_urls,
            topology_accessor,
@@ -186,10 +184,13 @@ impl TopologyRefresher {
    /// # Arguments
    ///
    /// * `topology`: active topology constructed from validator api data
-    fn check_layer_distribution(&self, active_topology: &NymTopology) -> bool {
+    /// * `mixnodes_count`: total number of active mixnodes
+    fn check_layer_distribution(
+        &self,
+        active_topology: &NymTopology,
+        mixnodes_count: usize,
+    ) -> bool {
        let mixes = active_topology.mixes();
-        let mixnodes_count = active_topology.num_mixnodes();
-
        if active_topology.gateways().is_empty() {
            return false;
        }
@@ -254,10 +255,11 @@ impl TopologyRefresher {
            Ok(gateways) => gateways,
        };

+        let mixnodes_count = mixnodes.len();
        let topology = nym_topology_from_detailed(mixnodes, gateways)
            .filter_system_version(&self.client_version);

-        if !self.check_layer_distribution(&topology) {
+        if !self.check_layer_distribution(&topology, mixnodes_count) {
            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
            None
        } else {
@@ -307,9 +309,7 @@ impl TopologyRefresher {
                    },
                }
            }
-            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-                .await
-                .expect("Task stopped without shutdown called");
+            assert!(shutdown.is_shutdown_poll());
            log::debug!("TopologyRefresher: Exiting");
        })
    }
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use config::{NymConfig, DB_FILE_NAME};
+use config::NymConfig;
 use nymsphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
@@ -125,10 +125,6 @@ impl<T: NymConfig> Config<T> {
        self.client.gateway_endpoint.gateway_id = id.into();
    }

-    pub fn set_custom_validators(&mut self, validator_urls: Vec<Url>) {
-        self.client.validator_urls = validator_urls;
-    }
-
    pub fn set_custom_validator_apis(&mut self, validator_api_urls: Vec<Url>) {
        self.client.validator_api_urls = validator_api_urls;
    }
@@ -183,10 +179,6 @@ impl<T: NymConfig> Config<T> {
        self.client.ack_key_file.clone()
    }

-    pub fn get_validator_endpoints(&self) -> Vec<Url> {
-        self.client.validator_urls.clone()
-    }
-
    pub fn get_validator_api_endpoints(&self) -> Vec<Url> {
        self.client.validator_api_urls.clone()
    }
@@ -314,10 +306,6 @@ pub struct Client<T> {
    #[serde(default)]
    disabled_credentials_mode: bool,

-    /// Addresses to nymd validators via which the client can communicate with the chain.
-    #[serde(default)]
-    validator_urls: Vec<Url>,
-
    /// Addresses to APIs running on validator from which the client gets the view of the network.
    validator_api_urls: Vec<Url>,

@@ -366,7 +354,6 @@ impl<T: NymConfig> Default for Client<T> {
            version: env!("CARGO_PKG_VERSION").to_string(),
            id: "".to_string(),
            disabled_credentials_mode: true,
-            validator_urls: vec![],
            validator_api_urls: vec![],
            private_identity_key_file: Default::default(),
            public_identity_key_file: Default::default(),
@@ -412,7 +399,7 @@ impl<T: NymConfig> Client<T> {
        T::default_data_directory(Some(id)).join("reply_key_store")
    }
    fn default_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join(DB_FILE_NAME)
+        T::default_data_directory(Some(id)).join("db.sqlite")
    }
 }

@@ -26,7 +26,4 @@ pub enum ClientCoreError {
    CouldNotLoadExistingGatewayConfiguration(std::io::Error),
    #[error("The current network topology seem to be insufficient to route any packets through")]
    InsufficientNetworkTopology,
-
-    #[error("Unexpected exit")]
-    UnexpectedExit,
 }
@@ -31,7 +31,7 @@ pub async fn query_gateway_details(
    let validator_api = validator_servers
        .choose(&mut thread_rng())
        .ok_or(ClientCoreError::ListOfValidatorApisIsEmpty)?;
-    let validator_client = validator_client::client::ApiClient::new(validator_api.clone());
+    let validator_client = validator_client::ApiClient::new(validator_api.clone());

    log::trace!("Fetching list of gateways from: {}", validator_api);
    let gateways = validator_client.get_cached_gateways().await?;
@@ -6,9 +6,11 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
+async-trait = "0.1.52"
 bip39 = "1.0.1"
 cfg-if = "0.1"
 clap = { version = "3.2", features = ["cargo", "derive"] }
+pickledb = "0.4.1"
 rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
@@ -1,29 +1,34 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use async_trait::async_trait;
 use clap::{Args, Subcommand};
 use completions::ArgShell;
+use pickledb::PickleDb;
 use rand::rngs::OsRng;
 use std::str::FromStr;

-use coconut_interface::{Base58, Parameters};
+use coconut_interface::{Attribute, Base58, BlindSignRequest, Bytable, Parameters};
 use credential_storage::storage::Storage;
 use credential_storage::PersistentStorage;
 use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 use credentials::coconut::utils::obtain_aggregate_signature;
 use crypto::asymmetric::{encryption, identity};
-use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
+use network_defaults::VOUCHER_INFO;
 use validator_client::nymd::tx::Hash;
-use validator_client::{CoconutApiClient, Config};

 use crate::client::Client;
 use crate::error::{CredentialClientError, Result};
-use crate::state::{KeyPair, State};
+use crate::state::{KeyPair, RequestData, State};

 #[derive(Subcommand)]
-pub(crate) enum Command {
-    /// Run the binary
-    Run(Run),
+pub(crate) enum Commands {
+    /// Deposit funds for buying coconut credential
+    Deposit(Deposit),
+    /// Lists the tx hashes of previous deposits
+    ListDeposits(ListDeposits),
+    /// Get a credential for a given deposit
+    GetCredential(GetCredential),

    /// Generate shell completions
    Completions(ArgShell),
@@ -32,81 +37,163 @@ pub(crate) enum Command {
    GenerateFigSpec,
 }

-#[derive(Args)]
-pub(crate) struct Run {
-    /// Home directory of the client that is supposed to use the credential.
-    #[clap(long)]
-    pub(crate) client_home_directory: std::path::PathBuf,
+#[async_trait]
+pub(crate) trait Execute {
+    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()>;
+}

+#[derive(Args, Clone)]
+pub(crate) struct Deposit {
    /// The nymd URL that should be used
    #[clap(long)]
-    pub(crate) nymd_url: String,
-
-    /// A mnemonic for the account that buys the credential
+    nymd_url: String,
+    /// A mnemonic for the account that does the deposit
    #[clap(long)]
-    pub(crate) mnemonic: String,
-
-    /// The amount of utokens the credential will hold
+    mnemonic: String,
+    /// The amount that needs to be deposited
    #[clap(long)]
-    pub(crate) amount: u64,
+    amount: u64,
 }

-pub(crate) async fn deposit(nymd_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));
+#[async_trait]
+impl Execute for Deposit {
+    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+        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 client = Client::new(nymd_url, mnemonic);
-    let tx_hash = client
-        .deposit(
-            amount,
-            signing_keypair.public_key.clone(),
-            encryption_keypair.public_key.clone(),
-            None,
-        )
-        .await?;
+        let client = Client::new(&self.nymd_url, &self.mnemonic);
+        let tx_hash = client
+            .deposit(
+                self.amount,
+                signing_keypair.public_key.clone(),
+                encryption_keypair.public_key.clone(),
+                None,
+            )
+            .await?;

-    let state = State {
-        amount,
-        tx_hash,
-        signing_keypair,
-        encryption_keypair,
-    };
+        let state = State {
+            amount: self.amount,
+            tx_hash: tx_hash.clone(),
+            signing_keypair,
+            encryption_keypair,
+            blind_request_data: None,
+            signature: None,
+        };
+        db.set(&tx_hash, &state).unwrap();

-    Ok(state)
+        println!("{:?}", state);
+
+        Ok(())
+    }
 }

-pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStorage) -> Result<()> {
-    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 coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client).await?;
+#[derive(Args, Clone)]
+pub(crate) struct ListDeposits {}

-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-    let bandwidth_credential_attributes = BandwidthVoucher::new(
-        &params,
-        state.amount.to_string(),
-        VOUCHER_INFO.to_string(),
-        Hash::from_str(&state.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
-        identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
-        encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
-    );
+#[async_trait]
+impl Execute for ListDeposits {
+    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
+        for kv in db.iter() {
+            println!("{:?}", kv.get_value::<State>());
+        }

-    let signature = obtain_aggregate_signature(
-        &params,
-        &bandwidth_credential_attributes,
-        &coconut_api_clients,
-    )
-    .await?;
-    shared_storage
-        .insert_coconut_credential(
-            state.amount.to_string(),
-            VOUCHER_INFO.to_string(),
-            bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
-            bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
-            signature.to_bs58(),
-        )
-        .await?;
-
-    Ok(())
+        Ok(())
+    }
+}
+
+#[derive(Args, Clone)]
+pub(crate) struct GetCredential {
+    /// The hash of a successful deposit transaction
+    #[clap(long)]
+    tx_hash: String,
+    /// The URLs to the validator-api endpoints the are run as coconut signer authorities, separated
+    /// by comma (,)
+    #[clap(long)]
+    signer_authorities: String,
+    /// If we want to get the signature without attaching a blind sign request; it is expected that
+    /// there is already a signature stored on the signer
+    #[clap(long, parse(from_flag))]
+    __no_request: bool,
+}
+
+#[async_trait]
+impl Execute for GetCredential {
+    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()> {
+        let mut state = db
+            .get::<State>(&self.tx_hash)
+            .ok_or(CredentialClientError::NoDeposit)?;
+
+        let urls = config::parse_validators(&self.signer_authorities);
+
+        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+        let bandwidth_credential_attributes = if self.__no_request {
+            if let Some(blind_request_data) = state.blind_request_data {
+                let serial_number =
+                    Attribute::try_from_byte_slice(&blind_request_data.serial_number)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                let binding_number =
+                    Attribute::try_from_byte_slice(&blind_request_data.binding_number)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                let pedersen_commitments_openings = vec![
+                    Attribute::try_from_byte_slice(&blind_request_data.first_attribute)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
+                    Attribute::try_from_byte_slice(&blind_request_data.second_attribute)
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
+                ];
+                let blind_sign_request =
+                    BlindSignRequest::from_bytes(blind_request_data.blind_sign_req.as_slice())
+                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
+                BandwidthVoucher::new_with_blind_sign_req(
+                    [serial_number, binding_number],
+                    [&state.amount.to_string(), VOUCHER_INFO],
+                    Hash::from_str(&self.tx_hash)
+                        .map_err(|_| CredentialClientError::InvalidTxHash)?,
+                    identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
+                    encryption::PrivateKey::from_base58_string(
+                        &state.encryption_keypair.private_key,
+                    )?,
+                    pedersen_commitments_openings,
+                    blind_sign_request,
+                )
+            } else {
+                return Err(CredentialClientError::NoLocalBlindSignRequest);
+            }
+        } else {
+            BandwidthVoucher::new(
+                &params,
+                state.amount.to_string(),
+                VOUCHER_INFO.to_string(),
+                Hash::from_str(&self.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
+                identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
+                encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
+            )
+        };
+
+        // Back up the blind sign req data, in case of sporadic failures
+        state.blind_request_data = Some(RequestData::new(
+            bandwidth_credential_attributes.get_private_attributes(),
+            bandwidth_credential_attributes.pedersen_commitments_openings(),
+            bandwidth_credential_attributes.blind_sign_request(),
+        )?);
+        db.set(&self.tx_hash, &state).unwrap();
+
+        let signature =
+            obtain_aggregate_signature(&params, &bandwidth_credential_attributes, &urls).await?;
+        shared_storage
+            .insert_coconut_credential(
+                state.amount.to_string(),
+                VOUCHER_INFO.to_string(),
+                bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
+                bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
+                signature.to_bs58(),
+            )
+            .await?;
+        state.signature = Some(signature.to_bs58());
+        db.set(&self.tx_hash, &state).unwrap();
+
+        println!("Signature: {:?}", state.signature);
+
+        Ok(())
+    }
 }
@@ -8,7 +8,6 @@ use credentials::error::Error as CredentialError;
 use crypto::asymmetric::encryption::KeyRecoveryError;
 use crypto::asymmetric::identity::Ed25519RecoveryError;
 use validator_client::nymd::error::NymdError;
-use validator_client::ValidatorClientError;

 pub type Result<T> = std::result::Result<T, CredentialClientError>;

@@ -17,12 +16,21 @@ pub enum CredentialClientError {
    #[error("Nymd error: {0}")]
    Nymd(#[from] NymdError),

-    #[error("Validator client error: {0}")]
-    ValidatorClientError(#[from] ValidatorClientError),
-
    #[error("Credential error: {0}")]
    Credential(#[from] CredentialError),

+    #[error("No previous deposit with that tx hash")]
+    NoDeposit,
+
+    #[error("Wrong number of attributes")]
+    WrongAttributeNumber,
+
+    #[error("Could not find any backed up blind sign request data")]
+    NoLocalBlindSignRequest,
+
+    #[error("The local blind sign request data is corrupted")]
+    CorruptedBlindSignRequest,
+
    #[error("The tx hash provided is not valid")]
    InvalidTxHash,

@@ -9,13 +9,14 @@ cfg_if::cfg_if! {
        mod error;
        mod state;

+        use commands::{Commands, Execute};
        use error::Result;
        use network_defaults::setup_env;
+        use clap::CommandFactory;
        use completions::fig_generate;
-        use commands::*;
-        use config::{DATA_DIR, DB_FILE_NAME};

-        use clap::{CommandFactory, Parser};
+        use clap::Parser;
+        use pickledb::{PickleDb, PickleDbDumpPolicy, SerializationMethod};

        #[derive(Parser)]
        #[clap(author = "Nymtech", version, about)]
@@ -24,26 +25,43 @@ cfg_if::cfg_if! {
            #[clap(short, long)]
            pub(crate) config_env_file: Option<std::path::PathBuf>,

+            /// Path where the sqlite credental database will be located.
+            /// It should point to a $HOME/$CLIENT_ID/data/db.sqlite file of
+            /// the client that is supposed to use the credential.
+            #[clap(long)]
+            pub(crate) credential_db_path: std::path::PathBuf,
+
            #[clap(subcommand)]
-            pub(crate) command: Command,
+            command: Commands,
        }

        #[tokio::main]
        async fn main() -> Result<()> {
            let args = Cli::parse();
            setup_env(args.config_env_file.clone());
+
+            let shared_storage = credential_storage::initialise_storage(args.credential_db_path.clone()).await;
+            let mut db = match PickleDb::load(
+                "credential.db",
+                PickleDbDumpPolicy::AutoDump,
+                SerializationMethod::Json,
+            ) {
+                Ok(db) => db,
+                Err(_) => PickleDb::new(
+                    "credential.db",
+                    PickleDbDumpPolicy::AutoDump,
+                    SerializationMethod::Json,
+                ),
+            };
+
            let bin_name = "nym-credential-client";

-            match args.command {
-                Command::Run(r) => {
-                    let db_path = r.client_home_directory.join(DATA_DIR).join(DB_FILE_NAME);
-                    let shared_storage = credential_storage::initialise_storage(db_path).await;
-
-                    let state = deposit(&r.nymd_url, &r.mnemonic, r.amount).await?;
-                    get_credential(&state, shared_storage).await?;
-                }
-                Command::Completions(c) => c.generate(&mut crate::Cli::into_app(), bin_name),
-                Command::GenerateFigSpec => fig_generate(&mut crate::Cli::into_app(), bin_name)
+            match &args.command {
+                Commands::Deposit(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::ListDeposits(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::GetCredential(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::Completions(s) => s.generate(&mut crate::Cli::into_app(), bin_name),
+                Commands::GenerateFigSpec => fig_generate(&mut crate::Cli::into_app(), bin_name)
            }

            Ok(())
@@ -1,10 +1,13 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use coconut_interface::{Attribute, BlindSignRequest, Bytable, PrivateAttribute};
 use serde::{Deserialize, Serialize};

 use crypto::asymmetric::{encryption, identity};

+use crate::error::{CredentialClientError, Result};
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct KeyPair {
    pub public_key: String,
@@ -35,4 +38,35 @@ pub(crate) struct State {
    pub tx_hash: String,
    pub signing_keypair: KeyPair,
    pub encryption_keypair: KeyPair,
+    pub blind_request_data: Option<RequestData>,
+    pub signature: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub(crate) struct RequestData {
+    pub serial_number: Vec<u8>,
+    pub binding_number: Vec<u8>,
+    pub first_attribute: Vec<u8>,
+    pub second_attribute: Vec<u8>,
+    pub blind_sign_req: Vec<u8>,
+}
+
+impl RequestData {
+    pub fn new(
+        private_attributes: Vec<PrivateAttribute>,
+        attributes: &[Attribute],
+        blind_sign_request: &BlindSignRequest,
+    ) -> Result<Self> {
+        if private_attributes.len() != 2 || attributes.len() != 2 {
+            Err(CredentialClientError::WrongAttributeNumber)
+        } else {
+            Ok(RequestData {
+                serial_number: private_attributes[0].to_byte_vec(),
+                binding_number: private_attributes[1].to_byte_vec(),
+                first_attribute: attributes[0].to_byte_vec(),
+                second_attribute: attributes[1].to_byte_vec(),
+                blind_sign_req: blind_sign_request.to_bytes(),
+            })
+        }
+    }
 }
@@ -1,10 +1,10 @@
 [package]
 name = "nym-client"
-version = "1.1.2"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
-rust-version = "1.65"
+rust-version = "1.56"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -43,7 +43,7 @@ async fn send_file_with_reply() {
        recipient,
        message: read_data,
        with_reply_surb: true,
-        connection_id: Some(0),
+        connection_id: 0,
    };

    println!("sending content of 'dummy_file' over the mix network...");
@@ -92,7 +92,7 @@ async fn send_file_without_reply() {
        recipient,
        message: read_data,
        with_reply_surb: false,
-        connection_id: Some(0),
+        connection_id: 0,
    };

    println!("sending content of 'dummy_file' over the mix network...");
@@ -23,13 +23,6 @@ id = '{{ client.id }}'
 # to claim bandwidth without presenting bandwidth credentials.
 disabled_credentials_mode = {{ client.disabled_credentials_mode }}

-# Addresses to nymd validators via which the client can communicate with the chain.
-validator_urls = [
-    {{#each client.validator_urls }}
-        '{{this}}',
-    {{/each}}
-]
-
 # Addresses to APIs running on validator from which the client gets the view of the network.
 validator_api_urls = [
    {{#each client.validator_api_urls }}
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use client_connections::{
-    ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths, TransmissionLane,
+    ClosedConnectionReceiver, ClosedConnectionSender, LaneQueueLengths, TransmissionLane,
 };
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
@@ -123,7 +123,7 @@ impl NymClient {
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
        lane_queue_lengths: LaneQueueLengths,
-        client_connection_rx: ConnectionCommandReceiver,
+        closed_connection_rx: ClosedConnectionReceiver,
        shutdown: ShutdownListener,
    ) {
        let mut controller_config = real_messages_control::Config::new(
@@ -154,7 +154,7 @@ impl NymClient {
            topology_accessor,
            reply_key_storage,
            lane_queue_lengths,
-            client_connection_rx,
+            closed_connection_rx,
        )
        .start_with_shutdown(shutdown);
    }
@@ -201,37 +201,11 @@ impl NymClient {
            .expect("provided gateway id is invalid!");

        #[cfg(feature = "coconut")]
-        let bandwidth_controller = {
-            let details = 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 nymd_url = self
-                .config
-                .get_base()
-                .get_validator_endpoints()
-                .pop()
-                .expect("No nymd validator endpoint provided");
-            let api_url = self
-                .config
-                .get_base()
-                .get_validator_api_endpoints()
-                .pop()
-                .expect("No validator api endpoint provided");
-            // overwrite env configuration with config URLs
-            client_config = client_config.with_urls(nymd_url, api_url);
-            let client = validator_client::Client::new_query(client_config)
-                .expect("Could not construct query client");
-            let coconut_api_clients =
-                validator_client::CoconutApiClient::all_coconut_api_clients(&client)
-                    .await
-                    .expect("Could not query api clients");
-            BandwidthController::new(
-                credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                    .await,
-                coconut_api_clients,
-            )
-        };
+        let bandwidth_controller = BandwidthController::new(
+            credential_storage::initialise_storage(self.config.get_base().get_database_path())
+                .await,
+            self.config.get_base().get_validator_api_endpoints(),
+        );
        #[cfg(not(feature = "coconut"))]
        let bandwidth_controller = BandwidthController::new(
            credential_storage::initialise_storage(self.config.get_base().get_database_path())
@@ -315,13 +289,13 @@ impl NymClient {
        buffer_requester: ReceivedBufferRequestSender,
        msg_input: InputMessageSender,
        shared_lane_queue_lengths: LaneQueueLengths,
-        client_connection_tx: ConnectionCommandSender,
+        closed_connection_tx: ClosedConnectionSender,
    ) {
        info!("Starting websocket listener...");

        let websocket_handler = websocket::Handler::new(
            msg_input,
-            client_connection_tx,
+            closed_connection_tx,
            buffer_requester,
            &self.as_mix_recipient(),
            shared_lane_queue_lengths,
@@ -342,12 +316,16 @@ impl NymClient {
        let lane = TransmissionLane::General;
        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb, lane);

-        self.input_tx
+        if self
+            .input_tx
            .as_ref()
            .expect("start method was not called before!")
            .send(input_msg)
            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+            .is_err()
+        {
+            panic!();
+        }
    }

    /// EXPERIMENTAL DIRECT RUST API
@@ -356,12 +334,16 @@ impl NymClient {
    pub async fn send_reply(&mut self, reply_surb: ReplySurb, message: Vec<u8>) {
        let input_msg = InputMessage::new_reply(reply_surb, message);

-        self.input_tx
+        if self
+            .input_tx
            .as_ref()
            .expect("start method was not called before!")
            .send(input_msg)
            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+            .is_err()
+        {
+            panic!();
+        }
    }

    /// EXPERIMENTAL DIRECT RUST API
@@ -458,7 +440,7 @@ impl NymClient {

        // Channels that the websocket listener can use to signal downstream to the real traffic
        // controller that connections are closed.
-        let (client_connection_tx, client_connection_rx) = mpsc::unbounded();
+        let (closed_connection_tx, closed_connection_rx) = mpsc::unbounded();

        // Shared queue length data. Published by the `OutQueueController` in the client, and used
        // primarily to throttle incoming connections (e.g socks5 for attached network-requesters)
@@ -471,7 +453,7 @@ impl NymClient {
            input_receiver,
            sphinx_message_sender.clone(),
            shared_lane_queue_lengths.clone(),
-            client_connection_rx,
+            closed_connection_rx,
            shutdown.subscribe(),
        );

@@ -492,7 +474,7 @@ impl NymClient {
                received_buffer_request_sender,
                input_sender,
                shared_lane_queue_lengths,
-                client_connection_tx,
+                closed_connection_tx,
            ),
            SocketType::None => {
                // if we did not start the socket, it means we're running (supposedly) in the native mode
@@ -25,13 +25,9 @@ pub(crate) struct Init {
    #[clap(long)]
    force_register_gateway: bool,

-    /// Comma separated list of rest endpoints of the nymd validators
+    /// Comma separated list of rest endpoints of the validators
    #[clap(long)]
-    nymd_validators: Option<String>,
-
-    /// Comma separated list of rest endpoints of the API validators
-    #[clap(long)]
-    api_validators: Option<String>,
+    validators: Option<String>,

    /// Whether to not start the websocket
    #[clap(long)]
@@ -56,8 +52,7 @@ pub(crate) struct Init {
 impl From<Init> for OverrideConfig {
    fn from(init_config: Init) -> Self {
        OverrideConfig {
-            nymd_validators: init_config.nymd_validators,
-            api_validators: init_config.api_validators,
+            validators: init_config.validators,
            disable_socket: init_config.disable_socket,
            port: init_config.port,
            fastmode: init_config.fastmode,
@@ -75,8 +75,7 @@ pub(crate) enum Commands {

 // Configuration that can be overridden.
 pub(crate) struct OverrideConfig {
-    nymd_validators: Option<String>,
-    api_validators: Option<String>,
+    validators: Option<String>,
    disable_socket: bool,
    port: Option<u16>,
    fastmode: bool,
@@ -99,18 +98,7 @@ pub(crate) async fn execute(args: &Cli) -> Result<(), ClientError> {
 }

 pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
-    if let Some(raw_validators) = args.nymd_validators {
-        config
-            .get_base_mut()
-            .set_custom_validators(config::parse_validators(&raw_validators));
-    } else if std::env::var(network_defaults::var_names::CONFIGURED).is_ok() {
-        let raw_validators = std::env::var(network_defaults::var_names::NYMD_VALIDATOR)
-            .expect("nymd validator not set");
-        config
-            .get_base_mut()
-            .set_custom_validators(config::parse_validators(&raw_validators));
-    }
-    if let Some(raw_validators) = args.api_validators {
+    if let Some(raw_validators) = args.validators {
        config
            .get_base_mut()
            .set_custom_validator_apis(config::parse_validators(&raw_validators));
@@ -18,13 +18,9 @@ pub(crate) struct Run {
    #[clap(long)]
    id: String,

-    /// Comma separated list of rest endpoints of the nymd validators
+    /// Comma separated list of rest endpoints of the validators
    #[clap(long)]
-    nymd_validators: Option<String>,
-
-    /// Comma separated list of rest endpoints of the API validators
-    #[clap(long)]
-    api_validators: Option<String>,
+    validators: Option<String>,

    /// Id of the gateway we want to connect to. If overridden, it is user's responsibility to
    /// ensure prior registration happened
@@ -49,8 +45,7 @@ pub(crate) struct Run {
 impl From<Run> for OverrideConfig {
    fn from(run_config: Run) -> Self {
        OverrideConfig {
-            nymd_validators: run_config.nymd_validators,
-            api_validators: run_config.api_validators,
+            validators: run_config.validators,
            disable_socket: run_config.disable_socket,
            port: run_config.port,
            fastmode: false,
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use client_connections::{
-    ConnectionCommand, ConnectionCommandSender, LaneQueueLengths, TransmissionLane,
+    ClosedConnectionSender, ConnectionCommand, LaneQueueLengths, TransmissionLane,
 };
 use client_core::client::{
    inbound_messages::{InputMessage, InputMessageSender},
@@ -37,7 +37,7 @@ impl Default for ReceivedResponseType {

 pub(crate) struct Handler {
    msg_input: InputMessageSender,
-    client_connection_tx: ConnectionCommandSender,
+    closed_connection_tx: ClosedConnectionSender,
    buffer_requester: ReceivedBufferRequestSender,
    self_full_address: Recipient,
    socket: Option<WebSocketStream<TcpStream>>,
@@ -50,7 +50,7 @@ impl Clone for Handler {
    fn clone(&self) -> Self {
        Handler {
            msg_input: self.msg_input.clone(),
-            client_connection_tx: self.client_connection_tx.clone(),
+            closed_connection_tx: self.closed_connection_tx.clone(),
            buffer_requester: self.buffer_requester.clone(),
            self_full_address: self.self_full_address,
            socket: None,
@@ -71,14 +71,14 @@ impl Drop for Handler {
 impl Handler {
    pub(crate) fn new(
        msg_input: InputMessageSender,
-        client_connection_tx: ConnectionCommandSender,
+        closed_connection_tx: ClosedConnectionSender,
        buffer_requester: ReceivedBufferRequestSender,
        self_full_address: &Recipient,
        lane_queue_lengths: LaneQueueLengths,
    ) -> Self {
        Handler {
            msg_input,
-            client_connection_tx,
+            closed_connection_tx,
            buffer_requester,
            self_full_address: *self_full_address,
            socket: None,
@@ -92,42 +92,25 @@ impl Handler {
        recipient: &Recipient,
        message: Vec<u8>,
        with_reply_surb: bool,
-        connection_id: Option<u64>,
+        connection_id: u64,
    ) -> Option<ServerResponse> {
-        // We map the absence of a connection id as going into the general lane.
-        let lane = connection_id.map_or(TransmissionLane::General, |id| {
-            TransmissionLane::ConnectionId(id)
-        });
-
        // the ack control is now responsible for chunking, etc.
+        let lane = TransmissionLane::ConnectionId(connection_id);
        let input_msg = InputMessage::new_fresh(*recipient, message, with_reply_surb, lane);
-        self.msg_input
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
-
-        // Only reply back with a `LaneQueueLength` if the sender providided a connection id
-        let connection_id = match lane {
-            TransmissionLane::General
-            | TransmissionLane::Reply
-            | TransmissionLane::Retransmission
-            | TransmissionLane::Control => return None,
-            TransmissionLane::ConnectionId(id) => id,
-        };
+        if self.msg_input.send(input_msg).await.is_err() {
+            panic!();
+        }

        // on receiving a send, we reply back the current lane queue length for that connection id.
        // Note that this does _NOT_ take into account the packets that have been received but not
        // yet reach `OutQueueControl`, so it might be a tad low.
-        let Ok(lane_queue_lengths) = self.lane_queue_lengths.lock() else {
-            log::warn!(
-                "Failed to get the lane queue length lock, \
-                not responding back with the current queue length"
-            );
-            return None;
-        };
+        if let Ok(lane_queue_lengths) = self.lane_queue_lengths.lock() {
+            let queue_length = lane_queue_lengths.get(&lane).unwrap_or(0);
+            return Some(ServerResponse::LaneQueueLength(connection_id, queue_length));
+        }

-        let queue_length = lane_queue_lengths.get(&lane).unwrap_or(0);
-        Some(ServerResponse::LaneQueueLength(connection_id, queue_length))
+        log::warn!("Failed to get the lane queue length lock, not responding back with the current queue length");
+        None
    }

    async fn handle_reply(
@@ -136,20 +119,13 @@ impl Handler {
        message: Vec<u8>,
    ) -> Option<ServerResponse> {
        if message.len() > ReplySurb::max_msg_len(Default::default()) {
-            return Some(
-                ServerResponse::new_error(
-                    format!(
-                        "too long message to put inside a reply SURB. Received: {} bytes and maximum is {} bytes",
-                        message.len(), ReplySurb::max_msg_len(Default::default()))
-                    )
-                );
+            return Some(ServerResponse::new_error(format!("too long message to put inside a reply SURB. Received: {} bytes and maximum is {} bytes", message.len(), ReplySurb::max_msg_len(Default::default()))));
        }

        let input_msg = InputMessage::new_reply(reply_surb, message);
-        self.msg_input
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+        if self.msg_input.send(input_msg).await.is_err() {
+            panic!();
+        }

        None
    }
@@ -159,7 +135,7 @@ impl Handler {
    }

    fn handle_closed_connection(&self, connection_id: u64) -> Option<ServerResponse> {
-        self.client_connection_tx
+        self.closed_connection_tx
            .unbounded_send(ConnectionCommand::Close(connection_id))
            .unwrap();
        None
@@ -34,7 +34,7 @@ pub enum ClientRequest {
        message: Vec<u8>,
        // Perhaps we could change it to a number to indicate how many reply_SURBs we want to include?
        with_reply_surb: bool,
-        connection_id: Option<u64>,
+        connection_id: u64,
    },
    Reply {
        message: Vec<u8>,
@@ -53,10 +53,10 @@ impl ClientRequest {
        recipient: Recipient,
        data: Vec<u8>,
        with_reply_surb: bool,
-        connection_id: Option<u64>,
+        connection_id: u64,
    ) -> Vec<u8> {
        let data_len_bytes = (data.len() as u64).to_be_bytes();
-        let conn_id_bytes = connection_id.unwrap_or(0).to_be_bytes();
+        let conn_id_bytes = connection_id.to_be_bytes();
        std::iter::once(SEND_REQUEST_TAG)
            .chain(std::iter::once(with_reply_surb as u8))
            .chain(recipient.to_bytes().iter().cloned()) // will not be length prefixed because the length is constant
@@ -106,11 +106,6 @@ impl ClientRequest {
        connection_id_bytes
            .copy_from_slice(&b[2 + Recipient::LEN..2 + Recipient::LEN + size_of::<u64>()]);
        let connection_id = u64::from_be_bytes(connection_id_bytes);
-        let connection_id = if connection_id == 0 {
-            None
-        } else {
-            Some(connection_id)
-        };

        let data_len_bytes =
            &b[2 + Recipient::LEN + size_of::<u64>()..2 + Recipient::LEN + 2 * size_of::<u64>()];
@@ -239,14 +234,7 @@ impl ClientRequest {
    }

    // CLOSED_CONNECTION_REQUEST_TAG
-    fn deserialize_closed_connection(b: &[u8]) -> Result<Self, error::Error> {
-        if b.len() != 1 + size_of::<u64>() {
-            return Err(error::Error::new(
-                ErrorKind::MalformedRequest,
-                "the received closed connection has invalid length".to_string(),
-            ));
-        }
-
+    fn deserialize_closed_connection(b: &[u8]) -> Self {
        // this MUST match because it was called by 'deserialize'
        debug_assert_eq!(b[0], CLOSED_CONNECTION_REQUEST_TAG);

@@ -254,7 +242,7 @@ impl ClientRequest {
        connection_id_bytes.copy_from_slice(&b[1..=size_of::<u64>()]);
        let connection_id = u64::from_be_bytes(connection_id_bytes);

-        Ok(ClientRequest::ClosedConnection(connection_id))
+        ClientRequest::ClosedConnection(connection_id)
    }

    // GET_LANE_QUEUE_LENGHT_TAG
@@ -266,14 +254,7 @@ impl ClientRequest {
    }

    // GET_LANE_QUEUE_LENGHT_TAG
-    fn deserialize_get_lane_queue_length(b: &[u8]) -> Result<Self, error::Error> {
-        if b.len() != 1 + size_of::<u64>() {
-            return Err(error::Error::new(
-                ErrorKind::MalformedRequest,
-                "the received get lane queue length has invalid length".to_string(),
-            ));
-        }
-
+    fn deserialize_get_lane_queue_length(b: &[u8]) -> Self {
        // this MUST match because it was called by 'deserialize'
        debug_assert_eq!(b[0], GET_LANE_QUEUE_LENGHT_TAG);

@@ -281,7 +262,7 @@ impl ClientRequest {
        connection_id_bytes.copy_from_slice(&b[1..=size_of::<u64>()]);
        let connection_id = u64::from_be_bytes(connection_id_bytes);

-        Ok(ClientRequest::GetLaneQueueLength(connection_id))
+        ClientRequest::GetLaneQueueLength(connection_id)
    }

    pub fn serialize(self) -> Vec<u8> {
@@ -332,8 +313,8 @@ impl ClientRequest {
            SEND_REQUEST_TAG => Self::deserialize_send(b),
            REPLY_REQUEST_TAG => Self::deserialize_reply(b),
            SELF_ADDRESS_REQUEST_TAG => Ok(Self::deserialize_self_address(b)),
-            CLOSED_CONNECTION_REQUEST_TAG => Self::deserialize_closed_connection(b),
-            GET_LANE_QUEUE_LENGHT_TAG => Self::deserialize_get_lane_queue_length(b),
+            CLOSED_CONNECTION_REQUEST_TAG => Ok(Self::deserialize_closed_connection(b)),
+            GET_LANE_QUEUE_LENGHT_TAG => Ok(Self::deserialize_get_lane_queue_length(b)),
            n => Err(error::Error::new(
                ErrorKind::UnknownRequest,
                format!("type {n}"),
@@ -369,7 +350,7 @@ mod tests {
            recipient,
            message: b"foomp".to_vec(),
            with_reply_surb: false,
-            connection_id: Some(42),
+            connection_id: 42,
        };

        let bytes = send_request_no_surb.serialize();
@@ -384,7 +365,7 @@ mod tests {
                assert_eq!(recipient.to_string(), recipient_string);
                assert_eq!(message, b"foomp".to_vec());
                assert!(!with_reply_surb);
-                assert_eq!(connection_id, Some(42))
+                assert_eq!(connection_id, 42)
            }
            _ => unreachable!(),
        }
@@ -393,7 +374,7 @@ mod tests {
            recipient,
            message: b"foomp".to_vec(),
            with_reply_surb: true,
-            connection_id: None,
+            connection_id: 213,
        };

        let bytes = send_request_surb.serialize();
@@ -408,7 +389,7 @@ mod tests {
                assert_eq!(recipient.to_string(), recipient_string);
                assert_eq!(message, b"foomp".to_vec());
                assert!(with_reply_surb);
-                assert_eq!(connection_id, None)
+                assert_eq!(connection_id, 213)
            }
            _ => unreachable!(),
        }
@@ -20,7 +20,7 @@ pub(super) enum ClientRequestText {
        message: String,
        recipient: String,
        with_reply_surb: bool,
-        connection_id: Option<u64>,
+        connection_id: u64,
    },
    SelfAddress,
    #[serde(rename_all = "camelCase")]
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.2"
+version = "1.1.0"
 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"
@@ -23,13 +23,6 @@ id = '{{ client.id }}'
 # to claim bandwidth without presenting bandwidth credentials.
 disabled_credentials_mode = {{ client.disabled_credentials_mode }}

-# Addresses to nymd validators via which the client can communicate with the chain.
-validator_urls = [
-    {{#each client.validator_urls }}
-        '{{this}}',
-    {{/each}}
-]
-
 # Addresses to APIs running on validator from which the client gets the view of the network.
 validator_api_urls = [
    {{#each client.validator_api_urls }}
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
+use std::sync::atomic::Ordering;

 use crate::client::config::Config;
 use crate::error::Socks5ClientError;
@@ -9,7 +9,7 @@ use crate::socks::{
    authentication::{AuthenticationMethods, Authenticator, User},
    server::SphinxSocksServer,
 };
-use client_connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
+use client_connections::{ClosedConnectionReceiver, ClosedConnectionSender, LaneQueueLengths};
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
@@ -38,7 +38,7 @@ use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use tap::TapFallible;
-use task::{wait_for_signal_and_error, ShutdownListener, ShutdownNotifier};
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

 pub mod config;

@@ -120,7 +120,7 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        client_connection_rx: ConnectionCommandReceiver,
+        closed_connection_rx: ClosedConnectionReceiver,
        lane_queue_lengths: LaneQueueLengths,
        shutdown: ShutdownListener,
    ) {
@@ -152,7 +152,7 @@ impl NymClient {
            topology_accessor,
            reply_key_storage,
            lane_queue_lengths,
-            client_connection_rx,
+            closed_connection_rx,
        )
        .start_with_shutdown(shutdown);
    }
@@ -199,37 +199,11 @@ impl NymClient {
            .expect("provided gateway id is invalid!");

        #[cfg(feature = "coconut")]
-        let bandwidth_controller = {
-            let details = 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 nymd_url = self
-                .config
-                .get_base()
-                .get_validator_endpoints()
-                .pop()
-                .expect("No nymd validator endpoint provided");
-            let api_url = self
-                .config
-                .get_base()
-                .get_validator_api_endpoints()
-                .pop()
-                .expect("No validator api endpoint provided");
-            // overwrite env configuration with config URLs
-            client_config = client_config.with_urls(nymd_url, api_url);
-            let client = validator_client::Client::new_query(client_config)
-                .expect("Could not construct query client");
-            let coconut_api_clients =
-                validator_client::CoconutApiClient::all_coconut_api_clients(&client)
-                    .await
-                    .expect("Could not query api clients");
-            BandwidthController::new(
-                credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                    .await,
-                coconut_api_clients,
-            )
-        };
+        let bandwidth_controller = BandwidthController::new(
+            credential_storage::initialise_storage(self.config.get_base().get_database_path())
+                .await,
+            self.config.get_base().get_validator_api_endpoints(),
+        );
        #[cfg(not(feature = "coconut"))]
        let bandwidth_controller = BandwidthController::new(
            credential_storage::initialise_storage(self.config.get_base().get_database_path())
@@ -312,9 +286,9 @@ impl NymClient {
        &self,
        buffer_requester: ReceivedBufferRequestSender,
        msg_input: InputMessageSender,
-        client_connection_tx: ConnectionCommandSender,
+        closed_connection_tx: ClosedConnectionSender,
        lane_queue_lengths: LaneQueueLengths,
-        mut shutdown: ShutdownListener,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting socks5 listener...");
        let auth_methods = vec![AuthenticationMethods::NoAuth as u8];
@@ -327,57 +301,38 @@ impl NymClient {
            self.config.get_provider_mix_address(),
            self.as_mix_recipient(),
            lane_queue_lengths,
-            shutdown.clone(),
+            shutdown,
        );
        tokio::spawn(async move {
-            // Ideally we should have a fully fledged task manager to check for errors in all
-            // tasks.
-            // However, pragmatically, we start out by at least reporting errors for some of the
-            // tasks that interact with the outside world and can fail in normal operation, such as
-            // network issues.
-            // TODO: replace this by a generic solution, such as a task manager that stores all
-            // JoinHandles of all spawned tasks.
-            if let Err(res) = sphinx_socks
-                .serve(msg_input, buffer_requester, client_connection_tx)
+            sphinx_socks
+                .serve(msg_input, buffer_requester, closed_connection_tx)
                .await
-            {
-                shutdown.send_we_stopped(Box::new(res));
-            }
        });
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub async fn run_forever(&mut self) -> Result<(), Box<dyn Error + Send>> {
-        let mut shutdown = self
-            .start()
-            .await
-            .map_err(|err| Box::new(err) as Box<dyn Error + Send>)?;
-
-        let res = wait_for_signal_and_error(&mut shutdown).await;
+    pub async fn run_forever(&mut self) -> Result<(), Socks5ClientError> {
+        let mut shutdown = self.start().await?;
+        wait_for_signal().await;

        log::info!("Sending shutdown");
+        client_core::client::SHUTDOWN_HAS_BEEN_SIGNALLED.store(true, Ordering::Relaxed);
        shutdown.signal_shutdown().ok();

        log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
        shutdown.wait_for_shutdown().await;

        log::info!("Stopping nym-socks5-client");
-        res
+        Ok(())
    }

    // Variant of `run_forever` that listends for remote control messages
    pub async fn run_and_listen(
        &mut self,
        mut receiver: Socks5ControlMessageReceiver,
-    ) -> Result<(), Box<dyn Error + Send>> {
-        // Start the main task
-        let mut shutdown = self
-            .start()
-            .await
-            .map_err(|err| Box::new(err) as Box<dyn Error + Send>)?;
-
-        let res = tokio::select! {
-            biased;
+    ) -> Result<(), Socks5ClientError> {
+        let mut shutdown = self.start().await?;
+        tokio::select! {
            message = receiver.next() => {
                log::debug!("Received message: {:?}", message);
                match message {
@@ -388,26 +343,21 @@ impl NymClient {
                        log::info!("Channel closed, stopping");
                    }
                }
-                Ok(())
-            }
-            Some(msg) = shutdown.wait_for_error() => {
-                log::info!("Task error: {:?}", msg);
-                Err(msg)
            }
            _ = tokio::signal::ctrl_c() => {
                log::info!("Received SIGINT");
-                Ok(())
            },
-        };
+        }

        log::info!("Sending shutdown");
+        client_core::client::SHUTDOWN_HAS_BEEN_SIGNALLED.store(true, Ordering::Relaxed);
        shutdown.signal_shutdown().ok();

        log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
        shutdown.wait_for_shutdown().await;

        log::info!("Stopping nym-socks5-client");
-        res
+        Ok(())
    }

    pub async fn start(&mut self) -> Result<ShutdownNotifier, Socks5ClientError> {
@@ -465,7 +415,7 @@ impl NymClient {

        // Channel for announcing closed (socks5) connections by the controller.
        // This will be forwarded to `OutQueueControl`
-        let (client_connection_tx, client_connection_rx) = mpsc::unbounded();
+        let (closed_connection_tx, closed_connection_rx) = mpsc::unbounded();

        // Shared queue length data. Published by the `OutQueueController` in the client, and used
        // primarily to throttle incoming connections
@@ -477,7 +427,7 @@ impl NymClient {
            ack_receiver,
            input_receiver,
            sphinx_message_sender.clone(),
-            client_connection_rx,
+            closed_connection_rx,
            shared_lane_queue_lengths.clone(),
            shutdown.subscribe(),
        );
@@ -497,7 +447,7 @@ impl NymClient {
        self.start_socks5_listener(
            received_buffer_request_sender,
            input_sender,
-            client_connection_tx,
+            closed_connection_tx,
            shared_lane_queue_lengths,
            shutdown.subscribe(),
        );
@@ -29,13 +29,9 @@ pub(crate) struct Init {
    #[clap(long)]
    force_register_gateway: bool,

-    /// Comma separated list of rest endpoints of the nymd validators
+    /// Comma separated list of rest endpoints of the validators
    #[clap(long)]
-    nymd_validators: Option<String>,
-
-    /// Comma separated list of rest endpoints of the API validators
-    #[clap(long)]
-    api_validators: Option<String>,
+    validators: Option<String>,

    /// Port for the socket to listen on in all subsequent runs
    #[clap(short, long)]
@@ -56,8 +52,7 @@ pub(crate) struct Init {
 impl From<Init> for OverrideConfig {
    fn from(init_config: Init) -> Self {
        OverrideConfig {
-            nymd_validators: init_config.nymd_validators,
-            api_validators: init_config.api_validators,
+            validators: init_config.validators,
            port: init_config.port,
            fastmode: init_config.fastmode,
            #[cfg(feature = "coconut")]
@@ -1,9 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
-
 use crate::client::config::Config;
+use crate::error::Socks5ClientError;
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use completions::{fig_generate, ArgShell};
@@ -79,8 +78,7 @@ pub(crate) enum Commands {

 // Configuration that can be overridden.
 pub(crate) struct OverrideConfig {
-    nymd_validators: Option<String>,
-    api_validators: Option<String>,
+    validators: Option<String>,
    port: Option<u16>,
    fastmode: bool,

@@ -88,7 +86,7 @@ pub(crate) struct OverrideConfig {
    enabled_credentials_mode: bool,
 }

-pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send>> {
+pub(crate) async fn execute(args: &Cli) -> Result<(), Socks5ClientError> {
    let bin_name = "nym-socks5-client";

    match &args.command {
@@ -102,16 +100,7 @@ pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send>> {
 }

 pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
-    if let Some(raw_validators) = args.nymd_validators {
-        config
-            .get_base_mut()
-            .set_custom_validators(parse_validators(&raw_validators));
-    } else if let Ok(raw_validators) = std::env::var(network_defaults::var_names::NYMD_VALIDATOR) {
-        config
-            .get_base_mut()
-            .set_custom_validators(parse_validators(&raw_validators));
-    }
-    if let Some(raw_validators) = args.api_validators {
+    if let Some(raw_validators) = args.validators {
        config
            .get_base_mut()
            .set_custom_validator_apis(parse_validators(&raw_validators));
@@ -31,13 +31,9 @@ pub(crate) struct Run {
    #[clap(long)]
    gateway: Option<String>,

-    /// Comma separated list of rest endpoints of the nymd validators
+    /// Comma separated list of rest endpoints of the validators
    #[clap(long)]
-    nymd_validators: Option<String>,
-
-    /// Comma separated list of rest endpoints of the API validators
-    #[clap(long)]
-    api_validators: Option<String>,
+    validators: Option<String>,

    /// Port for the socket to listen on
    #[clap(short, long)]
@@ -53,8 +49,7 @@ pub(crate) struct Run {
 impl From<Run> for OverrideConfig {
    fn from(run_config: Run) -> Self {
        OverrideConfig {
-            nymd_validators: run_config.nymd_validators,
-            api_validators: run_config.api_validators,
+            validators: run_config.validators,
            port: run_config.port,
            fastmode: false,

@@ -86,16 +81,14 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error + Send>> {
+pub(crate) async fn execute(args: &Run) -> Result<(), Socks5ClientError> {
    let id = &args.id;

    let mut config = match Config::load_from_file(Some(id)) {
        Ok(cfg) => cfg,
        Err(err) => {
            error!("Failed to load config for {}. Are you sure you have run `init` before? (Error was: {})", id, err);
-            return Err(Box::new(Socks5ClientError::FailedToLoadConfig(
-                id.to_string(),
-            )));
+            return Err(Socks5ClientError::FailedToLoadConfig(id.to_string()));
        }
    };

@@ -104,7 +97,7 @@ pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error

    if !version_check(&config) {
        error!("failed the local version check");
-        return Err(Box::new(Socks5ClientError::FailedLocalVersionCheck));
+        return Err(Socks5ClientError::FailedLocalVersionCheck);
    }

    NymClient::new(config).run_forever().await
@@ -3,8 +3,6 @@ use crypto::asymmetric::identity::Ed25519RecoveryError;
 use gateway_client::error::GatewayClientError;
 use validator_client::ValidatorClientError;

-use crate::socks::types::SocksProxyError;
-
 #[derive(thiserror::Error, Debug)]
 pub enum Socks5ClientError {
    #[error("I/O error: {0}")]
@@ -20,13 +18,8 @@ pub enum Socks5ClientError {
    #[error("Reply key storage error: {0}")]
    ReplyKeyStorageError(#[from] ReplyKeyStorageError),

-    #[error("SOCKS proxy error")]
-    SocksProxyError(SocksProxyError),
-
    #[error("Failed to load config for: {0}")]
    FailedToLoadConfig(String),
    #[error("Failed local version check, client and config mismatch")]
    FailedLocalVersionCheck,
-    #[error("Fail to bind address")]
-    FailToBindAddress,
 }
@@ -1,9 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
-
 use clap::{crate_version, Parser};
+use error::Socks5ClientError;
 use logging::setup_logging;
 use network_defaults::setup_env;

@@ -13,7 +12,7 @@ pub mod error;
 pub mod socks;

 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error + Send>> {
+async fn main() -> Result<(), Socks5ClientError> {
    setup_logging();
    println!("{}", banner());

@@ -168,13 +168,9 @@ impl SocksClient {
        controller_sender: ControllerSender,
        self_address: Recipient,
        lane_queue_lengths: LaneQueueLengths,
-        mut shutdown_listener: ShutdownListener,
+        shutdown_listener: ShutdownListener,
    ) -> Self {
-        // If this task fails and exits, we don't want to send shutdown signal
-        shutdown_listener.mark_as_success();
-
        let connection_id = Self::generate_random();
-
        SocksClient {
            controller_sender,
            connection_id,
@@ -206,7 +202,6 @@ impl SocksClient {
    pub async fn shutdown(&mut self) -> Result<(), SocksProxyError> {
        info!("client is shutting down its TCP stream");
        self.stream.shutdown().await?;
-        self.shutdown_listener.mark_as_success();
        Ok(())
    }

@@ -245,10 +240,9 @@ impl SocksClient {
            false,
            TransmissionLane::ConnectionId(self.connection_id),
        );
-        self.input_sender
-            .send(input_message)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+        if self.input_sender.send(input_message).await.is_err() {
+            panic!();
+        }
    }

    async fn run_proxy(&mut self, conn_receiver: ConnectionReceiver, remote_proxy_target: String) {
@@ -256,15 +250,10 @@ impl SocksClient {
            .await;

        let stream = self.stream.run_proxy();
-        let peer_addr = match stream.peer_addr() {
-            Ok(peer_addr) => peer_addr,
-            Err(err) => {
-                log::error!("Unable to extract the remote peer address: {err}");
-                return;
-            }
-        };
-        let local_stream_remote = peer_addr.to_string();
-
+        let local_stream_remote = stream
+            .peer_addr()
+            .expect("failed to extract peer address")
+            .to_string();
        let connection_id = self.connection_id;
        let input_sender = self.input_sender.clone();

@@ -1,5 +1,3 @@
-use std::time::Duration;
-
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
@@ -20,16 +18,9 @@ pub(crate) struct MixnetResponseListener {

 impl Drop for MixnetResponseListener {
    fn drop(&mut self) {
-        if let Err(err) = self
-            .buffer_requester
+        self.buffer_requester
            .unbounded_send(ReceivedBufferMessage::ReceiverDisconnect)
-        {
-            if self.shutdown.is_shutdown_poll() {
-                log::debug!("The buffer request failed: {}", err);
-            } else {
-                log::error!("The buffer request failed: {}", err);
-            }
-        }
+            .expect("the buffer request failed!")
    }
 }

@@ -105,9 +96,7 @@ impl MixnetResponseListener {
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), self.shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        assert!(self.shutdown.is_shutdown_poll());
        log::debug!("MixnetResponseListener: Exiting");
    }
 }
@@ -1,17 +1,17 @@
-use crate::error::Socks5ClientError;
-
 use super::authentication::Authenticator;
 use super::client::SocksClient;
-use super::{mixnet_responses::MixnetResponseListener, types::ResponseCode};
-use client_connections::{ConnectionCommandSender, LaneQueueLengths};
+use super::{
+    mixnet_responses::MixnetResponseListener,
+    types::{ResponseCode, SocksProxyError},
+};
+use client_connections::{ClosedConnectionSender, LaneQueueLengths};
 use client_core::client::{
    inbound_messages::InputMessageSender, received_buffer::ReceivedBufferRequestSender,
 };
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
-use proxy_helpers::connection_controller::{BroadcastActiveConnections, Controller};
+use proxy_helpers::connection_controller::Controller;
 use std::net::SocketAddr;
-use tap::TapFallible;
 use task::ShutdownListener;
 use tokio::net::TcpListener;

@@ -55,19 +55,14 @@ impl SphinxSocksServer {
        &mut self,
        input_sender: InputMessageSender,
        buffer_requester: ReceivedBufferRequestSender,
-        client_connection_tx: ConnectionCommandSender,
-    ) -> Result<(), Socks5ClientError> {
-        let listener = TcpListener::bind(self.listening_address)
-            .await
-            .tap_err(|err| log::error!("Failed to bind to address: {err}"))?;
+        closed_connection_tx: ClosedConnectionSender,
+    ) -> Result<(), SocksProxyError> {
+        let listener = TcpListener::bind(self.listening_address).await.unwrap();
        info!("Serving Connections...");

        // controller for managing all active connections
-        let (mut active_streams_controller, controller_sender) = Controller::new(
-            client_connection_tx,
-            BroadcastActiveConnections::Off,
-            self.shutdown.clone(),
-        );
+        let (mut active_streams_controller, controller_sender) =
+            Controller::new(closed_connection_tx, false, self.shutdown.clone());
        tokio::spawn(async move {
            active_streams_controller.run().await;
        });
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use self::config::Config;
-use client_connections::{ConnectionCommandReceiver, LaneQueueLengths, TransmissionLane};
+use client_connections::{ClosedConnectionReceiver, LaneQueueLengths, TransmissionLane};
 use client_core::client::{
    cover_traffic_stream::LoopCoverTrafficStream,
    inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender},
@@ -128,7 +128,7 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        client_connection_rx: ConnectionCommandReceiver,
+        closed_connection_rx: ClosedConnectionReceiver,
        lane_queue_lengths: LaneQueueLengths,
    ) {
        let mut controller_config = real_messages_control::Config::new(
@@ -155,7 +155,7 @@ impl NymClient {
            mix_sender,
            topology_accessor,
            lane_queue_lengths,
-            client_connection_rx,
+            closed_connection_rx,
        )
        .start();
    }
@@ -334,7 +334,7 @@ impl NymClient {

        // Channel that the real traffix controller can listed to for closing connections.
        // Currently unused in the wasm client.
-        let (_client_connection_tx, client_connection_rx) = mpsc::unbounded();
+        let (_closed_connection_tx, closed_connection_rx) = mpsc::unbounded();

        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
@@ -364,7 +364,7 @@ impl NymClient {
            ack_receiver,
            input_receiver,
            sphinx_message_sender.clone(),
-            client_connection_rx,
+            closed_connection_rx,
            shared_lane_queue_lengths,
        );

@@ -395,12 +395,16 @@ impl NymClient {

        let input_msg = InputMessage::new_fresh(recipient, message, false, lane);

-        self.input_tx
+        if self
+            .input_tx
            .as_ref()
            .expect("start method was not called before!")
            .send(input_msg)
            .await
-            .expect("InputMessageReceiver has stopped receiving!");
+            .is_err()
+        {
+            panic!();
+        }

        self
    }
@@ -6,7 +6,7 @@ use wasm_bindgen::prelude::*;

 #[wasm_bindgen]
 pub async fn get_gateway(api_server: String, preferred: Option<String>) -> GatewayEndpoint {
-    let validator_client = validator_client::client::ApiClient::new(api_server.parse().unwrap());
+    let validator_client = validator_client::ApiClient::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),
@@ -16,9 +16,11 @@ pub enum TransmissionLane {
    ConnectionId(ConnectionId),
 }

-/// Used by the connection controller to report current state for client connections.
-pub type ConnectionCommandSender = mpsc::UnboundedSender<ConnectionCommand>;
-pub type ConnectionCommandReceiver = mpsc::UnboundedReceiver<ConnectionCommand>;
+/// Announce connections that are closed, for whoever is interested.
+/// One usecase is that the network-requester and socks5-client wants to know about this, so that
+/// they can forward this to the `OutQueueControl` (via `ClientRequest` for the network-requester)
+pub type ClosedConnectionSender = mpsc::UnboundedSender<ConnectionCommand>;
+pub type ClosedConnectionReceiver = mpsc::UnboundedReceiver<ConnectionCommand>;

 pub enum ConnectionCommand {
    // Announce that at a connection was closed. E.g the `OutQueueControl` uses this to discard
@@ -17,8 +17,6 @@ use credential_storage::error::StorageError;
 #[cfg(feature = "coconut")]
 use std::str::FromStr;
 #[cfg(feature = "coconut")]
-use validator_client::client::CoconutApiClient;
-#[cfg(feature = "coconut")]
 use {
    coconut_interface::Base58,
    credentials::coconut::{
@@ -31,7 +29,7 @@ pub struct BandwidthController<St: Storage> {
    #[allow(dead_code)]
    storage: St,
    #[cfg(feature = "coconut")]
-    coconut_api_clients: Vec<CoconutApiClient>,
+    validator_endpoints: Vec<url::Url>,
 }

 impl<St> BandwidthController<St>
@@ -39,10 +37,10 @@ where
    St: Storage + Clone + 'static,
 {
    #[cfg(feature = "coconut")]
-    pub fn new(storage: St, coconut_api_clients: Vec<CoconutApiClient>) -> Self {
+    pub fn new(storage: St, validator_endpoints: Vec<url::Url>) -> Self {
        BandwidthController {
            storage,
-            coconut_api_clients,
+            validator_endpoints,
        }
    }

@@ -55,7 +53,7 @@ where
    pub async fn prepare_coconut_credential(
        &self,
    ) -> Result<coconut_interface::Credential, GatewayClientError> {
-        let verification_key = obtain_aggregate_verification_key(&self.coconut_api_clients).await?;
+        let verification_key = obtain_aggregate_verification_key(&self.validator_endpoints).await?;
        let bandwidth_credential = self.storage.get_next_coconut_credential().await?;
        let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
            .map_err(|_| StorageError::InconsistentData)?;
@@ -2,19 +2,25 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::bandwidth::BandwidthController;
+use crate::cleanup_socket_message;
 use crate::error::GatewayClientError;
 use crate::packet_router::PacketRouter;
 pub use crate::packet_router::{
    AcknowledgementReceiver, AcknowledgementSender, MixnetMessageReceiver, MixnetMessageSender,
 };
 use crate::socket_state::{PartiallyDelegated, SocketState};
-use crate::{cleanup_socket_message, try_decrypt_binary_message};
+#[cfg(target_arch = "wasm32")]
+use crate::wasm_storage::PersistentStorage;
+#[cfg(feature = "coconut")]
+use coconut_interface::Credential;
+#[cfg(not(target_arch = "wasm32"))]
+use credential_storage::PersistentStorage;
 use crypto::asymmetric::identity;
 use futures::{FutureExt, 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 gateway_requests::{BinaryRequest, ClientControlRequest, ServerResponse};
 use log::*;
 use network_defaults::{REMAINING_BANDWIDTH_THRESHOLD, TOKENS_TO_BURN};
 use nymsphinx::forwarding::packet::MixPacket;
@@ -22,20 +28,13 @@ use rand::rngs::OsRng;
 use std::convert::TryFrom;
 use std::sync::Arc;
 use std::time::Duration;
-use tungstenite::protocol::Message;
-
-#[cfg(feature = "coconut")]
-use coconut_interface::Credential;
-
-#[cfg(not(target_arch = "wasm32"))]
-use credential_storage::PersistentStorage;
 #[cfg(not(target_arch = "wasm32"))]
 use task::ShutdownListener;
+use tungstenite::protocol::Message;
+
 #[cfg(not(target_arch = "wasm32"))]
 use tokio_tungstenite::connect_async;

-#[cfg(target_arch = "wasm32")]
-use crate::wasm_storage::PersistentStorage;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;
 #[cfg(target_arch = "wasm32")]
@@ -307,8 +306,6 @@ impl GatewayClient {
            let m_shutdown = self.shutdown.clone();
            async {
                if let Some(mut s) = m_shutdown {
-                    // TODO: fix this by marking as success _after_ the select
-                    s.mark_as_success();
                    s.recv().await
                } else {
                    std::future::pending::<()>().await
@@ -339,15 +336,7 @@ impl GatewayClient {
                    };
                    match ws_msg {
                        Message::Binary(bin_msg) => {
-                            // if we have established the shared key already, attempt to use it for decryption
-                            // otherwise there's not much we can do apart from just routing what we have on hand
-                            if let Some(shared_keys) = &self.shared_key {
-                                if let Some(plaintext) = try_decrypt_binary_message(bin_msg, shared_keys) {
-                                    if let Err(err) = self.packet_router.route_received(vec![plaintext]) {
-                                        log::warn!("Route received failed: {:?}", err);
-                                    }
-                                }
-                            } else if let Err(err) = self.packet_router.route_received(vec![bin_msg]) {
+                            if let Err(err) = self.packet_router.route_received(vec![bin_msg]) {
                                log::warn!("Route received failed: {:?}", err);
                            }
                        }
@@ -447,33 +436,6 @@ impl GatewayClient {
        }
    }

-    fn check_gateway_protocol(
-        &self,
-        gateway_protocol: Option<u8>,
-    ) -> Result<(), GatewayClientError> {
-        // right now there are no failure cases here, but this might change in the future
-        match gateway_protocol {
-            None => {
-                warn!("the gateway we're connected to has not specified its protocol version. It's probably running version < 1.1.X, but that's still fine for now. It will become a hard error in 1.2.0");
-                // note: in 1.2.0 we will have to return a hard error here
-                Ok(())
-            }
-            Some(v) if v != PROTOCOL_VERSION => {
-                let err = GatewayClientError::IncompatibleProtocol {
-                    gateway: Some(v),
-                    current: PROTOCOL_VERSION,
-                };
-                error!("{err}");
-                Err(err)
-            }
-
-            Some(_) => {
-                info!("the gateway is using exactly the same protocol version as we are. We're good to continue!");
-                Ok(())
-            }
-        }
-    }
-
    async fn register(&mut self) -> Result<(), GatewayClientError> {
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
@@ -496,20 +458,11 @@ impl GatewayClient {
            .map_err(GatewayClientError::RegistrationFailure),
            _ => unreachable!(),
        }?;
-        let (authentication_status, gateway_protocol) = match self.read_control_response().await? {
-            ServerResponse::Register {
-                protocol_version,
-                status,
-            } => (status, protocol_version),
-            ServerResponse::Error { message } => {
-                return Err(GatewayClientError::GatewayError(message))
-            }
-            _ => return Err(GatewayClientError::UnexpectedResponse),
-        };
-
-        self.check_gateway_protocol(gateway_protocol)?;
-        self.authenticated = authentication_status;
-
+        self.authenticated = match self.read_control_response().await? {
+            ServerResponse::Register { status } => Ok(status),
+            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
+            _ => Err(GatewayClientError::UnexpectedResponse),
+        }?;
        if self.authenticated {
            self.shared_key = Some(Arc::new(shared_key));
        }
@@ -548,11 +501,9 @@ impl GatewayClient {

        match self.send_websocket_message(msg).await? {
            ServerResponse::Authenticate {
-                protocol_version,
                status,
                bandwidth_remaining,
            } => {
-                self.check_gateway_protocol(protocol_version)?;
                self.authenticated = status;
                self.bandwidth_remaining = bandwidth_remaining;
                Ok(())
@@ -85,9 +85,6 @@ pub enum GatewayClientError {

    #[error("Failed to send mixnet message")]
    MixnetMsgSenderFailedToSend,
-
-    #[error("Attempted to negotiate connection with gateway using incompatible protocol version. Ours is {current} and the gateway reports {gateway:?}")]
-    IncompatibleProtocol { gateway: Option<u8>, current: u8 },
 }

 impl GatewayClientError {
@@ -3,9 +3,6 @@

 use crate::error::GatewayClientError;
 pub use client::GatewayClient;
-use gateway_requests::registration::handshake::SharedKeys;
-use gateway_requests::BinaryResponse;
-use log::warn;
 pub use packet_router::{
    AcknowledgementReceiver, AcknowledgementSender, MixnetMessageReceiver, MixnetMessageSender,
 };
@@ -40,21 +37,3 @@ pub(crate) fn cleanup_socket_messages(
        None => Err(GatewayClientError::ConnectionAbruptlyClosed),
    }
 }
-
-pub(crate) fn try_decrypt_binary_message(
-    bin_msg: Vec<u8>,
-    shared_keys: &SharedKeys,
-) -> Option<Vec<u8>> {
-    match BinaryResponse::try_from_encrypted_tagged_bytes(bin_msg, shared_keys) {
-        Ok(bin_response) => match bin_response {
-            BinaryResponse::PushedMixMessage(plaintext) => Some(plaintext),
-        },
-        Err(err) => {
-            warn!(
-                "message received from the gateway was malformed! - {:?}",
-                err
-            );
-            None
-        }
-    }
-}
@@ -1,13 +1,14 @@
 // Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::cleanup_socket_messages;
 use crate::error::GatewayClientError;
 use crate::packet_router::PacketRouter;
-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 gateway_requests::BinaryResponse;
 use log::*;
 use std::sync::Arc;
 #[cfg(not(target_arch = "wasm32"))]
@@ -49,9 +50,21 @@ impl PartiallyDelegated {
            match ws_msg {
                Message::Binary(bin_msg) => {
                    // this function decrypts the request and checks the MAC
-                    if let Some(plaintext) = try_decrypt_binary_message(bin_msg, shared_key) {
-                        plaintexts.push(plaintext)
-                    }
+                    let plaintext = match BinaryResponse::try_from_encrypted_tagged_bytes(
+                        bin_msg, shared_key,
+                    ) {
+                        Ok(bin_response) => match bin_response {
+                            BinaryResponse::PushedMixMessage(plaintext) => plaintext,
+                        },
+                        Err(err) => {
+                            warn!(
+                                "message received from the gateway was malformed! - {:?}",
+                                err
+                            );
+                            continue;
+                        }
+                    };
+                    plaintexts.push(plaintext)
                }
                // I think that in the future we should perhaps have some sequence number system, i.e.
                // so each request/response pair can be easily identified, so that if messages are
@@ -10,6 +10,7 @@ rust-version = "1.56"
 [dependencies]
 base64 = "0.13"
 colored = "2.0"
+cw3 = "0.13.1"

 coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
 contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
@@ -38,7 +39,6 @@ async-trait = { version = "0.1.51", optional = true }
 bip39 = { version = "1", features = ["rand"], optional = true }
 config = { path = "../../config", optional = true }
 cosmrs = { git = "https://github.com/neacsu/cosmos-rust", branch = "neacsu/feegrant_support", features = ["rpc", "bip32", "cosmwasm"], optional = true}
-cw3 = { version = "0.13.4", optional = true }
 prost = { version = "0.10", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
@@ -55,7 +55,6 @@ nymd-client = [
    "bip39",
    "config",
    "cosmrs",
-    "cw3",
    "prost",
    "flate2",
    "sha2",
@@ -1,22 +1,16 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
+
 use crate::{validator_api, ValidatorClientError};
-use coconut_dkg_common::types::NodeIndex;
-#[cfg(feature = "nymd-client")]
-use coconut_dkg_common::{
-    dealer::ContractDealing, types::DealerDetails, verification_key::ContractVKShare,
-};
-#[cfg(feature = "nymd-client")]
-use coconut_interface::Base58;
-use coconut_interface::VerificationKey;
-use mixnet_contract_common::families::{Family, FamilyHead};
+use coconut_dkg_common::dealer::ContractDealing;
+use coconut_dkg_common::types::DealerDetails;
 use mixnet_contract_common::mixnode::MixNodeDetails;
+use mixnet_contract_common::MixId;
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef};
-use mixnet_contract_common::{IdentityKey, MixId};
-#[cfg(feature = "nymd-client")]
-use std::str::FromStr;
+use url::Url;
 use validator_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
+    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
+    VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
@@ -24,12 +18,10 @@ use validator_api_requests::models::{
 };

 #[cfg(feature = "nymd-client")]
-use crate::nymd::traits::{DkgQueryClient, MixnetQueryClient, MultisigQueryClient};
+use crate::nymd::traits::{DkgQueryClient, MixnetQueryClient};
 #[cfg(feature = "nymd-client")]
 use crate::nymd::{self, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient};
 #[cfg(feature = "nymd-client")]
-use cw3::ProposalResponse;
-#[cfg(feature = "nymd-client")]
 use mixnet_contract_common::{
    mixnode::MixNodeBond,
    pending_events::{PendingEpochEvent, PendingIntervalEvent},
@@ -37,7 +29,6 @@ use mixnet_contract_common::{
 };
 #[cfg(feature = "nymd-client")]
 use network_defaults::NymNetworkDetails;
-use url::Url;
 #[cfg(feature = "nymd-client")]
 use validator_api_requests::models::MixNodeBondAnnotated;

@@ -55,8 +46,6 @@ pub struct Config {
    mixnode_delegations_page_limit: Option<u32>,
    rewarded_set_page_limit: Option<u32>,
    dealers_page_limit: Option<u32>,
-    verification_key_page_limit: Option<u32>,
-    proposals_page_limit: Option<u32>,
 }

 #[cfg(feature = "nymd-client")]
@@ -87,8 +76,6 @@ impl Config {
            mixnode_delegations_page_limit: None,
            rewarded_set_page_limit: None,
            dealers_page_limit: None,
-            verification_key_page_limit: None,
-            proposals_page_limit: None,
        })
    }

@@ -137,8 +124,6 @@ pub struct Client<C> {
    mixnode_delegations_page_limit: Option<u32>,
    rewarded_set_page_limit: Option<u32>,
    dealers_page_limit: Option<u32>,
-    verification_key_page_limit: Option<u32>,
-    proposals_page_limit: Option<u32>,

    // ideally they would have been read-only, but unfortunately rust doesn't have such features
    pub validator_api: validator_api::Client,
@@ -166,8 +151,6 @@ impl Client<SigningNymdClient> {
            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
            rewarded_set_page_limit: config.rewarded_set_page_limit,
            dealers_page_limit: config.dealers_page_limit,
-            verification_key_page_limit: config.verification_key_page_limit,
-            proposals_page_limit: config.proposals_page_limit,
            validator_api: validator_api_client,
            nymd: nymd_client,
        })
@@ -202,8 +185,6 @@ impl Client<QueryNymdClient> {
            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
            rewarded_set_page_limit: config.rewarded_set_page_limit,
            dealers_page_limit: config.dealers_page_limit,
-            verification_key_page_limit: config.verification_key_page_limit,
-            proposals_page_limit: config.proposals_page_limit,
            validator_api: validator_api_client,
            nymd: nymd_client,
        })
@@ -220,7 +201,6 @@ impl Client<QueryNymdClient> {
 impl<C> Client<C> {
    // use case: somebody initialised client without a contract in order to upload and initialise one
    // and now they want to actually use it without making new client
-
    pub fn set_mixnet_contract_address(&mut self, mixnet_contract_address: cosmrs::AccountId) {
        self.nymd
            .set_mixnet_contract_address(mixnet_contract_address)
@@ -230,56 +210,6 @@ impl<C> Client<C> {
        self.nymd.mixnet_contract_address().clone()
    }

-    pub async fn get_all_node_families(&self) -> Result<Vec<Family>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut families = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let paged_response = self
-                .nymd
-                .get_all_node_families_paged(start_after.take(), None)
-                .await?;
-            families.extend(paged_response.families);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(families)
-    }
-
-    pub async fn get_all_family_members(
-        &self,
-    ) -> Result<Vec<(IdentityKey, FamilyHead)>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut members = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let paged_response = self
-                .nymd
-                .get_all_family_members_paged(start_after.take(), None)
-                .await?;
-            members.extend(paged_response.members);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(members)
-    }
-
    // basically handles paging for us
    pub async fn get_all_nymd_rewarded_set_mixnodes(
        &self,
@@ -672,59 +602,6 @@ impl<C> Client<C> {

        Ok(dealings)
    }
-
-    pub async fn get_all_nymd_verification_key_shares(
-        &self,
-    ) -> Result<Vec<ContractVKShare>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut shares = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nymd
-                .get_vk_shares_paged(start_after.take(), self.verification_key_page_limit)
-                .await?;
-            shares.append(&mut paged_response.shares);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res.into_string())
-            } else {
-                break;
-            }
-        }
-
-        Ok(shares)
-    }
-
-    pub async fn get_all_nymd_proposals(
-        &self,
-    ) -> Result<Vec<ProposalResponse>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut proposals = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let mut paged_response = self
-                .nymd
-                .list_proposals(start_after.take(), self.proposals_page_limit)
-                .await?;
-
-            let last_id = paged_response.proposals.last().map(|prop| prop.id);
-            proposals.append(&mut paged_response.proposals);
-
-            if let Some(start_after_res) = last_id {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(proposals)
-    }
 }

 // validator-api wrappers
@@ -778,53 +655,14 @@ impl<C> Client<C> {
    ) -> Result<BlindedSignatureResponse, ValidatorClientError> {
        Ok(self.validator_api.blind_sign(request_body).await?)
    }
-}

-#[derive(Clone)]
-pub struct CoconutApiClient {
-    pub api_client: ApiClient,
-    pub verification_key: VerificationKey,
-    pub node_id: NodeIndex,
-    #[cfg(feature = "nymd-client")]
-    pub cosmos_address: cosmrs::AccountId,
-}
-
-#[cfg(feature = "nymd-client")]
-impl CoconutApiClient {
-    pub async fn all_coconut_api_clients<C>(
-        nymd_client: &Client<C>,
-    ) -> Result<Vec<Self>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        Ok(nymd_client
-            .get_all_nymd_verification_key_shares()
-            .await?
-            .into_iter()
-            .filter_map(Self::try_from)
-            .collect())
-    }
-
-    fn try_from(share: ContractVKShare) -> Option<Self> {
-        if share.verified {
-            if let Ok(url_address) = Url::parse(&share.announce_address) {
-                if let Ok(verification_key) = VerificationKey::try_from_bs58(&share.share) {
-                    if let Ok(cosmos_address) = cosmrs::AccountId::from_str(share.owner.as_str()) {
-                        return Some(CoconutApiClient {
-                            api_client: ApiClient::new(url_address),
-                            verification_key,
-                            node_id: share.node_index,
-                            cosmos_address,
-                        });
-                    }
-                }
-            }
-        }
-        None
+    pub async fn get_coconut_verification_key(
+        &self,
+    ) -> Result<VerificationKeyResponse, ValidatorClientError> {
+        Ok(self.validator_api.get_coconut_verification_key().await?)
    }
 }

-#[derive(Clone)]
 pub struct ApiClient {
    pub validator_api: validator_api::Client,
    // TODO: perhaps if we really need it at some (currently I don't see any reasons for it)
@@ -930,6 +768,16 @@ impl ApiClient {
            .await?)
    }

+    pub async fn get_coconut_verification_key(
+        &self,
+    ) -> Result<VerificationKeyResponse, ValidatorClientError> {
+        Ok(self.validator_api.get_coconut_verification_key().await?)
+    }
+
+    pub async fn get_cosmos_address(&self) -> Result<CosmosAddressResponse, ValidatorClientError> {
+        Ok(self.validator_api.get_cosmos_address().await?)
+    }
+
    pub async fn verify_bandwidth_credential(
        &self,
        request_body: &VerifyCredentialBody,
@@ -9,8 +9,7 @@ mod error;
 pub mod nymd;
 pub mod validator_api;

-#[cfg(feature = "nymd-client")]
-pub use crate::client::{ApiClient, CoconutApiClient};
+pub use crate::client::ApiClient;
 pub use crate::error::ValidatorClientError;
 pub use validator_api_requests::*;

@@ -15,12 +15,12 @@ pub use coconut_dkg_common::event_attributes::*;
 pub struct Log {
    #[serde(default)]
    // weird thing is that the first msg_index seems to always be undefined on the raw logs
-    pub msg_index: usize,
+    msg_index: usize,
    // unless I'm missing something obvious, the "log" type in cosmjs is always an empty string
    // and launchpad cosmos validator was setting it to what essentially is just the raw version of what
    // we received (and we don't care about launchpad, we, as the time of writing this, work on the stargate)
    // log: String,
-    pub events: Vec<cosmwasm_std::Event>,
+    events: Vec<cosmwasm_std::Event>,
 }

 /// Searches in logs for the first event of the given event type and in that event
@@ -8,8 +8,7 @@ use coconut_dkg_common::dealer::{
    DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
 };
 use coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
-use coconut_dkg_common::types::EpochState;
-use coconut_dkg_common::verification_key::PagedVKSharesResponse;
+use coconut_dkg_common::types::{EpochState, MinimumDepositResponse};
 use cosmrs::AccountId;

 #[async_trait]
@@ -30,17 +29,13 @@ pub trait DkgQueryClient {
        page_limit: Option<u32>,
    ) -> Result<PagedDealerResponse, NymdError>;

+    async fn get_deposit_amount(&self) -> Result<MinimumDepositResponse, NymdError>;
    async fn get_dealings_paged(
        &self,
        idx: usize,
        start_after: Option<String>,
        page_limit: Option<u32>,
    ) -> Result<PagedDealingsResponse, NymdError>;
-    async fn get_vk_shares_paged(
-        &self,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedVKSharesResponse, NymdError>;
 }

 #[async_trait]
@@ -94,6 +89,13 @@ where
            .await
    }

+    async fn get_deposit_amount(&self) -> Result<MinimumDepositResponse, NymdError> {
+        let request = DkgQueryMsg::GetDepositAmount {};
+        self.client
+            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
+            .await
+    }
+
    async fn get_dealings_paged(
        &self,
        idx: usize,
@@ -109,18 +111,4 @@ where
            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
            .await
    }
-
-    async fn get_vk_shares_paged(
-        &self,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedVKSharesResponse, NymdError> {
-        let request = DkgQueryMsg::GetVerificationKeys {
-            limit: page_limit,
-            start_after,
-        };
-        self.client
-            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
-            .await
-    }
 }
@@ -3,11 +3,11 @@

 use crate::nymd::cosmwasm_client::types::ExecuteResult;
 use crate::nymd::error::NymdError;
+use crate::nymd::traits::dkg_query_client::DkgQueryClient;
 use crate::nymd::{Fee, NymdClient, SigningCosmWasmClient};
 use async_trait::async_trait;
 use coconut_dkg_common::msg::ExecuteMsg as DkgExecuteMsg;
 use coconut_dkg_common::types::EncodedBTEPublicKeyWithProof;
-use coconut_dkg_common::verification_key::VerificationKeyShare;
 use contracts_common::dealings::ContractSafeBytes;

 #[async_trait]
@@ -15,7 +15,6 @@ pub trait DkgSigningClient {
    async fn register_dealer(
        &self,
        bte_key: EncodedBTEPublicKeyWithProof,
-        announce_address: String,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

@@ -24,12 +23,6 @@ pub trait DkgSigningClient {
        commitment: ContractSafeBytes,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn submit_verification_key_share(
-        &self,
-        share: VerificationKeyShare,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError>;
 }

 #[async_trait]
@@ -40,13 +33,12 @@ where
    async fn register_dealer(
        &self,
        bte_key: EncodedBTEPublicKeyWithProof,
-        announce_address: String,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
        let req = DkgExecuteMsg::RegisterDealer {
            bte_key_with_proof: bte_key,
-            announce_address,
        };
+        let deposit = self.get_deposit_amount().await?;

        self.client
            .execute(
@@ -55,7 +47,7 @@ where
                &req,
                fee.unwrap_or_default(),
                format!("registering {} as a dealer", self.address()),
-                vec![],
+                vec![deposit.amount.into()],
            )
            .await
    }
@@ -78,23 +70,4 @@ where
            )
            .await
    }
-
-    async fn submit_verification_key_share(
-        &self,
-        share: VerificationKeyShare,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        let req = DkgExecuteMsg::CommitVerificationKeyShare { share };
-
-        self.client
-            .execute(
-                self.address(),
-                self.coconut_dkg_contract_address(),
-                &req,
-                fee.unwrap_or_default(),
-                "verification key share commitment",
-                vec![],
-            )
-            .await
-    }
 }
@@ -7,7 +7,6 @@ use crate::nymd::NymdClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
 use mixnet_contract_common::delegation::{MixNodeDelegationResponse, OwnerProxySubKey};
-use mixnet_contract_common::families::Family;
 use mixnet_contract_common::mixnode::{
    MixNodeDetails, MixnodeRewardingDetailsResponse, PagedMixnodesDetailsResponse,
    PagedUnbondedMixnodesResponse, StakeSaturationResponse, UnbondedMixnodeResponse,
@@ -21,9 +20,9 @@ use mixnet_contract_common::{
    CurrentIntervalResponse, EpochEventId, GatewayBondResponse, GatewayOwnershipResponse,
    IdentityKey, IntervalEventId, LayerDistribution, MixId, MixOwnershipResponse,
    MixnodeDetailsResponse, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
-    PagedFamiliesResponse, PagedGatewayResponse, PagedMembersResponse,
-    PagedMixNodeDelegationsResponse, PagedMixnodeBondsResponse, PagedRewardedSetResponse,
-    PendingEpochEventsResponse, PendingIntervalEventsResponse, QueryMsg as MixnetQueryMsg,
+    PagedGatewayResponse, PagedMixNodeDelegationsResponse, PagedMixnodeBondsResponse,
+    PagedRewardedSetResponse, PendingEpochEventsResponse, PendingIntervalEventsResponse,
+    QueryMsg as MixnetQueryMsg,
 };
 use serde::Deserialize;

@@ -74,24 +73,6 @@ pub trait MixnetQueryClient {
            .await
    }

-    async fn get_all_node_families_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<PagedFamiliesResponse, NymdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetAllFamiliesPaged { limit, start_after })
-            .await
-    }
-
-    async fn get_all_family_members_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<PagedMembersResponse, NymdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetAllMembersPaged { limit, start_after })
-            .await
-    }
-
    // mixnode-related:

    async fn get_mixnode_bonds_paged(
@@ -376,20 +357,6 @@ pub trait MixnetQueryClient {
        })
        .await
    }
-
-    async fn get_node_family_by_label(&self, label: &str) -> Result<Option<Family>, NymdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyByLabel {
-            label: label.to_string(),
-        })
-        .await
-    }
-
-    async fn get_node_family_by_head(&self, head: &str) -> Result<Option<Family>, NymdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyByHead {
-            head: head.to_string(),
-        })
-        .await
-    }
 }

 #[async_trait]
@@ -11,7 +11,7 @@ use cosmrs::AccountId;
 use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
 use mixnet_contract_common::reward_params::{IntervalRewardingParamsUpdate, Performance};
 use mixnet_contract_common::{
-    ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, LayerAssignment, MixId, MixNode,
+    ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, MixId, MixNode,
 };

 #[async_trait]
@@ -108,7 +108,7 @@ pub trait MixnetSigningClient {

    async fn advance_current_epoch(
        &self,
-        new_rewarded_set: Vec<LayerAssignment>,
+        new_rewarded_set: Vec<MixId>,
        expected_active_set_size: u32,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
@@ -136,147 +136,6 @@ pub trait MixnetSigningClient {
        .await
    }

-    // family related
-    async fn create_family(
-        &self,
-        owner_signature: String,
-        label: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::CreateFamily {
-                owner_signature,
-                label,
-            },
-            vec![],
-        )
-        .await
-    }
-
-    async fn create_family_on_behalf(
-        &self,
-        owner_address: String,
-        owner_signature: String,
-        label: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::CreateFamilyOnBehalf {
-                owner_address,
-                owner_signature,
-                label,
-            },
-            vec![],
-        )
-        .await
-    }
-
-    async fn join_family(
-        &self,
-        signature: String,
-        family_head: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::JoinFamily {
-                signature,
-                family_head,
-            },
-            vec![],
-        )
-        .await
-    }
-
-    async fn join_family_on_behalf(
-        &self,
-        member_address: String,
-        signature: String,
-        family_head: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::JoinFamilyOnBehalf {
-                member_address,
-                signature,
-                family_head,
-            },
-            vec![],
-        )
-        .await
-    }
-
-    async fn leave_family(
-        &self,
-        signature: String,
-        family_head: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::LeaveFamily {
-                signature,
-                family_head,
-            },
-            vec![],
-        )
-        .await
-    }
-
-    async fn leave_family_on_behalf(
-        &self,
-        member_address: String,
-        signature: String,
-        family_head: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::LeaveFamilyOnBehalf {
-                member_address,
-                signature,
-                family_head,
-            },
-            vec![],
-        )
-        .await
-    }
-
-    async fn kick_family_member(
-        &self,
-        signature: String,
-        member: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::KickFamilyMember { signature, member },
-            vec![],
-        )
-        .await
-    }
-
-    async fn kick_family_member_on_behalf(
-        &self,
-        head_address: String,
-        signature: String,
-        member: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::KickFamilyMemberOnBehalf {
-                head_address,
-                signature,
-                member,
-            },
-            vec![],
-        )
-        .await
-    }
    // mixnode-related:

    async fn bond_mixnode(
@@ -321,35 +180,6 @@ pub trait MixnetSigningClient {
        .await
    }

-    async fn pledge_more(
-        &self,
-        additional_pledge: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::PledgeMore {},
-            vec![additional_pledge],
-        )
-        .await
-    }
-
-    async fn pledge_more_on_behalf(
-        &self,
-        owner: AccountId,
-        additional_pledge: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_mixnet_contract(
-            fee,
-            MixnetExecuteMsg::PledgeMoreOnBehalf {
-                owner: owner.to_string(),
-            },
-            vec![additional_pledge],
-        )
-        .await
-    }
-
    async fn unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
        self.execute_mixnet_contract(fee, MixnetExecuteMsg::UnbondMixnode {}, vec![])
            .await
@@ -4,19 +4,13 @@
 use crate::nymd::error::NymdError;
 use crate::nymd::{CosmWasmClient, NymdClient};

-use cw3::{ProposalListResponse, ProposalResponse};
-use multisig_contract_common::msg::QueryMsg;
+use multisig_contract_common::msg::{ProposalResponse, QueryMsg};

 use async_trait::async_trait;

 #[async_trait]
 pub trait MultisigQueryClient {
    async fn get_proposal(&self, proposal_id: u64) -> Result<ProposalResponse, NymdError>;
-    async fn list_proposals(
-        &self,
-        start_after: Option<u64>,
-        limit: Option<u32>,
-    ) -> Result<ProposalListResponse, NymdError>;
 }

 #[async_trait]
@@ -27,15 +21,4 @@ impl<C: CosmWasmClient + Sync + Send> MultisigQueryClient for NymdClient<C> {
            .query_contract_smart(self.multisig_contract_address(), &request)
            .await
    }
-
-    async fn list_proposals(
-        &self,
-        start_after: Option<u64>,
-        limit: Option<u32>,
-    ) -> Result<ProposalListResponse, NymdError> {
-        let request = QueryMsg::ListProposals { start_after, limit };
-        self.client
-            .query_contract_smart(self.multisig_contract_address(), &request)
-            .await
-    }
 }
@@ -7,11 +7,11 @@ use crate::nymd::error::NymdError;
 use crate::nymd::{Fee, NymdClient};

 use coconut_bandwidth_contract_common::msg::ExecuteMsg as CoconutBandwidthExecuteMsg;
-use cw3::Vote;
 use multisig_contract_common::msg::ExecuteMsg;

 use async_trait::async_trait;
 use cosmwasm_std::{to_binary, Coin, CosmosMsg, WasmMsg};
+use cw3::Vote;

 #[async_trait]
 pub trait MultisigSigningClient {
@@ -64,21 +64,6 @@ pub trait VestingSigningClient {
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

-    async fn vesting_pledge_more(
-        &self,
-        additional_pledge: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        self.execute_vesting_contract(
-            fee,
-            VestingExecuteMsg::PledgeMore {
-                amount: additional_pledge.into(),
-            },
-            vec![],
-        )
-        .await
-    }
-
    async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError>;

    async fn vesting_track_unbond_mixnode(
@@ -9,7 +9,8 @@ use reqwest::Response;
 use serde::{Deserialize, Serialize};
 use url::Url;
 use validator_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
+    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
+    VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
    GatewayCoreStatusResponse, GatewayStatusReportResponse, GatewayUptimeHistoryResponse,
@@ -26,7 +27,6 @@ type Params<'a, K, V> = &'a [(K, V)];

 const NO_PARAMS: Params<'_, &'_ str, &'_ str> = &[];

-#[derive(Clone)]
 pub struct Client {
    url: Url,
    reqwest_client: reqwest::Client,
@@ -443,6 +443,34 @@ impl Client {
        .await
    }

+    pub async fn get_coconut_verification_key(
+        &self,
+    ) -> Result<VerificationKeyResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_VERIFICATION_KEY,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_cosmos_address(&self) -> Result<CosmosAddressResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_COSMOS_ADDRESS,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
    pub async fn verify_bandwidth_credential(
        &self,
        request_body: &VerifyCredentialBody,
@@ -15,6 +15,8 @@ pub const BANDWIDTH: &str = "bandwidth";

 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
 pub const COCONUT_PARTIAL_BANDWIDTH_CREDENTIAL: &str = "partial-bandwidth-credential";
+pub const COCONUT_VERIFICATION_KEY: &str = "verification-key";
+pub const COCONUT_COSMOS_ADDRESS: &str = "cosmos-address";
 pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";

 pub const STATUS_ROUTES: &str = "status";
@@ -22,7 +22,6 @@ thiserror = "1"
 time = { version = "0.3.6", features = ["parsing", "formatting"] }
 toml = "0.5.6"
 url = "2.2"
-tap = "1"

 cosmrs = { git = "https://github.com/neacsu/cosmos-rust", branch = "neacsu/feegrant_support" }
 cosmwasm-std = { version = "1.0.0" }
@@ -15,10 +15,4 @@ pub enum ContextError {
    // TODO: improve this to return known errors
    #[error("failed to create client - {0}")]
    NymdError(String),
-
-    #[error("{0}")]
-    NymdErrorPassthrough(#[from] validator_client::nymd::error::NymdError),
-
-    #[error("{0}")]
-    ValidatorClientError(#[from] validator_client::ValidatorClientError),
 }
@@ -6,7 +6,6 @@ use network_defaults::{
    var_names::{API_VALIDATOR, MIXNET_CONTRACT_ADDRESS, NYMD_VALIDATOR, VESTING_CONTRACT_ADDRESS},
    NymNetworkDetails,
 };
-use tap::prelude::*;
 use validator_client::nymd::{self, AccountId, NymdClient, QueryNymdClient, SigningNymdClient};
 pub use validator_client::validator_api::Client as ValidatorApiClient;

@@ -59,7 +58,7 @@ pub fn create_signing_client(
    network_details: &NymNetworkDetails,
 ) -> Result<SigningClient, ContextError> {
    let client_config = nymd::Config::try_from_nym_network_details(network_details)
-        .tap_err(|e| log::error!("Failed to get client config - {:?}", e))?;
+        .expect("failed to construct valid validator client config with the provided network");

    // get mnemonic
    let mnemonic = match std::env::var("MNEMONIC") {
@@ -88,7 +87,7 @@ pub fn create_query_client(
    network_details: &NymNetworkDetails,
 ) -> Result<QueryClient, ContextError> {
    let client_config = nymd::Config::try_from_nym_network_details(network_details)
-        .tap_err(|e| log::error!("Failed to get client config - {:?}", e))?;
+        .expect("failed to construct valid validator client config with the provided network");

    let nymd_url = network_details
        .endpoints
@@ -108,7 +107,7 @@ pub fn create_signing_client_with_validator_api(
    network_details: &NymNetworkDetails,
 ) -> Result<SigningClientWithValidatorAPI, ContextError> {
    let client_config = validator_client::Config::try_from_nym_network_details(network_details)
-        .tap_err(|e| log::error!("Failed to get client config - {:?}", e))?;
+        .expect("failed to construct valid validator client config with the provided network");

    // get mnemonic
    let mnemonic = match std::env::var("MNEMONIC") {
@@ -130,7 +129,7 @@ pub fn create_query_client_with_validator_api(
    network_details: &NymNetworkDetails,
 ) -> Result<QueryClientWithValidatorAPI, ContextError> {
    let client_config = validator_client::Config::try_from_nym_network_details(network_details)
-        .tap_err(|e| log::error!("Failed to get client config - {:?}", e))?;
+        .expect("failed to construct valid validator client config with the provided network");

    match validator_client::client::Client::new_query(client_config) {
        Ok(client) => Ok(client),
@@ -3,11 +3,11 @@

 use clap::Parser;
 use cosmrs::AccountId;
-use log::{error, info};
+use log::info;

 use validator_client::nymd::{Coin, VestingQueryClient};

-use crate::context::QueryClient;
+use crate::context::SigningClient;
 use crate::utils::show_error;
 use crate::utils::{pretty_coin, pretty_cosmwasm_coin};

@@ -18,16 +18,8 @@ pub struct Args {
    pub address: Option<AccountId>,
 }

-pub async fn balance(args: Args, client: QueryClient, address_from_mnemonic: Option<AccountId>) {
-    if args.address.is_none() && address_from_mnemonic.is_none() {
-        error!("Please specify an account address or a mnemonic to get the balance for");
-        return;
-    }
-
-    let account_id = args
-        .address
-        .unwrap_or_else(|| address_from_mnemonic.expect("please provide a mnemonic"));
-
+pub async fn balance(args: Args, client: SigningClient) {
+    let account_id = args.address.unwrap_or_else(|| client.address().clone());
    let vesting_address = account_id.to_string();
    let denom = client.current_chain_details().mix_denom.base.as_str();

@@ -4,11 +4,11 @@
 use clap::Parser;
 use cosmrs::AccountId;
 use cosmwasm_std::Coin as CosmWasmCoin;
-use log::{error, info};
+use log::info;

 use validator_client::nymd::{Coin, VestingQueryClient};

-use crate::context::QueryClient;
+use crate::context::SigningClient;
 use crate::utils::show_error;
 use crate::utils::{pretty_coin, pretty_cosmwasm_coin};

@@ -19,18 +19,8 @@ pub struct Args {
    pub address: Option<AccountId>,
 }

-pub async fn query(args: Args, client: QueryClient, address_from_mnemonic: Option<AccountId>) {
-    if args.address.is_none() && address_from_mnemonic.is_none() {
-        error!("Please specify an account address or a mnemonic to get the balance for");
-        return;
-    }
-
-    let account_id = args
-        .address
-        .unwrap_or_else(|| address_from_mnemonic.expect("please provide a mnemonic"));
-
-    info!("Checking account {} for a vesting schedule...", account_id);
-
+pub async fn query(args: Args, client: SigningClient) {
+    let account_id = args.address.unwrap_or_else(|| client.address().clone());
    let vesting_address = account_id.to_string();
    let denom = client.current_chain_details().mix_denom.base.as_str();

@@ -11,10 +11,6 @@ use std::{fs, io};

 pub mod defaults;

-pub const CONFIG_DIR: &str = "config";
-pub const DATA_DIR: &str = "data";
-pub const DB_FILE_NAME: &str = "db.sqlite";
-
 pub trait NymConfig: Default + Serialize + DeserializeOwned {
    fn template() -> &'static str;

@@ -27,17 +23,17 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
    // default, most probable, implementations; can be easily overridden where required
    fn default_config_directory(id: Option<&str>) -> PathBuf {
        if let Some(id) = id {
-            Self::default_root_directory().join(id).join(CONFIG_DIR)
+            Self::default_root_directory().join(id).join("config")
        } else {
-            Self::default_root_directory().join(CONFIG_DIR)
+            Self::default_root_directory().join("config")
        }
    }

    fn default_data_directory(id: Option<&str>) -> PathBuf {
        if let Some(id) = id {
-            Self::default_root_directory().join(id).join(DATA_DIR)
+            Self::default_root_directory().join(id).join("data")
        } else {
-            Self::default_root_directory().join(DATA_DIR)
+            Self::default_root_directory().join("data")
        }
    }

@@ -51,17 +47,17 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {

    fn try_default_config_directory(id: Option<&str>) -> Option<PathBuf> {
        if let Some(id) = id {
-            Self::try_default_root_directory().map(|d| d.join(id).join(CONFIG_DIR))
+            Self::try_default_root_directory().map(|d| d.join(id).join("config"))
        } else {
-            Self::try_default_root_directory().map(|d| d.join(CONFIG_DIR))
+            Self::try_default_root_directory().map(|d| d.join("config"))
        }
    }

    fn try_default_data_directory(id: Option<&str>) -> Option<PathBuf> {
        if let Some(id) = id {
-            Self::try_default_root_directory().map(|d| d.join(id).join(DATA_DIR))
+            Self::try_default_root_directory().map(|d| d.join(id).join("data"))
        } else {
-            Self::try_default_root_directory().map(|d| d.join(DATA_DIR))
+            Self::try_default_root_directory().map(|d| d.join("data"))
        }
    }

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

-pub const BANDWIDTH_PROPOSAL_ID: &str = "proposal_id";
+pub const PROPOSAL_ID: &str = "proposal_id";
@@ -7,9 +7,7 @@ edition = "2021"

 [dependencies]
 cosmwasm-std = "1.0.0"
-cw-utils = "0.13.4"
 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }

-contracts-common = { path = "../contracts-common" }
-multisig-contract-common = { path = "../multisig-contract" }
+contracts-common = { path = "../contracts-common" }
@@ -2,16 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, NodeIndex};
-use cosmwasm_std::Addr;
+use cosmwasm_std::{Addr, Coin};
 use serde::{Deserialize, Serialize};

-#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "snake_case")]
 pub struct DealerDetails {
    pub address: Addr,
    pub bte_public_key_with_proof: EncodedBTEPublicKeyWithProof,
-    pub announce_address: String,
    pub assigned_index: NodeIndex,
+    pub deposit: Coin,
 }

 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
@@ -28,7 +28,7 @@ impl DealerType {
    }
 }

-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub struct DealerDetailsResponse {
    pub details: Option<DealerDetails>,
@@ -44,7 +44,7 @@ impl DealerDetailsResponse {
    }
 }

-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub struct PagedDealerResponse {
    pub dealers: Vec<DealerDetails>,
@@ -2,4 +2,3 @@
 // SPDX-License-Identifier: Apache-2.0

 pub const NODE_INDEX: &str = "node_index";
-pub const DKG_PROPOSAL_ID: &str = "proposal_id";
@@ -2,4 +2,3 @@ pub mod dealer;
 pub mod event_attributes;
 pub mod msg;
 pub mod types;
-pub mod verification_key;
@@ -2,17 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof};
-use crate::verification_key::VerificationKeyShare;
-use cosmwasm_std::Addr;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 pub struct InstantiateMsg {
    pub group_addr: String,
-    pub multisig_addr: String,
-    pub admin: String,
    pub mix_denom: String,
+    pub admin: String,
 }

 #[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, JsonSchema)]
@@ -20,22 +17,19 @@ pub struct InstantiateMsg {
 pub enum ExecuteMsg {
    RegisterDealer {
        bte_key_with_proof: EncodedBTEPublicKeyWithProof,
-        announce_address: String,
    },

    CommitDealing {
        dealing_bytes: ContractSafeBytes,
    },

-    CommitVerificationKeyShare {
-        share: VerificationKeyShare,
-    },
-
-    VerifyVerificationKeyShare {
-        owner: Addr,
-    },
-
    AdvanceEpochState {},
+
+    // DEBUG ONLY TXs. THEY SHALL BE REMOVED BEFORE FINALISING THE CODE
+    // only exists for debugging purposes on local network to reset the entire state of the contract
+    DebugUnsafeResetAll {
+        init_msg: InstantiateMsg,
+    },
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
@@ -53,15 +47,12 @@ pub enum QueryMsg {
        limit: Option<u32>,
        start_after: Option<String>,
    },
+    GetDepositAmount {},
    GetDealing {
        idx: u64,
        limit: Option<u32>,
        start_after: Option<String>,
    },
-    GetVerificationKeys {
-        limit: Option<u32>,
-        start_after: Option<String>,
-    },
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
@@ -33,8 +33,6 @@ pub enum EpochState {
    PublicKeySubmission,
    DealingExchange,
    VerificationKeySubmission,
-    VerificationKeyValidation,
-    VerificationKeyFinalization,
    InProgress,
 }

@@ -50,8 +48,6 @@ impl Display for EpochState {
            EpochState::PublicKeySubmission => write!(f, "PublicKeySubmission"),
            EpochState::DealingExchange => write!(f, "DealingExchange"),
            EpochState::VerificationKeySubmission => write!(f, "VerificationKeySubmission"),
-            EpochState::VerificationKeyValidation => write!(f, "VerificationKeyValidation"),
-            EpochState::VerificationKeyFinalization => write!(f, "VerificationKeyFinalization"),
            EpochState::InProgress => write!(f, "InProgress"),
        }
    }
@@ -62,9 +58,7 @@ impl EpochState {
        match self {
            EpochState::PublicKeySubmission => Some(EpochState::DealingExchange),
            EpochState::DealingExchange => Some(EpochState::VerificationKeySubmission),
-            EpochState::VerificationKeySubmission => Some(EpochState::VerificationKeyValidation),
-            EpochState::VerificationKeyValidation => Some(EpochState::VerificationKeyFinalization),
-            EpochState::VerificationKeyFinalization => Some(EpochState::InProgress),
+            EpochState::VerificationKeySubmission => Some(EpochState::InProgress),
            EpochState::InProgress => None,
        }
    }
@@ -79,3 +73,15 @@ impl EpochState {
        states
    }
 }
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub struct MinimumDepositResponse {
+    pub amount: Coin,
+}
+
+impl MinimumDepositResponse {
+    pub fn new(amount: Coin) -> Self {
+        MinimumDepositResponse { amount }
+    }
+}
@@ -1,70 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::msg::ExecuteMsg;
-use crate::types::NodeIndex;
-use cosmwasm_std::{from_binary, to_binary, Addr, CosmosMsg, StdResult, Timestamp, WasmMsg};
-use cw_utils::Expiration;
-use multisig_contract_common::msg::ExecuteMsg as MultisigExecuteMsg;
-use serde::{Deserialize, Serialize};
-
-pub type VerificationKeyShare = String;
-
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
-pub struct ContractVKShare {
-    pub share: VerificationKeyShare,
-    pub announce_address: String,
-    pub node_index: NodeIndex,
-    pub owner: Addr,
-    pub verified: bool,
-}
-
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub struct PagedVKSharesResponse {
-    pub shares: Vec<ContractVKShare>,
-    pub per_page: usize,
-    pub start_next_after: Option<Addr>,
-}
-
-pub fn to_cosmos_msg(
-    owner: Addr,
-    coconut_dkg_addr: String,
-    multisig_addr: String,
-    expiration_time: Timestamp,
-) -> StdResult<CosmosMsg> {
-    let verify_vk_share_req = ExecuteMsg::VerifyVerificationKeyShare { owner };
-    let verify_vk_share_msg = CosmosMsg::Wasm(WasmMsg::Execute {
-        contract_addr: coconut_dkg_addr,
-        msg: to_binary(&verify_vk_share_req)?,
-        funds: vec![],
-    });
-    let req = MultisigExecuteMsg::Propose {
-        title: String::from("Verify VK share, as ordered by Coconut DKG Contract"),
-        description: String::new(),
-        msgs: vec![verify_vk_share_msg],
-        latest: Some(Expiration::AtTime(expiration_time)),
-    };
-    let msg = CosmosMsg::Wasm(WasmMsg::Execute {
-        contract_addr: multisig_addr,
-        msg: to_binary(&req)?,
-        funds: vec![],
-    });
-
-    Ok(msg)
-}
-
-pub fn owner_from_cosmos_msgs(msgs: &[CosmosMsg]) -> Option<Addr> {
-    if let Some(CosmosMsg::Wasm(WasmMsg::Execute {
-        contract_addr: _,
-        msg,
-        funds: _,
-    })) = msgs.get(0)
-    {
-        if let Ok(ExecuteMsg::VerifyVerificationKeyShare { owner }) = from_binary::<ExecuteMsg>(msg)
-        {
-            return Some(owner);
-        }
-    }
-    None
-}
@@ -15,7 +15,7 @@ pub const MAX_DISPLAY_SIZE: usize = 128;
 // TODO: if we are to use this for different types, it might make sense to introduce something like
 // CommitmentTypeId field on the below for distinguishing different ones. it would somehow become part of the trait
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, JsonSchema)]
-pub struct ContractSafeBytes(pub Vec<u8>);
+pub struct ContractSafeBytes(Vec<u8>);

 impl Deref for ContractSafeBytes {
    type Target = Vec<u8>;
@@ -1,7 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::{IdentityKey, MixId};
+use crate::MixId;
 use cosmwasm_std::{Addr, Coin, Decimal};
 use thiserror::Error;

@@ -133,40 +133,4 @@ pub enum MixnetContractError {

    #[error("Mixnode {mix_id} appears multiple times in the provided rewarded set update!")]
    DuplicateRewardedSetNode { mix_id: MixId },
-
-    #[error("Family with head {head} does not exist!")]
-    FamilyDoesNotExist { head: String },
-
-    #[error("Family with label '{0}' already exists")]
-    FamilyWithLabelExists(String),
-
-    #[error("Invalid layer expected 1, 2 or 3, got {0}")]
-    InvalidLayer(u8),
-
-    #[error("Head already has a family")]
-    FamilyCanHaveOnlyOne,
-
-    #[error("Already member of family {0}")]
-    AlreadyMemberOfFamily(String),
-
-    #[error("Can't join own family, family head {head}, member {member}")]
-    CantJoinOwnFamily {
-        head: IdentityKey,
-        member: IdentityKey,
-    },
-
-    #[error("Can't leave own family, family head {head}, member {member}")]
-    CantLeaveOwnFamily {
-        head: IdentityKey,
-        member: IdentityKey,
-    },
-
-    #[error("{member} is not a member of family {head}")]
-    NotAMember {
-        head: IdentityKey,
-        member: IdentityKey,
-    },
-
-    #[error("Feature is not yet implemented")]
-    NotImplemented,
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jon Häggblad	c61eb014c5	Add timeouts	2022-11-22 23:25:06 +01:00
Jon Häggblad	c10f788a89	getting lane queue lengths in place	2022-11-22 23:07:00 +01:00
Jon Häggblad	73fa863a6a	WIP	2022-11-22 21:55:33 +01:00
Jon Häggblad	a561f1b854	Pass lane queue lengths to inbound future	2022-11-22 13:58:53 +01:00
Jon Häggblad	1c379fa0db	WIP	2022-11-22 11:49:35 +01:00
Jon Häggblad	31778c6e51	WIP	2022-11-22 11:13:38 +01:00
Jon Häggblad	9d0562168e	WIP	2022-11-22 11:00:52 +01:00
Jon Häggblad	701f603825	FIX	2022-11-22 10:37:48 +01:00
Jon Häggblad	97b250433e	WIP	2022-11-22 10:30:16 +01:00