adding line break

Merge branch 'develop' into 308-figma-diff-pass
some cleaning
2022-09-12 17:42:25 +02:00 · 2022-09-12 17:41:14 +02:00 · 2022-09-12 17:39:03 +02:00 · 2022-09-12 17:35:39 +02:00 · 2022-09-12 12:32:10 +02:00 · 2022-09-12 10:38:48 +02:00
1103 changed files with 65140 additions and 27871 deletions
@@ -19,10 +19,10 @@
 Cargo.* @durch @futurechimp @jstuczyn @neacsu @octol

 # JS rules:
-*.js @mmsinclair @fmtabbara @Aid19801
-*.ts @mmsinclair @fmtabbara @Aid19801
-*.tsx @mmsinclair @fmtabbara @Aid19801
-*.jsx @mmsinclair @fmtabbara @Aid19801
+*.js @mmsinclair @fmtabbara
+*.ts @mmsinclair @fmtabbara
+*.tsx @mmsinclair @fmtabbara
+*.jsx @mmsinclair @fmtabbara

 # Something looking like possible documentation rules:
 *.md @mfahampshire
@@ -0,0 +1,36 @@
+name: Daily security audit
+
+on: workflow_dispatch
+jobs:
+  security_audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions-rs/audit-check@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+  notification:
+    if: ${{ failure() }}
+    needs: security_audit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - name: Keybase - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Keybase - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "Nym daily audit"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          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_NYMBTECH_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "test"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -13,9 +13,9 @@ jobs:
    - name: Install rsync
      run: sudo apt-get install rsync
    - uses: rlespinasse/github-slug-action@v3.x
-    - uses: actions/setup-node@v2
+    - uses: actions/setup-node@v3
      with:
-        node-version: '16'
+        node-version: 16
    - name: Setup yarn
      run: npm install -g yarn
    - name: Build
@@ -10,7 +10,7 @@ on:

 jobs:
  build:
-    runs-on: [ self-hosted, custom-linux-exoscale ]
+    runs-on: [ self-hosted, custom-linux ]
    # Enable sccache via environment variable
    env:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
@@ -41,6 +41,13 @@ jobs:
          command: test
          args: --workspace --all-features

+      - 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:
@@ -51,7 +58,7 @@ jobs:
        name: Clippy checks
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
+          args: --workspace --all-features

      - name: Run clippy
        uses: actions-rs/cargo@v1
@@ -4,7 +4,7 @@ on: workflow_dispatch

 jobs:
  build:
-    runs-on: [ self-hosted, custom-linux-exoscale ]
+    runs-on: [ self-hosted, custom-linux ]
    # Enable sccache via environment variable
    env:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
@@ -0,0 +1,56 @@
+name: Nym Connect (rust)
+
+on:
+  push:
+    paths-ignore:
+      - 'explorer/**'
+
+jobs:
+  build:
+    runs-on: [ self-hosted, custom-linux ]
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools libayatana-appindicator3-dev
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path nym-connect/Cargo.toml --workspace
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path nym-connect/Cargo.toml --workspace
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path nym-connect/Cargo.toml --all -- --check
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --manifest-path nym-connect/Cargo.toml --workspace --all-features
+
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --manifest-path nym-connect/Cargo.toml --workspace --all-features -- -D warnings
@@ -0,0 +1,38 @@
+name: Build release of Nym smart contracts
+on:
+  workflow_dispatch:
+
+defaults:
+  run:
+    working-directory: contracts
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: wasm32-unknown-unknown
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build release contracts
+        run: RUSTFLAGS='-C link-arg=-s' cargo build --release --target wasm32-unknown-unknown
+
+      - name: Upload Mixnet Contract Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: mixnet_contract.wasm
+          path: contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm
+          retention-days: 5
+
+      - name: Upload Vesting Contract Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: vesting_contract.wasm
+          path: contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
+          retention-days: 5
@@ -14,9 +14,9 @@ jobs:
    runs-on: custom-runner-linux
    steps:
      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - uses: actions/setup-node@v3
        with:
-          node-version: '16'
+          node-version: 16
      - name: Setup yarn
        run: npm install -g yarn
      - name: Run ESLint
@@ -1,6 +1,7 @@
 name: CI for Network Explorer

 on:
+  workflow_dispatch:
  push:
    paths:
      - 'explorer/**'
@@ -17,9 +18,9 @@ jobs:
    - name: Install rsync
      run: sudo apt-get install rsync
    - uses: rlespinasse/github-slug-action@v3.x
-    - uses: actions/setup-node@v2
+    - uses: actions/setup-node@v3
      with:
-        node-version: '16'
+        node-version: 16
    - name: Setup yarn
      run: npm install -g yarn
      continue-on-error: true
@@ -75,3 +76,14 @@ jobs:
      uses: docker://keybaseio/client:stable-node
      with:
        args: .github/workflows/support-files/notifications/entry_point.sh
+    - name: Deploy
+      if: github.event_name == 'workflow_dispatch'
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CD_PROD_NE_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/dist/"
+        REMOTE_HOST: ${{ secrets.CD_PROD_NE_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CD_PROD_NE_REMOTE_USER }}
+        TARGET: ${{ secrets.CD_PROD_NE_REMOTE_TARGET }}
+        EXCLUDE: "/dist/, /node_modules/"
@@ -2,7 +2,7 @@ name: Nightly builds

 on:
  schedule:
-    - cron: '14 4 * * *'
+    - cron: '14 1 * * *'
 jobs:
  matrix_prep:
    runs-on: ubuntu-latest
@@ -44,12 +44,31 @@ jobs:
          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:
@@ -75,9 +94,9 @@ jobs:
          command: clippy
          args: --workspace --all-targets -- -D warnings

-      - name: Reclaim some disk space (because Windows is being annoying)
+      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
        with:
          command: clean

