update branch to be in line with develop

Moving helpful comment into docs comment
Wallet: new UI for pending delegation (#1499 )
2022-08-18 13:28:05 +02:00 · 2022-08-18 10:45:42 +01:00 · 2022-08-18 11:20:32 +02:00 · 2022-08-17 17:21:36 +02:00 · 2022-08-17 13:27:53 +01:00 · 2022-08-16 14:19:55 +02:00
849 changed files with 40516 additions and 28643 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
@@ -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
@@ -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
@@ -50,6 +50,19 @@ jobs:
          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 +88,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_NYMTECH_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "test"
+          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,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
@@ -45,3 +45,4 @@ jobs:
            target/release/nym-socks5-client
            target/release/nym-validator-api
            target/release/nym-network-requester
+            target/release/nym-network-statistics
@@ -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
@@ -51,12 +51,12 @@ jobs:

      - name: Install dependencies
        run: yarn install
-        working-directory: nym-wallet/webdriver
+        working-directory: nym-wallet/wallet-ui-tests

      - name: Remove existing user datafile
        uses: JesseTG/rm@v1.0.2
        with:
-          path: nym-wallet/webdriver/common/data/user-data.json
+          path: nym-wallet/wallet-ui-tests/common/user-data.json

      - name: Create user data json file
        id: create-json
@@ -64,7 +64,7 @@ jobs:
        with:
          name: "user-data.json"
          json: ${{ secrets.WALLET_USERDATA }}
-          dir: "nym-wallet/webdriver/common/data/"
+          dir: "nym-wallet/wallet-ui-tests/common/"

      - name: Install tauri-driver
        uses: actions-rs/cargo@v1
@@ -73,5 +73,5 @@ jobs:
          args: tauri-driver

      - name: Launch tests
-        run: xvfb-run yarn test:runall
-        working-directory: nym-wallet/webdriver
+        run: xvfb-run yarn test
+        working-directory: nym-wallet/wallet-ui-tests
@@ -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 }}
+```
@@ -2,68 +2,96 @@

 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]
+## Unreleased
+
+### Changed
+
+- validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
+
+[#1541]: https://github.com/nymtech/nym/pull/1541
+
+
+## [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])
- mixnet-contract: Added ClaimOperatorReward and ClaimDelegatorReward messages ([#1292])
- mixnet-contract: Replace all naked `-` with `saturating_sub`.
+- 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 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])
- vesting-contract: Added ClaimOperatorReward and ClaimDelegatorReward messages ([#1292])
- wallet: add simple CLI tool for decrypting and recovering the wallet file.
- wallet: added support for multiple accounts ([#1265])
- wallet: compound and claim reward endpoints for operators and delegators ([#1302])
- wallet: require password to switch accounts
- wallet: the wallet backend learned how to keep track of validator name, either hardcoded or by querying the status endpoint.
+- validator-api: add `uptime`, `estimated_operator_apy`, `estimated_delegators_apy` to `/mixnodes/detailed` endpoint ([#1393])
 - 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

- mixnet-contract: `estimated_delegator_reward` calculation ([#1284])
- mixnet-contract: delegator and operator rewards use lambda and sigma instead of lambda_ticked and sigma_ticked ([#1284])
- 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: replaced integer division with fixed for performance calculations ([#1284])
- 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])
- mixnode: the mixnode learned how to shutdown gracefully.
- vesting-contract: replaced `checked_sub` with `saturating_sub` to fix the underflow in `get_vesting_tokens` ([#1275])
+- 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 ([#1496]).

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

 [#1249]: https://github.com/nymtech/nym/pull/1249
 [#1256]: https://github.com/nymtech/nym/pull/1256
-[#1257]: https://github.com/nymtech/nym/pull/1257
-[#1258]: https://github.com/nymtech/nym/pull/1258
 [#1260]: https://github.com/nymtech/nym/pull/1260
 [#1261]: https://github.com/nymtech/nym/pull/1261
-[#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
-[#1284]: https://github.com/nymtech/nym/pull/1284
-[#1292]: https://github.com/nymtech/nym/pull/1292
 [#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
-
-## [nym-wallet-v1.0.4](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.4) (2022-05-04)
-
-### 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])
+[#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

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

@@ -96,77 +124,10 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 [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)
@@ -245,108 +206,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - 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,22 +22,23 @@ 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/config",
-    "common/credentials",
-    "common/crypto",
-    "common/crypto/dkg",
-    "common/execute",
-    "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,9 +54,9 @@ members = [
    "common/nymsphinx/params",
    "common/nymsphinx/types",
    "common/pemstore",
-    "common/statistics",
    "common/socks5/proxy-helpers",
    "common/socks5/requests",
+    "common/statistics",
    "common/task",
    "common/topology",
    "common/types",
@@ -76,9 +77,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", "nym-wallet"]
+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,9 @@ build-contracts:
 build-wallet:
 	cargo build --manifest-path nym-wallet/Cargo.toml --workspace

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

@@ -52,6 +78,9 @@ 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

@@ -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');
+}
@@ -7,7 +7,7 @@ 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"
@@ -32,4 +32,4 @@ validator-client = { path = "../../common/client-libs/validator-client" }
 tempfile = "3.1.0"

 [features]
-coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
+coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
@@ -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,137 @@
+// 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 topology::{filter::VersionFilterable, gateway};
+use url::Url;
+
+use crate::{
+    client::key_manager::KeyManager,
+    config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
+};
+
+pub async fn query_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());
+
+    log::trace!("Fetching list of gateways from: {}", validator_api);
+    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>>();
+
+    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()
+    }
+}
+
+pub async fn register_with_gateway_and_store_keys<T>(
+    gateway_details: gateway::Node,
+    config: &Config<T>,
+) 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);
+    key_manager
+        .store_keys(&pathfinder)
+        .expect("Failed to generated keys");
+}
+
+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!")
+}
+
+pub fn show_address<T>(config: &Config<T>)
+where
+    T: config::NymConfig,
+{
+    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);
+    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()).unwrap(),
+    );
+
+    println!("\nThe address of this client is: {}", client_recipient);
+}
@@ -1,2 +1,3 @@
 pub mod client;
 pub mod config;
+pub mod init;
@@ -26,4 +26,4 @@ pemstore = { path = "../../common/pemstore" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }

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

-use bip39::Mnemonic;
-use std::str::FromStr;
-use url::Url;
-
 use crate::error::Result;
 use crate::{MNEMONIC, NYMD_URL};
-
-use network_defaults::{DEFAULT_NETWORK, MIX_DENOM, VOUCHER_INFO};
+use bip39::Mnemonic;
+use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
+use std::str::FromStr;
+use url::Url;
+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>,
+    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 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(DEFAULT_NETWORK, nymd_url.as_ref(), mnemonic, None)
-                .unwrap();
+            NymdClient::connect_with_mnemonic(config, nymd_url.as_ref(), mnemonic, None).unwrap();

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

    pub async fn deposit(
@@ -34,7 +39,7 @@ impl Client {
        encryption_key: String,
        fee: Option<Fee>,
    ) -> Result<String> {
-        let amount = Coin::new(amount as u128, MIX_DENOM.base.to_string());
+        let amount = Coin::new(amount as u128, self.mix_denom_base.clone());
        Ok(self
            .nymd_client
            .deposit(
@@ -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,9 +20,8 @@ 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
@@ -55,4 +55,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,
@@ -105,7 +105,7 @@ impl Config {
    }
 }

-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Socket {
    socket_type: SocketType,
@@ -1,248 +1,134 @@
 // 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;
 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. If this value is set, --eth-endpoint and
+    /// --eth-private_key don't need to be set.
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    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(all(feature = "eth", not(feature = "coconut")))]
+            enabled_credentials_mode: init_config.enabled_credentials_mode,

-    log::trace!("Fetching list of gateways from: {}", validator_api);
-    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() {
-        if matches.is_present("gateway") {
-            panic!("At the moment, gateway information can't be overwritten. If you want to point to a different gateway, client {}'s directory will need to be manually removed", id);
-        }
-        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");
-        log::trace!("Chosen gateway: {:?}", chosen_gateway_id);
-
-        let gateway_details = gateway_details(
-            config.get_base().get_validator_api_endpoints(),
-            chosen_gateway_id,
-        )
-        .await;
-        log::trace!("Used gateway: {}", gateway_details);
-        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;
+    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());
    log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
@@ -253,5 +139,58 @@ pub async fn execute(matches: ArgMatches<'static>) {
    );
    println!("Client configuration completed.");

-    show_address(&config);
+    client_core::init::show_address(config.get_base());
+}
+
+async fn setup_gateway(
+    id: &str,
+    register: bool,
+    user_chosen_gateway_id: Option<&str>,
+    config: &Config,
+) -> GatewayEndpoint {
+    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");
+
+        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);
+        gateway.into()
+    } else {
+        println!("Not registering gateway, will reuse existing config and keys");
+        match Config::load_from_file(Some(id)) {
+            Ok(existing_config) => existing_config.get_base().get_gateway_endpoint().clone(),
+            Err(err) => {
+                panic!(
+                    "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."
+                )
+            }
+        }
+    }
 }
@@ -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,56 +15,145 @@ 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(all(feature = "eth", not(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 matches.is_present("disable-socket") {
+    if args.disable_socket {
        config = config.with_socket(SocketType::None);
    }

-    if let Some(port) = matches.value_of("port").map(str::parse) {
-        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(all(feature = "eth", not(feature = "coconut")))]
+    {
+        if args.enabled_credentials_mode {
+            config.get_base_mut().with_disabled_credentials(false)
+        }
+        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,68 +1,77 @@
 // 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. If this value is set, --eth-endpoint and
+    /// --eth-private-key don't need to be set.
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    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(all(feature = "eth", not(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
@@ -73,7 +82,7 @@ fn version_check(cfg: &Config) -> bool {
    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);
+        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
@@ -84,8 +93,8 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-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 +104,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,7 +120,7 @@ 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);

@@ -143,7 +132,7 @@ fn do_upgrade(mut config: Config, matches: &ArgMatches<'_>, package_version: &Ve
        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),
+                11 => minor_0_12_upgrade(config, args, &config_version, package_version),
                _ => unsupported_upgrade(&config_version, package_version),
            },
            _ => unsupported_upgrade(&config_version, package_version),
@@ -151,10 +140,10 @@ fn do_upgrade(mut config: Config, matches: &ArgMatches<'_>, package_version: &Ve
    }
 }

-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") {
@@ -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"
@@ -47,4 +47,4 @@ coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gate
 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"] }
@@ -89,7 +89,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
@@ -20,6 +20,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,
@@ -35,7 +36,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,
@@ -272,6 +283,23 @@ impl NymClient {
        );
    }

+    // Variant of `run_forever` that listends for remote control messages
+    pub async fn run_and_listen(&mut self, mut receiver: Socks5ControlMessageReceiver) {
+        self.start().await;
+        tokio::select! {
+            message = receiver.next() => {
+                log::debug!("Received message: {:?}", message);
+                match message {
+                    Some(Socks5ControlMessage::Stop) => {
+                        log::info!("Shutting down");
+                        log::info!("Graceful shutdown of tasks not yet implemented, you might see (harmless) panics until then");
+                    }
+                    None => log::debug!("None"),
+                }
+            }
+        }
+    }
+
    pub async fn start(&mut self) {
        info!("Starting nym client");
        // channels for inter-component communication
@@ -1,249 +1,196 @@
 // 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;
 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. If this value is set, --eth-endpoint and
+    /// --eth-private_key don't need to be set.
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    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(all(feature = "eth", not(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() {
-        if matches.is_present("gateway") {
-            panic!("At the moment, gateway information can't be overwritten. If you want to point to a different gateway, client {}'s directory will need to be manually removed", id);
-        }
-        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;
+    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());
+}
+
+async fn setup_gateway(
+    id: &str,
+    register: bool,
+    user_chosen_gateway_id: Option<&str>,
+    config: &Config,
+) -> GatewayEndpoint {
+    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");
+
+        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);
+        gateway.into()
+    } else {
+        println!("Not registering gateway, will reuse existing config and keys");
+        match Config::load_from_file(Some(id)) {
+            Ok(existing_config) => existing_config.get_base().get_gateway_endpoint().clone(),
+            Err(err) => {
+                panic!(
+                    "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."
+                )
+            }
+        }
+    }
 }
@@ -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,52 +16,138 @@ 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(all(feature = "eth", not(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(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(all(feature = "eth", not(feature = "coconut")))]
+    {
+        if args.enabled_credentials_mode {
+            config.get_base_mut().with_disabled_credentials(false)
+        }
+        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,80 @@
 // 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. If this value is set, --eth-endpoint and
+    /// --eth-private-key don't need to be set.
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[clap(long, conflicts_with_all = &["eth-endpoint", "eth-private-key"])]
+    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(all(feature = "eth", not(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 +82,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 +96,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 +110,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,
@@ -5,7 +5,7 @@ use futures::StreamExt;
 use log::*;
 use nymsphinx::receiver::ReconstructedMessage;
 use proxy_helpers::connection_controller::{ControllerCommand, ControllerSender};
-use socks5_requests::Response;
+use socks5_requests::Message;

 pub(crate) struct MixnetResponseListener {
    buffer_requester: ReceivedBufferRequestSender,
@@ -44,12 +44,16 @@ 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,
        };

        self.controller_sender
@@ -1 +1 @@
-15.0.1
+16
@@ -31,9 +31,12 @@
    "eslint-plugin-import": "^2.25.4",
    "eslint-plugin-mocha": "^10.0.3",
    "eslint-plugin-prettier": "^4.0.0",
+    "expect": "^28.1.3",
+    "mocha": "^10.0.0",
    "prettier": "^2.5.1",
    "typedoc": "^0.22.13",
-    "typescript": "^4.1.3"
+    "ts-mocha": "^10.0.0",
+    "typescript": "^4.6.2"
  },
  "dependencies": {
    "@cosmjs/cosmwasm-stargate": "^0.28.0",
@@ -64,23 +64,20 @@ export default class ValidatorClient implements INymClient {

  readonly vestingContract: string;

-  readonly mainnetDenom = "unym";
+  readonly mainnetDenom = 'unym';

-  readonly mainnetPrefix = "n";
+  readonly mainnetPrefix = 'n';

  private constructor(
    client: SigningClient | QueryClient,
    prefix: string,
    mixnetContract: string,
-    vestingContract: string
+    vestingContract: string,
+    denom: string,
  ) {
    this.client = client;
    this.prefix = prefix;
-    if (prefix == this.mainnetPrefix) {
-      this.denom = this.mainnetDenom;
-    } else {
-      this.denom = `u${prefix}`;
-    }
+    this.denom = `u${denom}`;

    this.mixnetContract = mixnetContract;
    this.vestingContract = vestingContract;
@@ -93,11 +90,12 @@ export default class ValidatorClient implements INymClient {
    prefix: string,
    mixnetContract: string,
    vestingContract: string,
+    denom: string,
  ): Promise<ValidatorClient> {
    const wallet = await ValidatorClient.buildWallet(mnemonic, prefix);

-    const signingClient = await SigningClient.connectWithNymSigner(wallet, nymdUrl, validatorApiUrl, prefix);
-    return new ValidatorClient(signingClient, prefix, mixnetContract, vestingContract);
+    const signingClient = await SigningClient.connectWithNymSigner(wallet, nymdUrl, validatorApiUrl, prefix, denom);
+    return new ValidatorClient(signingClient, prefix, mixnetContract, vestingContract, denom);
  }

  static async connectForQuery(
@@ -106,9 +104,10 @@ export default class ValidatorClient implements INymClient {
    prefix: string,
    mixnetContract: string,
    vestingContract: string,
+    denom: string,
  ): Promise<ValidatorClient> {
    const queryClient = await QueryClient.connectWithNym(nymdUrl, validatorApiUrl);
-    return new ValidatorClient(queryClient, prefix, mixnetContract, vestingContract);
+    return new ValidatorClient(queryClient, prefix, mixnetContract, vestingContract, denom);
  }

  public get address(): string {
@@ -457,4 +456,4 @@ export default class ValidatorClient implements INymClient {
    this.assertSigning();
    return (this.client as ISigningClient).updateContractStateParams(this.mixnetContract, newParams, fee, memo);
  }
-}
+}
@@ -221,10 +221,12 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
    nymdUrl: string,
    validatorApiUrl: string,
    prefix: string,
+    denom: string,
  ): Promise<SigningClient> {
    const [{ address }] = await wallet.getAccounts();
    const signerOptions: SigningCosmWasmClientOptions = {
-      gasPrice: nymGasPrice(prefix),
+      prefix,
+      gasPrice: nymGasPrice(denom),
    };
    const tmClient = await Tendermint34Client.connect(nymdUrl);
    return new SigningClient(address, validatorApiUrl, tmClient, wallet, signerOptions);
@@ -7,13 +7,12 @@ const mainnetDenom = 'nym';
 export function nymGasPrice(prefix: string): GasPrice {
  if (typeof prefix === 'string') {
    if (prefix === mainnetPrefix) {
-      prefix = mainnetDenom;
+      return GasPrice.fromString(`0.025u${mainnetDenom}`);
    }
    return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
  }
-  else {
-    throw new Error(`${prefix} is not of type string`);
-  }
+
+  throw new Error(`${prefix} is not of type string`);
 }

 export const downloadWasm = async (url: string): Promise<Uint8Array> => {
@@ -0,0 +1,11 @@
+import ValidatorClient from '../../dist';
+import expect from 'expect';
+
+describe('Query: balances', () => {
+  it('can query for an account balance', async () => {
+    const client = await ValidatorClient.connectForQuery(
+      'https://rpc.nyx.nodes.guru/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
+    const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
+    expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
+  }).timeout(5000);
+})
@@ -0,0 +1,14 @@
+import ValidatorClient from '../../dist';
+import expect from 'expect';
+
+// TODO: implement for QA with .env for mnemonics
+// describe('Sign: send', () => {
+//   it('can send tokens', async () => {
+//     const client = await ValidatorClient.connect(
+//       '<ADD MNEMONIC HERE>',
+//       'https://rpc.nyx.nodes.guru/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
+//     await client.send('<ADD ADDRESS HERE>')
+//     const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
+//     expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
+//   }).timeout(5000);
+// })
@@ -5,7 +5,8 @@
        "esModuleInterop": true,
        "strict": true,
        "declaration": true,
-        "outDir": "./dist"
+        "outDir": "./dist",
+        "skipLibCheck": true
    },
    "typedocOptions": {
        "entryPoints": [
@@ -24,7 +24,8 @@
    },
    "../pkg": {
      "name": "@nymproject/nym-client-wasm",
-      "version": "0.0.1"
+      "version": "1.0.1",
+      "license": "Apache-2.0"
    },
    "node_modules/@discoveryjs/json-ext": {
      "version": "0.5.7",
@@ -5,7 +5,7 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

 // Serializable structures for what we find in common/crypto
-#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Copy, Clone, Debug, PartialEq, Eq, JsonSchema)]
 pub struct PublicKey([u8; 32]);

 impl PublicKey {
@@ -24,7 +24,7 @@ impl AsRef<[u8]> for PublicKey {
    }
 }

-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 pub struct Signature([u8; 32], [u8; 32]);

 impl Signature {
@@ -7,16 +7,16 @@ use serde::{Deserialize, Serialize};
 use crate::keys::PublicKey;
 use crate::payment::LinkPaymentData;

-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 pub struct InstantiateMsg {}

-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
    LinkPayment { data: LinkPaymentData },
 }

-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryMsg {
    GetPayments {
@@ -25,6 +25,6 @@ pub enum QueryMsg {
    },
 }

-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct MigrateMsg {}
@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};

 use crate::keys::{PublicKey, Signature};

-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, JsonSchema)]
 pub struct Payment {
    verification_key: PublicKey,
    gateway_identity: PublicKey,
@@ -27,7 +27,7 @@ impl Payment {
    }
 }

-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 pub struct LinkPaymentData {
    pub verification_key: PublicKey,
    pub gateway_identity: PublicKey,
@@ -51,7 +51,7 @@ impl LinkPaymentData {
    }
 }

-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize, JsonSchema)]
 pub struct PagedPaymentResponse {
    pub payments: Vec<Payment>,
    pub per_page: usize,
@@ -74,4 +74,4 @@ features = ["js"]
 [features]
 coconut = ["gateway-requests/coconut", "coconut-interface", "validator-client", "credentials/coconut"]
 wasm = ["web3/wasm", "web3/http", "web3/signing"]
-default = ["web3/default"]
+default = ["web3/default"]
@@ -1,47 +1,49 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::error::GatewayClientError;
+use std::str::FromStr;
+
 #[cfg(target_arch = "wasm32")]
-use crate::wasm_storage::{Storage, StorageError};
-#[cfg(feature = "coconut")]
-use coconut_interface::Base58;
-#[cfg(feature = "coconut")]
-#[cfg(not(target_arch = "wasm32"))]
-use credential_storage::error::StorageError;
+use crate::wasm_storage::Storage;
 #[cfg(not(target_arch = "wasm32"))]
 use credential_storage::storage::Storage;
+
+#[cfg(all(target_arch = "wasm32", feature = "coconut"))]
+use crate::wasm_storage::StorageError;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "coconut"))]
+use credential_storage::error::StorageError;
+
 #[cfg(feature = "coconut")]
-use credentials::coconut::{
-    bandwidth::prepare_for_spending, utils::obtain_aggregate_verification_key,
-};
-#[cfg(not(feature = "coconut"))]
-use credentials::token::bandwidth::TokenCredential;
-#[cfg(not(feature = "coconut"))]
-use crypto::asymmetric::identity;
-#[cfg(not(feature = "coconut"))]
-use network_defaults::{
-    eth_contract::ETH_ERC20_JSON_ABI, eth_contract::ETH_JSON_ABI, BANDWIDTH_VALUE,
-    ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_ERC20_APPROVE_FUNCTION_NAME,
-    ETH_ERC20_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN, UTOKENS_TO_BURN,
-};
-#[cfg(not(feature = "coconut"))]
-use pemstore::traits::PemStorableKeyPair;
-#[cfg(not(feature = "coconut"))]
-use rand::rngs::OsRng;
-#[cfg(not(feature = "coconut"))]
-use secp256k1::SecretKey;
-use std::str::FromStr;
-#[cfg(not(feature = "coconut"))]
-use web3::{
-    contract::{Contract, Options},
-    ethabi::Token,
-    signing::{Key, SecretKeyRef},
-    transports::Http,
-    types::{Address, U256, U64},
-    Web3,
+use {
+    coconut_interface::Base58,
+    credentials::coconut::{
+        bandwidth::prepare_for_spending, utils::obtain_aggregate_verification_key,
+    },
 };

-use crate::error::GatewayClientError;
+#[cfg(not(feature = "coconut"))]
+use {
+    credentials::token::bandwidth::TokenCredential,
+    crypto::asymmetric::identity,
+    network_defaults::{
+        eth_contract::ETH_ERC20_JSON_ABI, eth_contract::ETH_JSON_ABI, BANDWIDTH_VALUE,
+        ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_ERC20_APPROVE_FUNCTION_NAME,
+        ETH_ERC20_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN, UTOKENS_TO_BURN,
+    },
+    pemstore::traits::PemStorableKeyPair,
+    rand::rngs::OsRng,
+    secp256k1::SecretKey,
+    web3::{
+        contract::{Contract, Options},
+        ethabi::Token,
+        signing::{Key, SecretKeyRef},
+        transports::Http,
+        types::{Address, U256, U64},
+        Web3,
+    },
+};

 #[cfg(not(feature = "coconut"))]
 pub fn eth_contract(web3: Web3<Http>) -> Contract<Http> {
@@ -27,7 +27,7 @@ futures = "0.3"

 coconut-interface = { path = "../../coconut-interface" }
 network-defaults = { path = "../../network-defaults" }
-validator-api-requests = { path = "../../../validator-api/validator-api-requests" }
+validator-api-requests = { path = "../../../validator-api/validator-api-requests", features = ["coconut"] }

 # required for nymd-client
 # at some point it might be possible to make it wasm-compatible
@@ -35,7 +35,7 @@ validator-api-requests = { path = "../../../validator-api/validator-api-requests
 async-trait = { version = "0.1.51", optional = true }
 bip39 = { version = "1", features = ["rand"], optional = true }
 config = { path = "../../config", optional = true }
-cosmrs = { version = "0.7.0", features = ["rpc", "bip32", "cosmwasm"], optional = true}
+cosmrs = { git = "https://github.com/neacsu/cosmos-rust", branch = "neacsu/feegrant_support", features = ["rpc", "bip32", "cosmwasm"], optional = true}
 prost = { version = "0.10", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
@@ -43,6 +43,7 @@ itertools = { version = "0.10", optional = true }
 cosmwasm-std = { version = "1.0.0", optional = true }
 execute = { path = "../../execute" }

+[dev-dependencies]
 ts-rs = "6.1.2"

 [features]
@@ -2,27 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::{validator_api, ValidatorClientError};
-use coconut_interface::{
-    BlindSignRequestBody, BlindedSignatureResponse, ExecuteReleaseFundsRequestBody,
-    ProposeReleaseFundsRequestBody, ProposeReleaseFundsResponse, VerificationKeyResponse,
-    VerifyCredentialBody, VerifyCredentialResponse,
-};
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
 use url::Url;
-
+use validator_api_requests::coconut::{
+    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
+    VerifyCredentialBody, VerifyCredentialResponse,
+};
 use validator_api_requests::models::{
    CoreNodeStatusResponse, MixnodeStatusResponse, RewardEstimationResponse,
    StakeSaturationResponse,
 };
+
 #[cfg(feature = "nymd-client")]
 use validator_api_requests::models::{MixNodeBondAnnotated, UptimeResponse};

-#[cfg(feature = "nymd-client")]
-use network_defaults::DEFAULT_NETWORK;
-
 #[cfg(feature = "nymd-client")]
 use crate::nymd::{
-    error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
+    self, error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
 };

 #[cfg(feature = "nymd-client")]
@@ -32,18 +28,18 @@ use mixnet_contract_common::{
    RewardedSetUpdateDetails,
 };
 #[cfg(feature = "nymd-client")]
+use network_defaults::NymNetworkDetails;
+#[cfg(feature = "nymd-client")]
 use std::collections::{HashMap, HashSet};

 #[cfg(feature = "nymd-client")]
 #[must_use]
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Config {
-    network: network_defaults::all::Network,
    api_url: Url,
    nymd_url: Url,
-    mixnet_contract_address: cosmrs::AccountId,
-    vesting_contract_address: cosmrs::AccountId,
-    bandwidth_claim_contract_address: cosmrs::AccountId,
+
+    nymd_config: nymd::Config,

    mixnode_page_limit: Option<u32>,
    gateway_page_limit: Option<u32>,
@@ -53,42 +49,44 @@ pub struct Config {

 #[cfg(feature = "nymd-client")]
 impl Config {
-    pub fn new(network: network_defaults::all::Network, nymd_url: Url, api_url: Url) -> Self {
-        Config {
-            network,
-            nymd_url,
-            mixnet_contract_address: DEFAULT_NETWORK
-                .mixnet_contract_address()
+    pub fn try_from_nym_network_details(
+        details: &NymNetworkDetails,
+    ) -> Result<Self, ValidatorClientError> {
+        let mut api_url = details
+            .endpoints
+            .iter()
+            .filter_map(|d| d.api_url.as_ref())
+            .map(|url| Url::parse(url))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        if api_url.is_empty() {
+            return Err(ValidatorClientError::NoAPIUrlAvailable);
+        }
+
+        Ok(Config {
+            api_url: api_url.pop().unwrap(),
+            nymd_url: details.endpoints[0]
+                .nymd_url
                .parse()
-                .expect("Error parsing mixnet contract address"),
-            vesting_contract_address: DEFAULT_NETWORK
-                .vesting_contract_address()
-                .parse()
-                .expect("Error parsing vesting contract address"),
-            bandwidth_claim_contract_address: DEFAULT_NETWORK
-                .bandwidth_claim_contract_address()
-                .parse()
-                .expect("Error parsing bandwidth claim contract address"),
-            api_url,
+                .map_err(ValidatorClientError::MalformedUrlProvided)?,
+            nymd_config: nymd::Config::try_from_nym_network_details(details)?,
            mixnode_page_limit: None,
            gateway_page_limit: None,
            mixnode_delegations_page_limit: None,
            rewarded_set_page_limit: None,
-        }
+        })
    }

-    pub fn with_mixnode_contract_address(mut self, address: cosmrs::AccountId) -> Self {
-        self.mixnet_contract_address = address;
+    // TODO: this method shouldn't really exist as all information should be included immediately
+    // via `from_nym_network_details`, but it's here for, you guessed it, legacy compatibility
+    pub fn with_urls(mut self, nymd_url: Url, api_url: Url) -> Self {
+        self.nymd_url = nymd_url;
+        self.api_url = api_url;
        self
    }

-    pub fn with_vesting_contract_address(mut self, address: cosmrs::AccountId) -> Self {
-        self.vesting_contract_address = address;
-        self
-    }
-
-    pub fn with_bandwidth_claim_contract_address(mut self, address: cosmrs::AccountId) -> Self {
-        self.bandwidth_claim_contract_address = address;
+    pub fn with_nymd_url(mut self, nymd_url: Url) -> Self {
+        self.nymd_url = nymd_url;
        self
    }

@@ -115,10 +113,8 @@ impl Config {

 #[cfg(feature = "nymd-client")]
 pub struct Client<C> {
-    pub network: network_defaults::all::Network,
-    mixnet_contract_address: cosmrs::AccountId,
-    vesting_contract_address: cosmrs::AccountId,
-    bandwidth_claim_contract_address: cosmrs::AccountId,
+    // TODO: we really shouldn't be storing a mnemonic here, but removing it would be
+    // non-trivial amount of work and it's out of scope of the current branch
    mnemonic: Option<bip39::Mnemonic>,

    mixnode_page_limit: Option<u32>,
@@ -139,25 +135,18 @@ impl Client<SigningNymdClient> {
    ) -> Result<Client<SigningNymdClient>, ValidatorClientError> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
        let nymd_client = NymdClient::connect_with_mnemonic(
-            config.network,
+            config.nymd_config.clone(),
            config.nymd_url.as_str(),
            mnemonic.clone(),
            None,
-        )?
-        .with_mixnet_contract_address(config.mixnet_contract_address.clone())
-        .with_vesting_contract_address(config.vesting_contract_address.clone())
-        .with_bandwidth_claim_contract_address(config.bandwidth_claim_contract_address.clone());
+        )?;

        Ok(Client {
-            network: config.network,
-            mixnet_contract_address: config.mixnet_contract_address,
-            vesting_contract_address: config.vesting_contract_address,
-            bandwidth_claim_contract_address: config.bandwidth_claim_contract_address,
            mnemonic: Some(mnemonic),
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
-            rewarded_set_page_limit: None,
+            rewarded_set_page_limit: config.rewarded_set_page_limit,
            validator_api: validator_api_client,
            nymd: nymd_client,
        })
@@ -165,14 +154,11 @@ impl Client<SigningNymdClient> {

    pub fn change_nymd(&mut self, new_endpoint: Url) -> Result<(), ValidatorClientError> {
        self.nymd = NymdClient::connect_with_mnemonic(
-            self.network,
+            self.nymd.current_config().clone(),
            new_endpoint.as_ref(),
            self.mnemonic.clone().unwrap(),
            None,
-        )?
-        .with_mixnet_contract_address(self.mixnet_contract_address.clone())
-        .with_vesting_contract_address(self.vesting_contract_address.clone())
-        .with_bandwidth_claim_contract_address(self.bandwidth_claim_contract_address.clone());
+        )?;
        Ok(())
    }

@@ -185,15 +171,10 @@ impl Client<SigningNymdClient> {
 impl Client<QueryNymdClient> {
    pub fn new_query(config: Config) -> Result<Client<QueryNymdClient>, ValidatorClientError> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
-        let nymd_client = NymdClient::connect(config.nymd_url.as_str())?
-            .with_mixnet_contract_address(config.mixnet_contract_address.clone())
-            .with_vesting_contract_address(config.vesting_contract_address.clone());
+        let nymd_client =
+            NymdClient::connect(config.nymd_config.clone(), config.nymd_url.as_str())?;

        Ok(Client {
-            network: config.network,
-            mixnet_contract_address: config.mixnet_contract_address,
-            vesting_contract_address: config.vesting_contract_address,
-            bandwidth_claim_contract_address: config.bandwidth_claim_contract_address,
            mnemonic: None,
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
@@ -205,10 +186,7 @@ impl Client<QueryNymdClient> {
    }

    pub fn change_nymd(&mut self, new_endpoint: Url) -> Result<(), ValidatorClientError> {
-        self.nymd = NymdClient::connect(new_endpoint.as_ref())?
-            .with_mixnet_contract_address(self.mixnet_contract_address.clone())
-            .with_vesting_contract_address(self.vesting_contract_address.clone())
-            .with_bandwidth_claim_contract_address(self.bandwidth_claim_contract_address.clone());
+        self.nymd = NymdClient::connect(self.nymd.current_config().clone(), new_endpoint.as_ref())?;
        Ok(())
    }
 }
@@ -222,11 +200,12 @@ impl<C> Client<C> {
    // use case: somebody initialised client without a contract in order to upload and initialise one
    // and now they want to actually use it without making new client
    pub fn set_mixnet_contract_address(&mut self, mixnet_contract_address: cosmrs::AccountId) {
-        self.mixnet_contract_address = mixnet_contract_address
+        self.nymd
+            .set_mixnet_contract_address(mixnet_contract_address)
    }

    pub fn get_mixnet_contract_address(&self) -> cosmrs::AccountId {
-        self.mixnet_contract_address.clone()
+        self.nymd.mixnet_contract_address().clone()
    }

    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
@@ -318,6 +297,13 @@ impl<C> Client<C> {
        Ok(self.nymd.get_current_epoch().await?)
    }

+    pub async fn get_current_operator_cost(&self) -> Result<u64, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        Ok(self.nymd.get_current_operator_cost().await?)
+    }
+
    pub async fn get_mixnet_contract_version(&self) -> Result<MixnetContractVersion, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -734,6 +720,10 @@ impl ApiClient {
        Ok(self.validator_api.get_coconut_verification_key().await?)
    }

+    pub async fn get_cosmos_address(&self) -> Result<CosmosAddressResponse, ValidatorClientError> {
+        Ok(self.validator_api.get_cosmos_address().await?)
+    }
+
    pub async fn verify_bandwidth_credential(
        &self,
        request_body: &VerifyCredentialBody,
@@ -743,24 +733,4 @@ impl ApiClient {
            .verify_bandwidth_credential(request_body)
            .await?)
    }
-
-    pub async fn propose_release_funds(
-        &self,
-        request_body: &ProposeReleaseFundsRequestBody,
-    ) -> Result<ProposeReleaseFundsResponse, ValidatorClientError> {
-        Ok(self
-            .validator_api
-            .propose_release_funds(request_body)
-            .await?)
-    }
-
-    pub async fn execute_release_funds(
-        &self,
-        request_body: &ExecuteReleaseFundsRequestBody,
-    ) -> Result<(), ValidatorClientError> {
-        Ok(self
-            .validator_api
-            .execute_release_funds(request_body)
-            .await?)
-    }
 }
@@ -1,5 +1,5 @@
 use crate::nymd::error::NymdError;
-use crate::nymd::{NymdClient, QueryNymdClient};
+use crate::nymd::{Config as ClientConfig, NymdClient, QueryNymdClient};
 use crate::ApiClient;
 use network_defaults::all::Network;

@@ -54,10 +54,20 @@ fn setup_connection_tests<H: BuildHasher + 'static>(
            .get(&network)
            .expect("No configured contract address")
            .clone();
-        NymdClient::<QueryNymdClient>::connect(url.as_str())
-            .map(|client| client.with_mixnet_contract_address(address))
-            .map(move |client| ClientForConnectionTest::Nymd(network, url, Box::new(client)))
-            .ok()
+        let config = ClientConfig::try_from_nym_network_details(&network.details())
+            .expect("failed to create valid nymd client config");
+
+        if let Ok(mut client) = NymdClient::<QueryNymdClient>::connect(config, url.as_str()) {
+            // possibly redundant, but lets just leave it here
+            client.set_mixnet_contract_address(address);
+            Some(ClientForConnectionTest::Nymd(
+                network,
+                url,
+                Box::new(client),
+            ))
+        } else {
+            None
+        }
    });

    let api_connection_test_clients = api_urls.map(|(network, url)| {
@@ -76,7 +86,7 @@ fn extract_and_collect_results_into_map(
        .filter(|c| &c.url_type() == url_type)
        .map(|c| {
            let (network, url, result) = c.result();
-            (*network, (url.clone(), *result))
+            (network.clone(), (url.clone(), *result))
        })
        .into_group_map()
 }
@@ -18,4 +18,7 @@ pub enum ValidatorClientError {
    #[cfg(feature = "nymd-client")]
    #[error("There was an issue with the Nymd client - {0}")]
    NymdError(#[from] crate::nymd::error::NymdError),
+
+    #[error("No validator API url has been provided")]
+    NoAPIUrlAvailable,
 }
@@ -6,14 +6,14 @@ use std::fmt;
 pub use cosmrs::Coin as CosmosCoin;
 pub use cosmwasm_std::Coin as CosmWasmCoin;

-#[derive(Serialize, Deserialize, Clone, Copy, Default, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, Copy, Default, Debug, PartialEq, Eq)]
 pub struct MismatchedDenoms;

 // the reason the coin is created here as opposed to different place in the codebase is that
 // eventually we want to either publish the cosmwasm client separately or commit it to
 // some other project, like cosmrs. Either way, in that case we can't really have
 // a dependency on an internal type
-#[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, Eq)]
 pub struct Coin {
    pub amount: u128,
    pub denom: String,
@@ -8,10 +8,13 @@ use crate::nymd::cosmwasm_client::types::*;
 use crate::nymd::error::NymdError;
 use crate::nymd::fee::{Fee, DEFAULT_SIMULATED_GAS_MULTIPLIER};
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
-use crate::nymd::{Coin, GasPrice, TxResponse};
+use crate::nymd::{Coin, GasAdjustable, GasPrice, TxResponse};
 use async_trait::async_trait;
 use cosmrs::bank::MsgSend;
 use cosmrs::distribution::MsgWithdrawDelegatorReward;
+use cosmrs::feegrant::{
+    AllowedMsgAllowance, BasicAllowance, MsgGrantAllowance, MsgRevokeAllowance,
+};
 use cosmrs::proto::cosmos::tx::signing::v1beta1::SignMode;
 use cosmrs::rpc::endpoint::broadcast;
 use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl, SimpleRequest};
@@ -23,7 +26,7 @@ use serde::Serialize;
 use sha2::Digest;
 use sha2::Sha256;
 use std::convert::TryInto;
-use std::time::Duration;
+use std::time::{Duration, SystemTime};

 const DEFAULT_BROADCAST_POLLING_RATE: Duration = Duration::from_secs(4);
 const DEFAULT_BROADCAST_TIMEOUT: Duration = Duration::from_secs(60);
@@ -420,6 +423,63 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .check_response()
    }

+    #[allow(clippy::too_many_arguments)]
+    async fn grant_allowance(
+        &self,
+        granter: &AccountId,
+        grantee: &AccountId,
+        spend_limit: Vec<Coin>,
+        expiration: Option<SystemTime>,
+        allowed_messages: Vec<String>,
+        fee: Fee,
+        memo: impl Into<String> + Send + 'static,
+    ) -> Result<TxResponse, NymdError> {
+        let basic_allowance = BasicAllowance {
+            spend_limit: spend_limit.into_iter().map(Into::into).collect(),
+            expiration,
+        }
+        .to_any()
+        .map_err(|_| NymdError::SerializationError("BasicAllowance".to_owned()))?;
+
+        let allowed_msg_allowance = AllowedMsgAllowance {
+            allowance: Some(basic_allowance),
+            allowed_messages,
+        }
+        .to_any()
+        .map_err(|_| NymdError::SerializationError("AllowedMsgAllowance".to_owned()))?;
+
+        let grant_allowance_msg = MsgGrantAllowance {
+            granter: granter.to_owned(),
+            grantee: grantee.to_owned(),
+            allowance: Some(allowed_msg_allowance),
+        }
+        .to_any()
+        .map_err(|_| NymdError::SerializationError("MsgGrantAllowance".to_owned()))?;
+
+        self.sign_and_broadcast(granter, vec![grant_allowance_msg], fee, memo)
+            .await?
+            .check_response()
+    }
+
+    async fn revoke_allowance(
+        &self,
+        granter: &AccountId,
+        grantee: &AccountId,
+        fee: Fee,
+        memo: impl Into<String> + Send + 'static,
+    ) -> Result<TxResponse, NymdError> {
+        let revoke_allowance_msg = MsgRevokeAllowance {
+            granter: granter.to_owned(),
+            grantee: grantee.to_owned(),
+        }
+        .to_any()
+        .map_err(|_| NymdError::SerializationError("MsgRevokeAllowance".to_owned()))?;
+
+        self.sign_and_broadcast(granter, vec![revoke_allowance_msg], fee, memo)
+            .await?
+            .check_response()
+    }
+
    async fn delegate_tokens(
        &self,
        delegator_address: &AccountId,
@@ -490,28 +550,35 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        fee: Fee,
        memo: &String,
    ) -> Result<tx::Fee, NymdError> {
+        let auto_fee = |multiplier: Option<f32>| async move {
+            debug!("Trying to simulate gas costs...");
+            // from what I've seen in manual testing, gas estimation does not exist if transaction
+            // fails to get executed (for example if you send 'BondMixnode" with invalid signature)
+            let gas_estimation = self
+                .simulate(signer_address, messages.to_vec(), memo.clone())
+                .await?
+                .gas_info
+                .ok_or(NymdError::GasEstimationFailure)?
+                .gas_used;
+
+            let multiplier = multiplier.unwrap_or(DEFAULT_SIMULATED_GAS_MULTIPLIER);
+            let gas = gas_estimation.adjust_gas(multiplier);
+
+            debug!("Gas estimation: {}", gas_estimation);
+            debug!("Multiplying the estimation by {}", multiplier);
+            debug!("Final gas limit used: {}", gas);
+
+            let fee = self.gas_price() * gas;
+            Ok::<tx::Fee, NymdError>(tx::Fee::from_amount_and_gas(fee, gas))
+        };
        let fee = match fee {
            Fee::Manual(fee) => fee,
-            Fee::Auto(multiplier) => {
-                debug!("Trying to simulate gas costs...");
-                // from what I've seen in manual testing, gas estimation does not exist if transaction
-                // fails to get executed (for example if you send 'BondMixnode" with invalid signature)
-                let gas_estimation = self
-                    .simulate(signer_address, messages.to_vec(), memo.clone())
-                    .await?
-                    .gas_info
-                    .ok_or(NymdError::GasEstimationFailure)?
-                    .gas_used;
-
-                let multiplier = multiplier.unwrap_or(DEFAULT_SIMULATED_GAS_MULTIPLIER);
-                let gas = ((gas_estimation.value() as f32 * multiplier) as u64).into();
-
-                debug!("Gas estimation: {}", gas_estimation);
-                debug!("Multiplying the estimation by {}", multiplier);
-                debug!("Final gas limit used: {}", gas);
-
-                let fee = self.gas_price() * gas;
-                tx::Fee::from_amount_and_gas(fee, gas)
+            Fee::Auto(multiplier) => auto_fee(multiplier).await?,
+            Fee::PayerGranterAuto(auto_feegrant) => {
+                let mut fee = auto_fee(auto_feegrant.gas_adjustment).await?;
+                fee.payer = auto_feegrant.payer;
+                fee.granter = auto_feegrant.granter;
+                fee
            }
        };
        debug!("Fee used for the transaction: {:?}", fee);
@@ -130,6 +130,9 @@ pub enum NymdError {

    #[error("Coconut interface error: {0}")]
    CoconutInterfaceError(#[from] coconut_interface::error::CoconutInterfaceError),
+
+    #[error("Account had an unexpected bech32 prefix. Expected: {expected}, got: {got}")]
+    UnexpectedBech32Prefix { got: String, expected: String },
 }

 impl NymdError {
@@ -2,18 +2,39 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::nymd::Coin;
-use cosmrs::tx;
+use crate::nymd::Gas;
+use cosmrs::{tx, AccountId};
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};

 pub mod gas_price;

-pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: f32 = 1.3;
+pub type GasAdjustment = f32;
+
+pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: GasAdjustment = 1.3;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AutoFeeGrant {
+    pub gas_adjustment: Option<GasAdjustment>,
+    pub payer: Option<AccountId>,
+    pub granter: Option<AccountId>,
+}
+
+impl Display for AutoFeeGrant {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        if let Some(gas_adjustment) = self.gas_adjustment {
+            write!(f, "Feegrant in auto mode with {gas_adjustment} simulated multiplier with {:?} payer and {:?} granter", self.payer, self.granter)
+        } else {
+            write!(f, "Feegrant in auto mode with no custom simulated multiplier with {:?} payer and {:?} granter", self.payer, self.granter)
+        }
+    }
+}

 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Fee {
    Manual(#[serde(with = "sealed::TxFee")] tx::Fee),
-    Auto(Option<f32>),
+    Auto(Option<GasAdjustment>),
+    PayerGranterAuto(AutoFeeGrant),
 }

 impl Display for Fee {
@@ -37,15 +58,27 @@ impl Display for Fee {
                write!(f, "Fee in auto mode with {multiplier} simulated multiplier")
            }
            Fee::Auto(None) => write!(f, "Fee in auto mode with no custom simulated multiplier"),
+            Fee::PayerGranterAuto(auto_feegrant) => write!(f, "{}", auto_feegrant),
        }
    }
 }

 impl Fee {
+    pub fn new_payer_granter_auto(
+        gas_adjustment: Option<GasAdjustment>,
+        payer: Option<AccountId>,
+        granter: Option<AccountId>,
+    ) -> Self {
+        Fee::PayerGranterAuto(AutoFeeGrant {
+            gas_adjustment,
+            payer,
+            granter,
+        })
+    }
    pub fn try_get_manual_amount(&self) -> Option<Vec<Coin>> {
        match self {
            Fee::Manual(tx_fee) => Some(tx_fee.amount.iter().cloned().map(Into::into).collect()),
-            Fee::Auto(_) => None,
+            _ => None,
        }
    }
 }
@@ -56,8 +89,8 @@ impl From<tx::Fee> for Fee {
    }
 }

-impl From<f32> for Fee {
-    fn from(multiplier: f32) -> Self {
+impl From<GasAdjustment> for Fee {
+    fn from(multiplier: GasAdjustment) -> Self {
        Fee::Auto(Some(multiplier))
    }
 }
@@ -68,6 +101,21 @@ impl Default for Fee {
    }
 }

+pub trait GasAdjustable {
+    fn adjust_gas(&self, adjustment: GasAdjustment) -> Self;
+}
+
+impl GasAdjustable for Gas {
+    fn adjust_gas(&self, adjustment: GasAdjustment) -> Self {
+        if adjustment == 1.0 {
+            *self
+        } else {
+            let adjusted = (self.value() as f32 * adjustment).ceil();
+            (adjusted as u64).into()
+        }
+    }
+}
+
 // a workaround to provide serde implementation for tx::Fee. We don't want to ever expose any of those
 // types to the public and ideally they will get replaced by proper implementation inside comrs
 mod sealed {
@@ -15,19 +15,20 @@ use cosmrs::rpc::HttpClientUrl;
 use cosmrs::tx::Msg;
 use cosmwasm_std::Uint128;
 use execute::execute;
-pub use fee::gas_price::GasPrice;
 use mixnet_contract_common::mixnode::DelegationEvent;
 use mixnet_contract_common::{
-    ContractStateParams, Delegation, ExecuteMsg, Gateway, GatewayBond, GatewayOwnershipResponse,
-    IdentityKey, Interval, LayerDistribution, MixNode, MixNodeBond, MixOwnershipResponse,
-    MixnetContractVersion, MixnodeRewardingStatusResponse, PagedDelegatorDelegationsResponse,
-    PagedGatewayResponse, PagedMixDelegationsResponse, PagedMixnodeResponse,
-    PagedRewardedSetResponse, QueryMsg, RewardedSetUpdateDetails,
+    ContractStateParams, Delegation, ExecuteMsg, Gateway, GatewayBond, GatewayBondResponse,
+    GatewayOwnershipResponse, IdentityKey, Interval, LayerDistribution, MixNode, MixNodeBond,
+    MixOwnershipResponse, MixnetContractVersion, MixnodeBondResponse,
+    MixnodeRewardingStatusResponse, PagedDelegatorDelegationsResponse, PagedGatewayResponse,
+    PagedMixDelegationsResponse, PagedMixnodeResponse, PagedRewardedSetResponse, QueryMsg,
+    RewardedSetUpdateDetails,
 };
-use network_defaults::DEFAULT_NETWORK;
 use serde::Serialize;
 use std::convert::TryInto;
+use std::time::SystemTime;
 use vesting_contract_common::ExecuteMsg as VestingExecuteMsg;
+use vesting_contract_common::QueryMsg as VestingQueryMsg;

 pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
@@ -48,6 +49,8 @@ pub use cosmrs::tx::{self, Gas};
 pub use cosmrs::Coin as CosmosCoin;
 pub use cosmrs::{bip32, AccountId, Decimal, Denom};
 pub use cosmwasm_std::Coin as CosmWasmCoin;
+pub use fee::{gas_price::GasPrice, GasAdjustable, GasAdjustment};
+use network_defaults::{ChainDetails, NymNetworkDetails};
 pub use signing_client::Client as SigningNymdClient;
 pub use traits::{VestingQueryClient, VestingSigningClient};

@@ -58,67 +61,92 @@ pub mod fee;
 pub mod traits;
 pub mod wallet;

+#[derive(Debug, Clone)]
+pub struct Config {
+    pub(crate) chain_details: ChainDetails,
+
+    // I'd love to have used `NymContracts` struct directly here instead,
+    // however, I'd really prefer to use something more strongly typed (i.e. AccountId vs String)
+    pub(crate) mixnet_contract_address: Option<AccountId>,
+    pub(crate) vesting_contract_address: Option<AccountId>,
+    pub(crate) bandwidth_claim_contract_address: Option<AccountId>,
+    pub(crate) coconut_bandwidth_contract_address: Option<AccountId>,
+    pub(crate) multisig_contract_address: Option<AccountId>,
+    // TODO: add this in later commits
+    // pub(crate) gas_price: GasPrice,
+}
+
+impl Config {
+    fn parse_optional_account(
+        raw: Option<&String>,
+        expected_prefix: &str,
+    ) -> Result<Option<AccountId>, NymdError> {
+        if let Some(address) = raw {
+            let parsed: AccountId = address
+                .parse()
+                .map_err(|_| NymdError::MalformedAccountAddress(address.clone()))?;
+            if parsed.prefix() != expected_prefix {
+                Err(NymdError::UnexpectedBech32Prefix {
+                    got: parsed.prefix().into(),
+                    expected: expected_prefix.into(),
+                })
+            } else {
+                Ok(Some(parsed))
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn try_from_nym_network_details(details: &NymNetworkDetails) -> Result<Self, NymdError> {
+        let prefix = &details.chain_details.bech32_account_prefix;
+        Ok(Config {
+            chain_details: details.chain_details.clone(),
+            mixnet_contract_address: Self::parse_optional_account(
+                details.contracts.mixnet_contract_address.as_ref(),
+                prefix,
+            )?,
+            vesting_contract_address: Self::parse_optional_account(
+                details.contracts.vesting_contract_address.as_ref(),
+                prefix,
+            )?,
+            bandwidth_claim_contract_address: Self::parse_optional_account(
+                details.contracts.bandwidth_claim_contract_address.as_ref(),
+                prefix,
+            )?,
+            coconut_bandwidth_contract_address: Self::parse_optional_account(
+                details
+                    .contracts
+                    .coconut_bandwidth_contract_address
+                    .as_ref(),
+                prefix,
+            )?,
+            multisig_contract_address: Self::parse_optional_account(
+                details.contracts.multisig_contract_address.as_ref(),
+                prefix,
+            )?,
+        })
+    }
+}
+
 #[derive(Debug)]
 pub struct NymdClient<C> {
    client: C,
-    mixnet_contract_address: AccountId,
-    vesting_contract_address: AccountId,
-    bandwidth_claim_contract_address: AccountId,
-    coconut_bandwidth_contract_address: AccountId,
-    multisig_contract_address: AccountId,
+    config: Config,
    client_address: Option<Vec<AccountId>>,
    simulated_gas_multiplier: f32,
 }

-impl<C> NymdClient<C> {
-    pub fn with_mixnet_contract_address(mut self, address: AccountId) -> Self {
-        self.mixnet_contract_address = address;
-        self
-    }
-    pub fn with_vesting_contract_address(mut self, address: AccountId) -> Self {
-        self.vesting_contract_address = address;
-        self
-    }
-    pub fn with_bandwidth_claim_contract_address(mut self, address: AccountId) -> Self {
-        self.bandwidth_claim_contract_address = address;
-        self
-    }
-    pub fn with_coconut_bandwidth_contract_address(mut self, address: AccountId) -> Self {
-        self.coconut_bandwidth_contract_address = address;
-        self
-    }
-    pub fn with_multisig_contract_address(mut self, address: AccountId) -> Self {
-        self.multisig_contract_address = address;
-        self
-    }
-}
-
 impl NymdClient<QueryNymdClient> {
-    pub fn connect<U>(endpoint: U) -> Result<NymdClient<QueryNymdClient>, NymdError>
+    pub fn connect<U>(config: Config, endpoint: U) -> Result<NymdClient<QueryNymdClient>, NymdError>
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
        Ok(NymdClient {
            client: QueryNymdClient::new(endpoint)?,
+            config,
            client_address: None,
            simulated_gas_multiplier: DEFAULT_SIMULATED_GAS_MULTIPLIER,
-            mixnet_contract_address: DEFAULT_NETWORK
-                .mixnet_contract_address()
-                .parse()
-                .expect("Error parsing mixnet contract address"),
-            vesting_contract_address: DEFAULT_NETWORK
-                .vesting_contract_address()
-                .parse()
-                .expect("Error parsing vesting contract address"),
-            bandwidth_claim_contract_address: DEFAULT_NETWORK
-                .bandwidth_claim_contract_address()
-                .parse()
-                .expect("Error parsing bandwidth claim contract address"),
-            coconut_bandwidth_contract_address: DEFAULT_NETWORK
-                .coconut_bandwidth_contract_address()
-                .parse()
-                .unwrap(),
-            multisig_contract_address: DEFAULT_NETWORK.multisig_contract_address().parse().unwrap(),
        })
    }
 }
@@ -126,6 +154,7 @@ impl NymdClient<QueryNymdClient> {
 impl NymdClient<SigningNymdClient> {
    // maybe the wallet could be made into a generic, but for now, let's just have this one implementation
    pub fn connect_with_signer<U: Clone>(
+        config: Config,
        network: config::defaults::all::Network,
        endpoint: U,
        signer: DirectSecp256k1HdWallet,
@@ -134,40 +163,24 @@ impl NymdClient<SigningNymdClient> {
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
-        let denom = network.mix_denom().base;
+        let denom = network.base_mix_denom();
        let client_address = signer
            .try_derive_accounts()?
            .into_iter()
            .map(|account| account.address)
            .collect();
-        let gas_price = gas_price.unwrap_or(GasPrice::new_with_default_price(denom)?);
+        let gas_price = gas_price.unwrap_or(GasPrice::new_with_default_price(&denom)?);

        Ok(NymdClient {
            client: SigningNymdClient::connect_with_signer(endpoint, signer, gas_price)?,
+            config,
            client_address: Some(client_address),
            simulated_gas_multiplier: DEFAULT_SIMULATED_GAS_MULTIPLIER,
-            mixnet_contract_address: DEFAULT_NETWORK
-                .mixnet_contract_address()
-                .parse()
-                .expect("Error parsing mixnet contract address"),
-            vesting_contract_address: DEFAULT_NETWORK
-                .vesting_contract_address()
-                .parse()
-                .expect("Error parsing vesting contract address"),
-            bandwidth_claim_contract_address: DEFAULT_NETWORK
-                .bandwidth_claim_contract_address()
-                .parse()
-                .expect("Error parsing bandwidth claim contract address"),
-            coconut_bandwidth_contract_address: DEFAULT_NETWORK
-                .coconut_bandwidth_contract_address()
-                .parse()
-                .unwrap(),
-            multisig_contract_address: DEFAULT_NETWORK.multisig_contract_address().parse().unwrap(),
        })
    }

    pub fn connect_with_mnemonic<U: Clone>(
-        network: config::defaults::all::Network,
+        config: Config,
        endpoint: U,
        mnemonic: bip39::Mnemonic,
        gas_price: Option<GasPrice>,
@@ -175,8 +188,8 @@ impl NymdClient<SigningNymdClient> {
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
-        let prefix = network.bech32_prefix();
-        let denom = network.mix_denom().base;
+        let prefix = &config.chain_details.bech32_account_prefix;
+        let denom = &config.chain_details.mix_denom.base;
        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic)?;
        let client_address = wallet
            .try_derive_accounts()?
@@ -187,48 +200,82 @@ impl NymdClient<SigningNymdClient> {

        Ok(NymdClient {
            client: SigningNymdClient::connect_with_signer(endpoint, wallet, gas_price)?,
+            config,
            client_address: Some(client_address),
            simulated_gas_multiplier: DEFAULT_SIMULATED_GAS_MULTIPLIER,
-            mixnet_contract_address: network
-                .mixnet_contract_address()
-                .parse()
-                .expect("Error parsing mixnet contract address"),
-            vesting_contract_address: network
-                .vesting_contract_address()
-                .parse()
-                .expect("Error parsing vesting contract address"),
-            bandwidth_claim_contract_address: network
-                .bandwidth_claim_contract_address()
-                .parse()
-                .expect("Error parsing bandwidth claim contract address"),
-            coconut_bandwidth_contract_address: network
-                .coconut_bandwidth_contract_address()
-                .parse()
-                .unwrap(),
-            multisig_contract_address: network.multisig_contract_address().parse().unwrap(),
        })
    }
 }

 impl<C> NymdClient<C> {
+    pub fn current_config(&self) -> &Config {
+        &self.config
+    }
+
+    pub fn set_mixnet_contract_address(&mut self, address: AccountId) {
+        self.config.mixnet_contract_address = Some(address);
+    }
+
+    pub fn set_vesting_contract_address(&mut self, address: AccountId) {
+        self.config.vesting_contract_address = Some(address);
+    }
+
+    pub fn set_bandwidth_claim_contract_address(&mut self, address: AccountId) {
+        self.config.bandwidth_claim_contract_address = Some(address);
+    }
+
+    pub fn set_coconut_bandwidth_contract_address(&mut self, address: AccountId) {
+        self.config.coconut_bandwidth_contract_address = Some(address);
+    }
+
+    pub fn set_multisig_contract_address(&mut self, address: AccountId) {
+        self.config.multisig_contract_address = Some(address);
+    }
+
+    // TODO: this should get changed into Result<&AccountId, NymdError> (or Option<&AccountId> in future commits
+    // note: what unwrap is doing here is just moving a failure that would have normally
+    // occurred in `connect` when attempting to parse an empty address,
+    // so it's not introducing new source of failure (just moves it)
    pub fn mixnet_contract_address(&self) -> &AccountId {
-        &self.mixnet_contract_address
+        self.config.mixnet_contract_address.as_ref().unwrap()
    }

+    // TODO: this should get changed into Result<&AccountId, NymdError> (or Option<&AccountId> in future commits
+    // note: what unwrap is doing here is just moving a failure that would have normally
+    // occurred in `connect` when attempting to parse an empty address,
+    // so it's not introducing new source of failure (just moves it)
    pub fn vesting_contract_address(&self) -> &AccountId {
-        &self.vesting_contract_address
+        self.config.vesting_contract_address.as_ref().unwrap()
    }

+    // TODO: this should get changed into Result<&AccountId, NymdError> (or Option<&AccountId> in future commits
+    // note: what unwrap is doing here is just moving a failure that would have normally
+    // occurred in `connect` when attempting to parse an empty address,
+    // so it's not introducing new source of failure (just moves it)
    pub fn bandwidth_claim_contract_address(&self) -> &AccountId {
-        &self.bandwidth_claim_contract_address
+        self.config
+            .bandwidth_claim_contract_address
+            .as_ref()
+            .unwrap()
    }

+    // TODO: this should get changed into Result<&AccountId, NymdError> (or Option<&AccountId> in future commits
+    // note: what unwrap is doing here is just moving a failure that would have normally
+    // occurred in `connect` when attempting to parse an empty address,
+    // so it's not introducing new source of failure (just moves it)
    pub fn coconut_bandwidth_contract_address(&self) -> &AccountId {
-        &self.coconut_bandwidth_contract_address
+        self.config
+            .coconut_bandwidth_contract_address
+            .as_ref()
+            .unwrap()
    }

+    // TODO: this should get changed into Result<&AccountId, NymdError> (or Option<&AccountId> in future commits
+    // note: what unwrap is doing here is just moving a failure that would have normally
+    // occurred in `connect` when attempting to parse an empty address,
+    // so it's not introducing new source of failure (just moves it)
    pub fn multisig_contract_address(&self) -> &AccountId {
-        &self.multisig_contract_address
+        self.config.multisig_contract_address.as_ref().unwrap()
    }

    pub fn set_simulated_gas_multiplier(&mut self, multiplier: f32) {
@@ -268,6 +315,10 @@ impl<C> NymdClient<C> {
        self.client.gas_price()
    }

+    pub fn gas_adjustment(&self) -> GasAdjustment {
+        self.simulated_gas_multiplier
+    }
+
    pub async fn account_sequence(&self) -> Result<SequenceResponse, NymdError>
    where
        C: SigningCosmWasmClient + Sync,
@@ -380,6 +431,16 @@ impl<C> NymdClient<C> {
            .await
    }

+    pub async fn vesting_get_locked_pledge_cap(&self) -> Result<Uint128, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = VestingQueryMsg::GetLockedPledgeCap {};
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &request)
+            .await
+    }
+
    pub async fn get_delegator_rewards(
        &self,
        address: String,
@@ -426,6 +487,16 @@ impl<C> NymdClient<C> {
            .await
    }

+    pub async fn get_current_operator_cost(&self) -> Result<u64, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetCurrentOperatorCost {};
+        self.client
+            .query_contract_smart(self.mixnet_contract_address(), &request)
+            .await
+    }
+
    pub async fn get_mixnet_contract_version(&self) -> Result<MixnetContractVersion, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -595,6 +666,38 @@ impl<C> NymdClient<C> {
        Ok(response.gateway)
    }

+    /// Checks whether there is a bonded mixnode associated with the provided identity key
+    pub async fn get_mixnode_bond(
+        &self,
+        identity: IdentityKey,
+    ) -> Result<Option<MixNodeBond>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetMixnodeBond { identity };
+        let response: MixnodeBondResponse = self
+            .client
+            .query_contract_smart(self.mixnet_contract_address(), &request)
+            .await?;
+        Ok(response.mixnode)
+    }
+
+    /// Checks whether there is a bonded gateway associated with the provided identity key
+    pub async fn get_gateway_bond(
+        &self,
+        identity: IdentityKey,
+    ) -> Result<Option<GatewayBond>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = QueryMsg::GetGatewayBond { identity };
+        let response: GatewayBondResponse = self
+            .client
+            .query_contract_smart(self.mixnet_contract_address(), &request)
+            .await?;
+        Ok(response.gateway)
+    }
+
    pub async fn get_mixnodes_paged(
        &self,
        start_after: Option<IdentityKey>,
@@ -743,11 +846,54 @@ impl<C> NymdClient<C> {
            .await
    }

+    /// Grant a fee allowance from one address to another
+    pub async fn grant_allowance(
+        &self,
+        grantee: &AccountId,
+        spend_limit: Vec<Coin>,
+        expiration: Option<SystemTime>,
+        allowed_messages: Vec<String>,
+        memo: impl Into<String> + Send + 'static,
+        fee: Option<Fee>,
+    ) -> Result<TxResponse, NymdError>
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        self.client
+            .grant_allowance(
+                self.address(),
+                grantee,
+                spend_limit,
+                expiration,
+                allowed_messages,
+                fee,
+                memo,
+            )
+            .await
+    }
+
+    /// Revoke a fee allowance from one address to another
+    pub async fn revoke_allowance(
+        &self,
+        grantee: &AccountId,
+        memo: impl Into<String> + Send + 'static,
+        fee: Option<Fee>,
+    ) -> Result<TxResponse, NymdError>
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        self.client
+            .revoke_allowance(self.address(), grantee, fee, memo)
+            .await
+    }
+
    pub async fn execute<M>(
        &self,
        contract_address: &AccountId,
        msg: &M,
-        fee: Fee,
+        fee: Option<Fee>,
        memo: impl Into<String> + Send + 'static,
        funds: Vec<Coin>,
    ) -> Result<ExecuteResult, NymdError>
@@ -755,6 +901,7 @@ impl<C> NymdClient<C> {
        C: SigningCosmWasmClient + Sync,
        M: ?Sized + Serialize + Sync,
    {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        self.client
            .execute(self.address(), contract_address, msg, fee, memo, funds)
            .await
@@ -764,7 +911,7 @@ impl<C> NymdClient<C> {
        &self,
        contract_address: &AccountId,
        msgs: I,
-        fee: Fee,
+        fee: Option<Fee>,
        memo: impl Into<String> + Send + 'static,
    ) -> Result<ExecuteResult, NymdError>
    where
@@ -772,6 +919,7 @@ impl<C> NymdClient<C> {
        I: IntoIterator<Item = (M, Vec<Coin>)> + Send,
        M: Serialize,
    {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        self.client
            .execute_multiple(self.address(), contract_address, msgs, fee, memo)
            .await
@@ -860,6 +1008,29 @@ impl<C> NymdClient<C> {
            .await
    }

+    #[execute("mixnet")]
+    fn _compound_reward(
+        &self,
+        operator: Option<String>,
+        delegator: Option<String>,
+        mix_identity: Option<IdentityKey>,
+        proxy: Option<String>,
+        fee: Option<Fee>,
+    ) -> (ExecuteMsg, Option<Fee>)
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        (
+            ExecuteMsg::CompoundReward {
+                operator,
+                delegator,
+                mix_identity,
+                proxy,
+            },
+            fee,
+        )
+    }
+
    #[execute("mixnet")]
    fn _compound_operator_reward(&self, fee: Option<Fee>) -> (ExecuteMsg, Option<Fee>)
    where
@@ -949,6 +1120,18 @@ impl<C> NymdClient<C> {
        )
    }

+    #[execute("vesting")]
+    fn _vesting_update_locked_pledge_cap(
+        &self,
+        amount: Uint128,
+        fee: Option<Fee>,
+    ) -> (VestingExecuteMsg, Option<Fee>)
+    where
+        C: SigningCosmWasmClient + Sync,
+    {
+        (VestingExecuteMsg::UpdateLockedPledgeCap { amount }, fee)
+    }
+
    /// Announce a mixnode, paying a fee.
    pub async fn bond_mixnode(
        &self,
@@ -0,0 +1,33 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nymd::error::NymdError;
+use crate::nymd::{CosmWasmClient, NymdClient};
+
+use coconut_bandwidth_contract_common::msg::QueryMsg;
+use coconut_bandwidth_contract_common::spend_credential::SpendCredentialResponse;
+
+use async_trait::async_trait;
+
+#[async_trait]
+pub trait CoconutBandwidthQueryClient {
+    async fn get_spent_credential(
+        &self,
+        blinded_serial_number: String,
+    ) -> Result<SpendCredentialResponse, NymdError>;
+}
+
+#[async_trait]
+impl<C: CosmWasmClient + Sync + Send> CoconutBandwidthQueryClient for NymdClient<C> {
+    async fn get_spent_credential(
+        &self,
+        blinded_serial_number: String,
+    ) -> Result<SpendCredentialResponse, NymdError> {
+        let request = QueryMsg::GetSpentCredential {
+            blinded_serial_number,
+        };
+        self.client
+            .query_contract_smart(self.coconut_bandwidth_contract_address(), &request)
+            .await
+    }
+}
@@ -5,6 +5,7 @@ pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
 use crate::nymd::cosmwasm_client::types::ExecuteResult;
 use crate::nymd::error::NymdError;
 use crate::nymd::{Coin, Fee, NymdClient};
+use coconut_bandwidth_contract_common::spend_credential::SpendCredentialData;
 use coconut_bandwidth_contract_common::{deposit::DepositData, msg::ExecuteMsg};

 use async_trait::async_trait;
@@ -19,6 +20,13 @@ pub trait CoconutBandwidthSigningClient {
        encryption_key: String,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;
+    async fn spend_credential(
+        &self,
+        funds: Coin,
+        blinded_serial_number: String,
+        gateway_cosmos_address: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;
 }

 #[async_trait]
@@ -46,4 +54,30 @@ impl<C: SigningCosmWasmClient + Sync + Send> CoconutBandwidthSigningClient for N
            )
            .await
    }
+    async fn spend_credential(
+        &self,
+        funds: Coin,
+        blinded_serial_number: String,
+        gateway_cosmos_address: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let req = ExecuteMsg::SpendCredential {
+            data: SpendCredentialData::new(
+                funds.into(),
+                blinded_serial_number,
+                gateway_cosmos_address,
+            ),
+        };
+        self.client
+            .execute(
+                self.address(),
+                self.coconut_bandwidth_contract_address(),
+                &req,
+                fee,
+                "CoconutBandwidth::SpendCredential",
+                vec![],
+            )
+            .await
+    }
 }
@@ -1,14 +1,16 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+mod coconut_bandwidth_query_client;
 mod coconut_bandwidth_signing_client;
 mod multisig_query_client;
 mod multisig_signing_client;
 mod vesting_query_client;
 mod vesting_signing_client;

+pub use coconut_bandwidth_query_client::CoconutBandwidthQueryClient;
 pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
-pub use multisig_query_client::QueryClient;
+pub use multisig_query_client::MultisigQueryClient;
 pub use multisig_signing_client::MultisigSigningClient;
 pub use vesting_query_client::VestingQueryClient;
 pub use vesting_signing_client::VestingSigningClient;
@@ -9,12 +9,12 @@ use multisig_contract_common::msg::{ProposalResponse, QueryMsg};
 use async_trait::async_trait;

 #[async_trait]
-pub trait QueryClient {
+pub trait MultisigQueryClient {
    async fn get_proposal(&self, proposal_id: u64) -> Result<ProposalResponse, NymdError>;
 }

 #[async_trait]
-impl<C: CosmWasmClient + Sync + Send> QueryClient for NymdClient<C> {
+impl<C: CosmWasmClient + Sync + Send> MultisigQueryClient for NymdClient<C> {
    async fn get_proposal(&self, proposal_id: u64) -> Result<ProposalResponse, NymdError> {
        let request = QueryMsg::Proposal { proposal_id };
        self.client
--- a/Show More
+++ b/Show More
@@ -1 +1 @@
 .0.1