@@ -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"
+  }
+]
@@ -0,0 +1,174 @@
+name: Nightly builds on dispatch
+
+on: workflow_dispatch
+jobs:
+  matrix_prep:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      # creates the matrix strategy from nightly_build_matrix_includes.json
+      - uses: actions/checkout@v2
+      - id: set-matrix
+        uses: JoshuaTheMiller/conditional-build-matrix@main
+        with:
+          inputFile: '.github/workflows/nightly_build_matrix_on_dispatch.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
+  build:
+    needs: 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 squashfs-tools
+        if: matrix.os == 'ubuntu-latest'
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - 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: 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-latest' }}
+        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: 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
+    runs-on: ubuntu-latest
+    steps:
+      - name: Collect jobs status
+        uses: technote-space/workflow-conclusion-action@v2
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - 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"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          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-nightly"
+          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,26 @@
+name: Nightly builds on dispatch
+
+on: workflow_dispatch
+jobs:
+  notification:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - name: Keybase - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Keybase - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "Notification test"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          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-nightly"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -0,0 +1,50 @@
+name: Publish Nym CLI binaries
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet
+
+jobs:
+  publish-nym-cli:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest, windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-cli-`
+        if: startsWith(github.ref, 'refs/tags/nym-cli-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-cli-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build binary
+        run: make build-nym-cli
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-cli-${{ matrix.platform }}
+          path: |
+            target/release/nym-cli*
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            target/release/nym-cli
@@ -0,0 +1,96 @@
+name: Publish Nym Connect (MacOS)
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-connect
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Check the release tag starts with `nym-connect-`
+        if: startsWith(github.ref, 'refs/tags/nym-connect-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-connect-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install the Apple developer certificate for code signing
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
+        run: |
+          # create variables
+          CERTIFICATE_PATH=$RUNNER_TEMP/build_certificate.p12
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+
+          # import certificate and provisioning profile from secrets
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output $CERTIFICATE_PATH
+
+          # create temporary keychain
+          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+          security unlock-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
+
+          # import certificate to keychain
+          security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
+          security list-keychain -d user -s $KEYCHAIN_PATH
+
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.1
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
+      - name: Install app dependencies and build it
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        run: yarn && yarn build
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-connect_1.0.0_x64.dmg
+          path: nym-connect/target/release/bundle/dmg/nym-connect_1.0.0_x64.dmg
+          retention-days: 30
+
+      - name: Clean up keychain
+        if: ${{ always() }}
+        run: |
+          security delete-keychain $RUNNER_TEMP/app-signing.keychain-db
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            nym-connect/target/release/bundle/dmg/*.dmg
+            nym-connect/target/release/bundle/macos/*.app.tar.gz*
@@ -0,0 +1,68 @@
+name: Publish Nym Connect (Ubuntu)
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-connect
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Tauri dependencies
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y webkit2gtk-4.0 libayatana-appindicator3-dev
+      - name: Check the release tag starts with `nym-connect-`
+        if: startsWith(github.ref, 'refs/tags/nym-connect-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-connect-...')
+
+      - name: Node v16
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install app dependencies
+        run: yarn
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.1
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
+      - name: Build app
+        run: yarn build
+        env:
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-connect.AppImage.tar.gz
+          path: nym-connect/target/release/bundle/appimage/nym-connect_1.0.0_amd64.AppImage
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            nym-connect/target/release/bundle/appimage/*.AppImage
+            nym-connect/target/release/bundle/appimage/*.AppImage.tar.gz*
@@ -0,0 +1,90 @@
+name: Publish Nym Connect (Windows 10)
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+
+defaults:
+  run:
+    working-directory: nym-connect
+
+jobs:
+  publish-tauri:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [windows10]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - name: Clean up first
+        continue-on-error: true
+        working-directory: .
+        run: |
+          cd ..
+          del /s /q /A:H nym
+          rmdir /s /q nym
+
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-connect-`
+        if: startsWith(github.ref, 'refs/tags/nym-connect-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-connect-...')
+
+      - name: Import signing certificate
+        env:
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+        run: |
+          New-Item -ItemType directory -Path certificate
+          Set-Content -Path certificate/tempCert.txt -Value $env:WINDOWS_CERTIFICATE
+          certutil -decode certificate/tempCert.txt certificate/certificate.pfx
+          Remove-Item -path certificate -include tempCert.txt
+          Import-PfxCertificate -FilePath certificate/certificate.pfx -CertStoreLocation Cert:\CurrentUser\My -Password (ConvertTo-SecureString -String $env:WINDOWS_CERTIFICATE_PASSWORD -Force -AsPlainText)
+
+      - name: Node v16
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.1
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
+      - name: Install app dependencies
+        run: yarn
+
+      - name: Build and sign it
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ENABLE_CODE_SIGNING: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        run: yarn build
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-connect_1.0.0_x64_en-US.msi
+          path: nym-connect/target/release/bundle/msi/nym-connect_1.0.0_x64_en-US.msi
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            nym-connect/target/release/bundle/msi/*.msi
+            nym-connect/target/release/bundle/msi/*.msi.zip*
@@ -0,0 +1,59 @@
+name: CI for nym-connect
+
+on:
+  push:
+    paths:
+      - 'nym-connect/**'
+
+defaults:
+  run:
+    working-directory: nym-connect
+
+jobs:
+  build:
+    runs-on: custom-runner-linux
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install rsync
+      run: sudo apt-get install rsync
+    - uses: rlespinasse/github-slug-action@v3.x
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 16
+    - name: Install Yarn
+      run: npm install -g yarn
+    - run: yarn
+      continue-on-error: true
+    - name: Set environment from the example
+      run: cp .env.sample .env
+    - run: yarn storybook:build
+    - name: Deploy branch to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "nym-connect/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/nym-connect-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: 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
@@ -1,5 +1,7 @@
 name: Publish Nym binaries
+
 on:
+  workflow_dispatch:
  release:
    types: [created]
    
@@ -18,7 +20,7 @@ jobs:
      - uses: actions/checkout@v3

      - name: Check the release tag starts with `nym-binaries-`
-        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false
+        if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false && github.event_name != 'workflow_dispatch'
        uses: actions/github-script@v3
        with:
          script: |
@@ -35,8 +37,24 @@ jobs:
          command: build
          args: --workspace --release

+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: my-artifact
+          path: |
+            target/release/nym-client
+            target/release/nym-gateway
+            target/release/nym-mixnode
+            target/release/nym-socks5-client
+            target/release/nym-validator-api
+            target/release/nym-network-requester
+            target/release/nym-network-statistics
+            target/release/nym-cli
+          retention-days: 30
+
      - name: Upload to release based on tag name
        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
        with:
          files: |
            target/release/nym-client
@@ -45,3 +63,5 @@ jobs:
            target/release/nym-socks5-client
            target/release/nym-validator-api
            target/release/nym-network-requester
+            target/release/nym-network-statistics
+            target/release/nym-cli
@@ -1,5 +1,6 @@
 name: Publish Nym Wallet (MacOS)
 on:
+  workflow_dispatch:
  release:
    types: [created]

@@ -19,16 +20,16 @@ jobs:
      - uses: actions/checkout@v2

      - name: Check the release tag starts with `nym-wallet-`
-        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
+        if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false && github.event_name != 'workflow_dispatch'
        uses: actions/github-script@v3
        with:
          script: |
            core.setFailed('Release tag did not start with nym-wallet-...')

      - name: Node v16
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
        with:
-          node-version: 16.x
+          node-version: 16
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
@@ -55,6 +56,12 @@ jobs:
          security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
          security list-keychain -d user -s $KEYCHAIN_PATH

+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.1
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
      - name: Install app dependencies and build it
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -68,14 +75,22 @@ jobs:
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
        run: yarn && yarn build

-      - name: Upload to release based on tag name
-        uses: softprops/action-gh-release@v1
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
        with:
-          files: |
-            nym-wallet/target/release/bundle/dmg/*.dmg
-            nym-wallet/target/release/bundle/macos/*.app.tar.gz*
+          name: nym-wallet.app.tar.gz
+          path: nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz
+          retention-days: 5

      - name: Clean up keychain
        if: ${{ always() }}
        run: |
          security delete-keychain $RUNNER_TEMP/app-signing.keychain-db
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            nym-wallet/target/release/bundle/dmg/*.dmg
+            nym-wallet/target/release/bundle/macos/*.app.tar.gz*
@@ -30,15 +30,21 @@ jobs:
            core.setFailed('Release tag did not start with nym-wallet-...')

      - name: Node v16
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
        with:
-          node-version: 16.x
+          node-version: 16
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
      - name: Install app dependencies
        run: yarn
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.1
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
      - name: Build app
        run: yarn build
        env:
@@ -45,15 +45,21 @@ jobs:
          Import-PfxCertificate -FilePath certificate/certificate.pfx -CertStoreLocation Cert:\CurrentUser\My -Password (ConvertTo-SecureString -String $env:WINDOWS_CERTIFICATE_PASSWORD -Force -AsPlainText)

      - name: Node v16
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
        with:
-          node-version: 16.x
+          node-version: 16

      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable

+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.1
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
      - name: Install app dependencies
        run: yarn

@@ -0,0 +1,32 @@
+name: Release Nym Wallet
+on:
+  workflow_dispatch:
+    inputs:
+      nym_wallet_version:
+        description: 'The version of the Nym Wallet to release'
+        default: '1.0.x'
+        required: true
+        type: string
+jobs:
+  create-release:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Create release
+        uses: softprops/action-gh-release@v1
+        with:
+          body: >-
+            This is a pre-release
+            
+            Download the wallet for your platform:
+            
+              - [Linux](https://github.com/nymtech/nym/releases/download/nym-wallet-v${{ inputs.nym_wallet_version}}/nym-wallet_v${{ inputs.nym_wallet_version}}_amd64_ubuntu20.04.AppImage)
+              - [MacOS](https://github.com/nymtech/nym/releases/download/nym-wallet-v${{ inputs.nym_wallet_version}}/nym-wallet_v${{ inputs.nym_wallet_version}}_x64_macos_11.dmg)
+              - [Windows](https://github.com/nymtech/nym/releases/download/nym-wallet-v${{ inputs.nym_wallet_version}}/nym-wallet_v${{ inputs.nym_wallet_version}}_x64_windows.msi)
+          prerelease: true
+          name: Nym Wallet v${{ inputs.nym_wallet_version}}
+          tag_name: nym-wallet-v${{ inputs.nym_wallet_version}}
@@ -13,9 +13,9 @@ jobs:
    - name: Install rsync
      run: sudo apt-get install rsync
    - uses: rlespinasse/github-slug-action@v3.x
-    - uses: actions/setup-node@v2
+    - uses: actions/setup-node@v3
      with:
-        node-version: '16'
+        node-version: 16
    - name: Setup yarn
      run: npm install -g yarn
    - name: Build dependencies
@@ -34,9 +34,9 @@ jobs:
          toolchain: stable

      - name: Node v16
-        uses: actions/setup-node@v1
+        uses: actions/setup-node@v3
        with:
-          node-version: 16.x
+          node-version: 16

      - name: Install yarn for building application
        run: yarn install
@@ -3,7 +3,7 @@ require('dotenv').config();
 const Bot = require('keybase-bot');

 let context = {
-  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly'],
+  kinds: ['nym-wallet', 'ts-packages', 'network-explorer', 'nightly', 'nym-connect'],
 };

 /**
@@ -0,0 +1,29 @@
+const Handlebars = require('handlebars');
+const fs = require('fs');
+const path = require('path');
+
+async function addToContextAndValidate(context) {
+  if (!context.env.NYM_CI_WWW_LOCATION) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_LOCATION is set');
+  }
+  if (!context.env.NYM_CI_WWW_BASE) {
+    throw new Error('Please ensure the env var NYM_CI_WWW_BASE is set');
+  }
+}
+
+async function getMessageBody(context) {
+  const source = fs
+    .readFileSync(
+      context.env.IS_SUCCESS === 'true'
+        ? path.resolve(__dirname, 'templates', 'success')
+        : path.resolve(__dirname, 'templates', 'failure'),
+    )
+    .toString();
+  const template = Handlebars.compile(source);
+  return template(context);
+}
+
+module.exports = {
+  addToContextAndValidate,
+  getMessageBody,
+};
@@ -0,0 +1,11 @@
+🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥
+> :rocket: {{ env.NYM_PROJECT_NAME }}
+> 🔴 **FAILURE** :cry:
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```
@@ -0,0 +1,11 @@
+🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩🟩
+> :rocket: {{ env.NYM_PROJECT_NAME }}  ➡️➡️➡️➡️➡️ **View storybook:** https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}/
+> ✅ **SUCCESS**
+> `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
+> `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
+> `build ` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/actions/runs/{{ env.GITHUB_RUN_ID }}
+
+Commit message by `{{ env.GITHUB_ACTOR }}` at {{ timestamp }}:
+```
+{{ env.GIT_COMMIT_MESSAGE }}
+```
@@ -10,7 +10,9 @@ on:

 jobs:
  build:
-    runs-on: [ self-hosted, custom-linux-exoscale ]
+    runs-on: [ self-hosted, custom-linux ]
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
@@ -1,40 +1,110 @@
 # Changelog

-## [Unreleased]
+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).
+
+## Unreleased

 ### Added

- wallet: require password to switch accounts
- wallet: add simple CLI tool for decrypting and recovering the wallet file.
- wallet: added support for multiple accounts ([#1265])
- wallet: the wallet backend learned how to keep track of validator name, either hardcoded or by querying the status endpoint.
- mixnet-contract: Replace all naked `-` with `saturating_sub`.
- validator-api: add Swagger to document the REST API ([#1249]).
- all: added network compilation target to `--help` (or `--version`) commands ([#1256]).
- network-requester: send traffic statistics from all network requesters and receive it in a special network-requester that aggregates the data and exposes it via a rest API ([#1267], [#1278]).
-
-### Fixed
-
- vesting-contract: replaced `checked_sub` with `saturating_sub` to fix the underflow in `get_vesting_tokens` ([#1275])
- mixnet-contract: removed `expect` in `query_delegator_reward` and queries containing invalid proxy address should now return a more human-readable error ([#1257])
- mixnet-contract: Under certain circumstances nodes could not be unbonded ([#1255](https://github.com/nymtech/nym/issues/1255)) ([#1258])
- mixnode, gateway: attempting to determine reconnection backoff to persistently failing mixnode could result in a crash ([#1260])
-
-[#1258]: https://github.com/nymtech/nym/pull/1258
-[#1249]: https://github.com/nymtech/nym/pull/1249
-[#1256]: https://github.com/nymtech/nym/pull/1256
-[#1257]: https://github.com/nymtech/nym/pull/1257
-[#1260]: https://github.com/nymtech/nym/pull/1260
-[#1265]: https://github.com/nymtech/nym/pull/1265
-[#1267]: https://github.com/nymtech/nym/pull/1267
-[#1275]: https://github.com/nymtech/nym/pull/1275
-[#1278]: https://github.com/nymtech/nym/pull/1278
-
-## [nym-wallet-v1.0.4](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.4) (2022-05-04)
+- nym-cli: added CLI tool for interacting with the Nyx blockchain and Nym mixnet smart contracts ([#1577])
+- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])

 ### Changed

- all: the default behaviour of validator client is changed to use `broadcast_sync` and poll for transaction inclusion instead of using `broadcast_commit` to deal with timeouts ([#1246])
+- validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
+- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
+
+[#1541]: https://github.com/nymtech/nym/pull/1541
+[#1558]: https://github.com/nymtech/nym/pull/1558
+[#1577]: https://github.com/nymtech/nym/pull/1577
+[#1591]: https://github.com/nymtech/nym/pull/1591
+
+
+## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)
+
+### Added
+
+- socks5 client/websocket client: add `--force-register-gateway` flag, useful when rerunning init ([#1353])
+- all: added network compilation target to `--help` (or `--version`) commands ([#1256]).
+- explorer-api: learned how to sum the delegations by owner in a new endpoint.
+- explorer-api: add apy values to `mix_nodes` endpoint
+- gateway: Added gateway coconut verifications and validator-api communication for double spending protection ([#1261])
+- network-explorer-ui: Upgrade to React Router 6
+- rewarding: replace circulating supply with staking supply in reward calculations ([#1324])
+- validator-api: add `estimated_node_profit` and `estimated_operator_cost` to `reward-estimate` endpoint ([#1284])
+- validator-api: add detailed mixnode bond endpoints, and explorer-api makes use of that data to append stake saturation
+- validator-api: add Swagger to document the REST API ([#1249]).
+- validator-api: Added new endpoints for coconut spending flow and communications with coconut & multisig contracts ([#1261])
+- validator-api: add `uptime`, `estimated_operator_apy`, `estimated_delegators_apy` to `/mixnodes/detailed` endpoint ([#1393])
+- validator-api: add node info cache storing simulated active set inclusion probabilities
+- network-statistics: a new mixnet service that aggregates and exposes anonymized data about mixnet services ([#1328])
+- mixnode: Added basic mixnode hardware reporting to the HTTP API ([#1308]).
+- validator-api: endpoint, in coconut mode, for returning the validator-api cosmos address ([#1404]).
+- validator-client: add `denom` argument and add simple test for querying an account balance
+- gateway, validator-api: Checks for coconut credential double spending attempts, taking the coconut bandwidth contract as source of truth ([#1457])
+- coconut-bandwidth-contract: Record the state of a coconut credential; create specific proposal for releasing funds ([#1457])
+- inclusion-probability: add simulator for active set inclusion probability
+
+### Fixed
+
+- mixnode, gateway: attempting to determine reconnection backoff to persistently failing mixnode could result in a crash ([#1260])
+- mixnode: the mixnode learned how to shutdown gracefully
+- mixnode: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service.
+- native & socks5 clients: fail early when clients try to re-init with a different gateway, which is not supported yet ([#1322])
+- native & socks5 clients: rerun init will now reuse previous gateway configuration instead of failing ([#1353])
+- native & socks5 clients: deduplicate big chunks of init logic
+- validator: fixed local docker-compose setup to work on Apple M1 ([#1329])
+- explorer-api: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service ([#1482]).
+- network-requester: fix filter for suffix-only domains ([#1487])
+- validator-api: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service; cleaner shutdown, without panics ([#1496], [#1573]).
+
+### Changed
+
+- validator-client: created internal `Coin` type that replaces coins from `cosmrs` and `cosmwasm` for API entrypoints [[#1295]]
+- all: updated all `cosmwasm`-related dependencies to `1.0.0` and `cw-storage-plus` to `0.13.4` [[#1318]]
+- all: updated `rocket` to `0.5.0-rc.2`.
+- network-requester: allow to voluntarily store and send statistical data about the number of bytes the proxied server serves ([#1328])
+- gateway: allow to voluntarily send statistical data about the number of active inboxes served by a gateway ([#1376])
+- gateway & mixnode: move detailed build info back to `--version` from `--help`.
+- socks5 client/websocket client: upgrade to latest clap and switched to declarative commandline parsing.
+- validator-api: fee payment for multisig operations comes from the gateway account instead of the validator APIs' accounts ([#1419])
+- multisig-contract: Limit the proposal creating functionality to one address (coconut-bandwidth-contract address) ([#1457])
+- All binaries and cosmwasm blobs are configured at runtime now; binaries are configured using environment variables or .env files and contracts keep the configuration parameters in storage ([#1463])
+- gateway, network-statistics: include gateway id in the sent statistical data ([#1478])
+- network explorer: tweak how active set probability is shown ([#1503])
+- validator-api: rewarder set update fails without panicking on possible nymd queries ([#1520])
+- network-requester, socks5 client (nym-connect): send and receive respectively a message error to be displayed about filter check failure ([#1576]) 
+
+
+[#1249]: https://github.com/nymtech/nym/pull/1249
+[#1256]: https://github.com/nymtech/nym/pull/1256
+[#1260]: https://github.com/nymtech/nym/pull/1260
+[#1261]: https://github.com/nymtech/nym/pull/1261
+[#1267]: https://github.com/nymtech/nym/pull/1267
+[#1278]: https://github.com/nymtech/nym/pull/1278
+[#1295]: https://github.com/nymtech/nym/pull/1295
+[#1302]: https://github.com/nymtech/nym/pull/1302
+[#1308]: https://github.com/nymtech/nym/pull/1308
+[#1318]: https://github.com/nymtech/nym/pull/1318
+[#1322]: https://github.com/nymtech/nym/pull/1322
+[#1324]: https://github.com/nymtech/nym/pull/1324
+[#1328]: https://github.com/nymtech/nym/pull/1328
+[#1329]: https://github.com/nymtech/nym/pull/1329
+[#1353]: https://github.com/nymtech/nym/pull/1353
+[#1376]: https://github.com/nymtech/nym/pull/1376
+[#1393]: https://github.com/nymtech/nym/pull/1393
+[#1404]: https://github.com/nymtech/nym/pull/1404
+[#1419]: https://github.com/nymtech/nym/pull/1419
+[#1457]: https://github.com/nymtech/nym/pull/1457
+[#1463]: https://github.com/nymtech/nym/pull/1463
+[#1478]: https://github.com/nymtech/nym/pull/1478
+[#1482]: https://github.com/nymtech/nym/pull/1482
+[#1487]: https://github.com/nymtech/nym/pull/1487
+[#1496]: https://github.com/nymtech/nym/pull/1496
+[#1503]: https://github.com/nymtech/nym/pull/1503
+[#1520]: https://github.com/nymtech/nym/pull/1520
+[#1573]: https://github.com/nymtech/nym/pull/1573
+[#1576]: https://github.com/nymtech/nym/pull/1576

 ## [v1.0.1](https://github.com/nymtech/nym/tree/v1.0.1) (2022-05-04)

@@ -67,77 +137,10 @@

 [Full Changelog](https://github.com/nymtech/nym/compare/nym-wallet-v1.0.3...nym-binaries-1.0.0)

-## [nym-wallet-v1.0.3](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.3) (2022-04-25)
-
-[Full Changelog](https://github.com/nymtech/nym/compare/nym-binaries-1.0.0-rc.2...nym-wallet-v1.0.3)
-
-**Fixed bugs:**
-
- \[Issue\] Wallet 1.0.2 cannot send NYM tokens from a DelayedVestingAccount [\#1215](https://github.com/nymtech/nym/issues/1215)
- Main README not showing properly with GitHub dark mode [\#1211](https://github.com/nymtech/nym/issues/1211)
-
-**Merged pull requests:**
-
- Bugfix - wallet undelegation for vesting accounts [\#1220](https://github.com/nymtech/nym/pull/1220) ([mmsinclair](https://github.com/mmsinclair))
- Bugfix/delegation reconcile [\#1219](https://github.com/nymtech/nym/pull/1219) ([jstuczyn](https://github.com/jstuczyn))
- Bugfix/query proxied pending delegations [\#1218](https://github.com/nymtech/nym/pull/1218) ([jstuczyn](https://github.com/jstuczyn))
- Using custom gas multiplier in the wallet [\#1217](https://github.com/nymtech/nym/pull/1217) ([jstuczyn](https://github.com/jstuczyn))
- Feature/vesting accounts support [\#1216](https://github.com/nymtech/nym/pull/1216) ([jstuczyn](https://github.com/jstuczyn))
- Release/1.0.0 rc.2 [\#1214](https://github.com/nymtech/nym/pull/1214) ([jstuczyn](https://github.com/jstuczyn))
- chore: fix dark mode rendering [\#1212](https://github.com/nymtech/nym/pull/1212) ([pwnfoo](https://github.com/pwnfoo))
- Feature/spend coconut [\#1210](https://github.com/nymtech/nym/pull/1210) ([neacsu](https://github.com/neacsu))
- Bugfix/unique sphinx key [\#1207](https://github.com/nymtech/nym/pull/1207) ([jstuczyn](https://github.com/jstuczyn))
- Add cache read and write timeouts [\#1206](https://github.com/nymtech/nym/pull/1206) ([durch](https://github.com/durch))
- Additional, more informative routes [\#1204](https://github.com/nymtech/nym/pull/1204) ([durch](https://github.com/durch))
- Feature/aggregated econ dynamics explorer endpoint [\#1203](https://github.com/nymtech/nym/pull/1203) ([jstuczyn](https://github.com/jstuczyn))
- Debugging validator [\#1198](https://github.com/nymtech/nym/pull/1198) ([durch](https://github.com/durch))
- wallet: expose additional validator configuration functionality to the frontend [\#1195](https://github.com/nymtech/nym/pull/1195) ([octol](https://github.com/octol))
- Update rewarding validator address [\#1193](https://github.com/nymtech/nym/pull/1193) ([durch](https://github.com/durch))
- Crypto part of the Groth's NIDKG [\#1182](https://github.com/nymtech/nym/pull/1182) ([jstuczyn](https://github.com/jstuczyn))
- fix unbond page [\#1180](https://github.com/nymtech/nym/pull/1180) ([tommyv1987](https://github.com/tommyv1987))
- Type safe bounds [\#1179](https://github.com/nymtech/nym/pull/1179) ([durch](https://github.com/durch))
- Fix delegation paging [\#1174](https://github.com/nymtech/nym/pull/1174) ([durch](https://github.com/durch))
- Update binaries to rc version [\#1172](https://github.com/nymtech/nym/pull/1172) ([tommyv1987](https://github.com/tommyv1987))
- Bump ansi-regex from 4.1.0 to 4.1.1 in /docker/typescript\_client/upload\_contract [\#1171](https://github.com/nymtech/nym/pull/1171) ([dependabot[bot]](https://github.com/apps/dependabot))
-
 ## [nym-binaries-1.0.0-rc.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.0-rc.2) (2022-04-15)

 [Full Changelog](https://github.com/nymtech/nym/compare/nym-wallet-v1.0.2...nym-binaries-1.0.0-rc.2)

-## [nym-wallet-v1.0.2](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.2) (2022-04-05)
-
-[Full Changelog](https://github.com/nymtech/nym/compare/nym-wallet-v1.0.1...nym-wallet-v1.0.2)
-
-**Merged pull requests:**
-
- Wallet 1.0.2 visual tweaks [\#1197](https://github.com/nymtech/nym/pull/1197) ([mmsinclair](https://github.com/mmsinclair))
- Password for wallet with routes [\#1196](https://github.com/nymtech/nym/pull/1196) ([fmtabbara](https://github.com/fmtabbara))
- Add auto-updater to Nym Wallet [\#1194](https://github.com/nymtech/nym/pull/1194) ([mmsinclair](https://github.com/mmsinclair))
- Fix clippy warnings for beta toolchain [\#1191](https://github.com/nymtech/nym/pull/1191) ([octol](https://github.com/octol))
- wallet: expose validator urls to the frontend [\#1190](https://github.com/nymtech/nym/pull/1190) ([octol](https://github.com/octol))
- wallet: add test for decrypting stored wallet file [\#1189](https://github.com/nymtech/nym/pull/1189) ([octol](https://github.com/octol))
- Fix clippy warnings [\#1188](https://github.com/nymtech/nym/pull/1188) ([octol](https://github.com/octol))
- Password for wallet with routes [\#1187](https://github.com/nymtech/nym/pull/1187) ([mmsinclair](https://github.com/mmsinclair))
- wallet: add validate\_mnemonic [\#1186](https://github.com/nymtech/nym/pull/1186) ([octol](https://github.com/octol))
- wallet: support removing accounts from the wallet file [\#1185](https://github.com/nymtech/nym/pull/1185) ([octol](https://github.com/octol))
- Feature/adding discord [\#1184](https://github.com/nymtech/nym/pull/1184) ([gala1234](https://github.com/gala1234))
- wallet: config backend for validator selection [\#1183](https://github.com/nymtech/nym/pull/1183) ([octol](https://github.com/octol))
- Add storybook to wallet [\#1178](https://github.com/nymtech/nym/pull/1178) ([mmsinclair](https://github.com/mmsinclair))
- wallet: connection test nymd and api urls independently [\#1170](https://github.com/nymtech/nym/pull/1170) ([octol](https://github.com/octol))
- wallet: wire up account storage [\#1153](https://github.com/nymtech/nym/pull/1153) ([octol](https://github.com/octol))
- Feature/signature on deposit [\#1151](https://github.com/nymtech/nym/pull/1151) ([neacsu](https://github.com/neacsu))
-
-## [nym-wallet-v1.0.1](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.1) (2022-04-05)
-
-[Full Changelog](https://github.com/nymtech/nym/compare/nym-binaries-1.0.0-rc.1...nym-wallet-v1.0.1)
-
-**Closed issues:**
-
- Check enabling bbbc simultaneously with open access. Estimate what it would take to make this the default compilation target. [\#1175](https://github.com/nymtech/nym/issues/1175)
- Get coconut credential for deposited tokens [\#1138](https://github.com/nymtech/nym/issues/1138)
- Make payments lazy [\#1135](https://github.com/nymtech/nym/issues/1135)
- Uptime on node selection for sets [\#1049](https://github.com/nymtech/nym/issues/1049)
-
 ## [nym-binaries-1.0.0-rc.1](https://github.com/nymtech/nym/tree/nym-binaries-1.0.0-rc.1) (2022-03-28)

 [Full Changelog](https://github.com/nymtech/nym/compare/nym-wallet-v1.0.0...nym-binaries-1.0.0-rc.1)
@@ -216,108 +219,6 @@
 - feature/pedersen-commitments [\#1048](https://github.com/nymtech/nym/pull/1048) ([danielementary](https://github.com/danielementary))
 - Feature/reuse init owner [\#970](https://github.com/nymtech/nym/pull/970) ([neacsu](https://github.com/neacsu))

-## [nym-wallet-v1.0.0](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.0) (2022-02-03)
-
-[Full Changelog](https://github.com/nymtech/nym/compare/v0.12.1...nym-wallet-v1.0.0)
-
-**Implemented enhancements:**
-
- \[Feature Request\] Please enable registration without need for Telegram account [\#1016](https://github.com/nymtech/nym/issues/1016)
- Fast mixnode launch with a pre-built ISO + VM software [\#1001](https://github.com/nymtech/nym/issues/1001)
-
-**Fixed bugs:**
-
- \[Issue\] [\#1000](https://github.com/nymtech/nym/issues/1000)
- \[Issue\] `nym-client` requires multiple attempts to run a server [\#869](https://github.com/nymtech/nym/issues/869)
- De-'float'-ing `Interval` \(`Display` impl + `serde`\) [\#1065](https://github.com/nymtech/nym/pull/1065) ([jstuczyn](https://github.com/jstuczyn))
- display client address on wallet creation [\#1058](https://github.com/nymtech/nym/pull/1058) ([fmtabbara](https://github.com/fmtabbara))
-
-**Closed issues:**
-
- Rewarded set inclusion probability API endpoint [\#1037](https://github.com/nymtech/nym/issues/1037)
- Update cw-storage-plus to 0.11  [\#1032](https://github.com/nymtech/nym/issues/1032)
- Change `u128` fields in `RewardEstimationResponse` to `u64` [\#1029](https://github.com/nymtech/nym/issues/1029)
- Test out the mainnet Gravity Bridge [\#1006](https://github.com/nymtech/nym/issues/1006)
- Add vesting contract interface to nym-wallet [\#959](https://github.com/nymtech/nym/issues/959)
- Mixnode crash [\#486](https://github.com/nymtech/nym/issues/486)
-
-**Merged pull requests:**
-
- create custom urls for mainnet [\#1095](https://github.com/nymtech/nym/pull/1095) ([fmtabbara](https://github.com/fmtabbara))
- Wallet signing on MacOS [\#1093](https://github.com/nymtech/nym/pull/1093) ([mmsinclair](https://github.com/mmsinclair))
- Fix rust 2018 idioms warnings [\#1092](https://github.com/nymtech/nym/pull/1092) ([octol](https://github.com/octol))
- Prevent contract overwriting [\#1090](https://github.com/nymtech/nym/pull/1090) ([durch](https://github.com/durch))
- Logout operation [\#1087](https://github.com/nymtech/nym/pull/1087) ([jstuczyn](https://github.com/jstuczyn))
- Update to rust edition 2021 everywhere [\#1086](https://github.com/nymtech/nym/pull/1086) ([octol](https://github.com/octol))
- Tag contract errors, and print out lines for easier QA [\#1084](https://github.com/nymtech/nym/pull/1084) ([durch](https://github.com/durch))
- Feature/flexible vesting + utility queries [\#1083](https://github.com/nymtech/nym/pull/1083) ([durch](https://github.com/durch))
- Bump @openzeppelin/contracts from 4.3.1 to 4.4.2 in /contracts/basic-bandwidth-generation [\#1082](https://github.com/nymtech/nym/pull/1082) ([dependabot[bot]](https://github.com/apps/dependabot))
- Bump nth-check from 2.0.0 to 2.0.1 in /clients/native/examples/js-examples/websocket [\#1081](https://github.com/nymtech/nym/pull/1081) ([dependabot[bot]](https://github.com/apps/dependabot))
- Bump url-parse from 1.5.1 to 1.5.4 in /clients/native/examples/js-examples/websocket [\#1080](https://github.com/nymtech/nym/pull/1080) ([dependabot[bot]](https://github.com/apps/dependabot))
- Bump follow-redirects from 1.14.1 to 1.14.7 in /clients/native/examples/js-examples/websocket [\#1079](https://github.com/nymtech/nym/pull/1079) ([dependabot[bot]](https://github.com/apps/dependabot))
- Bump nanoid from 3.1.23 to 3.2.0 in /clients/native/examples/js-examples/websocket [\#1078](https://github.com/nymtech/nym/pull/1078) ([dependabot[bot]](https://github.com/apps/dependabot))
- Setup basic test for mixnode stats reporting [\#1077](https://github.com/nymtech/nym/pull/1077) ([octol](https://github.com/octol))
- Make wallet\_address mandatory for mixnode init [\#1076](https://github.com/nymtech/nym/pull/1076) ([octol](https://github.com/octol))
- Tidy nym-mixnode module visibility [\#1075](https://github.com/nymtech/nym/pull/1075) ([octol](https://github.com/octol))
- Feature/wallet login with password [\#1074](https://github.com/nymtech/nym/pull/1074) ([fmtabbara](https://github.com/fmtabbara))
- Add trait to mock client dependency in DelayForwarder [\#1073](https://github.com/nymtech/nym/pull/1073) ([octol](https://github.com/octol))
- Bump rust-version to latest stable for nym-mixnode [\#1072](https://github.com/nymtech/nym/pull/1072) ([octol](https://github.com/octol))
- Fixes CI for our wasm build [\#1069](https://github.com/nymtech/nym/pull/1069) ([jstuczyn](https://github.com/jstuczyn))
- Add @octol as codeowner [\#1068](https://github.com/nymtech/nym/pull/1068) ([octol](https://github.com/octol))
- set-up inclusion probability [\#1067](https://github.com/nymtech/nym/pull/1067) ([fmtabbara](https://github.com/fmtabbara))
- Feature/wasm client [\#1066](https://github.com/nymtech/nym/pull/1066) ([neacsu](https://github.com/neacsu))
- Changed bech32\_prefix from punk to nymt [\#1064](https://github.com/nymtech/nym/pull/1064) ([jstuczyn](https://github.com/jstuczyn))
- Bump nanoid from 3.1.30 to 3.2.0 in /testnet-faucet [\#1063](https://github.com/nymtech/nym/pull/1063) ([dependabot[bot]](https://github.com/apps/dependabot))
- Bump nanoid from 3.1.30 to 3.2.0 in /nym-wallet [\#1062](https://github.com/nymtech/nym/pull/1062) ([dependabot[bot]](https://github.com/apps/dependabot))
- Rework vesting contract storage [\#1061](https://github.com/nymtech/nym/pull/1061) ([durch](https://github.com/durch))
- Mixnet Contract constants extraction [\#1060](https://github.com/nymtech/nym/pull/1060) ([jstuczyn](https://github.com/jstuczyn))
- fix: make explorer footer year dynamic [\#1059](https://github.com/nymtech/nym/pull/1059) ([martinyung](https://github.com/martinyung))
- Add mnemonic just on creation, to display it [\#1057](https://github.com/nymtech/nym/pull/1057) ([neacsu](https://github.com/neacsu))
- Network Explorer: updates to API and UI to show the active set [\#1056](https://github.com/nymtech/nym/pull/1056) ([mmsinclair](https://github.com/mmsinclair))
- Made contract addresses for query NymdClient construction optional [\#1055](https://github.com/nymtech/nym/pull/1055) ([jstuczyn](https://github.com/jstuczyn))
- Introduced RPC query for total token supply [\#1053](https://github.com/nymtech/nym/pull/1053) ([jstuczyn](https://github.com/jstuczyn))
- Feature/tokio console [\#1052](https://github.com/nymtech/nym/pull/1052) ([durch](https://github.com/durch))
- Implemented beta clippy lint recommendations [\#1051](https://github.com/nymtech/nym/pull/1051) ([jstuczyn](https://github.com/jstuczyn))
- add new function to update profit percentage [\#1050](https://github.com/nymtech/nym/pull/1050) ([fmtabbara](https://github.com/fmtabbara))
- Upgrade Clap and use declarative argument parsing for nym-mixnode [\#1047](https://github.com/nymtech/nym/pull/1047) ([octol](https://github.com/octol))
- Feature/additional bond validation [\#1046](https://github.com/nymtech/nym/pull/1046) ([fmtabbara](https://github.com/fmtabbara))
- Fix clippy on relevant lints [\#1044](https://github.com/nymtech/nym/pull/1044) ([neacsu](https://github.com/neacsu))
- Bump shelljs from 0.8.4 to 0.8.5 in /contracts/basic-bandwidth-generation [\#1043](https://github.com/nymtech/nym/pull/1043) ([dependabot[bot]](https://github.com/apps/dependabot))
- Endpoint for rewarded set inclusion probabilities [\#1042](https://github.com/nymtech/nym/pull/1042) ([durch](https://github.com/durch))
- Bump follow-redirects from 1.14.4 to 1.14.7 in /contracts/basic-bandwidth-generation [\#1041](https://github.com/nymtech/nym/pull/1041) ([dependabot[bot]](https://github.com/apps/dependabot))
- Bump follow-redirects from 1.14.5 to 1.14.7 in /testnet-faucet [\#1040](https://github.com/nymtech/nym/pull/1040) ([dependabot[bot]](https://github.com/apps/dependabot))
- Feature/node settings update [\#1036](https://github.com/nymtech/nym/pull/1036) ([fmtabbara](https://github.com/fmtabbara))
- Migrate to cw-storage-plus 0.11.1 [\#1035](https://github.com/nymtech/nym/pull/1035) ([durch](https://github.com/durch))
- Bump @openzeppelin/contracts from 4.4.1 to 4.4.2 in /contracts/basic-bandwidth-generation [\#1034](https://github.com/nymtech/nym/pull/1034) ([dependabot[bot]](https://github.com/apps/dependabot))
- Feature/configurable wallet [\#1033](https://github.com/nymtech/nym/pull/1033) ([neacsu](https://github.com/neacsu))
- Feature/downcast reward estimation [\#1031](https://github.com/nymtech/nym/pull/1031) ([durch](https://github.com/durch))
- Wallet UI updates [\#1028](https://github.com/nymtech/nym/pull/1028) ([fmtabbara](https://github.com/fmtabbara))
- Remove migration code [\#1027](https://github.com/nymtech/nym/pull/1027) ([neacsu](https://github.com/neacsu))
- Chore/stricter dependency requirements [\#1025](https://github.com/nymtech/nym/pull/1025) ([jstuczyn](https://github.com/jstuczyn))
- Feature/validator api client endpoints [\#1024](https://github.com/nymtech/nym/pull/1024) ([jstuczyn](https://github.com/jstuczyn))
- Updated cosmrs to 0.4.1 [\#1023](https://github.com/nymtech/nym/pull/1023) ([jstuczyn](https://github.com/jstuczyn))
- Feature/testnet deploy scripts [\#1022](https://github.com/nymtech/nym/pull/1022) ([mfahampshire](https://github.com/mfahampshire))
- Changed wallet's client to a full validator client [\#1021](https://github.com/nymtech/nym/pull/1021) ([jstuczyn](https://github.com/jstuczyn))
- Fix 404 link [\#1020](https://github.com/nymtech/nym/pull/1020) ([RiccardoMasutti](https://github.com/RiccardoMasutti))
- Feature/additional mixnode endpoints [\#1019](https://github.com/nymtech/nym/pull/1019) ([jstuczyn](https://github.com/jstuczyn))
- Introduced denom check when trying to withdraw vested coins [\#1018](https://github.com/nymtech/nym/pull/1018) ([jstuczyn](https://github.com/jstuczyn))
- Add network defaults for qa [\#1017](https://github.com/nymtech/nym/pull/1017) ([neacsu](https://github.com/neacsu))
- Feature/expanded events [\#1015](https://github.com/nymtech/nym/pull/1015) ([jstuczyn](https://github.com/jstuczyn))
- update frontend to use new profit update api [\#1014](https://github.com/nymtech/nym/pull/1014) ([fmtabbara](https://github.com/fmtabbara))
- Feature/node state endpoint [\#1013](https://github.com/nymtech/nym/pull/1013) ([jstuczyn](https://github.com/jstuczyn))
- Feature/hourly set updates [\#1012](https://github.com/nymtech/nym/pull/1012) ([durch](https://github.com/durch))
- Feature/remove unused profit margin [\#1011](https://github.com/nymtech/nym/pull/1011) ([neacsu](https://github.com/neacsu))
- Feature/explorer node status [\#1010](https://github.com/nymtech/nym/pull/1010) ([jstuczyn](https://github.com/jstuczyn))
- Use serial integer instead of random [\#1009](https://github.com/nymtech/nym/pull/1009) ([durch](https://github.com/durch))
- Feature/configure profit [\#1008](https://github.com/nymtech/nym/pull/1008) ([neacsu](https://github.com/neacsu))
- Feature/fix gateway sign [\#1004](https://github.com/nymtech/nym/pull/1004) ([neacsu](https://github.com/neacsu))
- Fix clippy [\#1003](https://github.com/nymtech/nym/pull/1003) ([neacsu](https://github.com/neacsu))
- Update wallet version [\#998](https://github.com/nymtech/nym/pull/998) ([tommyv1987](https://github.com/tommyv1987))
- Fix wallet build instructions [\#997](https://github.com/nymtech/nym/pull/997) ([tommyv1987](https://github.com/tommyv1987))
- Make the separation between testnet-mode and erc20 bandwidth mode clearer [\#994](https://github.com/nymtech/nym/pull/994) ([neacsu](https://github.com/neacsu))
- Bump @openzeppelin/contracts from 3.4.0 to 4.4.1 in /contracts/basic-bandwidth-generation [\#983](https://github.com/nymtech/nym/pull/983) ([dependabot[bot]](https://github.com/apps/dependabot))
- Feature/implicit runtime [\#973](https://github.com/nymtech/nym/pull/973) ([jstuczyn](https://github.com/jstuczyn))
- Differentiate staking and ownership [\#961](https://github.com/nymtech/nym/pull/961) ([durch](https://github.com/durch))

 ## [v0.12.1](https://github.com/nymtech/nym/tree/v0.12.1) (2021-12-23)

@@ -22,20 +22,24 @@ members = [
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
+    "common/bandwidth-claim-contract",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
-    "common/credential-storage",
    "common/coconut-interface",
+    "common/commands",
    "common/config",
-    "common/credentials",
-    "common/crypto",
-    "common/crypto/dkg",
-    "common/bandwidth-claim-contract",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
    "common/cosmwasm-smart-contracts/contracts-common",
    "common/cosmwasm-smart-contracts/mixnet-contract",
+    "common/cosmwasm-smart-contracts/multisig-contract",
    "common/cosmwasm-smart-contracts/vesting-contract",
+    "common/credential-storage",
+    "common/credentials",
+    "common/crypto",
+    "common/crypto/dkg",
+    "common/execute",
+    "common/inclusion-probability",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -53,15 +57,21 @@ members = [
    "common/pemstore",
    "common/socks5/proxy-helpers",
    "common/socks5/requests",
+    "common/statistics",
+    "common/task",
    "common/topology",
+    "common/types",
    "common/wasm-utils",
    "explorer-api",
    "gateway",
    "gateway/gateway-requests",
    "mixnode",
    "service-providers/network-requester",
+    "service-providers/network-statistics",
    "validator-api",
    "validator-api/validator-api-requests",
+    "tools/nym-cli",
+    "tools/ts-rs-cli"
 ]

 default-members = [
@@ -69,9 +79,10 @@ default-members = [
    "clients/socks5",
    "gateway",
    "service-providers/network-requester",
+    "service-providers/network-statistics",
    "mixnode",
    "validator-api",
    "explorer-api",
 ]

-exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly"]
+exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly", "nym-wallet", "nym-connect"]
@@ -1,11 +1,13 @@
-test: build clippy-all cargo-test wasm fmt
+test: clippy-all cargo-test wasm fmt
+test-all: test cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet
-clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet
-cargo-test: test-main test-contracts test-wallet
-build: build-contracts build-wallet build-main
-fmt: fmt-main fmt-contracts fmt-wallet
+clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet clippy-all-connect
+clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
+cargo-test: test-main test-contracts test-wallet test-connect
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
+build: build-contracts build-wallet build-main build-connect
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect

 clippy-happy-main:
 	cargo clippy
@@ -16,6 +18,9 @@ clippy-happy-contracts:
 clippy-happy-wallet:
 	cargo clippy --manifest-path nym-wallet/Cargo.toml

+clippy-happy-connect:
+	cargo clippy --manifest-path nym-connect/Cargo.toml
+
 clippy-all-main:
 	cargo clippy --workspace --all-features -- -D warnings

@@ -25,15 +30,33 @@ clippy-all-contracts:
 clippy-all-wallet:
 	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings

+clippy-all-connect:
+	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings
+
 test-main:
 	cargo test --all-features --workspace

+test-main-expensive:
+	cargo test --all-features --workspace -- --ignored
+
 test-contracts:
 	cargo test --manifest-path contracts/Cargo.toml --all-features

+test-contracts-expensive:
+	cargo test --manifest-path contracts/Cargo.toml --all-features -- --ignored
+
 test-wallet:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features

+test-wallet-expensive:
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored
+
+test-connect:
+	cargo test --manifest-path nym-connect/Cargo.toml --all-features
+
+test-connect-expensive:
+	cargo test --manifest-path nym-connect/Cargo.toml --all-features -- --ignored
+
 build-main:
 	cargo build --workspace

@@ -43,6 +66,12 @@ build-contracts:
 build-wallet:
 	cargo build --manifest-path nym-wallet/Cargo.toml --workspace

+build-connect:
+	cargo build --manifest-path nym-connect/Cargo.toml --workspace
+
+build-nym-cli:
+	cargo build --release --manifest-path tools/nym-cli/Cargo.toml
+
 fmt-main:
 	cargo fmt --all

@@ -52,5 +81,12 @@ fmt-contracts:
 fmt-wallet:
 	cargo fmt --manifest-path nym-wallet/Cargo.toml --all

+fmt-connect:
+	cargo fmt --manifest-path nym-connect/Cargo.toml --all
+
 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
+
+generate-typescript:
+	cd tools/ts-rs-cli && cargo run && cd ../..
+	yarn types:lint:fix
@@ -9,8 +9,8 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr

 * nym-mixnode - shuffles [Sphinx](https://github.com/nymtech/sphinx) packets together to provide privacy against network-level attackers.
 * nym-client - an executable which you can build into your own applications. Use it for interacting with Nym nodes.
-* nym-socks5-client - a Socks5 proxy you can run on your machine, and use with existing applications
-* nym-gateway - acts sort of like a mailbox for mixnet messages, removing the need for directly delivery to potentially offline or firewalled devices.
+* nym-socks5-client - a Socks5 proxy you can run on your machine and use with existing applications.
+* nym-gateway - acts sort of like a mailbox for mixnet messages, which removes the need for direct delivery to potentially offline or firewalled devices.
 * nym-network-monitor - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
 * nym-explorer - a (projected) block explorer and (existing) mixnet viewer.
 * nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
@@ -0,0 +1,8 @@
+Update fonts by doing the following:
+
+1. Go to https://fonts.google.com/specimen/Open+Sans
+2. Add all the styles you want and select `@import`
+3. Copy the url (e.g. curl https://fonts.googleapis.com/css2\?family\=Open+Sans:ital,wght@0,300\;0,400\;0,500\;0,600\;0,700\;0,800\;1,300\;1,400\;1,500\;1,600\;1,700\;1,800\&display\=swap)
+4. Run `curl curl https://fonts.googleapis.com/css2\?family\=Open+Sans:ital,wght@0,300\;0,400\;0,500\;0,600\;0,700\;0,800\;1,300\;1,400\;1,500\;1,600\;1,700\;1,800\&display\=swap`
+5. Use the response as the CSS import directives and download the font files for each font weight
+6. Remember to delete any old font files
@@ -0,0 +1,96 @@
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 300;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk5hkaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 400;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk8ZkaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 500;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk_RkaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 600;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0RkxhjaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 700;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0RkyFjaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: italic;
+    font-weight: 800;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memQYaGs126MiZpBA-UFUIcVXSCEkx2cmqvXlWq8tWZ0Pw86hd0Rk0ZjaVc.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 300;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsiH0C4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 400;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjZ0C4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 500;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsjr0C4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 600;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsgH1y4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 700;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgsg-1y4n.ttf) format('truetype');
+}
+@font-face {
+    font-family: 'Open Sans';
+    font-style: normal;
+    font-weight: 800;
+    font-stretch: normal;
+    font-display: swap;
+    src: url(./memSYaGs126MiZpBA-UvWbX2vVnXBbObj2OVZyOOSr4dVJWUgshZ1y4n.ttf) format('truetype');
+}
@@ -0,0 +1,7 @@
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M171.7,30.3001 C132.7,-8.7999 69.3001,-8.7999 30.3001,30.3001 C-8.7999,69.4001 -8.7999,132.7 30.3001,171.7 C69.4001,210.8 132.7,210.8 171.7,171.7 C210.8,132.7 210.8,69.3001 171.7,30.3001 Z M163.1,163.1 C128.8,197.4 73.1001,197.4 38.8001,163.1 C4.5001,128.8 4.5001,73.1001 38.8001,38.8001 C73.1001,4.5001 128.8,4.5001 163.1,38.8001 C197.5,73.2001 197.5,128.8 163.1,163.1 Z" id="Shape" fill="#fff"></path>
+    <path d="M163.1,38.9 C128.8,4.60005 73.1002,4.60005 38.8002,38.9 C4.50019,73.2 4.50019,128.9 38.8002,163.2 C73.1002,197.5 128.8,197.5 163.1,163.2 C197.5,128.8 197.5,73.2 163.1,38.9 Z" id="Shape" fill="#000"></path>
+    <g id="T" transform="translate(25, 25) scale(5,5)">
+        <path d="M18.4804688,24 C19.203125,24 19.7182617,23.8608398 20.0258789,23.5825195 C20.3334961,23.3041992 20.4873047,22.9453125 20.4873047,22.5058594 C20.4873047,22.0566406 20.3334961,21.6928711 20.0258789,21.4145508 C19.7182617,21.1362305 19.203125,20.9970703 18.4804688,20.9970703 L18.4804688,20.9970703 L16.4589844,20.9970703 L16.4589844,9.24902344 L19.7548828,9.24902344 L19.7548828,12.0908203 C19.7548828,12.8134766 19.894043,13.3286133 20.1723633,13.6362305 C20.4506836,13.9438477 20.8095703,14.0976562 21.2490234,14.0976562 C21.6982422,14.0976562 22.0620117,13.9438477 22.340332,13.6362305 C22.6186523,13.3286133 22.7578125,12.8134766 22.7578125,12.0908203 L22.7578125,12.0908203 L22.7578125,6.24609375 L7.20117188,6.23144531 L7.20117188,12.0908203 C7.20117188,12.8134766 7.34033203,13.3286133 7.61865234,13.6362305 C7.89697266,13.9438477 8.25585938,14.0976562 8.6953125,14.0976562 C9.14453125,14.0976562 9.50830078,13.9438477 9.78662109,13.6362305 C10.0649414,13.3286133 10.2041016,12.8134766 10.2041016,12.0908203 L10.2041016,12.0908203 L10.2041016,9.24902344 L13.4560547,9.24902344 L13.4560547,20.9970703 L11.4492188,20.9970703 C10.7265625,20.9970703 10.2114258,21.1362305 9.90380859,21.4145508 C9.59619141,21.6928711 9.44238281,22.0517578 9.44238281,22.4912109 C9.44238281,22.9404297 9.59619141,23.3041992 9.90380859,23.5825195 C10.2114258,23.8608398 10.7265625,24 11.4492188,24 L11.4492188,24 L18.4804688,24 Z" id="T" fill="#fff"></path>
+    </g>
+</svg>
@@ -1,4 +1,4 @@
-<svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
    <path d="M170.7 29.3001C131.7 -9.7999 68.3001 -9.7999 29.3001 29.3001C-9.7999 68.4001 -9.7999 131.7 29.3001 170.7C68.4001 209.8 131.7 209.8 170.7 170.7C209.8 131.7 209.8 68.3001 170.7 29.3001ZM162.1 162.1C127.8 196.4 72.1001 196.4 37.8001 162.1C3.5001 127.8 3.5001 72.1001 37.8001 37.8001C72.1001 3.5001 127.8 3.5001 162.1 37.8001C196.5 72.2001 196.5 127.8 162.1 162.1Z" fill="white"/>
    <path d="M162.1 37.9C127.8 3.60005 72.1002 3.60005 37.8002 37.9C3.50019 72.2 3.50019 127.9 37.8002 162.2C72.1002 196.5 127.8 196.5 162.1 162.2C196.5 127.8 196.5 72.2 162.1 37.9ZM63.0002 170.7C56.8002 167.4 51.1002 163.2 46.1002 158.4V41.7C51.3002 36.7 57.2002 32.5 63.6002 29.1L137 140.9V29.3C143.2 32.6 148.9 36.8 153.9 41.6V158.3C148.7 163.3 142.8 167.5 136.4 170.9L63.0002 59.1V170.7Z" fill="#070B15"/>
    <path d="M154 158.3V41.7C148.9 36.9 143.2 32.7 137.1 29.4V140.9L63.5 29C57.1 32.4 51.2 36.6 46 41.6V158.3C51.1 163.1 56.8 167.3 62.9 170.6V59.1L136.5 171C142.9 167.6 148.8 163.3 154 158.3Z" fill="white"/>
@@ -0,0 +1,7 @@
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M171.7,30.3001 C132.7,-8.7999 69.3001,-8.7999 30.3001,30.3001 C-8.7999,69.4001 -8.7999,132.7 30.3001,171.7 C69.4001,210.8 132.7,210.8 171.7,171.7 C210.8,132.7 210.8,69.3001 171.7,30.3001 Z M163.1,163.1 C128.8,197.4 73.1001,197.4 38.8001,163.1 C4.5001,128.8 4.5001,73.1001 38.8001,38.8001 C73.1001,4.5001 128.8,4.5001 163.1,38.8001 C197.5,73.2001 197.5,128.8 163.1,163.1 Z" id="Shape" fill="#141521"></path>
+    <path d="M163.1,38.9 C128.8,4.60005 73.1002,4.60005 38.8002,38.9 C4.50019,73.2 4.50019,128.9 38.8002,163.2 C73.1002,197.5 128.8,197.5 163.1,163.2 C197.5,128.8 197.5,73.2 163.1,38.9 Z" id="Shape" fill="#FFFFFF"></path>
+    <g id="T" transform="translate(25, 25) scale(5,5)">
+        <path d="M18.4804688,24 C19.203125,24 19.7182617,23.8608398 20.0258789,23.5825195 C20.3334961,23.3041992 20.4873047,22.9453125 20.4873047,22.5058594 C20.4873047,22.0566406 20.3334961,21.6928711 20.0258789,21.4145508 C19.7182617,21.1362305 19.203125,20.9970703 18.4804688,20.9970703 L18.4804688,20.9970703 L16.4589844,20.9970703 L16.4589844,9.24902344 L19.7548828,9.24902344 L19.7548828,12.0908203 C19.7548828,12.8134766 19.894043,13.3286133 20.1723633,13.6362305 C20.4506836,13.9438477 20.8095703,14.0976562 21.2490234,14.0976562 C21.6982422,14.0976562 22.0620117,13.9438477 22.340332,13.6362305 C22.6186523,13.3286133 22.7578125,12.8134766 22.7578125,12.0908203 L22.7578125,12.0908203 L22.7578125,6.24609375 L7.20117188,6.23144531 L7.20117188,12.0908203 C7.20117188,12.8134766 7.34033203,13.3286133 7.61865234,13.6362305 C7.89697266,13.9438477 8.25585938,14.0976562 8.6953125,14.0976562 C9.14453125,14.0976562 9.50830078,13.9438477 9.78662109,13.6362305 C10.0649414,13.3286133 10.2041016,12.8134766 10.2041016,12.0908203 L10.2041016,12.0908203 L10.2041016,9.24902344 L13.4560547,9.24902344 L13.4560547,20.9970703 L11.4492188,20.9970703 C10.7265625,20.9970703 10.2114258,21.1362305 9.90380859,21.4145508 C9.59619141,21.6928711 9.44238281,22.0517578 9.44238281,22.4912109 C9.44238281,22.9404297 9.59619141,23.3041992 9.90380859,23.5825195 C10.2114258,23.8608398 10.7265625,24 11.4492188,24 L11.4492188,24 L18.4804688,24 Z" id="T" fill="#000" fill-rule="nonzero"></path>
+    </g>
+</svg>
@@ -1,4 +1,4 @@
-<svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
+<svg viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
    <path d="M170.7 29.3001C131.7 -9.7999 68.3001 -9.7999 29.3001 29.3001C-9.7999 68.4001 -9.7999 131.7 29.3001 170.7C68.4001 209.8 131.7 209.8 170.7 170.7C209.8 131.7 209.8 68.3001 170.7 29.3001ZM162.1 162.1C127.8 196.4 72.1001 196.4 37.8001 162.1C3.5001 127.8 3.5001 72.1001 37.8001 37.8001C72.1001 3.5001 127.8 3.5001 162.1 37.8001C196.5 72.2001 196.5 127.8 162.1 162.1Z" fill="#141521"/>
    <path d="M162.1 37.9C127.8 3.60005 72.1002 3.60005 37.8002 37.9C3.50019 72.2 3.50019 127.9 37.8002 162.2C72.1002 196.5 127.8 196.5 162.1 162.2C196.5 127.8 196.5 72.2 162.1 37.9ZM63.0002 170.7C56.8002 167.4 51.1002 163.2 46.1002 158.4V41.7C51.3002 36.7 57.2002 32.5 63.6002 29.1L137 140.9V29.3C143.2 32.6 148.9 36.8 153.9 41.6V158.3C148.7 163.3 142.8 167.5 136.4 170.9L63.0002 59.1V170.7Z" fill="white"/>
    <path d="M154 158.3V41.7C148.9 36.9 143.2 32.7 137.1 29.4V140.9L63.5 29C57.1 32.4 51.2 36.6 46 41.6V158.3C51.1 163.1 56.8 167.3 62.9 170.6V59.1L136.5 171C142.9 167.6 148.8 163.3 154 158.3Z" fill="#141521"/>
@@ -7,14 +7,15 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-dirs = "3.0"
+dirs = "4.0"
 futures = "0.3"
 humantime-serde = "1.0"
 log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 sled = "0.34"
-tokio = { version = "1.4", features = ["macros"] }
+thiserror = "1.0.34"
+tokio = { version = "1.19.1", features = ["macros"] }
 url = { version ="2.2", features = ["serde"] }

 # internal
@@ -25,11 +26,13 @@ gateway-requests = { path = "../../gateway/gateway-requests" }
 nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
 nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
+task = { path = "../../common/task" }
 topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client" }
+tap = "1.0.1"

 [dev-dependencies]
 tempfile = "3.1.0"

 [features]
-coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
+coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
@@ -13,6 +13,7 @@ use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 use tokio::time;

@@ -48,6 +49,9 @@ where

    /// Accessor to the common instance of network topology.
    topology_access: TopologyAccessor,
+
+    /// Listen to shutdown signals.
+    shutdown: ShutdownListener,
 }

 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -84,6 +88,7 @@ where
 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 impl LoopCoverTrafficStream<OsRng> {
+    #[allow(clippy::too_many_arguments)]
    pub fn new(
        ack_key: Arc<AckKey>,
        average_ack_delay: time::Duration,
@@ -92,6 +97,7 @@ impl LoopCoverTrafficStream<OsRng> {
        mix_tx: BatchMixMessageSender,
        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
    ) -> Self {
        let rng = OsRng;

@@ -105,6 +111,7 @@ impl LoopCoverTrafficStream<OsRng> {
            our_full_destination,
            rng,
            topology_access,
+            shutdown,
        }
    }

@@ -159,9 +166,25 @@ impl LoopCoverTrafficStream<OsRng> {
            self.average_cover_message_sending_delay,
        )));

-        while self.next().await.is_some() {
-            self.on_new_message().await;
+        let mut shutdown = self.shutdown.clone();
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = shutdown.recv() => {
+                    log::trace!("LoopCoverTrafficStream: Received shutdown");
+                }
+                next = self.next() => {
+                    if next.is_some() {
+                        self.on_new_message().await;
+                    } else {
+                        log::trace!("LoopCoverTrafficStream: Stopping since channel closed");
+                        break;
+                    }
+                }
+            }
        }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("LoopCoverTrafficStream: Exiting");
    }

    pub fn start(mut self) -> JoinHandle<()> {
@@ -6,6 +6,7 @@ use futures::StreamExt;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;

 pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
@@ -18,6 +19,7 @@ pub struct MixTrafficController {
    // later on gateway_client will need to be accessible by other entities
    gateway_client: GatewayClient,
    mix_rx: BatchMixMessageReceiver,
+    shutdown: ShutdownListener,

    // TODO: this is temporary work-around.
    // in long run `gateway_client` will be moved away from `MixTrafficController` anyway.
@@ -28,10 +30,12 @@ impl MixTrafficController {
    pub fn new(
        mix_rx: BatchMixMessageReceiver,
        gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
    ) -> MixTrafficController {
        MixTrafficController {
            gateway_client,
            mix_rx,
+            shutdown,
            consecutive_gateway_failure_count: 0,
        }
    }
@@ -66,9 +70,24 @@ impl MixTrafficController {
    }

    pub async fn run(&mut self) {
-        while let Some(mix_packets) = self.mix_rx.next().await {
-            self.on_messages(mix_packets).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                mix_packets = self.mix_rx.next() => match mix_packets {
+                    Some(mix_packets) => {
+                        self.on_messages(mix_packets).await;
+                    },
+                    None => {
+                        log::trace!("MixTrafficController: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("MixTrafficController: Received shutdown");
+                }
+            }
        }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("MixTrafficController: Exiting");
    }

    pub fn start(mut self) -> JoinHandle<()> {
@@ -1,3 +1,5 @@
+use std::sync::atomic::AtomicBool;
+
 pub mod cover_traffic_stream;
 pub mod inbound_messages;
 pub mod key_manager;
@@ -6,3 +8,10 @@ pub mod real_messages_control;
 pub mod received_buffer;
 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);
@@ -10,6 +10,7 @@ use nymsphinx::{
    chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
 };
 use std::sync::Arc;
+use task::ShutdownListener;

 /// Module responsible for listening for any data resembling acknowledgements from the network
 /// and firing actions to remove them from the 'Pending' state.
@@ -17,6 +18,7 @@ pub(super) struct AcknowledgementListener {
    ack_key: Arc<AckKey>,
    ack_receiver: AcknowledgementReceiver,
    action_sender: ActionSender,
+    shutdown: ShutdownListener,
 }

 impl AcknowledgementListener {
@@ -24,11 +26,13 @@ impl AcknowledgementListener {
        ack_key: Arc<AckKey>,
        ack_receiver: AcknowledgementReceiver,
        action_sender: ActionSender,
+        shutdown: ShutdownListener,
    ) -> Self {
        AcknowledgementListener {
            ack_key,
            ack_receiver,
            action_sender,
+            shutdown,
        }
    }

@@ -65,12 +69,26 @@ impl AcknowledgementListener {

    pub(super) async fn run(&mut self) {
        debug!("Started AcknowledgementListener");
-        while let Some(acks) = self.ack_receiver.next().await {
-            // realistically we would only be getting one ack at the time
-            for ack in acks {
-                self.on_ack(ack).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                acks = self.ack_receiver.next() => match acks {
+                    Some(acks) => {
+                        // realistically we would only be getting one ack at the time
+                        for ack in acks {
+                            self.on_ack(ack).await;
+                        }
+                    },
+                    None => {
+                        log::trace!("AcknowledgementListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("AcknowledgementListener: Received shutdown");
+                }
            }
        }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("AcknowledgementListener: Exiting");
    }
 }
@@ -6,12 +6,13 @@ use crate::client::real_messages_control::acknowledgement_control::Retransmissio
 use futures::channel::mpsc::{self, UnboundedReceiver, UnboundedSender};
 use futures::StreamExt;
 use log::*;
-use nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey, TimerError};
+use nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue, QueueKey};
 use nymsphinx::chunking::fragment::FragmentIdentifier;
 use nymsphinx::Delay as SphinxDelay;
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;

 pub(crate) type ActionSender = UnboundedSender<Action>;

@@ -99,12 +100,16 @@ pub(super) struct ActionController {

    /// Channel for notifying `RetransmissionRequestListener` about expired acknowledgements.
    retransmission_sender: RetransmissionRequestSender,
+
+    /// Listen for shutdown notifications
+    shutdown: ShutdownListener,
 }

 impl ActionController {
    pub(super) fn new(
        config: Config,
        retransmission_sender: RetransmissionRequestSender,
+        shutdown: ShutdownListener,
    ) -> (Self, ActionSender) {
        let (sender, receiver) = mpsc::unbounded();
        (
@@ -114,6 +119,7 @@ impl ActionController {
                pending_acks_timers: NonExhaustiveDelayQueue::new(),
                incoming_actions: receiver,
                retransmission_sender,
+                shutdown,
            },
            sender,
        )
@@ -209,16 +215,11 @@ impl ActionController {
    }

    // note: when the entry expires it's automatically removed from pending_acks_timers
-    fn handle_expired_ack_timer(
-        &mut self,
-        expired_ack: Result<Expired<FragmentIdentifier>, TimerError>,
-    ) {
+    fn handle_expired_ack_timer(&mut self, expired_ack: Expired<FragmentIdentifier>) {
        // I'm honestly not sure how to handle it, because getting it means other things in our
        // system are already misbehaving. If we ever see this panic, then I guess we should worry
        // about it. Perhaps just reschedule it at later point?
-        let frag_id = expired_ack
-            .expect("Tokio timer returned an error!")
-            .into_inner();
+        let frag_id = expired_ack.into_inner();

        trace!("{} has expired", frag_id);

@@ -251,14 +252,30 @@ impl ActionController {
    }

    pub(super) async fn run(&mut self) {
-        loop {
-            // at some point there will be a global shutdown signal here as the third option
+        while !self.shutdown.is_shutdown() {
            tokio::select! {
-                // we NEVER expect for ANY sender to get dropped so unwrap here is fine
-                action = self.incoming_actions.next() => self.process_action(action.unwrap()),
-                // pending ack queue Stream CANNOT return a `None` so unwrap here is fine
-                expired_ack = self.pending_acks_timers.next() => self.handle_expired_ack_timer(expired_ack.unwrap())
+                action = self.incoming_actions.next() => match action {
+                    Some(action) => self.process_action(action),
+                    None => {
+                        log::trace!(
+                            "ActionController: Stopping since incoming actions channel closed"
+                        );
+                        break;
+                    }
+                },
+                expired_ack = self.pending_acks_timers.next() => match expired_ack {
+                    Some(expired_ack) => self.handle_expired_ack_timer(expired_ack),
+                    None => {
+                        log::trace!("ActionController: Stopping since ack channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("ActionController: Received shutdown");
+                }
            }
        }
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("ActionController: Exiting");
    }
 }
@@ -16,6 +16,7 @@ use nymsphinx::preparer::MessagePreparer;
 use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
 use std::sync::Arc;
+use task::ShutdownListener;

 /// Module responsible for dealing with the received messages: splitting them, creating acknowledgements,
 /// putting everything into sphinx packets, etc.
@@ -32,6 +33,7 @@ where
    real_message_sender: BatchRealMessageSender,
    topology_access: TopologyAccessor,
    reply_key_storage: ReplyKeyStorage,
+    shutdown: ShutdownListener,
 }

 impl<R> InputMessageListener<R>
@@ -50,6 +52,7 @@ where
        real_message_sender: BatchRealMessageSender,
        topology_access: TopologyAccessor,
        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) -> Self {
        InputMessageListener {
            ack_key,
@@ -60,6 +63,7 @@ where
            real_message_sender,
            topology_access,
            reply_key_storage,
+            shutdown,
        }
    }

@@ -133,7 +137,6 @@ where
            let prepared_fragment = self
                .message_preparer
                .prepare_chunk_for_sending(chunk_clone, topology, &self.ack_key, &recipient)
-                .await
                .unwrap();

            real_messages.push(RealMessage::new(
@@ -183,9 +186,23 @@ where

    pub(super) async fn run(&mut self) {
        debug!("Started InputMessageListener");
-        while let Some(input_msg) = self.input_receiver.next().await {
-            self.on_input_message(input_msg).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                input_msg = self.input_receiver.next() => match input_msg {
+                    Some(input_msg) => {
+                        self.on_input_message(input_msg).await;
+                    },
+                    None => {
+                        log::trace!("InputMessageListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("InputMessageListener: Received shutdown");
+                }
+            }
        }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("InputMessageListener: Exiting");
    }
 }
@@ -25,6 +25,7 @@ use std::{
    sync::{Arc, Weak},
    time::Duration,
 };
+use task::ShutdownListener;
 use tokio::task::JoinHandle;

 mod acknowledgement_listener;
@@ -152,6 +153,7 @@ impl<R> AcknowledgementController<R>
 where
    R: 'static + CryptoRng + Rng + Clone + Send,
 {
+    #[allow(clippy::too_many_arguments)]
    pub(super) fn new(
        config: Config,
        rng: R,
@@ -160,13 +162,14 @@ where
        ack_recipient: Recipient,
        reply_key_storage: ReplyKeyStorage,
        connectors: AcknowledgementControllerConnectors,
+        shutdown: ShutdownListener,
    ) -> Self {
        let (retransmission_tx, retransmission_rx) = mpsc::unbounded();

        let action_config =
            action_controller::Config::new(config.ack_wait_addition, config.ack_wait_multiplier);
        let (action_controller, action_sender) =
-            ActionController::new(action_config, retransmission_tx);
+            ActionController::new(action_config, retransmission_tx, shutdown.clone());

        let message_preparer = MessagePreparer::new(
            rng,
@@ -180,6 +183,7 @@ where
            Arc::clone(&ack_key),
            connectors.ack_receiver,
            action_sender.clone(),
+            shutdown.clone(),
        );

        // will listen for any new messages from the client
@@ -192,6 +196,7 @@ where
            connectors.real_message_sender.clone(),
            topology_access.clone(),
            reply_key_storage,
+            shutdown.clone(),
        );

        // will listen for any ack timeouts and trigger retransmission
@@ -203,12 +208,13 @@ where
            connectors.real_message_sender,
            retransmission_rx,
            topology_access,
+            shutdown.clone(),
        );

        // will listen for events indicating the packet was sent through the network so that
        // the retransmission timer should be started.
        let sent_notification_listener =
-            SentNotificationListener::new(connectors.sent_notifier, action_sender);
+            SentNotificationListener::new(connectors.sent_notifier, action_sender, shutdown);

        AcknowledgementController {
            acknowledgement_listener: Some(acknowledgement_listener),
@@ -232,27 +238,27 @@ where
        // graceful shutdowns.
        let ack_listener_fut = tokio::spawn(async move {
            acknowledgement_listener.run().await;
-            error!("The acknowledgement listener has finished execution!");
+            debug!("The acknowledgement listener has finished execution!");
            acknowledgement_listener
        });
        let input_listener_fut = tokio::spawn(async move {
            input_message_listener.run().await;
-            error!("The input listener has finished execution!");
+            debug!("The input listener has finished execution!");
            input_message_listener
        });
        let retransmission_req_fut = tokio::spawn(async move {
            retransmission_request_listener.run().await;
-            error!("The retransmission request listener has finished execution!");
+            debug!("The retransmission request listener has finished execution!");
            retransmission_request_listener
        });
        let sent_notification_fut = tokio::spawn(async move {
            sent_notification_listener.run().await;
-            error!("The sent notification listener has finished execution!");
+            debug!("The sent notification listener has finished execution!");
            sent_notification_listener
        });
        let action_controller_fut = tokio::spawn(async move {
            action_controller.run().await;
-            error!("The controller has finished execution!");
+            debug!("The controller has finished execution!");
            action_controller
        });

@@ -14,6 +14,7 @@ use nymsphinx::preparer::MessagePreparer;
 use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};
+use task::ShutdownListener;

 // responsible for packet retransmission upon fired timer
 pub(super) struct RetransmissionRequestListener<R>
@@ -27,12 +28,14 @@ where
    real_message_sender: BatchRealMessageSender,
    request_receiver: RetransmissionRequestReceiver,
    topology_access: TopologyAccessor,
+    shutdown: ShutdownListener,
 }

 impl<R> RetransmissionRequestListener<R>
 where
    R: CryptoRng + Rng,
 {
+    #[allow(clippy::too_many_arguments)]
    pub(super) fn new(
        ack_key: Arc<AckKey>,
        ack_recipient: Recipient,
@@ -41,6 +44,7 @@ where
        real_message_sender: BatchRealMessageSender,
        request_receiver: RetransmissionRequestReceiver,
        topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
    ) -> Self {
        RetransmissionRequestListener {
            ack_key,
@@ -50,6 +54,7 @@ where
            real_message_sender,
            request_receiver,
            topology_access,
+            shutdown,
        }
    }

@@ -83,7 +88,6 @@ where
        let prepared_fragment = self
            .message_preparer
            .prepare_chunk_for_sending(chunk_clone, topology_ref, &self.ack_key, packet_recipient)
-            .await
            .unwrap();

        // if we have the ONLY strong reference to the ack data, it means it was removed from the
@@ -122,9 +126,22 @@ where

    pub(super) async fn run(&mut self) {
        debug!("Started RetransmissionRequestListener");
-        while let Some(timed_out_ack) = self.request_receiver.next().await {
-            self.on_retransmission_request(timed_out_ack).await;
+
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                timed_out_ack = self.request_receiver.next() => match timed_out_ack {
+                    Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack).await,
+                    None => {
+                        log::trace!("RetransmissionRequestListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("RetransmissionRequestListener: Received shutdown");
+                }
+            }
        }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("RetransmissionRequestListener: Exiting");
    }
 }
@@ -6,6 +6,7 @@ use super::SentPacketNotificationReceiver;
 use futures::StreamExt;
 use log::*;
 use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
+use task::ShutdownListener;

 /// Module responsible for starting up retransmission timers.
 /// It is required because when we send our packet to the `real traffic stream` controlled
@@ -14,16 +15,19 @@ use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
 pub(super) struct SentNotificationListener {
    sent_notifier: SentPacketNotificationReceiver,
    action_sender: ActionSender,
+    shutdown: ShutdownListener,
 }

 impl SentNotificationListener {
    pub(super) fn new(
        sent_notifier: SentPacketNotificationReceiver,
        action_sender: ActionSender,
+        shutdown: ShutdownListener,
    ) -> Self {
        SentNotificationListener {
            sent_notifier,
            action_sender,
+            shutdown,
        }
    }

@@ -44,9 +48,23 @@ impl SentNotificationListener {

    pub(super) async fn run(&mut self) {
        debug!("Started SentNotificationListener");
-        while let Some(frag_id) = self.sent_notifier.next().await {
-            self.on_sent_message(frag_id).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                frag_id = self.sent_notifier.next() => match frag_id {
+                    Some(frag_id) => {
+                        self.on_sent_message(frag_id).await;
+                    }
+                    None => {
+                        log::trace!("SentNotificationListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("SentNotificationListener: Received shutdown");
+                }
+            }
        }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("SentNotificationListener: Exiting");
    }
 }
@@ -22,6 +22,7 @@ use nymsphinx::addressing::clients::Recipient;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;

 mod acknowledgement_control;
@@ -91,6 +92,7 @@ impl RealMessagesController<OsRng> {
        mix_sender: BatchMixMessageSender,
        topology_access: TopologyAccessor,
        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) -> Self {
        let rng = OsRng;

@@ -119,6 +121,7 @@ impl RealMessagesController<OsRng> {
            config.self_recipient,
            reply_key_storage,
            ack_controller_connectors,
+            shutdown.clone(),
        );

        let out_queue_config = real_traffic_stream::Config::new(
@@ -136,6 +139,7 @@ impl RealMessagesController<OsRng> {
            rng,
            config.self_recipient,
            topology_access,
+            shutdown,
        );

        RealMessagesController {
@@ -153,12 +157,12 @@ impl RealMessagesController<OsRng> {
        // graceful shutdowns.
        let out_queue_control_fut = tokio::spawn(async move {
            out_queue_control.run_out_queue_control().await;
-            error!("The out queue controller has finished execution!");
+            debug!("The out queue controller has finished execution!");
            out_queue_control
        });
        let ack_control_fut = tokio::spawn(async move {
            ack_control.run().await;
-            error!("The acknowledgement controller has finished execution!");
+            debug!("The acknowledgement controller has finished execution!");
            ack_control
        });

@@ -19,6 +19,7 @@ use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::time;

 /// Configurable parameters of the `OutQueueControl`
@@ -83,6 +84,9 @@ where

    /// Buffer containing all real messages received. It is first exhausted before more are pulled.
    received_buffer: VecDeque<RealMessage>,
+
+    /// Listens for shutdown signals
+    shutdown: ShutdownListener,
 }

 pub(crate) struct RealMessage {
@@ -174,6 +178,7 @@ where
        rng: R,
        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
+        shutdown: ShutdownListener,
    ) -> Self {
        OutQueueControl {
            config,
@@ -186,6 +191,7 @@ where
            rng,
            topology_access,
            received_buffer: VecDeque::with_capacity(0), // we won't be putting any data into this guy directly
+            shutdown,
        }
    }

@@ -239,7 +245,15 @@ where
        // - we run out of memory
        // - the receiver channel is closed
        // in either case there's no recovery and we can only panic
-        self.mix_tx.unbounded_send(vec![next_message]).unwrap();
+        if let Err(err) = self.mix_tx.unbounded_send(vec![next_message]) {
+            if self.shutdown.is_shutdown_poll() {
+                log::info!("Failed to send (shutdown detected)");
+            } else {
+                // We don't try to limp along, panic to avoid continuing in a potentially
+                // inconsistent state
+                panic!("{err}");
+            }
+        }

        // JS: Not entirely sure why or how it fixes stuff, but without the yield call,
        // the UnboundedReceiver [of mix_rx] will not get a chance to read anything
@@ -257,9 +271,26 @@ where
            self.config.average_message_sending_delay,
        )));

-        while let Some(next_message) = self.next().await {
-            self.on_message(next_message).await;
+        let mut shutdown = self.shutdown.clone();
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = shutdown.recv() => {
+                    log::trace!("OutQueueControl: Received shutdown");
+                }
+                next_message = self.next() => match next_message {
+                    Some(next_message) => {
+                        self.on_message(next_message).await;
+                    },
+                    None => {
+                        log::trace!("OutQueueControl: Stopping since channel closed");
+                        break;
+                    }
+                }
+            }
        }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("OutQueueControl: Exiting");
    }

    pub(crate) async fn run_out_queue_control(&mut self) {
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::reply_key_storage::ReplyKeyStorage;
+use crate::client::SHUTDOWN_HAS_BEEN_SIGNALLED;
 use crypto::asymmetric::encryption;
 use crypto::symmetric::stream_cipher;
 use crypto::Digest;
@@ -14,7 +15,9 @@ use nymsphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncr
 use nymsphinx::params::{ReplySurbEncryptionAlgorithm, ReplySurbKeyDigestAlgorithm};
 use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;

 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
@@ -292,16 +295,27 @@ impl RequestReceiver {

    fn start(mut self) -> JoinHandle<()> {
        tokio::spawn(async move {
-            while let Some(request) = self.query_receiver.next().await {
-                match request {
-                    ReceivedBufferMessage::ReceiverAnnounce(sender) => {
-                        self.received_buffer.connect_sender(sender).await;
-                    }
-                    ReceivedBufferMessage::ReceiverDisconnect => {
-                        self.received_buffer.disconnect_sender().await
-                    }
-                }
+            loop {
+                tokio::select! {
+                    request = self.query_receiver.next() => {
+                        match request {
+                            Some(ReceivedBufferMessage::ReceiverAnnounce(sender)) => {
+                                self.received_buffer.connect_sender(sender).await;
+                            }
+                            Some(ReceivedBufferMessage::ReceiverDisconnect) => {
+                                self.received_buffer.disconnect_sender().await
+                            }
+                            None => {
+                                log::trace!("RequestReceiver: Stopping since channel closed");
+                                break;
+                            },
+                        }
+                    },
+                };
            }
+
+            assert!(SHUTDOWN_HAS_BEEN_SIGNALLED.load(Ordering::Relaxed));
+            log::debug!("RequestReceiver: Exiting");
        })
    }
 }
@@ -309,23 +323,41 @@ impl RequestReceiver {
 struct FragmentedMessageReceiver {
    received_buffer: ReceivedMessagesBuffer,
    mixnet_packet_receiver: MixnetMessageReceiver,
+    shutdown: ShutdownListener,
 }

 impl FragmentedMessageReceiver {
    fn new(
        received_buffer: ReceivedMessagesBuffer,
        mixnet_packet_receiver: MixnetMessageReceiver,
+        shutdown: ShutdownListener,
    ) -> Self {
        FragmentedMessageReceiver {
            received_buffer,
            mixnet_packet_receiver,
+            shutdown,
        }
    }
    fn start(mut self) -> JoinHandle<()> {
        tokio::spawn(async move {
-            while let Some(new_messages) = self.mixnet_packet_receiver.next().await {
-                self.received_buffer.handle_new_received(new_messages).await;
+            while !self.shutdown.is_shutdown() {
+                tokio::select! {
+                    new_messages = self.mixnet_packet_receiver.next() => match new_messages {
+                        Some(new_messages) => {
+                            self.received_buffer.handle_new_received(new_messages).await;
+                        }
+                        None => {
+                            log::trace!("FragmentedMessageReceiver: Stopping since channel closed");
+                            break;
+                        }
+                    },
+                    _ = self.shutdown.recv() => {
+                        log::trace!("FragmentedMessageReceiver: Received shutdown");
+                    }
+                }
            }
+            assert!(self.shutdown.is_shutdown_poll());
+            log::debug!("FragmentedMessageReceiver: Exiting");
        })
    }
 }
@@ -341,6 +373,7 @@ impl ReceivedMessagesBufferController {
        query_receiver: ReceivedBufferRequestReceiver,
        mixnet_packet_receiver: MixnetMessageReceiver,
        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) -> Self {
        let received_buffer =
            ReceivedMessagesBuffer::new(local_encryption_keypair, reply_key_storage);
@@ -349,6 +382,7 @@ impl ReceivedMessagesBufferController {
            fragmented_message_receiver: FragmentedMessageReceiver::new(
                received_buffer.clone(),
                mixnet_packet_receiver,
+                shutdown,
            ),
            request_receiver: RequestReceiver::new(received_buffer, query_receiver),
        }
@@ -10,6 +10,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::time;
 use std::time::Duration;
+use task::ShutdownListener;
 use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio::task::JoinHandle;
 use topology::{nym_topology_from_bonds, NymTopology};
@@ -303,12 +304,20 @@ impl TopologyRefresher {
        self.topology_accessor.is_routable().await
    }

-    pub fn start(mut self) -> JoinHandle<()> {
+    pub fn start(mut self, mut shutdown: ShutdownListener) -> JoinHandle<()> {
        tokio::spawn(async move {
-            loop {
-                tokio::time::sleep(self.refresh_rate).await;
-                self.refresh().await;
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    _ = tokio::time::sleep(self.refresh_rate) => {
+                        self.refresh().await;
+                    },
+                    _ = shutdown.recv() => {
+                        log::trace!("TopologyRefresher: Received shutdown");
+                    },
+                }
            }
+            assert!(shutdown.is_shutdown_poll());
+            log::debug!("TopologyRefresher: Exiting");
        })
    }
 }
@@ -1,7 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use config::defaults::*;
 use config::NymConfig;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
@@ -114,12 +113,8 @@ impl<T: NymConfig> Config<T> {
        self.client.disabled_credentials_mode = disabled_credentials_mode;
    }

-    pub fn with_gateway_endpoint<S: Into<String>>(&mut self, id: S, owner: S, listener: S) {
-        self.client.gateway_endpoint = GatewayEndpoint {
-            gateway_id: id.into(),
-            gateway_owner: owner.into(),
-            gateway_listener: listener.into(),
-        };
+    pub fn with_gateway_endpoint(&mut self, gateway_endpoint: GatewayEndpoint) {
+        self.client.gateway_endpoint = gateway_endpoint;
    }

    pub fn with_gateway_id<S: Into<String>>(&mut self, id: S) {
@@ -142,7 +137,7 @@ impl<T: NymConfig> Config<T> {

    pub fn set_high_default_traffic_volume(&mut self) {
        self.debug.average_packet_delay = Duration::from_millis(10);
-        self.debug.loop_cover_traffic_average_delay = Duration::from_millis(2000000); // basically don't really send cover messages
+        self.debug.loop_cover_traffic_average_delay = Duration::from_millis(2_000_000); // basically don't really send cover messages
        self.debug.message_sending_average_delay = Duration::from_millis(4); // 250 "real" messages / s
    }

@@ -206,6 +201,10 @@ impl<T: NymConfig> Config<T> {
        self.client.gateway_endpoint.gateway_listener.clone()
    }

+    pub fn get_gateway_endpoint(&self) -> &GatewayEndpoint {
+        &self.client.gateway_endpoint
+    }
+
    pub fn get_database_path(&self) -> PathBuf {
        self.client.database_path.clone()
    }
@@ -272,20 +271,31 @@ impl<T: NymConfig> Default for Config<T> {
    }
 }

-#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
-struct GatewayEndpoint {
+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
+pub struct GatewayEndpoint {
    /// gateway_id specifies ID of the gateway to which the client should send messages.
    /// If initially omitted, a random gateway will be chosen from the available topology.
-    gateway_id: String,
+    pub gateway_id: String,

    /// Address of the gateway owner to which the client should send messages.
-    gateway_owner: String,
+    pub gateway_owner: String,

    /// Address of the gateway listener to which all client requests should be sent.
-    gateway_listener: String,
+    pub gateway_listener: String,
 }

-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+impl From<topology::gateway::Node> for GatewayEndpoint {
+    fn from(node: topology::gateway::Node) -> GatewayEndpoint {
+        let gateway_listener = node.clients_address();
+        GatewayEndpoint {
+            gateway_id: node.identity_key.to_base58_string(),
+            gateway_owner: node.owner,
+            gateway_listener,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
 pub struct Client<T> {
    /// Version of the client for which this configuration was created.
    #[serde(default = "missing_string_value")]
@@ -345,7 +355,7 @@ pub struct Client<T> {
    nym_root_directory: PathBuf,

    #[serde(skip)]
-    super_struct: PhantomData<*const T>,
+    super_struct: PhantomData<T>,
 }

 impl<T: NymConfig> Default for Client<T> {
@@ -355,7 +365,7 @@ impl<T: NymConfig> Default for Client<T> {
            version: env!("CARGO_PKG_VERSION").to_string(),
            id: "".to_string(),
            disabled_credentials_mode: true,
-            validator_api_urls: default_api_endpoints(),
+            validator_api_urls: vec![],
            private_identity_key_file: Default::default(),
            public_identity_key_file: Default::default(),
            private_encryption_key_file: Default::default(),
@@ -408,7 +418,7 @@ impl<T: NymConfig> Client<T> {
    }
 }

-#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Logging {}

@@ -0,0 +1,27 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crypto::asymmetric::identity::Ed25519RecoveryError;
+use gateway_client::error::GatewayClientError;
+use validator_client::ValidatorClientError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum ClientCoreError {
+    #[error("I/O error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Gateway client error: {0}")]
+    GatewayClientError(#[from] GatewayClientError),
+    #[error("Ed25519 error: {0}")]
+    Ed25519RecoveryError(#[from] Ed25519RecoveryError),
+    #[error("Validator client error: {0}")]
+    ValidatorClientError(#[from] ValidatorClientError),
+
+    #[error("No gateway with id: {0}")]
+    NoGatewayWithId(String),
+    #[error("No gateways on network")]
+    NoGatewaysOnNetwork,
+    #[error("List of validator apis is empty")]
+    ListOfValidatorApisIsEmpty,
+    #[error("Could not load existing gateway configuration: {0}")]
+    CouldNotLoadExistingGatewayConfiguration(std::io::Error),
+}
@@ -0,0 +1,148 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+//! Collection of initialization steps used by client implementations
+
+use std::{sync::Arc, time::Duration};
+
+use config::NymConfig;
+use crypto::asymmetric::{encryption, identity};
+use gateway_client::GatewayClient;
+use gateway_requests::registration::handshake::SharedKeys;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::addressing::nodes::NodeIdentity;
+use rand::rngs::OsRng;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+use tap::TapFallible;
+use topology::{filter::VersionFilterable, gateway};
+use url::Url;
+
+use crate::{
+    client::key_manager::KeyManager,
+    config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
+    error::ClientCoreError,
+};
+
+pub async fn query_gateway_details(
+    validator_servers: Vec<Url>,
+    chosen_gateway_id: Option<&str>,
+) -> Result<gateway::Node, ClientCoreError> {
+    let validator_api = validator_servers
+        .choose(&mut thread_rng())
+        .ok_or(ClientCoreError::ListOfValidatorApisIsEmpty)?;
+    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?;
+    let valid_gateways = gateways
+        .into_iter()
+        .filter_map(|gateway| gateway.try_into().ok())
+        .collect::<Vec<gateway::Node>>();
+
+    let filtered_gateways = valid_gateways.filter_by_version(env!("CARGO_PKG_VERSION"));
+
+    // if we have chosen particular gateway - use it, otherwise choose a random one.
+    // (remember that in active topology all gateways have at least 100 reputation so should
+    // be working correctly)
+    if let Some(gateway_id) = chosen_gateway_id {
+        filtered_gateways
+            .iter()
+            .find(|gateway| gateway.identity_key.to_base58_string() == gateway_id)
+            .ok_or_else(|| ClientCoreError::NoGatewayWithId(gateway_id.to_string()))
+            .cloned()
+    } else {
+        filtered_gateways
+            .choose(&mut rand::thread_rng())
+            .ok_or(ClientCoreError::NoGatewaysOnNetwork)
+            .cloned()
+    }
+}
+
+pub async fn register_with_gateway_and_store_keys<T>(
+    gateway_details: gateway::Node,
+    config: &Config<T>,
+) -> Result<(), ClientCoreError>
+where
+    T: NymConfig,
+{
+    let mut rng = OsRng;
+    let mut key_manager = KeyManager::new(&mut rng);
+
+    let shared_keys =
+        register_with_gateway(&gateway_details, key_manager.identity_keypair()).await?;
+    key_manager.insert_gateway_shared_key(shared_keys);
+
+    let pathfinder = ClientKeyPathfinder::new_from_config(config);
+    Ok(key_manager
+        .store_keys(&pathfinder)
+        .tap_err(|err| log::error!("Failed to generate keys: {err}"))?)
+}
+
+async fn register_with_gateway(
+    gateway: &gateway::Node,
+    our_identity: Arc<identity::KeyPair>,
+) -> Result<Arc<SharedKeys>, ClientCoreError> {
+    let timeout = Duration::from_millis(1500);
+    let mut gateway_client = GatewayClient::new_init(
+        gateway.clients_address(),
+        gateway.identity_key,
+        gateway.owner.clone(),
+        our_identity.clone(),
+        timeout,
+        None,
+    );
+    gateway_client
+        .establish_connection()
+        .await
+        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
+    let shared_keys = gateway_client
+        .perform_initial_authentication()
+        .await
+        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
+    Ok(shared_keys)
+}
+
+pub fn show_address<T>(config: &Config<T>) -> Result<(), ClientCoreError>
+where
+    T: config::NymConfig,
+{
+    fn load_identity_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<identity::KeyPair, ClientCoreError> {
+        let identity_keypair: identity::KeyPair =
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+                pathfinder.private_identity_key().to_owned(),
+                pathfinder.public_identity_key().to_owned(),
+            ))
+            .tap_err(|_| log::error!("Failed to read stored identity key files"))?;
+        Ok(identity_keypair)
+    }
+
+    fn load_sphinx_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<encryption::KeyPair, ClientCoreError> {
+        let sphinx_keypair: encryption::KeyPair =
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+                pathfinder.private_encryption_key().to_owned(),
+                pathfinder.public_encryption_key().to_owned(),
+            ))
+            .tap_err(|_| log::error!("Failed to read stored sphinx key files"))?;
+        Ok(sphinx_keypair)
+    }
+
+    let pathfinder = ClientKeyPathfinder::new_from_config(config);
+    let identity_keypair = load_identity_keys(&pathfinder)?;
+    let sphinx_keypair = load_sphinx_keys(&pathfinder)?;
+
+    let client_recipient = Recipient::new(
+        *identity_keypair.public_key(),
+        *sphinx_keypair.public_key(),
+        // TODO: below only works under assumption that gateway address == gateway id
+        // (which currently is true)
+        NodeIdentity::from_base58_string(config.get_gateway_id())?,
+    );
+
+    println!("\nThe address of this client is: {}", client_recipient);
+    Ok(())
+}
@@ -1,2 +1,4 @@
 pub mod client;
 pub mod config;
+pub mod error;
+pub mod init;
@@ -15,10 +15,10 @@ rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
 url = "2.2"
-tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime

-coconut-bandwidth-contract-common = { path = "../../common/cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 coconut-interface = { path = "../../common/coconut-interface" }
+config = { path = "../../common/config" }
 credentials = { path = "../../common/credentials" }
 credential-storage = { path = "../../common/credential-storage" }
 crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
@@ -27,4 +27,4 @@ pemstore = { path = "../../common/pemstore" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }

 [features]
-coconut = ["credentials/coconut"]
+coconut = ["credentials/coconut"]
@@ -1,67 +1,53 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::error::Result;
 use bip39::Mnemonic;
-use coconut_bandwidth_contract_common::deposit::DepositData;
+use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
 use std::str::FromStr;
 use url::Url;
-
-use crate::error::Result;
-use crate::{CONTRACT_ADDRESS, MNEMONIC, NYMD_URL};
-
-use coconut_bandwidth_contract_common::msg::ExecuteMsg;
-use network_defaults::DEFAULT_NETWORK;
-use validator_client::nymd::{
-    AccountId, CosmosCoin, Decimal, Denom, NymdClient, SigningNymdClient,
-};
+use validator_client::nymd;
+use validator_client::nymd::traits::CoconutBandwidthSigningClient;
+use validator_client::nymd::{Coin, Fee, NymdClient, SigningNymdClient};

 pub(crate) struct Client {
    nymd_client: NymdClient<SigningNymdClient>,
-    denom: Denom,
-    contract_address: AccountId,
+    mix_denom_base: String,
 }

 impl Client {
-    pub fn new() -> Self {
-        let nymd_url = Url::from_str(NYMD_URL).unwrap();
-        let mnemonic = Mnemonic::from_str(MNEMONIC).unwrap();
-        let nymd_client = NymdClient::connect_with_mnemonic(
-            DEFAULT_NETWORK,
-            nymd_url.as_ref(),
-            None,
-            None,
-            None,
-            mnemonic,
-            None,
-        )
-        .unwrap();
-        let denom = Denom::from_str(network_defaults::DENOM).unwrap();
-        let contract_address = AccountId::from_str(CONTRACT_ADDRESS).unwrap();
+    pub fn new(nymd_url: &str, mnemonic: &str) -> Self {
+        let nymd_url = Url::from_str(nymd_url).unwrap();
+        let mnemonic = Mnemonic::from_str(mnemonic).unwrap();
+        let network_details = NymNetworkDetails::new_from_env();
+        let config = nymd::Config::try_from_nym_network_details(&network_details)
+            .expect("failed to construct valid validator client config with the provided network");
+        let nymd_client =
+            NymdClient::connect_with_mnemonic(config, nymd_url.as_ref(), mnemonic, None).unwrap();

        Client {
            nymd_client,
-            denom,
-            contract_address,
+            mix_denom_base: network_details.chain_details.mix_denom.base,
        }
    }

    pub async fn deposit(
        &self,
        amount: u64,
-        info: &str,
        verification_key: String,
        encryption_key: String,
+        fee: Option<Fee>,
    ) -> Result<String> {
-        let req = ExecuteMsg::DepositFunds {
-            data: DepositData::new(info.to_string(), verification_key, encryption_key),
-        };
-        let funds = vec![CosmosCoin {
-            denom: self.denom.clone(),
-            amount: Decimal::from(amount),
-        }];
+        let amount = Coin::new(amount as u128, self.mix_denom_base.clone());
        Ok(self
            .nymd_client
-            .execute(&self.contract_address, &req, Default::default(), "", funds)
+            .deposit(
+                amount,
+                String::from(VOUCHER_INFO),
+                verification_key,
+                encryption_key,
+                fee,
+            )
            .await?
            .transaction_hash
            .to_string())
@@ -6,7 +6,6 @@ use clap::{Args, Subcommand};
 use pickledb::PickleDb;
 use rand::rngs::OsRng;
 use std::str::FromStr;
-use url::Url;

 use coconut_interface::{Attribute, Base58, BlindSignRequest, Bytable, Parameters};
 use credential_storage::storage::Storage;
@@ -20,7 +19,6 @@ use validator_client::nymd::tx::Hash;
 use crate::client::Client;
 use crate::error::{CredentialClientError, Result};
 use crate::state::{KeyPair, RequestData, State};
-use crate::SIGNER_AUTHORITIES;

 #[derive(Subcommand)]
 pub(crate) enum Commands {
@@ -39,6 +37,12 @@ pub(crate) trait Execute {

 #[derive(Args, Clone)]
 pub(crate) struct Deposit {
+    /// The nymd URL that should be used
+    #[clap(long)]
+    nymd_url: String,
+    /// A mnemonic for the account that does the deposit
+    #[clap(long)]
+    mnemonic: String,
    /// The amount that needs to be deposited
    #[clap(long)]
    amount: u64,
@@ -51,13 +55,13 @@ impl Execute for Deposit {
        let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
        let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));

-        let client = Client::new();
+        let client = Client::new(&self.nymd_url, &self.mnemonic);
        let tx_hash = client
            .deposit(
                self.amount,
-                VOUCHER_INFO,
                signing_keypair.public_key.clone(),
                encryption_keypair.public_key.clone(),
+                None,
            )
            .await?;

@@ -96,6 +100,10 @@ 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))]
@@ -108,7 +116,8 @@ impl Execute for GetCredential {
        let mut state = db
            .get::<State>(&self.tx_hash)
            .ok_or(CredentialClientError::NoDeposit)?;
-        let urls = SIGNER_AUTHORITIES.map(|addr| Url::from_str(addr).unwrap());
+
+        let urls = config::parse_validators(&self.signer_authorities);

        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
        let bandwidth_credential_attributes = if self.__no_request {
@@ -11,20 +11,24 @@ cfg_if::cfg_if! {

        use commands::{Commands, Execute};
        use error::Result;
+        use network_defaults::setup_env;

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

-        pub const MNEMONIC: &str = "jazz fatigue diagram account outer wrist slide cherry mother grid network pause wolf pig round answer mail junior better hair dismiss toward access end";
-        pub const NYMD_URL: &str = "http://127.0.0.1:26657";
-        pub const CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
-        pub const SIGNER_AUTHORITIES: [&str; 1] = [
-            "http://127.0.0.1:8080",
-        ];
-
        #[derive(Parser)]
        #[clap(author = "Nymtech", version, about)]
        struct Cli {
+            /// Path pointing to an env file that configures the client.
+            #[clap(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)]
            command: Commands,
        }
@@ -32,8 +36,9 @@ cfg_if::cfg_if! {
        #[tokio::main]
        async fn main() -> Result<()> {
            let args = Cli::parse();
+            setup_env(args.config_env_file.clone());

-            let shared_storage = credential_storage::initialise_storage(std::path::PathBuf::from("/tmp/credential.db")).await;
+            let shared_storage = credential_storage::initialise_storage(args.credential_db_path.clone()).await;
            let mut db = match PickleDb::load(
                "credential.db",
                PickleDbDumpPolicy::AutoDump,
@@ -1,7 +1,8 @@
 [package]
 name = "nym-client"
-version = "1.0.1"
+version = "1.0.2"
 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.56"

@@ -19,33 +20,33 @@ futures = "0.3" # bunch of futures stuff, however, now that I think about it, it
 # and the single instance of abortable we have should really be refactored anyway
 url = "2.2"

-clap = "2.33.0" # for the command line arguments
-dirs = "3.0" # for determining default store directories in config
-dotenv = "0.15.0" # for obtaining environmental variables (only used for RUST_LOG for time being)
+clap = { version = "3.2.8", features = ["cargo", "derive"] }
+dirs = "4.0"
 log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
 rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
 sled = "0.34" # for storage of replySURB decryption keys
-tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal"] } # async runtime
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket

 ## internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
+network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
+task = { path = "../../common/task" }
 topology = { path = "../../common/topology" }
-websocket-requests = { path = "websocket-requests" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
-network-defaults = { path = "../../common/network-defaults" }
+websocket-requests = { path = "websocket-requests" }

 [features]
 coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut", "client-core/coconut"]
@@ -55,4 +56,4 @@ eth = []
 serde_json = "1.0" # for the "textsend" example

 [build-dependencies]
-vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
+vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
@@ -11,7 +11,7 @@ use std::path::PathBuf;

 mod template;

-#[derive(Debug, Deserialize, PartialEq, Serialize, Clone, Copy)]
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize, Clone, Copy)]
 #[serde(deny_unknown_fields)]
 pub enum SocketType {
    WebSocket,
@@ -50,6 +50,10 @@ impl NymConfig for Config {
            .join("clients")
    }

+    fn try_default_root_directory() -> Option<PathBuf> {
+        dirs::home_dir().map(|path| path.join(".nym").join("clients"))
+    }
+
    fn root_directory(&self) -> PathBuf {
        self.base.get_nym_root_directory()
    }
@@ -105,7 +109,7 @@ impl Config {
    }
 }

-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Socket {
    socket_type: SocketType,
@@ -32,6 +32,7 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

 use crate::client::config::{Config, SocketType};
 use crate::websocket;
@@ -85,6 +86,7 @@ impl NymClient {
        &self,
        topology_accessor: TopologyAccessor,
        mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting loop cover traffic stream...");

@@ -98,6 +100,7 @@ impl NymClient {
            mix_tx,
            self.as_mix_recipient(),
            topology_accessor,
+            shutdown,
        )
        .start();
    }
@@ -109,6 +112,7 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
+        shutdown: ShutdownListener,
    ) {
        let controller_config = real_messages_control::Config::new(
            self.key_manager.ack_key(),
@@ -129,6 +133,7 @@ impl NymClient {
            mix_sender,
            topology_accessor,
            reply_key_storage,
+            shutdown,
        )
        .start();
    }
@@ -140,6 +145,7 @@ impl NymClient {
        query_receiver: ReceivedBufferRequestReceiver,
        mixnet_receiver: MixnetMessageReceiver,
        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting received messages buffer controller...");
        ReceivedMessagesBufferController::new(
@@ -147,6 +153,7 @@ impl NymClient {
            query_receiver,
            mixnet_receiver,
            reply_key_storage,
+            shutdown,
        )
        .start()
    }
@@ -155,6 +162,7 @@ impl NymClient {
        &mut self,
        mixnet_message_sender: MixnetMessageSender,
        ack_sender: AcknowledgementSender,
+        shutdown: ShutdownListener,
    ) -> GatewayClient {
        let gateway_id = self.config.get_base().get_gateway_id();
        if gateway_id.is_empty() {
@@ -197,11 +205,12 @@ impl NymClient {
            ack_sender,
            self.config.get_base().get_gateway_response_timeout(),
            Some(bandwidth_controller),
+            Some(shutdown),
        );

-        if self.config.get_base().get_disabled_credentials_mode() {
-            gateway_client.set_disabled_credentials_mode(true)
-        }
+        gateway_client
+            .set_disabled_credentials_mode(self.config.get_base().get_disabled_credentials_mode());
+
        gateway_client
            .authenticate_and_start()
            .await
@@ -212,7 +221,11 @@ impl NymClient {

    // future responsible for periodically polling directory server and updating
    // the current global view of topology
-    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
+    async fn start_topology_refresher(
+        &mut self,
+        topology_accessor: TopologyAccessor,
+        shutdown: ShutdownListener,
+    ) {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -234,7 +247,7 @@ impl NymClient {
        }

        info!("Starting topology refresher...");
-        topology_refresher.start();
+        topology_refresher.start(shutdown);
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -245,9 +258,10 @@ impl NymClient {
        &mut self,
        mix_rx: BatchMixMessageReceiver,
        gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        MixTrafficController::new(mix_rx, gateway_client, shutdown).start();
    }

    fn start_websocket_listener(
@@ -308,20 +322,26 @@ impl NymClient {

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
    pub async fn run_forever(&mut self) {
-        self.start().await;
-        if let Err(e) = tokio::signal::ctrl_c().await {
-            error!(
-                "There was an error while capturing SIGINT - {:?}. We will terminate regardless",
-                e
-            );
-        }
+        let shutdown = self.start().await;
+        wait_for_signal().await;

        println!(
-            "Received SIGINT - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
+            "Received signal - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
        );
+
+        log::info!("Sending shutdown");
+        shutdown.signal_shutdown().ok();
+
+        // Some of these components have shutdown signalling implemented as part of socks5 work,
+        // but since it's not fully implemented (yet) for all the components of the native client,
+        // we don't try to wait and instead just stop immediately.
+        //log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
+        //shutdown.wait_for_shutdown().await;
+
+        log::info!("Stopping nym-client");
    }

-    pub async fn start(&mut self) {
+    pub async fn start(&mut self) -> ShutdownNotifier {
        info!("Starting nym client");
        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
@@ -351,30 +371,43 @@ impl NymClient {
            ReplyKeyStorage::load(self.config.get_base().get_reply_encryption_key_store_path())
                .expect("Failed to load reply key storage!");

+        // Shutdown notifier for signalling tasks to stop
+        let shutdown = ShutdownNotifier::default();
+
        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
-        self.start_topology_refresher(shared_topology_accessor.clone())
+        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
            .await;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
            reply_key_storage.clone(),
+            shutdown.subscribe(),
        );

        let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
            .await;

-        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
+        self.start_mix_traffic_controller(
+            sphinx_message_receiver,
+            gateway_client,
+            shutdown.subscribe(),
+        );
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
            ack_receiver,
            input_receiver,
            sphinx_message_sender.clone(),
+            shutdown.subscribe(),
        );

-        self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
+        self.start_cover_traffic_stream(
+            shared_topology_accessor,
+            sphinx_message_sender,
+            shutdown.subscribe(),
+        );

        match self.config.get_socket_type() {
            SocketType::WebSocket => {
@@ -399,5 +432,7 @@ impl NymClient {

        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
    }
 }
@@ -1,245 +1,203 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{App, Arg, ArgMatches};
-use client_core::client::key_manager::KeyManager;
-use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use clap::Args;
+use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;
-use crypto::asymmetric::{encryption, identity};
-use gateway_client::GatewayClient;
-use gateway_requests::registration::handshake::SharedKeys;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::addressing::nodes::NodeIdentity;
-use rand::rngs::OsRng;
-use rand::seq::SliceRandom;
-use rand::thread_rng;
-use std::convert::TryInto;
-use std::sync::Arc;
-use std::time::Duration;
-use topology::{filter::VersionFilterable, gateway};
-use url::Url;

-use crate::client::config::Config;
-use crate::commands::override_config;
-#[cfg(feature = "eth")]
-#[cfg(not(feature = "coconut"))]
-use crate::commands::{
-    DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY, ENABLED_CREDENTIALS_MODE_ARG_NAME,
-    ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+use crate::{
+    client::config::Config,
+    commands::{override_config, OverrideConfig},
 };

-pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    let app = App::new("init")
-        .about("Initialise a Nym client. Do this first!")
-        .arg(Arg::with_name("id")
-            .long("id")
-            .help("Id of the nym-mixnet-client we want to create config for.")
-            .takes_value(true)
-            .required(true)
-        )
-        .arg(Arg::with_name("gateway")
-            .long("gateway")
-            .help("Id of the gateway we are going to connect to.")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("validators")
-                 .long("validators")
-                 .help("Comma separated list of rest endpoints of the validators")
-                 .takes_value(true),
-        )
-        .arg(Arg::with_name("disable-socket")
-            .long("disable-socket")
-            .help("Whether to not start the websocket")
-        )
-        .arg(Arg::with_name("port")
-            .short("p")
-            .long("port")
-            .help("Port for the socket (if applicable) to listen on in all subsequent runs")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("fastmode")
-            .long("fastmode")
-            .hidden(true) // this will prevent this flag from being displayed in `--help`
-            .help("Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init")
-        );
-    #[cfg(feature = "eth")]
-    #[cfg(not(feature = "coconut"))]
-        let app = app
-        .arg(
-            Arg::with_name(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .long(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .help("Set this client to work in a disabled credentials mode that would attempt to use gateway without bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
-                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
-        )
-        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
-            .long(ETH_ENDPOINT_ARG_NAME)
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true)
-            .default_value_if(ENABLED_CREDENTIALS_MODE_ARG_NAME, None, DEFAULT_ETH_ENDPOINT)
-            .required(true))
-        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
-            .long(ETH_PRIVATE_KEY_ARG_NAME)
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true)
-            .default_value_if(ENABLED_CREDENTIALS_MODE_ARG_NAME, None, DEFAULT_ETH_PRIVATE_KEY)
-            .required(true)
-        );
+#[cfg(all(feature = "eth", not(feature = "coconut")))]
+use crate::commands::{DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY};

-    app
+#[derive(Args, Clone)]
+pub(crate) struct Init {
+    /// Id of the nym-mixnet-client we want to create config for.
+    #[clap(long)]
+    id: String,
+
+    /// Id of the gateway we are going to connect to.
+    #[clap(long)]
+    gateway: Option<String>,
+
+    /// Force register gateway. WARNING: this will overwrite any existing keys for the given id,
+    /// potentially causing loss of access.
+    #[clap(long)]
+    force_register_gateway: bool,
+
+    /// Comma separated list of rest endpoints of the validators
+    #[clap(long)]
+    validators: Option<String>,
+
+    /// Whether to not start the websocket
+    #[clap(long)]
+    disable_socket: bool,
+
+    /// Port for the socket (if applicable) to listen on in all subsequent runs
+    #[clap(short, long)]
+    port: Option<u16>,
+
+    /// Mostly debug-related option to increase default traffic rate so that you would not need to
+    /// modify config post init
+    #[clap(long, hidden = true)]
+    fastmode: bool,
+
+    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
+    enabled_credentials_mode: bool,
+
+    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
+    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(
+        long,
+        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_ENDPOINT))
+    )]
+    eth_endpoint: String,
+
+    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
+    /// want to set this value, use --enabled-credentials-mode instead")
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(
+        long,
+        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_PRIVATE_KEY))
+    )]
+    eth_private_key: String,
 }

-async fn register_with_gateway(
-    gateway: &gateway::Node,
-    our_identity: Arc<identity::KeyPair>,
-) -> Arc<SharedKeys> {
-    let timeout = Duration::from_millis(1500);
-    let mut gateway_client = GatewayClient::new_init(
-        gateway.clients_address(),
-        gateway.identity_key,
-        gateway.owner.clone(),
-        our_identity.clone(),
-        timeout,
-    );
-    gateway_client
-        .establish_connection()
-        .await
-        .expect("failed to establish connection with the gateway!");
-    gateway_client
-        .perform_initial_authentication()
-        .await
-        .expect("failed to register with the gateway!")
-}
+impl From<Init> for OverrideConfig {
+    fn from(init_config: Init) -> Self {
+        OverrideConfig {
+            validators: init_config.validators,
+            disable_socket: init_config.disable_socket,
+            port: init_config.port,
+            fastmode: init_config.fastmode,

-async fn gateway_details(
-    validator_servers: Vec<Url>,
-    chosen_gateway_id: Option<&str>,
-) -> gateway::Node {
-    let validator_api = validator_servers
-        .choose(&mut thread_rng())
-        .expect("The list of validator apis is empty");
-    let validator_client = validator_client::ApiClient::new(validator_api.clone());
+            #[cfg(any(feature = "eth", feature = "coconut"))]
+            enabled_credentials_mode: init_config.enabled_credentials_mode,

-    let gateways = validator_client.get_cached_gateways().await.unwrap();
-    let valid_gateways = gateways
-        .into_iter()
-        .filter_map(|gateway| gateway.try_into().ok())
-        .collect::<Vec<gateway::Node>>();
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_private_key: Some(init_config.eth_private_key),

-    let filtered_gateways = valid_gateways.filter_by_version(env!("CARGO_PKG_VERSION"));
-
-    // if we have chosen particular gateway - use it, otherwise choose a random one.
-    // (remember that in active topology all gateways have at least 100 reputation so should
-    // be working correctly)
-    if let Some(gateway_id) = chosen_gateway_id {
-        filtered_gateways
-            .iter()
-            .find(|gateway| gateway.identity_key.to_base58_string() == gateway_id)
-            .expect(&*format!("no gateway with id {} exists!", gateway_id))
-            .clone()
-    } else {
-        filtered_gateways
-            .choose(&mut rand::thread_rng())
-            .expect("there are no gateways on the network!")
-            .clone()
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_endpoint: Some(init_config.eth_endpoint),
+        }
    }
 }

-fn show_address(config: &Config) {
-    fn load_identity_keys(pathfinder: &ClientKeyPathfinder) -> identity::KeyPair {
-        let identity_keypair: identity::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_identity_key().to_owned(),
-                pathfinder.public_identity_key().to_owned(),
-            ))
-            .expect("Failed to read stored identity key files");
-        identity_keypair
-    }
-
-    fn load_sphinx_keys(pathfinder: &ClientKeyPathfinder) -> encryption::KeyPair {
-        let sphinx_keypair: encryption::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_encryption_key().to_owned(),
-                pathfinder.public_encryption_key().to_owned(),
-            ))
-            .expect("Failed to read stored sphinx key files");
-        sphinx_keypair
-    }
-
-    let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
-    let identity_keypair = load_identity_keys(&pathfinder);
-    let sphinx_keypair = load_sphinx_keys(&pathfinder);
-
-    let client_recipient = Recipient::new(
-        *identity_keypair.public_key(),
-        *sphinx_keypair.public_key(),
-        // TODO: below only works under assumption that gateway address == gateway id
-        // (which currently is true)
-        NodeIdentity::from_base58_string(config.get_base().get_gateway_id()).unwrap(),
-    );
-
-    println!("\nThe address of this client is: {}", client_recipient);
-}
-
-pub async fn execute(matches: ArgMatches<'static>) {
+pub(crate) async fn execute(args: &Init) {
    println!("Initialising client...");

-    let id = matches.value_of("id").unwrap(); // required for now
+    let id = &args.id;

-    let already_init = if Config::default_config_file_path(Some(id)).exists() {
-        println!("Client \"{}\" was already initialised before! Config information will be overwritten (but keys will be kept)!", id);
-        true
-    } else {
-        false
-    };
+    let already_init = Config::default_config_file_path(Some(id)).exists();
+    if already_init {
+        println!(
+            "Client \"{}\" was already initialised before! \
+            Config information will be overwritten (but keys will be kept)!",
+            id
+        );
+    }
+
+    // Usually you only register with the gateway on the first init, however you can force
+    // re-registering if wanted.
+    let user_wants_force_register = args.force_register_gateway;
+
+    // If the client was already initialized, don't generate new keys and don't re-register with
+    // the gateway (because this would create a new shared key).
+    // Unless the user really wants to.
+    let register_gateway = !already_init || user_wants_force_register;
+
+    // Attempt to use a user-provided gateway, if possible
+    let user_chosen_gateway_id = args.gateway.as_deref();

    let mut config = Config::new(id);
+    let override_config_fields = OverrideConfig::from(args.clone());
+    config = override_config(config, override_config_fields);

-    let mut rng = OsRng;
-
-    // TODO: ideally that should be the last thing that's being done to config.
-    // However, we are later further overriding it with gateway id
-    config = override_config(config, &matches);
-    if matches.is_present("fastmode") {
-        config.get_base_mut().set_high_default_traffic_volume();
-    }
-
-    // if client was already initialised, don't generate new keys, not re-register with gateway
-    // (because this would create new shared key)
-    if !already_init {
-        // create identity, encryption and ack keys.
-        let mut key_manager = KeyManager::new(&mut rng);
-
-        let chosen_gateway_id = matches.value_of("gateway");
-
-        let gateway_details = gateway_details(
-            config.get_base().get_validator_api_endpoints(),
-            chosen_gateway_id,
-        )
-        .await;
-        let shared_keys =
-            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
-
-        config.get_base_mut().with_gateway_endpoint(
-            gateway_details.identity_key.to_base58_string(),
-            gateway_details.owner.clone(),
-            gateway_details.clients_address(),
-        );
-        key_manager.insert_gateway_shared_key(shared_keys);
-
-        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
-        key_manager
-            .store_keys(&pathfinder)
-            .expect("Failed to generated keys");
-        println!("Saved all generated keys");
-    }
+    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config)
+        .await
+        .unwrap_or_else(|err| {
+            eprintln!("Failed to setup gateway\nError: {err}");
+            std::process::exit(1)
+        });
+    config.get_base_mut().with_gateway_endpoint(gateway);

    let config_save_location = config.get_config_file_save_location();
    config
        .save_to_file(None)
        .expect("Failed to save the config file");
-    println!("Saved configuration file to {:?}", config_save_location);
-    println!("Using gateway: {}", config.get_base().get_gateway_id(),);
-    println!("Client configuration completed.\n\n\n");

-    show_address(&config);
+    println!("Saved configuration file to {:?}", config_save_location);
+    println!("Using gateway: {}", config.get_base().get_gateway_id());
+    log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
+    log::debug!("Gateway owner: {}", config.get_base().get_gateway_owner());
+    log::debug!(
+        "Gateway listener: {}",
+        config.get_base().get_gateway_listener()
+    );
+    println!("Client configuration completed.");
+
+    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
+        eprintln!("Failed to show address\nError: {err}");
+        std::process::exit(1)
+    });
+}
+
+async fn setup_gateway(
+    id: &str,
+    register: bool,
+    user_chosen_gateway_id: Option<&str>,
+    config: &Config,
+) -> Result<GatewayEndpoint, ClientCoreError> {
+    if register {
+        // Get the gateway details by querying the validator-api. Either pick one at random or use
+        // the chosen one if it's among the available ones.
+        println!("Configuring gateway");
+        let gateway = client_core::init::query_gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            user_chosen_gateway_id,
+        )
+        .await?;
+        log::debug!("Querying gateway gives: {}", gateway);
+
+        // Registering with gateway by setting up and writing shared keys to disk
+        log::trace!("Registering gateway");
+        client_core::init::register_with_gateway_and_store_keys(gateway.clone(), config.get_base())
+            .await?;
+        println!("Saved all generated keys");
+
+        Ok(gateway.into())
+    } else if user_chosen_gateway_id.is_some() {
+        // Just set the config, don't register or create any keys
+        // This assumes that the user knows what they are doing, and that the existing keys are
+        // valid for the gateway being used
+        println!("Using gateway provided by user, keeping existing keys");
+        let gateway = client_core::init::query_gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            user_chosen_gateway_id,
+        )
+        .await?;
+        log::debug!("Querying gateway gives: {}", gateway);
+        Ok(gateway.into())
+    } else {
+        println!("Not registering gateway, will reuse existing config and keys");
+        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })?;
+
+        Ok(existing_config.get_base().get_gateway_endpoint().clone())
+    }
 }
@@ -2,14 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::{Config, SocketType};
-use clap::ArgMatches;
-use url::Url;
+use clap::{Parser, Subcommand};

-pub(crate) const ENABLED_CREDENTIALS_MODE_ARG_NAME: &str = "enabled-credentials-mode";
-#[cfg(not(feature = "coconut"))]
-pub(crate) const ETH_ENDPOINT_ARG_NAME: &str = "eth_endpoint";
-#[cfg(not(feature = "coconut"))]
-pub(crate) const ETH_PRIVATE_KEY_ARG_NAME: &str = "eth_private_key";
 #[cfg(not(feature = "coconut"))]
 pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
@@ -21,60 +15,148 @@ pub(crate) mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;

-fn parse_validators(raw: &str) -> Vec<Url> {
-    raw.split(',')
-        .map(|raw_validator| {
-            raw_validator
-                .trim()
-                .parse()
-                .expect("one of the provided validator api urls is invalid")
-        })
-        .collect()
+fn long_version() -> String {
+    format!(
+        r#"
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+"#,
+        "Build Timestamp:",
+        env!("VERGEN_BUILD_TIMESTAMP"),
+        "Build Version:",
+        env!("VERGEN_BUILD_SEMVER"),
+        "Commit SHA:",
+        env!("VERGEN_GIT_SHA"),
+        "Commit Date:",
+        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
+        "Commit Branch:",
+        env!("VERGEN_GIT_BRANCH"),
+        "rustc Version:",
+        env!("VERGEN_RUSTC_SEMVER"),
+        "rustc Channel:",
+        env!("VERGEN_RUSTC_CHANNEL"),
+        "cargo Profile:",
+        env!("VERGEN_CARGO_PROFILE"),
+    )
 }

-pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> Config {
-    if let Some(raw_validators) = matches.value_of("validators") {
+fn long_version_static() -> &'static str {
+    Box::leak(long_version().into_boxed_str())
+}
+
+#[derive(Parser)]
+#[clap(author = "Nymtech", version, long_version = long_version_static(), about)]
+pub(crate) struct Cli {
+    /// Path pointing to an env file that configures the client.
+    #[clap(long)]
+    pub(crate) config_env_file: Option<std::path::PathBuf>,
+
+    #[clap(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+pub(crate) enum Commands {
+    /// Initialise a Nym client. Do this first!
+    Init(init::Init),
+    /// Run the Nym client with provided configuration client optionally overriding set parameters
+    Run(run::Run),
+    /// Try to upgrade the client
+    Upgrade(upgrade::Upgrade),
+}
+
+// Configuration that can be overridden.
+pub(crate) struct OverrideConfig {
+    validators: Option<String>,
+    disable_socket: bool,
+    port: Option<u16>,
+    fastmode: bool,
+
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    enabled_credentials_mode: bool,
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    eth_private_key: Option<String>,
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    eth_endpoint: Option<String>,
+}
+
+pub(crate) async fn execute(args: &Cli) {
+    match &args.command {
+        Commands::Init(m) => init::execute(m).await,
+        Commands::Run(m) => run::execute(m).await,
+        Commands::Upgrade(m) => upgrade::execute(m),
+    }
+}
+
+pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
+    if let Some(raw_validators) = args.validators {
        config
            .get_base_mut()
-            .set_custom_validator_apis(parse_validators(raw_validators));
+            .set_custom_validator_apis(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::API_VALIDATOR)
+            .expect("api validator not set");
+        config
+            .get_base_mut()
+            .set_custom_validator_apis(config::parse_validators(&raw_validators));
    }

-    if let Some(gateway_id) = matches.value_of("gateway") {
-        config.get_base_mut().with_gateway_id(gateway_id);
-    }
-
-    if matches.is_present("disable-socket") {
+    if args.disable_socket {
        config = config.with_socket(SocketType::None);
    }

-    if let Some(port) = matches.value_of("port").map(|port| port.parse::<u16>()) {
-        if let Err(err) = port {
-            // if port was overridden, it must be parsable
-            panic!("Invalid port value provided - {:?}", err);
+    if let Some(port) = args.port {
+        config = config.with_port(port);
+    }
+
+    #[cfg(all(not(feature = "eth"), not(feature = "coconut")))]
+    {
+        config
+            .get_base_mut()
+            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT.to_string());
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
+    }
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    {
+        if args.enabled_credentials_mode {
+            config.get_base_mut().with_disabled_credentials(false)
        }
-        config = config.with_port(port.unwrap());
    }

-    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
-        config.get_base_mut().with_eth_endpoint(eth_endpoint);
-    } else if !cfg!(feature = "eth") {
-        config
-            .get_base_mut()
-            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT);
-    }
-    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_private_key) = matches.value_of(ETH_PRIVATE_KEY_ARG_NAME) {
-        config.get_base_mut().with_eth_private_key(eth_private_key);
-    } else if !cfg!(feature = "eth") {
-        config
-            .get_base_mut()
-            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    {
+        if let Some(eth_endpoint) = args.eth_endpoint {
+            config.get_base_mut().with_eth_endpoint(eth_endpoint);
+        }
+        if let Some(eth_private_key) = args.eth_private_key {
+            config.get_base_mut().with_eth_private_key(eth_private_key);
+        }
    }

-    if matches.is_present(ENABLED_CREDENTIALS_MODE_ARG_NAME) {
-        config.get_base_mut().with_disabled_credentials(false)
+    if args.fastmode {
+        config.get_base_mut().set_high_default_traffic_volume();
    }

    config
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::CommandFactory;
+
+    #[test]
+    fn verify_cli() {
+        Cli::command().debug_assert();
+    }
+}
@@ -1,68 +1,76 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::config::Config;
-use crate::client::NymClient;
-use crate::commands::override_config;
-#[cfg(feature = "eth")]
-#[cfg(not(feature = "coconut"))]
-use crate::commands::{
-    ENABLED_CREDENTIALS_MODE_ARG_NAME, ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+use crate::{
+    client::{config::Config, NymClient},
+    commands::{override_config, OverrideConfig},
 };
-use clap::{App, Arg, ArgMatches};
+
+use clap::Args;
 use config::NymConfig;
 use log::*;
 use version_checker::is_minor_version_compatible;

-pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    let app = App::new("run")
-        .about("Run the Nym client with provided configuration client optionally overriding set parameters")
-        .arg(Arg::with_name("id")
-            .long("id")
-            .help("Id of the nym-mixnet-client we want to run.")
-            .takes_value(true)
-            .required(true)
-        )
-        // the rest of arguments are optional, they are used to override settings in config file
-        .arg(Arg::with_name("validators")
-                .long("validators")
-                .help("Comma separated list rest rest endpoints of the validators")
-                .takes_value(true),
-        )
-        .arg(Arg::with_name("gateway")
-            .long("gateway")
-            .help("Id of the gateway we want to connect to. If overridden, it is user's responsibility to ensure prior registration happened")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("disable-socket")
-            .long("disable-socket")
-            .help("Whether to not start the websocket")
-        )
-        .arg(Arg::with_name("port")
-            .short("p")
-            .long("port")
-            .help("Port for the socket (if applicable) to listen on")
-            .takes_value(true)
-        );
-    #[cfg(feature = "eth")]
-    #[cfg(not(feature = "coconut"))]
-        let app = app
-        .arg(
-            Arg::with_name(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .long(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .help("Set this client to work in a enabled credentials mode that would attempt to use gateway with bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
-                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
-        )
-        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
-            .long(ETH_ENDPOINT_ARG_NAME)
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true))
-        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
-            .long(ETH_PRIVATE_KEY_ARG_NAME)
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true));
+#[derive(Args, Clone)]
+pub(crate) struct Run {
+    /// Id of the nym-mixnet-client we want to run.
+    #[clap(long)]
+    id: String,

-    app
+    /// Comma separated list of rest endpoints of the validators
+    #[clap(long)]
+    validators: Option<String>,
+
+    /// Id of the gateway we want to connect to. If overridden, it is user's responsibility to
+    /// ensure prior registration happened
+    #[clap(long)]
+    gateway: Option<String>,
+
+    /// Whether to not start the websocket
+    #[clap(long)]
+    disable_socket: bool,
+
+    /// Port for the socket to listen on
+    #[clap(short, long)]
+    port: Option<u16>,
+
+    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
+    enabled_credentials_mode: bool,
+
+    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
+    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long)]
+    eth_endpoint: Option<String>,
+
+    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
+    /// want to set this value, use --enabled-credentials-mode instead")
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long)]
+    eth_private_key: Option<String>,
+}
+
+impl From<Run> for OverrideConfig {
+    fn from(run_config: Run) -> Self {
+        OverrideConfig {
+            validators: run_config.validators,
+            disable_socket: run_config.disable_socket,
+            port: run_config.port,
+            fastmode: false,
+
+            #[cfg(any(feature = "eth", feature = "coconut"))]
+            enabled_credentials_mode: run_config.enabled_credentials_mode,
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_private_key: run_config.eth_private_key,
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_endpoint: run_config.eth_endpoint,
+        }
+    }
 }

 // this only checks compatibility between config the binary. It does not take into consideration
@@ -70,8 +78,10 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
 fn version_check(cfg: &Config) -> bool {
    let binary_version = env!("CARGO_PKG_VERSION");
    let config_version = cfg.get_base().get_version();
-    if binary_version != config_version {
-        warn!("The mixnode binary has different version than what is specified in config file! {} and {}", binary_version, config_version);
+    if binary_version == config_version {
+        true
+    } else {
+        warn!("The native-client binary has different version than what is specified in config file! {} and {}", binary_version, config_version);
        if is_minor_version_compatible(binary_version, config_version) {
            info!("but they are still semver compatible. However, consider running the `upgrade` command");
            true
@@ -79,13 +89,11 @@ fn version_check(cfg: &Config) -> bool {
            error!("and they are semver incompatible! - please run the `upgrade` command before attempting `run` again");
            false
        }
-    } else {
-        true
    }
 }

-pub async fn execute(matches: ArgMatches<'static>) {
-    let id = matches.value_of("id").unwrap();
+pub(crate) async fn execute(args: &Run) {
+    let id = &args.id;

    let mut config = match Config::load_from_file(Some(id)) {
        Ok(cfg) => cfg,
@@ -95,7 +103,8 @@ pub async fn execute(matches: ArgMatches<'static>) {
        }
    };

-    config = override_config(config, &matches);
+    let override_config_fields = OverrideConfig::from(args.clone());
+    config = override_config(config, override_config_fields);

    if !version_check(&config) {
        error!("failed the local version check");
@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::{Config, MISSING_VALUE};
-use clap::{App, Arg, ArgMatches};
-use config::defaults::default_api_endpoints;
+
 use config::NymConfig;
+use version_checker::Version;
+
+use clap::Args;
 use std::fmt::Display;
 use std::process;
-use version_checker::Version;

 #[allow(dead_code)]
 fn fail_upgrade<D1: Display, D2: Display>(from_version: D1, to_version: D2) -> ! {
@@ -49,14 +50,11 @@ fn unsupported_upgrade(current_version: &Version, config_version: &Version) -> !
    process::exit(1)
 }

-pub fn command_args<'a, 'b>() -> App<'a, 'b> {
-    App::new("upgrade").about("Try to upgrade the client").arg(
-        Arg::with_name("id")
-            .long("id")
-            .help("Id of the nym-client we want to upgrade")
-            .takes_value(true)
-            .required(true),
-    )
+#[derive(Args, Clone)]
+pub(crate) struct Upgrade {
+    /// Id of the nym-client we want to upgrade
+    #[clap(long)]
+    id: String,
 }

 fn parse_config_version(config: &Config) -> Version {
@@ -95,7 +93,7 @@ fn parse_package_version() -> Version {

 fn minor_0_12_upgrade(
    mut config: Config,
-    _matches: &ArgMatches<'_>,
+    _matches: &Upgrade,
    config_version: &Version,
    package_version: &Version,
 ) -> Config {
@@ -107,15 +105,6 @@ fn minor_0_12_upgrade(

    print_start_upgrade(&config_version, &to_version);

-    println!(
-        "Setting validator API endpoints to {:?}",
-        default_api_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validator_apis(default_api_endpoints());
-
    config
        .get_base_mut()
        .set_custom_version(to_version.to_string().as_ref());
@@ -131,30 +120,30 @@ fn minor_0_12_upgrade(
    config
 }

-fn do_upgrade(mut config: Config, matches: &ArgMatches<'_>, package_version: Version) {
+fn do_upgrade(mut config: Config, args: &Upgrade, package_version: &Version) {
    loop {
        let config_version = parse_config_version(&config);

-        if config_version == package_version {
+        if &config_version == package_version {
            println!("You're using the most recent version!");
            return;
        }

        config = match config_version.major {
            0 => match config_version.minor {
-                9 | 10 => outdated_upgrade(&config_version, &package_version),
-                11 => minor_0_12_upgrade(config, matches, &config_version, &package_version),
-                _ => unsupported_upgrade(&config_version, &package_version),
+                9 | 10 => outdated_upgrade(&config_version, package_version),
+                11 => minor_0_12_upgrade(config, args, &config_version, package_version),
+                _ => unsupported_upgrade(&config_version, package_version),
            },
-            _ => unsupported_upgrade(&config_version, &package_version),
+            _ => unsupported_upgrade(&config_version, package_version),
        }
    }
 }

-pub fn execute(matches: &ArgMatches<'_>) {
+pub(crate) fn execute(args: &Upgrade) {
    let package_version = parse_package_version();

-    let id = matches.value_of("id").unwrap();
+    let id = &args.id;

    let existing_config = Config::load_from_file(Some(id)).unwrap_or_else(|err| {
        eprintln!("failed to load existing config file! - {:?}", err);
@@ -167,5 +156,5 @@ pub fn execute(matches: &ArgMatches<'_>) {
    }

    // here be upgrade path to 0.9.X and beyond based on version number from config
-    do_upgrade(existing_config, matches, package_version)
+    do_upgrade(existing_config, args, &package_version)
 }
@@ -1,8 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{crate_version, App, ArgMatches};
-use network_defaults::DEFAULT_NETWORK;
+use clap::{crate_version, Parser};
+use network_defaults::setup_env;

 pub mod client;
 pub mod commands;
@@ -10,34 +10,12 @@ pub mod websocket;

 #[tokio::main]
 async fn main() {
-    dotenv::dotenv().ok();
    setup_logging();
    println!("{}", banner());

-    let arg_matches = App::new("Nym Client")
-        .version(crate_version!())
-        .long_version(&*long_version())
-        .author("Nymtech")
-        .about("Implementation of the Nym Client")
-        .subcommand(commands::init::command_args())
-        .subcommand(commands::run::command_args())
-        .subcommand(commands::upgrade::command_args())
-        .get_matches();
-
-    execute(arg_matches).await;
-}
-
-async fn execute(matches: ArgMatches<'static>) {
-    match matches.subcommand() {
-        ("init", Some(m)) => commands::init::execute(m.clone()).await,
-        ("run", Some(m)) => commands::run::execute(m.clone()).await,
-        ("upgrade", Some(m)) => commands::upgrade::execute(m),
-        _ => println!("{}", usage()),
-    }
-}
-
-fn usage() -> &'static str {
-    "usage: --help to see available options.\n\n"
+    let args = commands::Cli::parse();
+    setup_env(args.config_env_file.clone());
+    commands::execute(&args).await;
 }

 fn banner() -> String {
@@ -57,40 +35,6 @@ fn banner() -> String {
    )
 }

-fn long_version() -> String {
-    format!(
-        r#"
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-"#,
-        "Build Timestamp:",
-        env!("VERGEN_BUILD_TIMESTAMP"),
-        "Build Version:",
-        env!("VERGEN_BUILD_SEMVER"),
-        "Commit SHA:",
-        env!("VERGEN_GIT_SHA"),
-        "Commit Date:",
-        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
-        "Commit Branch:",
-        env!("VERGEN_GIT_BRANCH"),
-        "rustc Version:",
-        env!("VERGEN_RUSTC_SEMVER"),
-        "rustc Channel:",
-        env!("VERGEN_RUSTC_CHANNEL"),
-        "cargo Profile:",
-        env!("VERGEN_CARGO_PROFILE"),
-        "Network:",
-        DEFAULT_NETWORK
-    )
-}
-
 fn setup_logging() {
    let mut log_builder = pretty_env_logger::formatted_timed_builder();
    if let Ok(s) = ::std::env::var("RUST_LOG") {
@@ -108,5 +52,7 @@ fn setup_logging() {
        .filter_module("want", log::LevelFilter::Warn)
        .filter_module("tungstenite", log::LevelFilter::Warn)
        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
+        .filter_module("handlebars", log::LevelFilter::Warn)
+        .filter_module("sled", log::LevelFilter::Warn)
        .init();
 }
@@ -10,4 +10,4 @@ edition = "2021"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

-nymsphinx = { path = "../../../common/nymsphinx" }
+nymsphinx = { path = "../../../common/nymsphinx" }
@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt;

 // no need to go fancy here like we've done in other places.
-#[derive(PartialEq, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub struct Error {
    pub kind: ErrorKind,
    pub message: String,
@@ -30,7 +30,7 @@ impl Error {
 }

 #[repr(u8)]
-#[derive(PartialEq, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub enum ErrorKind {
    /// The received request contained no data.
    EmptyRequest = 0x01,
@@ -1,7 +1,8 @@
 [package]
 name = "nym-socks5-client"
-version = "1.0.1"
+version = "1.0.2"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
+description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
 rust-version = "1.56"

@@ -10,9 +11,8 @@ name = "nym_socks5"
 path = "src/lib.rs"

 [dependencies]
-clap = "2.33.0"
-dirs = "3.0" # for determining default store directories in config
-dotenv = "0.15.0"
+clap = { version = "3.2.8", features = ["cargo", "derive"] }
+dirs = "4.0"
 futures = "0.3"
 log = "0.4"
 pin-project = "1.0"
@@ -20,31 +20,32 @@ pretty_env_logger = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] } # for config serialization/deserialization
 snafu = "0.6"
-tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal"] }
+tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal"] }
 url = "2.2"

 # internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
+network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
 ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
-socks5-requests = { path = "../../common/socks5/requests" }
-topology = { path = "../../common/topology" }
 pemstore = { path = "../../common/pemstore" }
 proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
+socks5-requests = { path = "../../common/socks5/requests" }
+task = { path = "../../common/task" }
+topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
-network-defaults = { path = "../../common/network-defaults" }

 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut", "client-core/coconut"]
 eth = []

 [build-dependencies]
-vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
+vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
@@ -33,6 +33,10 @@ impl NymConfig for Config {
            .join("socks5-clients")
    }

+    fn try_default_root_directory() -> Option<PathBuf> {
+        dirs::home_dir().map(|path| path.join(".nym").join("socks5-clients"))
+    }
+
    fn root_directory(&self) -> PathBuf {
        self.base.get_nym_root_directory()
    }
@@ -89,7 +93,7 @@ impl Config {
    }
 }

-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Socks5 {
    /// The port on which the client will be listening for incoming requests
@@ -1,6 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use std::sync::atomic::Ordering;
+
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
@@ -20,6 +22,7 @@ use client_core::client::topology_control::{
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
+use futures::StreamExt;
 use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
@@ -28,6 +31,7 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

 use crate::client::config::Config;
 use crate::socks::{
@@ -35,7 +39,17 @@ use crate::socks::{
    server::SphinxSocksServer,
 };

-pub(crate) mod config;
+pub mod config;
+
+// Channels used to control the main task from outside
+pub type Socks5ControlMessageSender = mpsc::UnboundedSender<Socks5ControlMessage>;
+pub type Socks5ControlMessageReceiver = mpsc::UnboundedReceiver<Socks5ControlMessage>;
+
+#[derive(Debug)]
+pub enum Socks5ControlMessage {
+    /// Tell the main task to stop
+    Stop,
+}

 pub struct NymClient {
    /// Client configuration options, including, among other things, packet sending rates,
@@ -73,6 +87,7 @@ impl NymClient {
        &self,
        topology_accessor: TopologyAccessor,
        mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting loop cover traffic stream...");

@@ -86,6 +101,7 @@ impl NymClient {
            mix_tx,
            self.as_mix_recipient(),
            topology_accessor,
+            shutdown,
        )
        .start();
    }
@@ -97,6 +113,7 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
+        shutdown: ShutdownListener,
    ) {
        let controller_config = client_core::client::real_messages_control::Config::new(
            self.key_manager.ack_key(),
@@ -117,6 +134,7 @@ impl NymClient {
            mix_sender,
            topology_accessor,
            reply_key_storage,
+            shutdown,
        )
        .start();
    }
@@ -128,6 +146,7 @@ impl NymClient {
        query_receiver: ReceivedBufferRequestReceiver,
        mixnet_receiver: MixnetMessageReceiver,
        reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting received messages buffer controller...");
        ReceivedMessagesBufferController::new(
@@ -135,6 +154,7 @@ impl NymClient {
            query_receiver,
            mixnet_receiver,
            reply_key_storage,
+            shutdown,
        )
        .start()
    }
@@ -143,6 +163,7 @@ impl NymClient {
        &mut self,
        mixnet_message_sender: MixnetMessageSender,
        ack_sender: AcknowledgementSender,
+        shutdown: ShutdownListener,
    ) -> GatewayClient {
        let gateway_id = self.config.get_base().get_gateway_id();
        if gateway_id.is_empty() {
@@ -185,11 +206,12 @@ impl NymClient {
            ack_sender,
            self.config.get_base().get_gateway_response_timeout(),
            Some(bandwidth_controller),
+            Some(shutdown),
        );

-        if self.config.get_base().get_disabled_credentials_mode() {
-            gateway_client.set_disabled_credentials_mode(true)
-        }
+        gateway_client
+            .set_disabled_credentials_mode(self.config.get_base().get_disabled_credentials_mode());
+
        gateway_client
            .authenticate_and_start()
            .await
@@ -200,7 +222,11 @@ impl NymClient {

    // future responsible for periodically polling directory server and updating
    // the current global view of topology
-    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
+    async fn start_topology_refresher(
+        &mut self,
+        topology_accessor: TopologyAccessor,
+        shutdown: ShutdownListener,
+    ) {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -222,7 +248,7 @@ impl NymClient {
        }

        info!("Starting topology refresher...");
-        topology_refresher.start();
+        topology_refresher.start(shutdown);
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -233,15 +259,17 @@ impl NymClient {
        &mut self,
        mix_rx: BatchMixMessageReceiver,
        gateway_client: GatewayClient,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        MixTrafficController::new(mix_rx, gateway_client, shutdown).start();
    }

    fn start_socks5_listener(
        &self,
        buffer_requester: ReceivedBufferRequestSender,
        msg_input: InputMessageSender,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting socks5 listener...");
        let auth_methods = vec![AuthenticationMethods::NoAuth as u8];
@@ -253,26 +281,57 @@ impl NymClient {
            authenticator,
            self.config.get_provider_mix_address(),
            self.as_mix_recipient(),
+            shutdown,
        );
        tokio::spawn(async move { sphinx_socks.serve(msg_input, buffer_requester).await });
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
    pub async fn run_forever(&mut self) {
-        self.start().await;
-        if let Err(e) = tokio::signal::ctrl_c().await {
-            error!(
-                "There was an error while capturing SIGINT - {:?}. We will terminate regardless",
-                e
-            );
-        }
+        let mut shutdown = self.start().await;
+        wait_for_signal().await;

-        println!(
-            "Received SIGINT - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
-        );
+        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");
    }

-    pub async fn start(&mut self) {
+    // Variant of `run_forever` that listends for remote control messages
+    pub async fn run_and_listen(&mut self, mut receiver: Socks5ControlMessageReceiver) {
+        let mut shutdown = self.start().await;
+        tokio::select! {
+            message = receiver.next() => {
+                log::debug!("Received message: {:?}", message);
+                match message {
+                    Some(Socks5ControlMessage::Stop) => {
+                        log::info!("Received stop message");
+                    }
+                    None => {
+                        log::info!("Channel closed, stopping");
+                    }
+                }
+            }
+            _ = tokio::signal::ctrl_c() => {
+                log::info!("Received SIGINT");
+            },
+        }
+
+        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");
+    }
+
+    pub async fn start(&mut self) -> ShutdownNotifier {
        info!("Starting nym client");
        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
@@ -302,33 +361,52 @@ impl NymClient {
            ReplyKeyStorage::load(self.config.get_base().get_reply_encryption_key_store_path())
                .expect("Failed to load reply key storage!");

+        // Shutdown notifier for signalling tasks to stop
+        let shutdown = ShutdownNotifier::default();
+
        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
-        self.start_topology_refresher(shared_topology_accessor.clone())
+        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
            .await;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
            reply_key_storage.clone(),
+            shutdown.subscribe(),
        );

        let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
            .await;

-        self.start_mix_traffic_controller(sphinx_message_receiver, gateway_client);
+        self.start_mix_traffic_controller(
+            sphinx_message_receiver,
+            gateway_client,
+            shutdown.subscribe(),
+        );
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
            ack_receiver,
            input_receiver,
            sphinx_message_sender.clone(),
+            shutdown.subscribe(),
        );

-        self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
-        self.start_socks5_listener(received_buffer_request_sender, input_sender);
+        self.start_cover_traffic_stream(
+            shared_topology_accessor,
+            sphinx_message_sender,
+            shutdown.subscribe(),
+        );
+        self.start_socks5_listener(
+            received_buffer_request_sender,
+            input_sender,
+            shutdown.subscribe(),
+        );

        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
    }
 }
@@ -1,246 +1,202 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{App, Arg, ArgMatches};
-use client_core::client::key_manager::KeyManager;
-use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use clap::Args;
+use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;
-use crypto::asymmetric::{encryption, identity};
-use gateway_client::GatewayClient;
-use gateway_requests::registration::handshake::SharedKeys;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::addressing::nodes::NodeIdentity;
-use rand::{prelude::SliceRandom, rngs::OsRng, thread_rng};
-use std::convert::TryInto;
-use std::sync::Arc;
-use std::time::Duration;
-use topology::{filter::VersionFilterable, gateway};
-use url::Url;

-use crate::client::config::Config;
-use crate::commands::override_config;
-#[cfg(feature = "eth")]
-#[cfg(not(feature = "coconut"))]
-use crate::commands::{
-    DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY, ENABLED_CREDENTIALS_MODE_ARG_NAME,
-    ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+use crate::{
+    client::config::Config,
+    commands::{override_config, OverrideConfig},
 };

-pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    let app = App::new("init")
-        .about("Initialise a Nym client. Do this first!")
-        .arg(Arg::with_name("id")
-            .long("id")
-            .help("Id of the nym-mixnet-client we want to create config for.")
-            .takes_value(true)
-            .required(true)
-        )
-        .arg(Arg::with_name("provider")
-            .long("provider")
-            .help("Address of the socks5 provider to send messages to.")
-            .takes_value(true)
-            .required(true)
-        )
-        .arg(Arg::with_name("gateway")
-            .long("gateway")
-            .help("Id of the gateway we are going to connect to.")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("validators")
-                 .long("validators")
-                 .help("Comma separated list of rest endpoints of the validators")
-                 .takes_value(true),
-        )
-        .arg(Arg::with_name("port")
-            .short("p")
-            .long("port")
-            .help("Port for the socket to listen on in all subsequent runs")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("fastmode")
-            .long("fastmode")
-            .hidden(true) // this will prevent this flag from being displayed in `--help`
-            .help("Mostly debug-related option to increase default traffic rate so that you would not need to modify config post init")
-        );
-    #[cfg(feature = "eth")]
-    #[cfg(not(feature = "coconut"))]
-        let app = app
-        .arg(
-            Arg::with_name(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .long(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .help("Set this client to work in a enabled credentials mode that would attempt to use gateway with bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
-                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
-        )
-        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
-            .long(ETH_ENDPOINT_ARG_NAME)
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true)
-            .default_value_if(ENABLED_CREDENTIALS_MODE_ARG_NAME, None, DEFAULT_ETH_ENDPOINT)
-            .required(true))
-        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
-            .long(ETH_PRIVATE_KEY_ARG_NAME)
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true)
-            .default_value_if(ENABLED_CREDENTIALS_MODE_ARG_NAME, None, DEFAULT_ETH_PRIVATE_KEY)
-            .required(true)
-        );
+#[cfg(all(feature = "eth", not(feature = "coconut")))]
+use crate::commands::{DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY};

-    app
+#[derive(Args, Clone)]
+pub(crate) struct Init {
+    /// Id of the nym-mixnet-client we want to create config for.
+    #[clap(long)]
+    id: String,
+
+    /// Address of the socks5 provider to send messages to.
+    #[clap(long)]
+    provider: String,
+
+    /// Id of the gateway we are going to connect to.
+    #[clap(long)]
+    gateway: Option<String>,
+
+    /// Force register gateway. WARNING: this will overwrite any existing keys for the given id,
+    /// potentially causing loss of access.
+    #[clap(long)]
+    force_register_gateway: bool,
+
+    /// Comma separated list of rest endpoints of the validators
+    #[clap(long)]
+    validators: Option<String>,
+
+    /// Port for the socket to listen on in all subsequent runs
+    #[clap(short, long)]
+    port: Option<u16>,
+
+    /// Mostly debug-related option to increase default traffic rate so that you would not need to
+    /// modify config post init
+    #[clap(long, hidden = true)]
+    fastmode: bool,
+
+    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
+    enabled_credentials_mode: bool,
+
+    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
+    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(
+        long,
+        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_ENDPOINT))
+    )]
+    eth_endpoint: String,
+
+    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
+    /// want to set this value, use --enabled-credentials-mode instead")
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(
+        long,
+        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_PRIVATE_KEY))
+    )]
+    eth_private_key: String,
 }

-async fn register_with_gateway(
-    gateway: &gateway::Node,
-    our_identity: Arc<identity::KeyPair>,
-) -> Arc<SharedKeys> {
-    let timeout = Duration::from_millis(1500);
-    let mut gateway_client = GatewayClient::new_init(
-        gateway.clients_address(),
-        gateway.identity_key,
-        gateway.owner.clone(),
-        our_identity.clone(),
-        timeout,
-    );
-    gateway_client
-        .establish_connection()
-        .await
-        .expect("failed to establish connection with the gateway!");
-    gateway_client
-        .perform_initial_authentication()
-        .await
-        .expect("failed to register with the gateway!")
-}
+impl From<Init> for OverrideConfig {
+    fn from(init_config: Init) -> Self {
+        OverrideConfig {
+            validators: init_config.validators,
+            port: init_config.port,
+            fastmode: init_config.fastmode,

-async fn gateway_details(
-    validator_servers: Vec<Url>,
-    chosen_gateway_id: Option<&str>,
-) -> gateway::Node {
-    let validator_api = validator_servers
-        .choose(&mut thread_rng())
-        .expect("The list of validator apis is empty");
-    let validator_client = validator_client::ApiClient::new(validator_api.clone());
+            #[cfg(any(feature = "eth", feature = "coconut"))]
+            enabled_credentials_mode: init_config.enabled_credentials_mode,

-    let gateways = validator_client.get_cached_gateways().await.unwrap();
-    let valid_gateways = gateways
-        .into_iter()
-        .filter_map(|gateway| gateway.try_into().ok())
-        .collect::<Vec<gateway::Node>>();
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_private_key: Some(init_config.eth_private_key),

-    let filtered_gateways = valid_gateways.filter_by_version(env!("CARGO_PKG_VERSION"));
-
-    // if we have chosen particular gateway - use it, otherwise choose a random one.
-    // (remember that in active topology all gateways have at least 100 reputation so should
-    // be working correctly)
-    if let Some(gateway_id) = chosen_gateway_id {
-        filtered_gateways
-            .iter()
-            .find(|gateway| gateway.identity_key.to_base58_string() == gateway_id)
-            .expect(&*format!("no gateway with id {} exists!", gateway_id))
-            .clone()
-    } else {
-        filtered_gateways
-            .choose(&mut rand::thread_rng())
-            .expect("there are no gateways on the network!")
-            .clone()
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_endpoint: Some(init_config.eth_endpoint),
+        }
    }
 }

-fn show_address(config: &Config) {
-    fn load_identity_keys(pathfinder: &ClientKeyPathfinder) -> identity::KeyPair {
-        let identity_keypair: identity::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_identity_key().to_owned(),
-                pathfinder.public_identity_key().to_owned(),
-            ))
-            .expect("Failed to read stored identity key files");
-        identity_keypair
-    }
-
-    fn load_sphinx_keys(pathfinder: &ClientKeyPathfinder) -> encryption::KeyPair {
-        let sphinx_keypair: encryption::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_encryption_key().to_owned(),
-                pathfinder.public_encryption_key().to_owned(),
-            ))
-            .expect("Failed to read stored sphinx key files");
-        sphinx_keypair
-    }
-
-    let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
-    let identity_keypair = load_identity_keys(&pathfinder);
-    let sphinx_keypair = load_sphinx_keys(&pathfinder);
-
-    let client_recipient = Recipient::new(
-        *identity_keypair.public_key(),
-        *sphinx_keypair.public_key(),
-        // TODO: below only works under assumption that gateway address == gateway id
-        // (which currently is true)
-        NodeIdentity::from_base58_string(config.get_base().get_gateway_id()).unwrap(),
-    );
-
-    println!("\nThe address of this client is: {}", client_recipient);
-}
-
-pub async fn execute(matches: ArgMatches<'static>) {
+pub(crate) async fn execute(args: &Init) {
    println!("Initialising client...");

-    let id = matches.value_of("id").unwrap(); // required for now
-    let provider_address = matches.value_of("provider").unwrap();
+    let id = &args.id;
+    let provider_address = &args.provider;

-    let already_init = if Config::default_config_file_path(Some(id)).exists() {
-        println!("Socks5 client \"{}\" was already initialised before! Config information will be overwritten (but keys will be kept)!", id);
-        true
-    } else {
-        false
-    };
+    let already_init = Config::default_config_file_path(Some(id)).exists();
+    if already_init {
+        println!(
+            "SOCKS5 client \"{}\" was already initialised before! \
+            Config information will be overwritten (but keys will be kept)!",
+            id
+        );
+    }
+
+    // Usually you only register with the gateway on the first init, however you can force
+    // re-registering if wanted.
+    let user_wants_force_register = args.force_register_gateway;
+
+    // If the client was already initialized, don't generate new keys and don't re-register with
+    // the gateway (because this would create a new shared key).
+    // Unless the user really wants to.
+    let register_gateway = !already_init || user_wants_force_register;
+
+    // Attempt to use a user-provided gateway, if possible
+    let user_chosen_gateway_id = args.gateway.as_deref();

    let mut config = Config::new(id, provider_address);
+    let override_config_fields = OverrideConfig::from(args.clone());
+    config = override_config(config, override_config_fields);

-    let mut rng = OsRng;
-
-    // TODO: ideally that should be the last thing that's being done to config.
-    // However, we are later further overriding it with gateway id
-    config = override_config(config, &matches);
-    if matches.is_present("fastmode") {
-        config.get_base_mut().set_high_default_traffic_volume();
-    }
-
-    // if client was already initialised, don't generate new keys, not re-register with gateway
-    // (because this would create new shared key)
-    if !already_init {
-        // create identity, encryption and ack keys.
-        let mut key_manager = KeyManager::new(&mut rng);
-
-        let chosen_gateway_id = matches.value_of("gateway");
-
-        let gateway_details = gateway_details(
-            config.get_base().get_validator_api_endpoints(),
-            chosen_gateway_id,
-        )
-        .await;
-        let shared_keys =
-            register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
-
-        config.get_base_mut().with_gateway_endpoint(
-            gateway_details.identity_key.to_base58_string(),
-            gateway_details.owner.clone(),
-            gateway_details.clients_address(),
-        );
-        key_manager.insert_gateway_shared_key(shared_keys);
-
-        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
-        key_manager
-            .store_keys(&pathfinder)
-            .expect("Failed to generated keys");
-        println!("Saved all generated keys");
-    }
+    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config)
+        .await
+        .unwrap_or_else(|err| {
+            eprintln!("Failed to setup gateway\nError: {err}");
+            std::process::exit(1)
+        });
+    config.get_base_mut().with_gateway_endpoint(gateway);

    let config_save_location = config.get_config_file_save_location();
    config
        .save_to_file(None)
        .expect("Failed to save the config file");
-    println!("Saved configuration file to {:?}", config_save_location);
-    println!("Using gateway: {}", config.get_base().get_gateway_id(),);
-    println!("Client configuration completed.\n\n\n");

-    show_address(&config);
+    println!("Saved configuration file to {:?}", config_save_location);
+    println!("Using gateway: {}", config.get_base().get_gateway_id());
+    log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
+    log::debug!("Gateway owner: {}", config.get_base().get_gateway_owner());
+    log::debug!(
+        "Gateway listener: {}",
+        config.get_base().get_gateway_listener()
+    );
+    println!("Client configuration completed.");
+
+    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
+        eprintln!("Failed to show address\nError: {err}");
+        std::process::exit(1)
+    });
+}
+
+async fn setup_gateway(
+    id: &str,
+    register: bool,
+    user_chosen_gateway_id: Option<&str>,
+    config: &Config,
+) -> Result<GatewayEndpoint, ClientCoreError> {
+    if register {
+        // Get the gateway details by querying the validator-api. Either pick one at random or use
+        // the chosen one if it's among the available ones.
+        println!("Configuring gateway");
+        let gateway = client_core::init::query_gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            user_chosen_gateway_id,
+        )
+        .await?;
+        log::debug!("Querying gateway gives: {}", gateway);
+
+        // Registering with gateway by setting up and writing shared keys to disk
+        log::trace!("Registering gateway");
+        client_core::init::register_with_gateway_and_store_keys(gateway.clone(), config.get_base())
+            .await?;
+        println!("Saved all generated keys");
+
+        Ok(gateway.into())
+    } else if user_chosen_gateway_id.is_some() {
+        // Just set the config, don't register or create any keys
+        // This assumes that the user knows what they are doing, and that the existing keys are
+        // valid for the gateway being used
+        println!("Using gateway provided by user, keeping existing keys");
+        let gateway = client_core::init::query_gateway_details(
+            config.get_base().get_validator_api_endpoints(),
+            user_chosen_gateway_id,
+        )
+        .await?;
+        log::debug!("Querying gateway gives: {}", gateway);
+        Ok(gateway.into())
+    } else {
+        println!("Not registering gateway, will reuse existing config and keys");
+        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })?;
+        Ok(existing_config.get_base().get_gateway_endpoint().clone())
+    }
 }
@@ -2,18 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::Config;
-use clap::ArgMatches;
-use url::Url;
+use clap::{Parser, Subcommand};
+use config::parse_validators;

-pub(crate) mod init;
+pub mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;

-pub(crate) const ENABLED_CREDENTIALS_MODE_ARG_NAME: &str = "enabled-credentials-mode";
-#[cfg(not(feature = "coconut"))]
-pub(crate) const ETH_ENDPOINT_ARG_NAME: &str = "eth_endpoint";
-#[cfg(not(feature = "coconut"))]
-pub(crate) const ETH_PRIVATE_KEY_ARG_NAME: &str = "eth_private_key";
 #[cfg(not(feature = "coconut"))]
 pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
@@ -21,56 +16,141 @@ pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
 pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
    "0000000000000000000000000000000000000000000000000000000000000001";

-fn parse_validators(raw: &str) -> Vec<Url> {
-    raw.split(',')
-        .map(|raw_validator| {
-            raw_validator
-                .trim()
-                .parse()
-                .expect("one of the provided validator api urls is invalid")
-        })
-        .collect()
+fn long_version() -> String {
+    format!(
+        r#"
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+{:<20}{}
+"#,
+        "Build Timestamp:",
+        env!("VERGEN_BUILD_TIMESTAMP"),
+        "Build Version:",
+        env!("VERGEN_BUILD_SEMVER"),
+        "Commit SHA:",
+        env!("VERGEN_GIT_SHA"),
+        "Commit Date:",
+        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
+        "Commit Branch:",
+        env!("VERGEN_GIT_BRANCH"),
+        "rustc Version:",
+        env!("VERGEN_RUSTC_SEMVER"),
+        "rustc Channel:",
+        env!("VERGEN_RUSTC_CHANNEL"),
+        "cargo Profile:",
+        env!("VERGEN_CARGO_PROFILE"),
+    )
 }

-pub(crate) fn override_config(mut config: Config, matches: &ArgMatches<'_>) -> Config {
-    if let Some(raw_validators) = matches.value_of("validators") {
+fn long_version_static() -> &'static str {
+    Box::leak(long_version().into_boxed_str())
+}
+
+#[derive(Parser)]
+#[clap(author = "Nymtech", version, long_version = long_version_static(), about)]
+pub(crate) struct Cli {
+    /// Path pointing to an env file that configures the client.
+    #[clap(long)]
+    pub(crate) config_env_file: Option<std::path::PathBuf>,
+
+    #[clap(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+pub(crate) enum Commands {
+    /// Initialise a Nym client. Do this first!
+    Init(init::Init),
+    /// Run the Nym client with provided configuration client optionally overriding set parameters
+    Run(run::Run),
+    /// Try to upgrade the client
+    Upgrade(upgrade::Upgrade),
+}
+
+// Configuration that can be overridden.
+pub(crate) struct OverrideConfig {
+    validators: Option<String>,
+    port: Option<u16>,
+    fastmode: bool,
+
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    enabled_credentials_mode: bool,
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    eth_private_key: Option<String>,
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    eth_endpoint: Option<String>,
+}
+
+pub(crate) async fn execute(args: &Cli) {
+    match &args.command {
+        Commands::Init(m) => init::execute(m).await,
+        Commands::Run(m) => run::execute(m).await,
+        Commands::Upgrade(m) => upgrade::execute(m),
+    }
+}
+
+pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
+    if let Some(raw_validators) = args.validators {
        config
            .get_base_mut()
-            .set_custom_validator_apis(parse_validators(raw_validators));
+            .set_custom_validator_apis(parse_validators(&raw_validators));
+    } else if let Ok(raw_validators) = std::env::var(network_defaults::var_names::API_VALIDATOR) {
+        config
+            .get_base_mut()
+            .set_custom_validator_apis(parse_validators(&raw_validators));
    }

-    if let Some(gateway_id) = matches.value_of("gateway") {
-        config.get_base_mut().with_gateway_id(gateway_id);
+    if let Some(port) = args.port {
+        config = config.with_port(port);
    }

-    if let Some(port) = matches.value_of("port").map(|port| port.parse::<u16>()) {
-        if let Err(err) = port {
-            // if port was overridden, it must be parsable
-            panic!("Invalid port value provided - {:?}", err);
+    #[cfg(all(not(feature = "eth"), not(feature = "coconut")))]
+    {
+        config
+            .get_base_mut()
+            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT.to_string());
+        config
+            .get_base_mut()
+            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
+    }
+
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    {
+        if args.enabled_credentials_mode {
+            config.get_base_mut().with_disabled_credentials(false)
+        }
+    }
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    {
+        if let Some(eth_endpoint) = args.eth_endpoint {
+            config.get_base_mut().with_eth_endpoint(eth_endpoint);
+        }
+        if let Some(eth_private_key) = args.eth_private_key {
+            config.get_base_mut().with_eth_private_key(eth_private_key);
        }
-        config = config.with_port(port.unwrap());
    }

-    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_endpoint) = matches.value_of(ETH_ENDPOINT_ARG_NAME) {
-        config.get_base_mut().with_eth_endpoint(eth_endpoint);
-    } else if !cfg!(feature = "eth") {
-        config
-            .get_base_mut()
-            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT);
-    }
-    #[cfg(not(feature = "coconut"))]
-    if let Some(eth_private_key) = matches.value_of(ETH_PRIVATE_KEY_ARG_NAME) {
-        config.get_base_mut().with_eth_private_key(eth_private_key);
-    } else if !cfg!(feature = "eth") {
-        config
-            .get_base_mut()
-            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY);
-    }
-
-    if matches.is_present(ENABLED_CREDENTIALS_MODE_ARG_NAME) {
-        config.get_base_mut().with_disabled_credentials(false)
+    if args.fastmode {
+        config.get_base_mut().set_high_default_traffic_volume();
    }

    config
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::CommandFactory;
+
+    #[test]
+    fn verify_cli() {
+        Cli::command().debug_assert();
+    }
+}
@@ -1,74 +1,79 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::config::Config;
-use crate::client::NymClient;
-use crate::commands::override_config;
-#[cfg(feature = "eth")]
-#[cfg(not(feature = "coconut"))]
-use crate::commands::{
-    ENABLED_CREDENTIALS_MODE_ARG_NAME, ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME,
+use crate::{
+    client::{config::Config, NymClient},
+    commands::{override_config, OverrideConfig},
 };
-use clap::{App, Arg, ArgMatches};
+
+use clap::Args;
 use config::NymConfig;
 use log::*;
 use version_checker::is_minor_version_compatible;

-pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
-    let app = App::new("run")
-        .about("Run the Nym client with provided configuration client optionally overriding set parameters")
-        .arg(Arg::with_name("id")
-            .long("id")
-            .help("Id of the nym-mixnet-client we want to run.")
-            .takes_value(true)
-            .required(true)
-        )
-        // the rest of arguments are optional, they are used to override settings in config file
-        .arg(Arg::with_name("config")
-            .long("config")
-            .help("Custom path to the nym-mixnet-client configuration file")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("provider")
-            .long("provider")
-            .help("Address of the socks5 provider to send messages to.")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("validators")
-                .long("validators")
-                .help("Comma separated list of rest endpoints of the validators")
-                .takes_value(true),
-        )
-        .arg(Arg::with_name("gateway")
-            .long("gateway")
-            .help("Id of the gateway we want to connect to. If overridden, it is user's responsibility to ensure prior registration happened")
-            .takes_value(true)
-        )
-        .arg(Arg::with_name("port")
-            .short("p")
-            .long("port")
-            .help("Port for the socket to listen on")
-            .takes_value(true)
-        );
-    #[cfg(feature = "eth")]
-    #[cfg(not(feature = "coconut"))]
-    let app = app
-        .arg(
-            Arg::with_name(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .long(ENABLED_CREDENTIALS_MODE_ARG_NAME)
-                .help("Set this client to work in a disabled credentials mode that would attempt to use gateway without bandwidth credential requirement. If this value is set, --eth_endpoint and --eth_private_key don't need to be set.")
-                .conflicts_with_all(&[ETH_ENDPOINT_ARG_NAME, ETH_PRIVATE_KEY_ARG_NAME])
-        )
-        .arg(Arg::with_name(ETH_ENDPOINT_ARG_NAME)
-            .long(ETH_ENDPOINT_ARG_NAME)
-            .help("URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true))
-        .arg(Arg::with_name(ETH_PRIVATE_KEY_ARG_NAME)
-            .long(ETH_PRIVATE_KEY_ARG_NAME)
-            .help("Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't want to set this value, use --testnet-mode instead")
-            .takes_value(true));
+#[derive(Args, Clone)]
+pub(crate) struct Run {
+    /// Id of the nym-mixnet-client we want to run.
+    #[clap(long)]
+    id: String,

-    app
+    /// Custom path to the nym-mixnet-client configuration file
+    #[clap(long)]
+    config: Option<String>,
+
+    /// Address of the socks5 provider to send messages to.
+    #[clap(long)]
+    provider: Option<String>,
+
+    /// Id of the gateway we want to connect to. If overridden, it is user's responsibility to
+    /// ensure prior registration happened
+    #[clap(long)]
+    gateway: Option<String>,
+
+    /// Comma separated list of rest endpoints of the validators
+    #[clap(long)]
+    validators: Option<String>,
+
+    /// Port for the socket to listen on
+    #[clap(short, long)]
+    port: Option<u16>,
+
+    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
+    enabled_credentials_mode: bool,
+
+    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
+    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long)]
+    eth_endpoint: Option<String>,
+
+    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
+    /// want to set this value, use --enabled-credentials-mode instead
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long)]
+    eth_private_key: Option<String>,
+}
+
+impl From<Run> for OverrideConfig {
+    fn from(run_config: Run) -> Self {
+        OverrideConfig {
+            validators: run_config.validators,
+            port: run_config.port,
+            fastmode: false,
+
+            #[cfg(any(feature = "eth", feature = "coconut"))]
+            enabled_credentials_mode: run_config.enabled_credentials_mode,
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_private_key: run_config.eth_private_key,
+
+            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            eth_endpoint: run_config.eth_endpoint,
+        }
+    }
 }

 // this only checks compatibility between config the binary. It does not take into consideration
@@ -76,8 +81,13 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
 fn version_check(cfg: &Config) -> bool {
    let binary_version = env!("CARGO_PKG_VERSION");
    let config_version = cfg.get_base().get_version();
-    if binary_version != config_version {
-        warn!("The mixnode binary has different version than what is specified in config file! {} and {}", binary_version, config_version);
+    if binary_version == config_version {
+        true
+    } else {
+        warn!(
+            "The mixnode binary has different version than what is specified in config file! {} and {}",
+            binary_version, config_version
+        );
        if is_minor_version_compatible(binary_version, config_version) {
            info!("but they are still semver compatible. However, consider running the `upgrade` command");
            true
@@ -85,13 +95,11 @@ fn version_check(cfg: &Config) -> bool {
            error!("and they are semver incompatible! - please run the `upgrade` command before attempting `run` again");
            false
        }
-    } else {
-        true
    }
 }

-pub async fn execute(matches: ArgMatches<'static>) {
-    let id = matches.value_of("id").unwrap();
+pub(crate) async fn execute(args: &Run) {
+    let id = &args.id;

    let mut config = match Config::load_from_file(Some(id)) {
        Ok(cfg) => cfg,
@@ -101,7 +109,8 @@ pub async fn execute(matches: ArgMatches<'static>) {
        }
    };

-    config = override_config(config, &matches);
+    let override_config_fields = OverrideConfig::from(args.clone());
+    config = override_config(config, override_config_fields);

    if !version_check(&config) {
        error!("failed the local version check");
@@ -2,13 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::{Config, MISSING_VALUE};
-use clap::{App, Arg, ArgMatches};
-use config::defaults::default_api_endpoints;
+
 use config::NymConfig;
-use std::fmt::Display;
-use std::process;
 use version_checker::Version;

+use clap::Args;
+use std::{fmt::Display, process};
+
 #[allow(dead_code)]
 fn fail_upgrade<D1: Display, D2: Display>(from_version: D1, to_version: D2) -> ! {
    print_failed_upgrade(from_version, to_version);
@@ -49,14 +49,11 @@ fn unsupported_upgrade(current_version: &Version, config_version: &Version) -> !
    process::exit(1)
 }

-pub fn command_args<'a, 'b>() -> App<'a, 'b> {
-    App::new("upgrade").about("Try to upgrade the client").arg(
-        Arg::with_name("id")
-            .long("id")
-            .help("Id of the nym-client we want to upgrade")
-            .takes_value(true)
-            .required(true),
-    )
+#[derive(Args, Clone)]
+pub(crate) struct Upgrade {
+    /// Id of the nym-client we want to upgrade
+    #[clap(long)]
+    id: String,
 }

 fn parse_config_version(config: &Config) -> Version {
@@ -95,7 +92,7 @@ fn parse_package_version() -> Version {

 fn minor_0_12_upgrade(
    mut config: Config,
-    _matches: &ArgMatches<'_>,
+    _args: &Upgrade,
    config_version: &Version,
    package_version: &Version,
 ) -> Config {
@@ -107,15 +104,6 @@ fn minor_0_12_upgrade(

    print_start_upgrade(&config_version, &to_version);

-    println!(
-        "Setting validator API endpoints to {:?}",
-        default_api_endpoints()
-    );
-
-    config
-        .get_base_mut()
-        .set_custom_validator_apis(default_api_endpoints());
-
    config
        .get_base_mut()
        .set_custom_version(to_version.to_string().as_ref());
@@ -131,30 +119,30 @@ fn minor_0_12_upgrade(
    config
 }

-fn do_upgrade(mut config: Config, matches: &ArgMatches<'_>, package_version: Version) {
+fn do_upgrade(mut config: Config, args: &Upgrade, package_version: &Version) {
    loop {
        let config_version = parse_config_version(&config);

-        if config_version == package_version {
+        if &config_version == package_version {
            println!("You're using the most recent version!");
            return;
        }

        config = match config_version.major {
            0 => match config_version.minor {
-                9 | 10 => outdated_upgrade(&config_version, &package_version),
-                11 => minor_0_12_upgrade(config, matches, &config_version, &package_version),
-                _ => unsupported_upgrade(&config_version, &package_version),
+                9 | 10 => outdated_upgrade(&config_version, package_version),
+                11 => minor_0_12_upgrade(config, args, &config_version, package_version),
+                _ => unsupported_upgrade(&config_version, package_version),
            },
-            _ => unsupported_upgrade(&config_version, &package_version),
+            _ => unsupported_upgrade(&config_version, package_version),
        }
    }
 }

-pub fn execute(matches: &ArgMatches<'_>) {
+pub(crate) fn execute(args: &Upgrade) {
    let package_version = parse_package_version();

-    let id = matches.value_of("id").unwrap();
+    let id = &args.id;

    let existing_config = Config::load_from_file(Some(id)).unwrap_or_else(|err| {
        eprintln!("failed to load existing config file! - {:?}", err);
@@ -167,5 +155,5 @@ pub fn execute(matches: &ArgMatches<'_>) {
    }

    // here be upgrade path to 0.9.X and beyond based on version number from config
-    do_upgrade(existing_config, matches, package_version)
+    do_upgrade(existing_config, args, &package_version)
 }
@@ -1,8 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{crate_version, App, ArgMatches};
-use network_defaults::DEFAULT_NETWORK;
+use clap::{crate_version, Parser};
+use network_defaults::setup_env;

 pub mod client;
 mod commands;
@@ -10,34 +10,12 @@ pub mod socks;

 #[tokio::main]
 async fn main() {
-    dotenv::dotenv().ok();
    setup_logging();
    println!("{}", banner());

-    let arg_matches = App::new("Nym Socks5 Proxy")
-        .version(env!("CARGO_PKG_VERSION"))
-        .author("Nymtech")
-        .long_version(&*long_version())
-        .about("A Socks5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address")
-        .subcommand(commands::init::command_args())
-        .subcommand(commands::run::command_args())
-        .subcommand(commands::upgrade::command_args())
-        .get_matches();
-
-    execute(arg_matches).await;
-}
-
-async fn execute(matches: ArgMatches<'static>) {
-    match matches.subcommand() {
-        ("init", Some(m)) => commands::init::execute(m.clone()).await,
-        ("run", Some(m)) => commands::run::execute(m.clone()).await,
-        ("upgrade", Some(m)) => commands::upgrade::execute(m),
-        _ => println!("{}", usage()),
-    }
-}
-
-fn usage() -> &'static str {
-    "usage: --help to see available options.\n\n"
+    let args = commands::Cli::parse();
+    setup_env(args.config_env_file.clone());
+    commands::execute(&args).await;
 }

 fn banner() -> String {
@@ -57,40 +35,6 @@ fn banner() -> String {
    )
 }

-fn long_version() -> String {
-    format!(
-        r#"
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-"#,
-        "Build Timestamp:",
-        env!("VERGEN_BUILD_TIMESTAMP"),
-        "Build Version:",
-        env!("VERGEN_BUILD_SEMVER"),
-        "Commit SHA:",
-        env!("VERGEN_GIT_SHA"),
-        "Commit Date:",
-        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
-        "Commit Branch:",
-        env!("VERGEN_GIT_BRANCH"),
-        "rustc Version:",
-        env!("VERGEN_RUSTC_SEMVER"),
-        "rustc Channel:",
-        env!("VERGEN_RUSTC_CHANNEL"),
-        "cargo Profile:",
-        env!("VERGEN_CARGO_PROFILE"),
-        "Network:",
-        DEFAULT_NETWORK
-    )
-}
-
 fn setup_logging() {
    let mut log_builder = pretty_env_logger::formatted_timed_builder();
    if let Ok(s) = ::std::env::var("RUST_LOG") {
@@ -9,7 +9,7 @@ pub(crate) enum AuthenticationMethods {
    NoMethods = 0xFF,
 }

-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 /// A socks5 user with a matching password.
 pub struct User {
    pub username: String,
@@ -20,6 +20,7 @@ use socks5_requests::{ConnectionId, Message, RemoteAddress, Request};
 use std::io;
 use std::net::SocketAddr;
 use std::pin::Pin;
+use task::ShutdownListener;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
 use tokio::{self, net::TcpStream};

@@ -140,6 +141,7 @@ pub(crate) struct SocksClient {
    service_provider: Recipient,
    self_address: Recipient,
    started_proxy: bool,
+    shutdown_listener: ShutdownListener,
 }

 impl Drop for SocksClient {
@@ -163,6 +165,7 @@ impl SocksClient {
        service_provider: Recipient,
        controller_sender: ControllerSender,
        self_address: Recipient,
+        shutdown_listener: ShutdownListener,
    ) -> Self {
        let connection_id = Self::generate_random();
        SocksClient {
@@ -176,6 +179,7 @@ impl SocksClient {
            service_provider,
            self_address,
            started_proxy: false,
+            shutdown_listener,
        }
    }

@@ -250,6 +254,7 @@ impl SocksClient {
            conn_receiver,
            input_sender,
            connection_id,
+            self.shutdown_listener.clone(),
        )
        .run(move |conn_id, read_data, socket_closed| {
            let provider_request = Request::new_send(conn_id, read_data, socket_closed);
@@ -1,16 +1,19 @@
-use client_core::client::received_buffer::ReconstructedMessagesReceiver;
-use client_core::client::received_buffer::{ReceivedBufferMessage, ReceivedBufferRequestSender};
 use futures::channel::mpsc;
 use futures::StreamExt;
 use log::*;
+
+use client_core::client::received_buffer::ReconstructedMessagesReceiver;
+use client_core::client::received_buffer::{ReceivedBufferMessage, ReceivedBufferRequestSender};
 use nymsphinx::receiver::ReconstructedMessage;
 use proxy_helpers::connection_controller::{ControllerCommand, ControllerSender};
-use socks5_requests::Response;
+use socks5_requests::Message;
+use task::ShutdownListener;

 pub(crate) struct MixnetResponseListener {
    buffer_requester: ReceivedBufferRequestSender,
    mix_response_receiver: ReconstructedMessagesReceiver,
    controller_sender: ControllerSender,
+    shutdown: ShutdownListener,
 }

 impl Drop for MixnetResponseListener {
@@ -25,6 +28,7 @@ impl MixnetResponseListener {
    pub(crate) fn new(
        buffer_requester: ReceivedBufferRequestSender,
        controller_sender: ControllerSender,
+        shutdown: ShutdownListener,
    ) -> Self {
        let (mix_response_sender, mix_response_receiver) = mpsc::unbounded();
        buffer_requester
@@ -35,6 +39,7 @@ impl MixnetResponseListener {
            buffer_requester,
            mix_response_receiver,
            controller_sender,
+            shutdown,
        }
    }

@@ -44,12 +49,23 @@ impl MixnetResponseListener {
            warn!("this message had a surb - we didn't do anything with it");
        }

-        let response = match Response::try_from_bytes(&raw_message) {
+        let response = match Message::try_from_bytes(&raw_message) {
            Err(err) => {
                warn!("failed to parse received response - {:?}", err);
                return;
            }
-            Ok(data) => data,
+            Ok(Message::Request(_)) => {
+                warn!("unexpected request");
+                return;
+            }
+            Ok(Message::Response(data)) => data,
+            Ok(Message::NetworkRequesterResponse(r)) => {
+                error!(
+                    "Network requester failed on connection id {} with error: {}",
+                    r.connection_id, r.network_requester_error
+                );
+                return;
+            }
        };

        self.controller_sender
@@ -62,11 +78,25 @@ impl MixnetResponseListener {
    }

    pub(crate) async fn run(&mut self) {
-        while let Some(received_responses) = self.mix_response_receiver.next().await {
-            for reconstructed_message in received_responses {
-                self.on_message(reconstructed_message).await;
+        while !self.shutdown.is_shutdown() {
+            tokio::select! {
+                received_responses = self.mix_response_receiver.next() => match received_responses {
+                    Some(received_responses) => {
+                        for reconstructed_message in received_responses {
+                            self.on_message(reconstructed_message).await;
+                        }
+                    },
+                    None => {
+                        log::trace!("MixnetResponseListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("MixnetResponseListener: Received shutdown");
+                }
            }
        }
-        error!("We should never see this message");
+        assert!(self.shutdown.is_shutdown_poll());
+        log::debug!("MixnetResponseListener: Exiting");
    }
 }
@@ -11,6 +11,7 @@ use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use proxy_helpers::connection_controller::Controller;
 use std::net::SocketAddr;
+use task::ShutdownListener;
 use tokio::net::TcpListener;

 /// A Socks5 server that listens for connections.
@@ -19,6 +20,7 @@ pub struct SphinxSocksServer {
    listening_address: SocketAddr,
    service_provider: Recipient,
    self_address: Recipient,
+    shutdown: ShutdownListener,
 }

 impl SphinxSocksServer {
@@ -28,6 +30,7 @@ impl SphinxSocksServer {
        authenticator: Authenticator,
        service_provider: Recipient,
        self_address: Recipient,
+        shutdown: ShutdownListener,
    ) -> Self {
        // hardcode ip as we (presumably) ONLY want to listen locally. If we change it, we can
        // just modify the config
@@ -38,6 +41,7 @@ impl SphinxSocksServer {
            listening_address: format!("{}:{}", ip, port).parse().unwrap(),
            service_provider,
            self_address,
+            shutdown,
        }
    }

@@ -52,62 +56,73 @@ impl SphinxSocksServer {
        info!("Serving Connections...");

        // controller for managing all active connections
-        let (mut active_streams_controller, controller_sender) = Controller::new();
+        let (mut active_streams_controller, controller_sender) =
+            Controller::new(self.shutdown.clone());
        tokio::spawn(async move {
            active_streams_controller.run().await;
        });

        // listener for mix messages
-        let mut mixnet_response_listener =
-            MixnetResponseListener::new(buffer_requester, controller_sender.clone());
-
+        let mut mixnet_response_listener = MixnetResponseListener::new(
+            buffer_requester,
+            controller_sender.clone(),
+            self.shutdown.clone(),
+        );
        tokio::spawn(async move {
            mixnet_response_listener.run().await;
        });

        loop {
-            if let Ok((stream, _remote)) = listener.accept().await {
-                // TODO Optimize this
-                let mut client = SocksClient::new(
-                    stream,
-                    self.authenticator.clone(),
-                    input_sender.clone(),
-                    self.service_provider,
-                    controller_sender.clone(),
-                    self.self_address,
-                );
+            tokio::select! {
+                Ok((stream, _remote)) = listener.accept() => {
+                    // TODO Optimize this
+                    let mut client = SocksClient::new(
+                        stream,
+                        self.authenticator.clone(),
+                        input_sender.clone(),
+                        self.service_provider,
+                        controller_sender.clone(),
+                        self.self_address,
+                        self.shutdown.clone(),
+                    );

-                tokio::spawn(async move {
-                    {
-                        match client.run().await {
-                            Ok(_) => {}
-                            Err(error) => {
-                                error!("Error! {}", error);
-                                let error_text = format!("{}", error);
+                    tokio::spawn(async move {
+                        {
+                            match client.run().await {
+                                Ok(_) => {}
+                                Err(error) => {
+                                    error!("Error! {}", error);
+                                    let error_text = format!("{}", error);

-                                let response: ResponseCode;
+                                    let response: ResponseCode;

-                                if error_text.contains("Host") {
-                                    response = ResponseCode::HostUnreachable;
-                                } else if error_text.contains("Network") {
-                                    response = ResponseCode::NetworkUnreachable;
-                                } else if error_text.contains("ttl") {
-                                    response = ResponseCode::TtlExpired
-                                } else {
-                                    response = ResponseCode::Failure
+                                    if error_text.contains("Host") {
+                                        response = ResponseCode::HostUnreachable;
+                                    } else if error_text.contains("Network") {
+                                        response = ResponseCode::NetworkUnreachable;
+                                    } else if error_text.contains("ttl") {
+                                        response = ResponseCode::TtlExpired
+                                    } else {
+                                        response = ResponseCode::Failure
+                                    }
+
+                                    if client.error(response).await.is_err() {
+                                        warn!("Failed to send error code");
+                                    };
+                                    if client.shutdown().await.is_err() {
+                                        warn!("Failed to shutdown TcpStream");
+                                    };
                                }
-
-                                if client.error(response).await.is_err() {
-                                    warn!("Failed to send error code");
-                                };
-                                if client.shutdown().await.is_err() {
-                                    warn!("Failed to shutdown TcpStream");
-                                };
-                            }
-                        };
-                        // client gets dropped here
-                    }
-                });
+                            };
+                            // client gets dropped here
+                        }
+                    });
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("SphinxSocksServer: Received shutdown");
+                    log::debug!("SphinxSocksServer: Exiting");
+                    return Ok(());
+                }
            }
        }
    }
@@ -1 +1 @@
-15.0.1
+16
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .0.1