adding line break

Merge branch 'develop' into 308-figma-diff-pass
some cleaning
2022-09-12 17:42:25 +02:00 · 2022-09-12 17:41:14 +02:00 · 2022-09-12 17:39:03 +02:00 · 2022-09-12 17:35:39 +02:00 · 2022-09-12 12:32:10 +02:00 · 2022-09-12 10:38:48 +02:00
513 changed files with 28032 additions and 5032 deletions
@@ -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
@@ -1,6 +1,7 @@
 name: CI for Network Explorer

 on:
+  workflow_dispatch:
  push:
    paths:
      - 'explorer/**'
@@ -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/"
@@ -44,6 +44,12 @@ jobs:
          command: build
          args: --workspace

+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
      - name: Run all tests
        uses: actions-rs/cargo@v1
        with:
@@ -0,0 +1,26 @@
+name: Nightly builds on dispatch
+
+on: workflow_dispatch
+jobs:
+  notification:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - name: Keybase - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Keybase - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: nightly
+          NYM_PROJECT_NAME: "Notification test"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "ci-nightly"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -0,0 +1,50 @@
+name: Publish Nym CLI binaries
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet
+
+jobs:
+  publish-nym-cli:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest, windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-cli-`
+        if: startsWith(github.ref, 'refs/tags/nym-cli-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-cli-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build binary
+        run: make build-nym-cli
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-cli-${{ matrix.platform }}
+          path: |
+            target/release/nym-cli*
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            target/release/nym-cli
@@ -1,5 +1,7 @@
 name: Publish Nym binaries
+
 on:
+  workflow_dispatch:
  release:
    types: [created]
    
@@ -18,7 +20,7 @@ jobs:
      - uses: actions/checkout@v3

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

+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: my-artifact
+          path: |
+            target/release/nym-client
+            target/release/nym-gateway
+            target/release/nym-mixnode
+            target/release/nym-socks5-client
+            target/release/nym-validator-api
+            target/release/nym-network-requester
+            target/release/nym-network-statistics
+            target/release/nym-cli
+          retention-days: 30
+
      - name: Upload to release based on tag name
        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
        with:
          files: |
            target/release/nym-client
@@ -45,3 +63,5 @@ jobs:
            target/release/nym-socks5-client
            target/release/nym-validator-api
            target/release/nym-network-requester
+            target/release/nym-network-statistics
+            target/release/nym-cli
@@ -2,16 +2,29 @@

 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]
+### Added
+
+- nym-cli: added CLI tool for interacting with the Nyx blockchain and Nym mixnet smart contracts ([#1577])
+- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
+
+### Changed
+
+- validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
+- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
+
+[#1541]: https://github.com/nymtech/nym/pull/1541
+[#1558]: https://github.com/nymtech/nym/pull/1558
+[#1577]: https://github.com/nymtech/nym/pull/1577
+[#1591]: https://github.com/nymtech/nym/pull/1591
+
+
+## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)

 ### Added

 - socks5 client/websocket client: add `--force-register-gateway` flag, useful when rerunning init ([#1353])
- nym-connect: initial proof-of-concept of a UI around the socks5 client was added
- nym-connect: add ability to select network requester and gateway ([#1427])
- nym-connect: add ability to export gateway keys as JSON
- nym-connect: add auto updater
 - 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
@@ -23,10 +36,14 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - validator-api: add Swagger to document the REST API ([#1249]).
 - validator-api: Added new endpoints for coconut spending flow and communications with coconut & multisig contracts ([#1261])
 - validator-api: add `uptime`, `estimated_operator_apy`, `estimated_delegators_apy` to `/mixnodes/detailed` endpoint ([#1393])
+- validator-api: add node info cache storing simulated active set inclusion probabilities
 - network-statistics: a new mixnet service that aggregates and exposes anonymized data about mixnet services ([#1328])
 - mixnode: Added basic mixnode hardware reporting to the HTTP API ([#1308]).
 - validator-api: endpoint, in coconut mode, for returning the validator-api cosmos address ([#1404]).
 - validator-client: add `denom` argument and add simple test for querying an account balance
+- gateway, validator-api: Checks for coconut credential double spending attempts, taking the coconut bandwidth contract as source of truth ([#1457])
+- coconut-bandwidth-contract: Record the state of a coconut credential; create specific proposal for releasing funds ([#1457])
+- inclusion-probability: add simulator for active set inclusion probability

 ### Fixed

@@ -37,10 +54,12 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - native & socks5 clients: rerun init will now reuse previous gateway configuration instead of failing ([#1353])
 - native & socks5 clients: deduplicate big chunks of init logic
 - validator: fixed local docker-compose setup to work on Apple M1 ([#1329])
+- explorer-api: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service ([#1482]).
+- network-requester: fix filter for suffix-only domains ([#1487])
+- validator-api: listen out for SIGTERM and SIGQUIT too, making it play nicely as a system service; cleaner shutdown, without panics ([#1496], [#1573]).

 ### Changed

- nym-connect: reuse config id instead of creating a new id on each connection
 - 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`.
@@ -49,6 +68,13 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - gateway & mixnode: move detailed build info back to `--version` from `--help`.
 - socks5 client/websocket client: upgrade to latest clap and switched to declarative commandline parsing.
 - validator-api: fee payment for multisig operations comes from the gateway account instead of the validator APIs' accounts ([#1419])
+- multisig-contract: Limit the proposal creating functionality to one address (coconut-bandwidth-contract address) ([#1457])
+- All binaries and cosmwasm blobs are configured at runtime now; binaries are configured using environment variables or .env files and contracts keep the configuration parameters in storage ([#1463])
+- gateway, network-statistics: include gateway id in the sent statistical data ([#1478])
+- network explorer: tweak how active set probability is shown ([#1503])
+- validator-api: rewarder set update fails without panicking on possible nymd queries ([#1520])
+- network-requester, socks5 client (nym-connect): send and receive respectively a message error to be displayed about filter check failure ([#1576]) 
+

 [#1249]: https://github.com/nymtech/nym/pull/1249
 [#1256]: https://github.com/nymtech/nym/pull/1256
@@ -69,76 +95,16 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1393]: https://github.com/nymtech/nym/pull/1393
 [#1404]: https://github.com/nymtech/nym/pull/1404
 [#1419]: https://github.com/nymtech/nym/pull/1419
-[#1427]: https://github.com/nymtech/nym/pull/1427
-
-## [nym-wallet-v1.0.7](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.7) (2022-07-11)
-
- wallet: dark mode
- wallet: when simulating gas costs, an automatic adjustment is being used ([#1388]).
-
-[#1388]: https://github.com/nymtech/nym/pull/1388
-
-## [nym-contracts-v1.0.1](https://github.com/nymtech/nym/tree/nym-contracts-v1.0.1) (2022-06-22)
-
-### Added
-
- mixnet-contract: Added ClaimOperatorReward and ClaimDelegatorReward messages ([#1292])
- mixnet-contract: Replace all naked `-` with `saturating_sub`.
- mixnet-contract: Added staking_supply field to ContractStateParams.
- mixnet-contract: Added a query to get MixnodeBond by identity key ([#1369]).
- mixnet-contract: Added a query to get GatewayBond by identity key ([#1369]).
- vesting-contract: Added ClaimOperatorReward and ClaimDelegatorReward messages ([#1292])
- vesting-contract: Added limit to the amount of tokens one can pledge ([#1331])
-
-### 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])
- mixnet-contract: Using correct staking supply when distributing rewards. ([#1373])
- vesting-contract: replaced `checked_sub` with `saturating_sub` to fix the underflow in `get_vesting_tokens` ([#1275])
-
-
-[#1255]: https://github.com/nymtech/nym/pull/1255
-[#1257]: https://github.com/nymtech/nym/pull/1257
-[#1258]: https://github.com/nymtech/nym/pull/1258
-[#1275]: https://github.com/nymtech/nym/pull/1275
-[#1284]: https://github.com/nymtech/nym/pull/1284
-[#1292]: https://github.com/nymtech/nym/pull/1292
-[#1331]: https://github.com/nymtech/nym/pull/1331
-[#1369]: https://github.com/nymtech/nym/pull/1369
-[#1373]: https://github.com/nymtech/nym/pull/1373
-
-## [nym-wallet-v1.0.6](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.6) (2022-06-21)
-
- wallet: undelegating now uses either the mixnet or vesting contract, or both, depending on how delegations were made
- wallet: redeeming and compounding now uses both the mixnet and vesting contract
- wallet: the wallet backend learned how to archive wallet files
- wallet: add ENABLE_QA_MODE environment variable to enable QA mode on built wallet
-
-## [nym-wallet-v1.0.5](https://github.com/nymtech/nym/tree/nym-wallet-v1.0.5) (2022-06-14)
-
- 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.
- wallet: new delegation and rewards UI
- wallet: show version in nav bar
- wallet: contract admin route put back
- wallet: staking_supply field to StateParams
- wallet: show transaction hash for redeeming or compounding rewards
-
-[#1265]: https://github.com/nymtech/nym/pull/1265
-[#1302]: https://github.com/nymtech/nym/pull/1302
-
-## [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])
+[#1457]: https://github.com/nymtech/nym/pull/1457
+[#1463]: https://github.com/nymtech/nym/pull/1463
+[#1478]: https://github.com/nymtech/nym/pull/1478
+[#1482]: https://github.com/nymtech/nym/pull/1482
+[#1487]: https://github.com/nymtech/nym/pull/1487
+[#1496]: https://github.com/nymtech/nym/pull/1496
+[#1503]: https://github.com/nymtech/nym/pull/1503
+[#1520]: https://github.com/nymtech/nym/pull/1520
+[#1573]: https://github.com/nymtech/nym/pull/1573
+[#1576]: https://github.com/nymtech/nym/pull/1576

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

@@ -171,77 +137,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)
@@ -320,108 +219,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,24 @@ members = [
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
+    "common/bandwidth-claim-contract",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
-    "common/credential-storage",
    "common/coconut-interface",
+    "common/commands",
    "common/config",
-    "common/credentials",
-    "common/crypto",
-    "common/crypto/dkg",
-    "common/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 +55,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",
@@ -68,6 +70,7 @@ members = [
    "service-providers/network-statistics",
    "validator-api",
    "validator-api/validator-api-requests",
+    "tools/nym-cli",
    "tools/ts-rs-cli"
 ]

@@ -76,6 +79,7 @@ default-members = [
    "clients/socks5",
    "gateway",
    "service-providers/network-requester",
+    "service-providers/network-statistics",
    "mixnode",
    "validator-api",
    "explorer-api",
@@ -1,5 +1,5 @@
+test: clippy-all cargo-test wasm fmt
 test-all: test cargo-test-expensive
-test: build clippy-all cargo-test wasm fmt
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
 clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet clippy-all-connect
@@ -69,6 +69,9 @@ build-wallet:
 build-connect:
 	cargo build --manifest-path nym-connect/Cargo.toml --workspace

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

@@ -14,6 +14,7 @@ log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 sled = "0.34"
+thiserror = "1.0.34"
 tokio = { version = "1.19.1", features = ["macros"] }
 url = { version ="2.2", features = ["serde"] }

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

 [dev-dependencies]
 tempfile = "3.1.0"
@@ -13,6 +13,7 @@ use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
+use task::ShutdownListener;
 use tokio::task::JoinHandle;
 use tokio::time;

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

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

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

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

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

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

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

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

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

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

    pub fn start(mut self) -> JoinHandle<()> {
@@ -1,3 +1,5 @@
+use std::sync::atomic::AtomicBool;
+
 pub mod cover_traffic_stream;
 pub mod inbound_messages;
 pub mod key_manager;
@@ -6,3 +8,10 @@ pub mod real_messages_control;
 pub mod received_buffer;
 pub mod reply_key_storage;
 pub mod topology_control;
+
+// This is *NOT* used to signal shutdown.
+// It's critical that we don't have any tasks finishing early, this is an additional safety check
+// that tasks exiting are doing so because shutdown has been signalled, and no other reason.
+// In particular for tasks that rely on their associated channel being closed to signal shutdown,
+// and don't have access to a shutdown listener channel.
+pub static SHUTDOWN_HAS_BEEN_SIGNALLED: AtomicBool = AtomicBool::new(false);
@@ -10,6 +10,7 @@ use nymsphinx::{
    chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
 };
 use std::sync::Arc;
+use task::ShutdownListener;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-use config::defaults::*;
 use config::NymConfig;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
@@ -366,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(),
@@ -0,0 +1,27 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crypto::asymmetric::identity::Ed25519RecoveryError;
+use gateway_client::error::GatewayClientError;
+use validator_client::ValidatorClientError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum ClientCoreError {
+    #[error("I/O error: {0}")]
+    IoError(#[from] std::io::Error),
+    #[error("Gateway client error: {0}")]
+    GatewayClientError(#[from] GatewayClientError),
+    #[error("Ed25519 error: {0}")]
+    Ed25519RecoveryError(#[from] Ed25519RecoveryError),
+    #[error("Validator client error: {0}")]
+    ValidatorClientError(#[from] ValidatorClientError),
+
+    #[error("No gateway with id: {0}")]
+    NoGatewayWithId(String),
+    #[error("No gateways on network")]
+    NoGatewaysOnNetwork,
+    #[error("List of validator apis is empty")]
+    ListOfValidatorApisIsEmpty,
+    #[error("Could not load existing gateway configuration: {0}")]
+    CouldNotLoadExistingGatewayConfiguration(std::io::Error),
+}
@@ -14,25 +14,27 @@ use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::rngs::OsRng;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
+use tap::TapFallible;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;

 use crate::{
    client::key_manager::KeyManager,
    config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
+    error::ClientCoreError,
 };

 pub async fn query_gateway_details(
    validator_servers: Vec<Url>,
    chosen_gateway_id: Option<&str>,
-) -> gateway::Node {
+) -> Result<gateway::Node, ClientCoreError> {
    let validator_api = validator_servers
        .choose(&mut thread_rng())
-        .expect("The list of validator apis is empty");
+        .ok_or(ClientCoreError::ListOfValidatorApisIsEmpty)?;
    let validator_client = validator_client::ApiClient::new(validator_api.clone());

    log::trace!("Fetching list of gateways from: {}", validator_api);
-    let gateways = validator_client.get_cached_gateways().await.unwrap();
+    let gateways = validator_client.get_cached_gateways().await?;
    let valid_gateways = gateways
        .into_iter()
        .filter_map(|gateway| gateway.try_into().ok())
@@ -47,38 +49,40 @@ pub async fn query_gateway_details(
        filtered_gateways
            .iter()
            .find(|gateway| gateway.identity_key.to_base58_string() == gateway_id)
-            .expect(&*format!("no gateway with id {} exists!", gateway_id))
-            .clone()
+            .ok_or_else(|| ClientCoreError::NoGatewayWithId(gateway_id.to_string()))
+            .cloned()
    } else {
        filtered_gateways
            .choose(&mut rand::thread_rng())
-            .expect("there are no gateways on the network!")
-            .clone()
+            .ok_or(ClientCoreError::NoGatewaysOnNetwork)
+            .cloned()
    }
 }

 pub async fn register_with_gateway_and_store_keys<T>(
    gateway_details: gateway::Node,
    config: &Config<T>,
-) where
+) -> Result<(), ClientCoreError>
+where
    T: NymConfig,
 {
    let mut rng = OsRng;
    let mut key_manager = KeyManager::new(&mut rng);

-    let shared_keys = register_with_gateway(&gateway_details, key_manager.identity_keypair()).await;
+    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
+    Ok(key_manager
        .store_keys(&pathfinder)
-        .expect("Failed to generated keys");
+        .tap_err(|err| log::error!("Failed to generate keys: {err}"))?)
 }

 async fn register_with_gateway(
    gateway: &gateway::Node,
    our_identity: Arc<identity::KeyPair>,
-) -> Arc<SharedKeys> {
+) -> Result<Arc<SharedKeys>, ClientCoreError> {
    let timeout = Duration::from_millis(1500);
    let mut gateway_client = GatewayClient::new_init(
        gateway.clients_address(),
@@ -86,52 +90,59 @@ async fn register_with_gateway(
        gateway.owner.clone(),
        our_identity.clone(),
        timeout,
+        None,
    );
    gateway_client
        .establish_connection()
        .await
-        .expect("failed to establish connection with the gateway!");
-    gateway_client
+        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
+    let shared_keys = gateway_client
        .perform_initial_authentication()
        .await
-        .expect("failed to register with the gateway!")
+        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
+    Ok(shared_keys)
 }

-pub fn show_address<T>(config: &Config<T>)
+pub fn show_address<T>(config: &Config<T>) -> Result<(), ClientCoreError>
 where
    T: config::NymConfig,
 {
-    fn load_identity_keys(pathfinder: &ClientKeyPathfinder) -> identity::KeyPair {
+    fn load_identity_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<identity::KeyPair, ClientCoreError> {
        let identity_keypair: identity::KeyPair =
            pemstore::load_keypair(&pemstore::KeyPairPath::new(
                pathfinder.private_identity_key().to_owned(),
                pathfinder.public_identity_key().to_owned(),
            ))
-            .expect("Failed to read stored identity key files");
-        identity_keypair
+            .tap_err(|_| log::error!("Failed to read stored identity key files"))?;
+        Ok(identity_keypair)
    }

-    fn load_sphinx_keys(pathfinder: &ClientKeyPathfinder) -> encryption::KeyPair {
+    fn load_sphinx_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<encryption::KeyPair, ClientCoreError> {
        let sphinx_keypair: encryption::KeyPair =
            pemstore::load_keypair(&pemstore::KeyPairPath::new(
                pathfinder.private_encryption_key().to_owned(),
                pathfinder.public_encryption_key().to_owned(),
            ))
-            .expect("Failed to read stored sphinx key files");
-        sphinx_keypair
+            .tap_err(|_| log::error!("Failed to read stored sphinx key files"))?;
+        Ok(sphinx_keypair)
    }

    let pathfinder = ClientKeyPathfinder::new_from_config(config);
-    let identity_keypair = load_identity_keys(&pathfinder);
-    let sphinx_keypair = load_sphinx_keys(&pathfinder);
+    let 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(),
+        NodeIdentity::from_base58_string(config.get_gateway_id())?,
    );

    println!("\nThe address of this client is: {}", client_recipient);
+    Ok(())
 }
@@ -1,3 +1,4 @@
 pub mod client;
 pub mod config;
+pub mod error;
 pub mod init;
@@ -18,6 +18,7 @@ url = "2.2"
 tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime

 coconut-interface = { path = "../../common/coconut-interface" }
+config = { path = "../../common/config" }
 credentials = { path = "../../common/credentials" }
 credential-storage = { path = "../../common/credential-storage" }
 crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
@@ -2,9 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::Result;
-use crate::{MNEMONIC, NYMD_URL};
 use bip39::Mnemonic;
-use network_defaults::{DEFAULT_NETWORK, MIX_DENOM, VOUCHER_INFO};
+use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
 use std::str::FromStr;
 use url::Url;
 use validator_client::nymd;
@@ -13,18 +12,23 @@ 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 config = nymd::Config::try_from_nym_network_details(&DEFAULT_NETWORK.details())
+    pub fn new(nymd_url: &str, mnemonic: &str) -> Self {
+        let nymd_url = Url::from_str(nymd_url).unwrap();
+        let mnemonic = Mnemonic::from_str(mnemonic).unwrap();
+        let network_details = NymNetworkDetails::new_from_env();
+        let config = nymd::Config::try_from_nym_network_details(&network_details)
            .expect("failed to construct valid validator client config with the provided network");
        let nymd_client =
            NymdClient::connect_with_mnemonic(config, nymd_url.as_ref(), mnemonic, None).unwrap();

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

    pub async fn deposit(
@@ -34,7 +38,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(
@@ -6,7 +6,6 @@ use clap::{Args, Subcommand};
 use pickledb::PickleDb;
 use rand::rngs::OsRng;
 use std::str::FromStr;
-use url::Url;

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

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

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

-        let client = Client::new();
+        let client = Client::new(&self.nymd_url, &self.mnemonic);
        let tx_hash = client
            .deposit(
                self.amount,
@@ -96,6 +100,10 @@ pub(crate) struct GetCredential {
    /// The hash of a successful deposit transaction
    #[clap(long)]
    tx_hash: String,
+    /// The URLs to the validator-api endpoints the are run as coconut signer authorities, separated
+    /// by comma (,)
+    #[clap(long)]
+    signer_authorities: String,
    /// If we want to get the signature without attaching a blind sign request; it is expected that
    /// there is already a signature stored on the signer
    #[clap(long, parse(from_flag))]
@@ -108,7 +116,8 @@ impl Execute for GetCredential {
        let mut state = db
            .get::<State>(&self.tx_hash)
            .ok_or(CredentialClientError::NoDeposit)?;
-        let urls = SIGNER_AUTHORITIES.map(|addr| Url::from_str(addr).unwrap());
+
+        let urls = config::parse_validators(&self.signer_authorities);

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

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

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

-        pub const MNEMONIC: &str = "jazz fatigue diagram account outer wrist slide cherry mother grid network pause wolf pig round answer mail junior better hair dismiss toward access end";
-        pub const NYMD_URL: &str = "http://127.0.0.1:26657";
-        pub const CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
-        pub const SIGNER_AUTHORITIES: [&str; 1] = [
-            "http://127.0.0.1:8080",
-        ];
-
        #[derive(Parser)]
        #[clap(author = "Nymtech", version, about)]
        struct Cli {
+            /// Path pointing to an env file that configures the client.
+            #[clap(long)]
+            pub(crate) config_env_file: Option<std::path::PathBuf>,
+
+            /// Path where the sqlite credental database will be located.
+            /// It should point to a $HOME/$CLIENT_ID/data/db.sqlite file of
+            /// the client that is supposed to use the credential.
+            #[clap(long)]
+            pub(crate) credential_db_path: std::path::PathBuf,
+
            #[clap(subcommand)]
            command: Commands,
        }
@@ -32,8 +36,9 @@ cfg_if::cfg_if! {
        #[tokio::main]
        async fn main() -> Result<()> {
            let args = Cli::parse();
+            setup_env(args.config_env_file.clone());

-            let shared_storage = credential_storage::initialise_storage(std::path::PathBuf::from("/tmp/credential.db")).await;
+            let shared_storage = credential_storage::initialise_storage(args.credential_db_path.clone()).await;
            let mut db = match PickleDb::load(
                "credential.db",
                PickleDbDumpPolicy::AutoDump,
@@ -1,6 +1,6 @@
 [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"
@@ -22,7 +22,6 @@ url = "2.2"

 clap = { version = "3.2.8", features = ["cargo", "derive"] }
 dirs = "4.0"
-dotenv = "0.15.0" # for obtaining environmental variables (only used for RUST_LOG for time being)
 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
@@ -34,19 +33,20 @@ tokio-tungstenite = "0.14" # websocket
 ## internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
+network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
+task = { path = "../../common/task" }
 topology = { path = "../../common/topology" }
-websocket-requests = { path = "websocket-requests" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
-network-defaults = { path = "../../common/network-defaults" }
+websocket-requests = { path = "websocket-requests" }

 [features]
 coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut", "client-core/coconut"]
@@ -50,6 +50,10 @@ impl NymConfig for Config {
            .join("clients")
    }

+    fn try_default_root_directory() -> Option<PathBuf> {
+        dirs::home_dir().map(|path| path.join(".nym").join("clients"))
+    }
+
    fn root_directory(&self) -> PathBuf {
        self.base.get_nym_root_directory()
    }
@@ -32,6 +32,7 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
    }
 }
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::Args;
-use client_core::config::GatewayEndpoint;
+use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;

 use crate::{
@@ -46,10 +46,9 @@ pub(crate) struct Init {
    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"])]
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
    enabled_credentials_mode: bool,

    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
@@ -79,7 +78,7 @@ impl From<Init> for OverrideConfig {
            port: init_config.port,
            fastmode: init_config.fastmode,

-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
            enabled_credentials_mode: init_config.enabled_credentials_mode,

            #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -121,7 +120,12 @@ pub(crate) async fn execute(args: &Init) {
    let override_config_fields = OverrideConfig::from(args.clone());
    config = override_config(config, override_config_fields);

-    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config).await;
+    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config)
+        .await
+        .unwrap_or_else(|err| {
+            eprintln!("Failed to setup gateway\nError: {err}");
+            std::process::exit(1)
+        });
    config.get_base_mut().with_gateway_endpoint(gateway);

    let config_save_location = config.get_config_file_save_location();
@@ -139,7 +143,10 @@ pub(crate) async fn execute(args: &Init) {
    );
    println!("Client configuration completed.");

-    client_core::init::show_address(config.get_base());
+    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
+        eprintln!("Failed to show address\nError: {err}");
+        std::process::exit(1)
+    });
 }

 async fn setup_gateway(
@@ -147,7 +154,7 @@ async fn setup_gateway(
    register: bool,
    user_chosen_gateway_id: Option<&str>,
    config: &Config,
-) -> GatewayEndpoint {
+) -> Result<GatewayEndpoint, ClientCoreError> {
    if register {
        // Get the gateway details by querying the validator-api. Either pick one at random or use
        // the chosen one if it's among the available ones.
@@ -156,16 +163,16 @@ async fn setup_gateway(
            config.get_base().get_validator_api_endpoints(),
            user_chosen_gateway_id,
        )
-        .await;
+        .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;
+            .await?;
        println!("Saved all generated keys");

-        gateway.into()
+        Ok(gateway.into())
    } else if user_chosen_gateway_id.is_some() {
        // Just set the config, don't register or create any keys
        // This assumes that the user knows what they are doing, and that the existing keys are
@@ -175,22 +182,22 @@ async fn setup_gateway(
            config.get_base().get_validator_api_endpoints(),
            user_chosen_gateway_id,
        )
-        .await;
+        .await?;
        log::debug!("Querying gateway gives: {}", gateway);
-        gateway.into()
+        Ok(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."
-                )
-            }
-        }
+        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })?;
+
+        Ok(existing_config.get_base().get_gateway_endpoint().clone())
    }
 }
@@ -3,8 +3,6 @@

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

 #[cfg(not(feature = "coconut"))]
 pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
@@ -28,7 +26,6 @@ fn long_version() -> String {
 {:<20}{}
 {:<20}{}
 {:<20}{}
-{:<20}{}
 "#,
        "Build Timestamp:",
        env!("VERGEN_BUILD_TIMESTAMP"),
@@ -46,8 +43,6 @@ fn long_version() -> String {
        env!("VERGEN_RUSTC_CHANNEL"),
        "cargo Profile:",
        env!("VERGEN_CARGO_PROFILE"),
-        "Network:",
-        DEFAULT_NETWORK
    )
 }

@@ -58,6 +53,10 @@ fn long_version_static() -> &'static 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,
 }
@@ -79,7 +78,7 @@ pub(crate) struct OverrideConfig {
    port: Option<u16>,
    fastmode: bool,

-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    enabled_credentials_mode: bool,

    #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -97,22 +96,17 @@ pub(crate) async fn execute(args: &Cli) {
    }
 }

-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()
-}
-
 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 args.disable_socket {
@@ -132,12 +126,15 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
            .get_base_mut()
            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
    }
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    {
        if args.enabled_credentials_mode {
            config.get_base_mut().with_disabled_credentials(false)
        }
+    }
+
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    {
        if let Some(eth_endpoint) = args.eth_endpoint {
            config.get_base_mut().with_eth_endpoint(eth_endpoint);
        }
@@ -35,10 +35,9 @@ pub(crate) struct Run {
    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"])]
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
    enabled_credentials_mode: bool,

    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
@@ -62,7 +61,7 @@ impl From<Run> for OverrideConfig {
            port: run_config.port,
            fastmode: false,

-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
            enabled_credentials_mode: run_config.enabled_credentials_mode,

            #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -82,7 +81,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
@@ -3,7 +3,7 @@

 use crate::client::config::{Config, MISSING_VALUE};

-use config::{defaults::default_api_endpoints, NymConfig};
+use config::NymConfig;
 use version_checker::Version;

 use clap::Args;
@@ -105,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());
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::{crate_version, Parser};
+use network_defaults::setup_env;

 pub mod client;
 pub mod commands;
@@ -9,11 +10,11 @@ pub mod websocket;

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

    let args = commands::Cli::parse();
+    setup_env(args.config_env_file.clone());
    commands::execute(&args).await;
 }

@@ -1,6 +1,6 @@
 [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"
@@ -13,7 +13,6 @@ path = "src/lib.rs"
 [dependencies]
 clap = { version = "3.2.8", features = ["cargo", "derive"] }
 dirs = "4.0"
-dotenv = "0.15.0"
 futures = "0.3"
 log = "0.4"
 pin-project = "1.0"
@@ -27,21 +26,22 @@ url = "2.2"
 # internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
+network-defaults = { path = "../../common/network-defaults" }
 nymsphinx = { path = "../../common/nymsphinx" }
 ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
-socks5-requests = { path = "../../common/socks5/requests" }
-topology = { path = "../../common/topology" }
 pemstore = { path = "../../common/pemstore" }
 proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
+socks5-requests = { path = "../../common/socks5/requests" }
+task = { path = "../../common/task" }
+topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
-network-defaults = { path = "../../common/network-defaults" }

 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut", "client-core/coconut"]
@@ -33,6 +33,10 @@ impl NymConfig for Config {
            .join("socks5-clients")
    }

+    fn try_default_root_directory() -> Option<PathBuf> {
+        dirs::home_dir().map(|path| path.join(".nym").join("socks5-clients"))
+    }
+
    fn root_directory(&self) -> PathBuf {
        self.base.get_nym_root_directory()
    }
@@ -1,6 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use std::sync::atomic::Ordering;
+
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
@@ -29,6 +31,7 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

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

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

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

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

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

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

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

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

-        println!(
-            "Received SIGINT - the client will terminate now (threads are not yet nicely stopped, if you see stack traces that's alright)."
-        );
+        log::info!("Sending shutdown");
+        client_core::client::SHUTDOWN_HAS_BEEN_SIGNALLED.store(true, Ordering::Relaxed);
+        shutdown.signal_shutdown().ok();
+
+        log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
+        shutdown.wait_for_shutdown().await;
+
+        log::info!("Stopping nym-socks5-client");
    }

    // Variant of `run_forever` that listends for remote control messages
    pub async fn run_and_listen(&mut self, mut receiver: Socks5ControlMessageReceiver) {
-        self.start().await;
+        let mut shutdown = 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");
+                        log::info!("Received stop message");
+                    }
+                    None => {
+                        log::info!("Channel closed, stopping");
                    }
-                    None => log::debug!("None"),
                }
            }
+            _ = tokio::signal::ctrl_c() => {
+                log::info!("Received SIGINT");
+            },
        }
+
+        log::info!("Sending shutdown");
+        client_core::client::SHUTDOWN_HAS_BEEN_SIGNALLED.store(true, Ordering::Relaxed);
+        shutdown.signal_shutdown().ok();
+
+        log::info!("Waiting for tasks to finish... (Press ctrl-c to force)");
+        shutdown.wait_for_shutdown().await;
+
+        log::info!("Stopping nym-socks5-client");
    }

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

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

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

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

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

        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
    }
 }
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::Args;
-use client_core::config::GatewayEndpoint;
+use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;

 use crate::{
@@ -46,10 +46,9 @@ pub(crate) struct Init {
    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"])]
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
    enabled_credentials_mode: bool,

    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
@@ -78,7 +77,7 @@ impl From<Init> for OverrideConfig {
            port: init_config.port,
            fastmode: init_config.fastmode,

-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
            enabled_credentials_mode: init_config.enabled_credentials_mode,

            #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -121,7 +120,12 @@ pub(crate) async fn execute(args: &Init) {
    let override_config_fields = OverrideConfig::from(args.clone());
    config = override_config(config, override_config_fields);

-    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config).await;
+    let gateway = setup_gateway(id, register_gateway, user_chosen_gateway_id, &config)
+        .await
+        .unwrap_or_else(|err| {
+            eprintln!("Failed to setup gateway\nError: {err}");
+            std::process::exit(1)
+        });
    config.get_base_mut().with_gateway_endpoint(gateway);

    let config_save_location = config.get_config_file_save_location();
@@ -139,7 +143,10 @@ pub(crate) async fn execute(args: &Init) {
    );
    println!("Client configuration completed.");

-    client_core::init::show_address(config.get_base());
+    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
+        eprintln!("Failed to show address\nError: {err}");
+        std::process::exit(1)
+    });
 }

 async fn setup_gateway(
@@ -147,7 +154,7 @@ async fn setup_gateway(
    register: bool,
    user_chosen_gateway_id: Option<&str>,
    config: &Config,
-) -> GatewayEndpoint {
+) -> Result<GatewayEndpoint, ClientCoreError> {
    if register {
        // Get the gateway details by querying the validator-api. Either pick one at random or use
        // the chosen one if it's among the available ones.
@@ -156,16 +163,16 @@ async fn setup_gateway(
            config.get_base().get_validator_api_endpoints(),
            user_chosen_gateway_id,
        )
-        .await;
+        .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;
+            .await?;
        println!("Saved all generated keys");

-        gateway.into()
+        Ok(gateway.into())
    } else if user_chosen_gateway_id.is_some() {
        // Just set the config, don't register or create any keys
        // This assumes that the user knows what they are doing, and that the existing keys are
@@ -175,22 +182,21 @@ async fn setup_gateway(
            config.get_base().get_validator_api_endpoints(),
            user_chosen_gateway_id,
        )
-        .await;
+        .await?;
        log::debug!("Querying gateway gives: {}", gateway);
-        gateway.into()
+        Ok(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."
-                )
-            }
-        }
+        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })?;
+        Ok(existing_config.get_base().get_gateway_endpoint().clone())
    }
 }
@@ -3,8 +3,7 @@

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

 pub mod init;
 pub(crate) mod run;
@@ -28,7 +27,6 @@ fn long_version() -> String {
 {:<20}{}
 {:<20}{}
 {:<20}{}
-{:<20}{}
 "#,
        "Build Timestamp:",
        env!("VERGEN_BUILD_TIMESTAMP"),
@@ -46,8 +44,6 @@ fn long_version() -> String {
        env!("VERGEN_RUSTC_CHANNEL"),
        "cargo Profile:",
        env!("VERGEN_CARGO_PROFILE"),
-        "Network:",
-        DEFAULT_NETWORK
    )
 }

@@ -58,6 +54,10 @@ fn long_version_static() -> &'static 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,
 }
@@ -78,7 +78,7 @@ pub(crate) struct OverrideConfig {
    port: Option<u16>,
    fastmode: bool,

-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    enabled_credentials_mode: bool,

    #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -96,22 +96,15 @@ pub(crate) async fn execute(args: &Cli) {
    }
 }

-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()
-}
-
 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));
+    } 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) = args.port {
@@ -128,11 +121,14 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
    }

-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(any(feature = "eth", feature = "coconut"))]
    {
        if args.enabled_credentials_mode {
            config.get_base_mut().with_disabled_credentials(false)
        }
+    }
+    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    {
        if let Some(eth_endpoint) = args.eth_endpoint {
            config.get_base_mut().with_eth_endpoint(eth_endpoint);
        }
@@ -39,10 +39,9 @@ pub(crate) struct Run {
    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"])]
+    /// with bandwidth credential requirement.
+    #[cfg(any(feature = "eth", feature = "coconut"))]
+    #[clap(long)]
    enabled_credentials_mode: bool,

    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
@@ -65,7 +64,7 @@ impl From<Run> for OverrideConfig {
            port: run_config.port,
            fastmode: false,

-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(any(feature = "eth", feature = "coconut"))]
            enabled_credentials_mode: run_config.enabled_credentials_mode,

            #[cfg(all(feature = "eth", not(feature = "coconut")))]
@@ -3,7 +3,7 @@

 use crate::client::config::{Config, MISSING_VALUE};

-use config::{defaults::default_api_endpoints, NymConfig};
+use config::NymConfig;
 use version_checker::Version;

 use clap::Args;
@@ -104,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());
@@ -2,9 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod client;
-// This is only used as we reach into the init functions in nym-connect. We need to refactor the
-// init functions so that nym-connect can just call the same init function as the regular socks5
-// client.
-#[allow(unused)]
-pub mod commands;
 pub mod socks;
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::{crate_version, Parser};
+use network_defaults::setup_env;

 pub mod client;
 mod commands;
@@ -9,11 +10,11 @@ pub mod socks;

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

    let args = commands::Cli::parse();
+    setup_env(args.config_env_file.clone());
    commands::execute(&args).await;
 }

@@ -20,6 +20,7 @@ use socks5_requests::{ConnectionId, Message, RemoteAddress, Request};
 use std::io;
 use std::net::SocketAddr;
 use std::pin::Pin;
+use task::ShutdownListener;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
 use tokio::{self, net::TcpStream};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-                                if error_text.contains("Host") {
-                                    response = ResponseCode::HostUnreachable;
-                                } else if error_text.contains("Network") {
-                                    response = ResponseCode::NetworkUnreachable;
-                                } else if error_text.contains("ttl") {
-                                    response = ResponseCode::TtlExpired
-                                } else {
-                                    response = ResponseCode::Failure
+                                    if error_text.contains("Host") {
+                                        response = ResponseCode::HostUnreachable;
+                                    } else if error_text.contains("Network") {
+                                        response = ResponseCode::NetworkUnreachable;
+                                    } else if error_text.contains("ttl") {
+                                        response = ResponseCode::TtlExpired
+                                    } else {
+                                        response = ResponseCode::Failure
+                                    }
+
+                                    if client.error(response).await.is_err() {
+                                        warn!("Failed to send error code");
+                                    };
+                                    if client.shutdown().await.is_err() {
+                                        warn!("Failed to shutdown TcpStream");
+                                    };
                                }
-
-                                if client.error(response).await.is_err() {
-                                    warn!("Failed to send error code");
-                                };
-                                if client.shutdown().await.is_err() {
-                                    warn!("Failed to shutdown TcpStream");
-                                };
-                            }
-                        };
-                        // client gets dropped here
-                    }
-                });
+                            };
+                            // client gets dropped here
+                        }
+                    });
+                },
+                _ = self.shutdown.recv() => {
+                    log::trace!("SphinxSocksServer: Received shutdown");
+                    log::debug!("SphinxSocksServer: Exiting");
+                    return Ok(());
+                }
            }
        }
    }
@@ -4,8 +4,8 @@ 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');
+      'https://rpc.nymtech.net/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
    const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
    expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
  }).timeout(5000);
-})
+})
@@ -132,9 +132,7 @@ impl NymClient {
            bandwidth_controller,
        );

-        if disabled_credentials_mode {
-            gateway_client.set_disabled_credentials_mode(true)
-        }
+        gateway_client.set_disabled_credentials_mode(disabled_credentials_mode);

        gateway_client
            .authenticate_and_start()
@@ -199,7 +197,6 @@ impl NymClient {
            // don't bother with acks etc. for time being
            let prepared_fragment = message_preparer
                .prepare_chunk_for_sending(message_chunk, topology, &self.ack_key, &recipient)
-                .await
                .unwrap();

            console_warn!("packet is going to have round trip time of {:?}, but we're not going to do anything for acks anyway ", prepared_fragment.total_delay);
@@ -20,13 +20,13 @@ web3 = { version = "0.17.0", default-features = false }
 async-trait = { version = "0.1.51" }

 # internal
+coconut-interface = { path = "../../coconut-interface", optional = true }
 credentials = { path = "../../credentials" }
 crypto = { path = "../../crypto" }
 gateway-requests = { path = "../../../gateway/gateway-requests" }
+network-defaults = { path = "../../network-defaults" }
 nymsphinx = { path = "../../nymsphinx" }
 pemstore = { path = "../../pemstore" }
-coconut-interface = { path = "../../coconut-interface", optional = true }
-network-defaults = { path = "../../network-defaults" }
 validator-client = { path = "../validator-client", optional = true }

 [dependencies.tungstenite]
@@ -38,12 +38,19 @@ default-features = false
 version = "1.19.1"
 features = ["macros", "rt", "net", "sync", "time"]

+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
+version = "0.1.9"
+features = ["net", "sync", "time"]
+
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 version = "0.14"

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.credential-storage]
 path = "../../credential-storage"

+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.task]
+path = "../../task"
+
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2"
@@ -30,6 +30,8 @@ use rand::rngs::OsRng;
 use std::convert::TryFrom;
 use std::sync::Arc;
 use std::time::Duration;
+#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
 use tungstenite::protocol::Message;

 #[cfg(not(target_arch = "wasm32"))]
@@ -65,6 +67,10 @@ pub struct GatewayClient {
    reconnection_attempts: usize,
    /// Delay between each subsequent reconnection attempt.
    reconnection_backoff: Duration,
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Listen to shutdown messages.
+    shutdown: Option<ShutdownListener>,
 }

 impl GatewayClient {
@@ -80,6 +86,7 @@ impl GatewayClient {
        ack_sender: AcknowledgementSender,
        response_timeout_duration: Duration,
        bandwidth_controller: Option<BandwidthController<PersistentStorage>>,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
    ) -> Self {
        GatewayClient {
            authenticated: false,
@@ -91,12 +98,19 @@ impl GatewayClient {
            local_identity,
            shared_key,
            connection: SocketState::NotConnected,
-            packet_router: PacketRouter::new(ack_sender, mixnet_message_sender),
+            packet_router: PacketRouter::new(
+                ack_sender,
+                mixnet_message_sender,
+                #[cfg(not(target_arch = "wasm32"))]
+                shutdown.clone(),
+            ),
            response_timeout_duration,
            bandwidth_controller,
            should_reconnect_on_failure: true,
            reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
            reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown,
        }
    }

@@ -123,6 +137,7 @@ impl GatewayClient {
        gateway_owner: String,
        local_identity: Arc<identity::KeyPair>,
        response_timeout_duration: Duration,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
    ) -> Self {
        use futures::channel::mpsc;

@@ -130,7 +145,12 @@ impl GatewayClient {
        // perfectly fine here, because it's not meant to be used
        let (ack_tx, _) = mpsc::unbounded();
        let (mix_tx, _) = mpsc::unbounded();
-        let packet_router = PacketRouter::new(ack_tx, mix_tx);
+        let packet_router = PacketRouter::new(
+            ack_tx,
+            mix_tx,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown.clone(),
+        );

        GatewayClient {
            authenticated: false,
@@ -148,6 +168,8 @@ impl GatewayClient {
            should_reconnect_on_failure: false,
            reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
            reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown,
        }
    }

@@ -279,8 +301,31 @@ impl GatewayClient {
        let mut fused_timeout = timeout.fuse();
        let mut fused_stream = conn.fuse();

+        // Bit of an ugly workaround for selecting on an `Option` without having access to
+        // `tokio::select`
+        #[cfg(not(target_arch = "wasm32"))]
+        let shutdown = {
+            let m_shutdown = self.shutdown.clone();
+            async {
+                if let Some(mut s) = m_shutdown {
+                    s.recv().await
+                }
+            }
+            .fuse()
+        };
+        #[cfg(not(target_arch = "wasm32"))]
+        tokio::pin!(shutdown);
+
+        #[cfg(target_arch = "wasm32")]
+        let mut shutdown = Box::pin(async {}.fuse());
+
        loop {
            futures::select! {
+                _ = shutdown => {
+                    log::trace!("GatewayClient control response: Received shutdown");
+                    log::debug!("GatewayClient control response: Exiting");
+                    break Err(GatewayClientError::ConnectionClosedGatewayShutdown);
+                }
                _ = &mut fused_timeout => {
                    break Err(GatewayClientError::Timeout);
                }
@@ -291,14 +336,16 @@ impl GatewayClient {
                    };
                    match ws_msg {
                        Message::Binary(bin_msg) => {
-                            self.packet_router.route_received(vec![bin_msg]);
+                            if let Err(err) = self.packet_router.route_received(vec![bin_msg]) {
+                                log::warn!("Route received failed: {:?}", err);
+                            }
                        }
                        Message::Text(txt_msg) => {
                            break ServerResponse::try_from(txt_msg).map_err(|_| GatewayClientError::MalformedResponse);
                        }
                        _ => (),
                    }
-               }
+                }
            }
        }
    }
@@ -723,6 +770,8 @@ impl GatewayClient {
                                .as_ref()
                                .expect("no shared key present even though we're authenticated!"),
                        ),
+                        #[cfg(not(target_arch = "wasm32"))]
+                        self.shutdown.clone(),
                    )
                }
                _ => unreachable!(),
@@ -64,6 +64,9 @@ pub enum GatewayClientError {
    #[error("Connection was abruptly closed")]
    ConnectionAbruptlyClosed,

+    #[error("Connection was abruptly closed as gateway was stopped")]
+    ConnectionClosedGatewayShutdown,
+
    #[error("Received response was malformed")]
    MalformedResponse,

@@ -93,6 +96,9 @@ pub enum GatewayClientError {

    #[error("Timed out")]
    Timeout,
+
+    #[error("Failed to send mixnet message")]
+    MixnetMsgSenderFailedToSend,
 }

 impl GatewayClientError {
@@ -8,6 +8,10 @@ use futures::channel::mpsc;
 use log::*;
 use nymsphinx::addressing::nodes::MAX_NODE_ADDRESS_UNPADDED_LEN;
 use nymsphinx::params::packet_sizes::PacketSize;
+#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
+
+use crate::error::GatewayClientError;

 pub type MixnetMessageSender = mpsc::UnboundedSender<Vec<Vec<u8>>>;
 pub type MixnetMessageReceiver = mpsc::UnboundedReceiver<Vec<Vec<u8>>>;
@@ -19,20 +23,28 @@ pub type AcknowledgementReceiver = mpsc::UnboundedReceiver<Vec<Vec<u8>>>;
 pub struct PacketRouter {
    ack_sender: AcknowledgementSender,
    mixnet_message_sender: MixnetMessageSender,
+    #[cfg(not(target_arch = "wasm32"))]
+    shutdown: Option<ShutdownListener>,
 }

 impl PacketRouter {
    pub fn new(
        ack_sender: AcknowledgementSender,
        mixnet_message_sender: MixnetMessageSender,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
    ) -> Self {
        PacketRouter {
            ack_sender,
            mixnet_message_sender,
+            #[cfg(not(target_arch = "wasm32"))]
+            shutdown,
        }
    }

-    pub fn route_received(&self, unwrapped_packets: Vec<Vec<u8>>) {
+    pub fn route_received(
+        &mut self,
+        unwrapped_packets: Vec<Vec<u8>>,
+    ) -> Result<(), GatewayClientError> {
        let mut received_messages = Vec::new();
        let mut received_acks = Vec::new();

@@ -60,24 +72,29 @@ impl PacketRouter {
            }
        }

-        // due to how we are currently using it, those unwraps can't fail, but if we ever
-        // wanted to make `gateway-client` into some more generic library, we would probably need
-        // to catch that error or something.
        if !received_messages.is_empty() {
            trace!("routing 'real'");
-            self.mixnet_message_sender
-                .unbounded_send(received_messages)
-                .unwrap();
+            if let Err(err) = self.mixnet_message_sender.unbounded_send(received_messages) {
+                #[cfg(not(target_arch = "wasm32"))]
+                if let Some(shutdown) = &mut self.shutdown {
+                    if shutdown.is_shutdown_poll() {
+                        // This should ideally not happen, but it's ok
+                        log::warn!("Failed to send mixnet message due to receiver task shutdown");
+                        return Err(GatewayClientError::MixnetMsgSenderFailedToSend);
+                    }
+                }
+                // This should never happen during ordinary operation the way it's currently used.
+                // Abort to be on the safe side
+                panic!("Failed to send mixnet message: {:?}", err);
+            }
        }

        if !received_acks.is_empty() {
            trace!("routing acks");
-            match self.ack_sender.unbounded_send(received_acks) {
-                Ok(_) => {}
-                Err(e) => {
-                    error!("failed to send ack: {:?}", e);
-                }
+            if let Err(e) = self.ack_sender.unbounded_send(received_acks) {
+                error!("failed to send ack: {:?}", e);
            };
        }
+        Ok(())
    }
 }
@@ -11,6 +11,8 @@ use gateway_requests::registration::handshake::SharedKeys;
 use gateway_requests::BinaryResponse;
 use log::*;
 use std::sync::Arc;
+#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
 use tungstenite::Message;

 #[cfg(not(target_arch = "wasm32"))]
@@ -44,9 +46,9 @@ pub(crate) struct PartiallyDelegated {
 impl PartiallyDelegated {
    fn route_socket_message(
        ws_msg: Message,
-        packet_router: &PacketRouter,
+        packet_router: &mut PacketRouter,
        shared_key: &SharedKeys,
-    ) {
+    ) -> Result<(), GatewayClientError> {
        match ws_msg {
            Message::Binary(bin_msg) => {
                // this function decrypts the request and checks the MAC
@@ -60,7 +62,7 @@ impl PartiallyDelegated {
                                "message received from the gateway was malformed! - {:?}",
                                err
                            );
-                            return;
+                            return Ok(());
                        }
                    };

@@ -74,18 +76,22 @@ impl PartiallyDelegated {
            // This would also require NOT discarding any text responses here.

            // TODO: those can return the "send confirmations" - perhaps it should be somehow worked around?
-            Message::Text(text) => trace!(
-                "received a text message - probably a response to some previous query! - {}",
-                text
-            ),
-            _ => (),
-        };
+            Message::Text(text) => {
+                trace!(
+                    "received a text message - probably a response to some previous query! - {}",
+                    text
+                );
+                Ok(())
+            }
+            _ => Ok(()),
+        }
    }

    pub(crate) fn split_and_listen_for_mixnet_messages(
        conn: WsConn,
        packet_router: PacketRouter,
        shared_key: Arc<SharedKeys>,
+        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
    ) -> Self {
        // when called for, it NEEDS TO yield back the stream so that we could merge it and
        // read control request responses.
@@ -97,10 +103,34 @@ impl PartiallyDelegated {
        let mixnet_receiver_future = async move {
            let mut fused_receiver = notify_receiver.fuse();
            let mut fused_stream = (&mut stream).fuse();
+            let mut packet_router = packet_router;
+
+            // Bit of an ugly workaround for selecting on an `Option` without having access to
+            // `tokio::select`
+            #[cfg(not(target_arch = "wasm32"))]
+            let shutdown = {
+                let m_shutdown = shutdown.clone();
+                async {
+                    if let Some(mut s) = m_shutdown {
+                        s.recv().await
+                    }
+                }
+                .fuse()
+            };
+            #[cfg(not(target_arch = "wasm32"))]
+            tokio::pin!(shutdown);
+
+            #[cfg(target_arch = "wasm32")]
+            let mut shutdown = Box::pin(async {}.fuse());

            let ret_err = loop {
                futures::select! {
-                    _ = fused_receiver => {
+                    _ = shutdown => {
+                        log::trace!("GatewayClient listener: Received shutdown");
+                        log::debug!("GatewayClient listener: Exiting");
+                        return;
+                    }
+                    _ = &mut fused_receiver => {
                        break Ok(());
                    }
                    msg = fused_stream.next() => {
@@ -108,7 +138,9 @@ impl PartiallyDelegated {
                            Err(err) => break Err(err),
                            Ok(msg) => msg
                        };
-                        Self::route_socket_message(ws_msg, &packet_router, shared_key.as_ref());
+                        if let Err(err) = Self::route_socket_message(ws_msg, &mut packet_router, shared_key.as_ref()) {
+                            log::warn!("Route socket message failed: {:?}", err);
+                        }
                    }
                };
            };
@@ -162,12 +194,10 @@ impl PartiallyDelegated {
            .expect("stream sender was somehow dropped without sending anything!");

        if let Some(res) = receive_res {
-            if let Err(err) = res {
-                // the receiver got an error. most likely a network one.
-                return Err(err);
-            } else {
-                panic!("This should have NEVER happened - returned a stream before receiving notification")
-            }
+            let _res = res?;
+            panic!(
+                "This should have NEVER happened - returned a stream before receiving notification"
+            )
        }

        // this call failing is incredibly unlikely, but not impossible.
@@ -5,8 +5,7 @@ use crate::{validator_api, ValidatorClientError};
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
 use url::Url;
 use validator_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse,
-    ProposeReleaseFundsRequestBody, ProposeReleaseFundsResponse, VerificationKeyResponse,
+    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
    VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
@@ -29,7 +28,7 @@ use mixnet_contract_common::{
    RewardedSetUpdateDetails,
 };
 #[cfg(feature = "nymd-client")]
-use network_defaults::{all::Network, NymNetworkDetails};
+use network_defaults::NymNetworkDetails;
 #[cfg(feature = "nymd-client")]
 use std::collections::{HashMap, HashSet};

@@ -114,9 +113,6 @@ impl Config {

 #[cfg(feature = "nymd-client")]
 pub struct Client<C> {
-    // compatibility : (
-    pub network: Network,
-
    // 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>,
@@ -135,9 +131,6 @@ pub struct Client<C> {
 impl Client<SigningNymdClient> {
    pub fn new_signing(
        config: Config,
-        // we need to provide network argument due to compatibility with other components (wallet...)
-        // that rely on its existence...
-        network: Network,
        mnemonic: bip39::Mnemonic,
    ) -> Result<Client<SigningNymdClient>, ValidatorClientError> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
@@ -149,7 +142,6 @@ impl Client<SigningNymdClient> {
        )?;

        Ok(Client {
-            network,
            mnemonic: Some(mnemonic),
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
@@ -177,18 +169,12 @@ impl Client<SigningNymdClient> {

 #[cfg(feature = "nymd-client")]
 impl Client<QueryNymdClient> {
-    pub fn new_query(
-        config: Config,
-        // we need to provide network argument due to compatibility with other components (wallet...)
-        // that rely on its existence...
-        network: Network,
-    ) -> Result<Client<QueryNymdClient>, ValidatorClientError> {
+    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_config.clone(), config.nymd_url.as_str())?;

        Ok(Client {
-            network,
            mnemonic: None,
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
@@ -747,14 +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?)
-    }
 }
@@ -489,7 +489,7 @@ impl TryFrom<ProtoContractCodeHistoryEntry> for ContractCodeHistoryEntry {
    }
 }

-#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, Default, Eq, PartialEq, Serialize)]
 pub struct GasInfo {
    /// GasWanted is the maximum units of work we allow this tx to perform.
    pub gas_wanted: Gas,
@@ -645,7 +645,7 @@ impl InstantiateOptions {
    }
 }

-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct InstantiateResult {
    /// The address of the newly instantiated contract
    pub contract_address: AccountId,
@@ -658,7 +658,7 @@ pub struct InstantiateResult {
    pub gas_info: GasInfo,
 }

-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct ChangeAdminResult {
    pub logs: Vec<Log>,

@@ -668,7 +668,7 @@ pub struct ChangeAdminResult {
    pub gas_info: GasInfo,
 }

-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct MigrateResult {
    pub logs: Vec<Log>,

@@ -678,7 +678,7 @@ pub struct MigrateResult {
    pub gas_info: GasInfo,
 }

-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 pub struct ExecuteResult {
    pub logs: Vec<Log>,

@@ -10,6 +10,8 @@ use crate::nymd::error::NymdError;
 use crate::nymd::fee::DEFAULT_SIMULATED_GAS_MULTIPLIER;
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
 use cosmrs::cosmwasm;
+use cosmrs::rpc::endpoint::block::Response as BlockResponse;
+use cosmrs::rpc::query::Query;
 use cosmrs::rpc::Error as TendermintRpcError;
 use cosmrs::rpc::HttpClientUrl;
 use cosmrs::tx::Msg;
@@ -24,7 +26,7 @@ use mixnet_contract_common::{
    PagedMixDelegationsResponse, PagedMixnodeResponse, PagedRewardedSetResponse, QueryMsg,
    RewardedSetUpdateDetails,
 };
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use std::time::SystemTime;
 use vesting_contract_common::ExecuteMsg as VestingExecuteMsg;
@@ -212,6 +214,10 @@ impl<C> NymdClient<C> {
        &self.config
    }

+    pub fn current_chain_details(&self) -> &ChainDetails {
+        &self.config.chain_details
+    }
+
    pub fn set_mixnet_contract_address(&mut self, address: AccountId) {
        self.config.mixnet_contract_address = Some(address);
    }
@@ -282,6 +288,30 @@ impl<C> NymdClient<C> {
        self.simulated_gas_multiplier = multiplier;
    }

+    pub async fn query_contract_smart<M, T>(
+        &self,
+        contract: &AccountId,
+        query_msg: &M,
+    ) -> Result<T, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+        M: ?Sized + Serialize + Sync,
+        for<'a> T: Deserialize<'a>,
+    {
+        self.client.query_contract_smart(contract, query_msg).await
+    }
+
+    pub async fn query_contract_raw(
+        &self,
+        contract: &AccountId,
+        query_data: Vec<u8>,
+    ) -> Result<Vec<u8>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.query_contract_raw(contract, query_data).await
+    }
+
    pub fn wrap_contract_execute_message<M>(
        &self,
        contract_address: &AccountId,
@@ -308,6 +338,13 @@ impl<C> NymdClient<C> {
        &self.client_address.as_ref().unwrap()[0]
    }

+    pub fn signer(&self) -> &DirectSecp256k1HdWallet
+    where
+        C: SigningCosmWasmClient,
+    {
+        self.client.signer()
+    }
+
    pub fn gas_price(&self) -> &GasPrice
    where
        C: SigningCosmWasmClient,
@@ -331,11 +368,26 @@ impl<C> NymdClient<C> {
        address: &AccountId,
    ) -> Result<Option<Account>, NymdError>
    where
-        C: SigningCosmWasmClient + Sync,
+        C: CosmWasmClient + Sync,
    {
        self.client.get_account(address).await
    }

+    pub async fn get_account_public_key(
+        &self,
+        address: &AccountId,
+    ) -> Result<Option<cosmrs::crypto::PublicKey>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        if let Some(account) = self.client.get_account(address).await? {
+            let base_account = account.try_get_base_account()?;
+            return Ok(base_account.pubkey);
+        }
+
+        Ok(None)
+    }
+
    pub async fn get_current_block_timestamp(&self) -> Result<TendermintTime, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -353,6 +405,13 @@ impl<C> NymdClient<C> {
        Ok(self.client.get_block(height).await?.block.header.time)
    }

+    pub async fn get_block(&self, height: Option<u32>) -> Result<BlockResponse, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.get_block(height).await
+    }
+
    pub async fn get_current_block_height(&self) -> Result<Height, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -397,6 +456,13 @@ impl<C> NymdClient<C> {
        self.client.get_balance(address, denom).await
    }

+    pub async fn get_all_balances(&self, address: &AccountId) -> Result<Vec<Coin>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.get_all_balances(address).await
+    }
+
    pub async fn get_tx(&self, id: tx::Hash) -> Result<TxResponse, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -404,6 +470,13 @@ impl<C> NymdClient<C> {
        self.client.get_tx(id).await
    }

+    pub async fn search_tx(&self, query: Query) -> Result<Vec<TxResponse>, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        self.client.search_tx(query).await
+    }
+
    pub async fn get_total_supply(&self) -> Result<Vec<Coin>, NymdError>
    where
        C: CosmWasmClient + Sync,
@@ -893,7 +966,7 @@ impl<C> NymdClient<C> {
        &self,
        contract_address: &AccountId,
        msg: &M,
-        fee: Fee,
+        fee: Option<Fee>,
        memo: impl Into<String> + Send + 'static,
        funds: Vec<Coin>,
    ) -> Result<ExecuteResult, NymdError>
@@ -901,6 +974,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
@@ -910,7 +984,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
@@ -918,6 +992,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
@@ -1006,6 +1081,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
@@ -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
@@ -12,7 +12,6 @@ use multisig_contract_common::msg::ExecuteMsg;
 use async_trait::async_trait;
 use cosmwasm_std::{to_binary, Coin, CosmosMsg, WasmMsg};
 use cw3::Vote;
-use network_defaults::DEFAULT_NETWORK;

 #[async_trait]
 pub trait MultisigSigningClient {
@@ -49,7 +48,10 @@ impl<C: SigningCosmWasmClient + Sync + Send> MultisigSigningClient for NymdClien
    ) -> Result<ExecuteResult, NymdError> {
        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
        let release_funds_req = CoconutBandwidthExecuteMsg::ReleaseFunds {
-            funds: Coin::new(voucher_value, DEFAULT_NETWORK.mix_denom().base),
+            funds: Coin::new(
+                voucher_value,
+                self.config.chain_details.mix_denom.base.clone(),
+            ),
        };
        let release_funds_msg = CosmosMsg::Wasm(WasmMsg::Execute {
            contract_addr: self.coconut_bandwidth_contract_address().to_string(),
@@ -7,9 +7,11 @@ use crate::nymd::error::NymdError;
 use crate::nymd::NymdClient;
 use async_trait::async_trait;
 use cosmwasm_std::{Coin as CosmWasmCoin, Timestamp};
+use mixnet_contract_common::IdentityKey;
 use vesting_contract::vesting::Account;
 use vesting_contract_common::{
-    messages::QueryMsg as VestingQueryMsg, OriginalVestingResponse, Period, PledgeData,
+    messages::QueryMsg as VestingQueryMsg, AllDelegationsResponse, DelegationTimesResponse,
+    OriginalVestingResponse, Period, PledgeData, VestingDelegation,
 };

 #[async_trait]
@@ -70,6 +72,37 @@ pub trait VestingQueryClient {
        &self,
        vesting_account_address: &str,
    ) -> Result<Period, NymdError>;
+
+    async fn get_delegation_timestamps(
+        &self,
+        address: &str,
+        mix_identity: String,
+    ) -> Result<DelegationTimesResponse, NymdError>;
+
+    async fn get_all_vesting_delegations_paged(
+        &self,
+        start_after: Option<(u32, IdentityKey, u64)>,
+        limit: Option<u32>,
+    ) -> Result<AllDelegationsResponse, NymdError>;
+
+    async fn get_all_vesting_delegations(&self) -> Result<Vec<VestingDelegation>, NymdError> {
+        let mut delegations = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .get_all_vesting_delegations_paged(start_after.take(), None)
+                .await?;
+            delegations.append(&mut paged_response.delegations);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(delegations)
+    }
 }

 #[async_trait]
@@ -232,4 +265,29 @@ impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
            .query_contract_smart(self.vesting_contract_address(), &request)
            .await
    }
+
+    async fn get_delegation_timestamps(
+        &self,
+        address: &str,
+        mix_identity: String,
+    ) -> Result<DelegationTimesResponse, NymdError> {
+        let request = VestingQueryMsg::GetDelegationTimes {
+            address: address.to_string(),
+            mix_identity,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &request)
+            .await
+    }
+
+    async fn get_all_vesting_delegations_paged(
+        &self,
+        start_after: Option<(u32, IdentityKey, u64)>,
+        limit: Option<u32>,
+    ) -> Result<AllDelegationsResponse, NymdError> {
+        let request = VestingQueryMsg::GetAllDelegations { start_after, limit };
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &request)
+            .await
+    }
 }
@@ -4,7 +4,7 @@
 use crate::nymd::error::NymdError;
 use config::defaults;
 use cosmrs::bip32::{DerivationPath, XPrv};
-use cosmrs::crypto::secp256k1::SigningKey;
+use cosmrs::crypto::secp256k1::{Signature, SigningKey};
 use cosmrs::crypto::PublicKey;
 use cosmrs::tx::SignDoc;
 use cosmrs::{tx, AccountId};
@@ -105,6 +105,17 @@ impl DirectSecp256k1HdWallet {
        self.secret.to_string()
    }

+    pub fn sign_raw_with_account(
+        &self,
+        signer: &AccountData,
+        message: &[u8],
+    ) -> Result<Signature, NymdError> {
+        signer
+            .private_key
+            .sign(message)
+            .map_err(|_| NymdError::SigningFailure)
+    }
+
    pub fn sign_direct_with_account(
        &self,
        signer: &AccountData,
@@ -207,35 +218,20 @@ mod tests {
            "acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel",
            "step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball"
        ];
-        let prefixes = vec![
-            MAINNET.bech32_prefix(),
-            SANDBOX.bech32_prefix(),
-            QA.bech32_prefix(),
-        ];
+        let prefix = MAINNET.bech32_prefix();

-        for prefix in prefixes {
-            let addrs = match prefix.as_ref() {
-                "nymt" => vec![
-                    "nymt1jw6mp7d5xqc7w6xm79lha27glmd0vdt339me94",
-                    "nymt1h5hgn94nsq4kh99rjj794hr5h5q6yfm23rjshv",
-                    "nymt17n9flp6jflljg6fp05dsy07wcprf2uuufgn4d4",
-                ],
-                "n" => vec![
-                    "n1jw6mp7d5xqc7w6xm79lha27glmd0vdt3l9artf",
-                    "n1h5hgn94nsq4kh99rjj794hr5h5q6yfm2lr52es",
-                    "n17n9flp6jflljg6fp05dsy07wcprf2uuu8g40rf",
-                ],
-                _ => panic!("Test needs to be updated with new bech32 prefix"),
-            };
-            for (idx, mnemonic) in mnemonics.iter().enumerate() {
-                let wallet =
-                    DirectSecp256k1HdWallet::from_mnemonic(&prefix, mnemonic.parse().unwrap())
-                        .unwrap();
-                assert_eq!(
-                    wallet.try_derive_accounts().unwrap()[0].address,
-                    addrs[idx].parse().unwrap()
-                )
-            }
+        let addrs = vec![
+            "n1jw6mp7d5xqc7w6xm79lha27glmd0vdt3l9artf",
+            "n1h5hgn94nsq4kh99rjj794hr5h5q6yfm2lr52es",
+            "n17n9flp6jflljg6fp05dsy07wcprf2uuu8g40rf",
+        ];
+        for (idx, mnemonic) in mnemonics.iter().enumerate() {
+            let wallet =
+                DirectSecp256k1HdWallet::from_mnemonic(&prefix, mnemonic.parse().unwrap()).unwrap();
+            assert_eq!(
+                wallet.try_derive_accounts().unwrap()[0].address,
+                addrs[idx].parse().unwrap()
+            )
        }
    }
 }
@@ -8,8 +8,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use url::Url;
 use validator_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse,
-    ProposeReleaseFundsRequestBody, ProposeReleaseFundsResponse, VerificationKeyResponse,
+    BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
    VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
@@ -405,23 +404,6 @@ impl Client {
        )
        .await
    }
-
-    pub async fn propose_release_funds(
-        &self,
-        request_body: &ProposeReleaseFundsRequestBody,
-    ) -> Result<ProposeReleaseFundsResponse, ValidatorAPIError> {
-        self.post_validator_api(
-            &[
-                routes::API_VERSION,
-                routes::COCONUT_ROUTES,
-                routes::BANDWIDTH,
-                routes::COCONUT_PROPOSE_RELEASE_FUNDS,
-            ],
-            NO_PARAMS,
-            request_body,
-        )
-        .await
-    }
 }

 // utility function that should solve the double slash problem in validator API forever.
@@ -19,7 +19,6 @@ pub const COCONUT_PARTIAL_BANDWIDTH_CREDENTIAL: &str = "partial-bandwidth-creden
 pub const COCONUT_VERIFICATION_KEY: &str = "verification-key";
 pub const COCONUT_COSMOS_ADDRESS: &str = "cosmos-address";
 pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
-pub const COCONUT_PROPOSE_RELEASE_FUNDS: &str = "propose-release-funds";

 pub const STATUS_ROUTES: &str = "status";
 pub const MIXNODE: &str = "mixnode";
@@ -0,0 +1,32 @@
+[package]
+name = "nym-cli-commands"
+version = "1.0.0"
+authors = ["Nym Technologies SA"]
+edition = "2021"
+
+[dependencies]
+base64 = "0.13.0"
+bip39 = "1.0.1"
+bs58 = "0.4"
+comfy-table = "6.0.0"
+cfg-if = "1.0.0"
+clap = { version = "3.2", features = ["derive"] }
+handlebars = "3.0.1"
+humantime-serde = "1.0"
+k256 = { version = "0.10", features = ["ecdsa", "sha256"] }
+log = "0.4"
+rand = {version = "0.6", features = ["std"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1"
+thiserror = "1"
+time = { version = "0.3.6", features = ["parsing", "formatting"] }
+toml = "0.5.6"
+url = "2.2"
+
+cosmrs = { git = "https://github.com/neacsu/cosmos-rust", branch = "neacsu/feegrant_support" }
+cosmwasm-std = { version = "1.0.0" }
+
+validator-client = { path = "../client-libs/validator-client", features = ["nymd-client"] }
+network-defaults = { path = "../network-defaults" }
+mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
+vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }
@@ -0,0 +1,13 @@
+# Common `clap` Command Crate
+
+This crate contains `clap` commands for common operations:
+
+- account creation and queries
+- block queries
+- cosmwasm uploads, instantiate, execution, query, etc
+- mixnet actions and queries
+- sign and verify messages
+- query for transactions
+- create vesting schedules and query for them
+
+For how to use this crate, please see the [Nym CLI](../../tools/nym-cli).
@@ -0,0 +1,4 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+// TODO: add coconut commands here
@@ -0,0 +1,18 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ContextError {
+    #[error("mnemonic was not provided, pass as an argument or an env var called MNEMONIC")]
+    MnemonicNotProvided,
+
+    #[error("failed to parse mnemonic - {0}")]
+    Bip39Error(#[from] bip39::Error),
+
+    // there are lots of error that can occur in the nymd client, so just pass through their display details
+    // TODO: improve this to return known errors
+    #[error("failed to create client - {0}")]
+    NymdError(String),
+}
@@ -0,0 +1,138 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use network_defaults::{
+    setup_env,
+    var_names::{API_VALIDATOR, MIXNET_CONTRACT_ADDRESS, NYMD_VALIDATOR, VESTING_CONTRACT_ADDRESS},
+    NymNetworkDetails,
+};
+use validator_client::nymd::{self, AccountId, NymdClient, QueryNymdClient, SigningNymdClient};
+pub use validator_client::validator_api::Client as ValidatorApiClient;
+
+use crate::context::errors::ContextError;
+
+pub mod errors;
+
+pub type SigningClient = validator_client::nymd::NymdClient<SigningNymdClient>;
+pub type QueryClient = validator_client::nymd::NymdClient<QueryNymdClient>;
+pub type SigningClientWithValidatorAPI = validator_client::Client<SigningNymdClient>;
+pub type QueryClientWithValidatorAPI = validator_client::Client<QueryNymdClient>;
+
+#[derive(Debug)]
+pub struct ClientArgs {
+    pub config_env_file: Option<std::path::PathBuf>,
+    pub nymd_url: Option<String>,
+    pub validator_api_url: Option<String>,
+    pub mnemonic: Option<bip39::Mnemonic>,
+    pub mixnet_contract_address: Option<AccountId>,
+    pub vesting_contract_address: Option<AccountId>,
+}
+
+pub fn get_network_details(args: &ClientArgs) -> Result<NymNetworkDetails, ContextError> {
+    // let the network defaults crate handle setting up the env vars if the file arg is set, otherwise
+    // it will default to what is already in env vars, falling back to mainnet
+    setup_env(args.config_env_file.clone());
+
+    // override the env vars with user supplied arguments, if set
+    if let Some(nymd_url) = args.nymd_url.as_ref() {
+        std::env::set_var(NYMD_VALIDATOR, nymd_url);
+    }
+    if let Some(validator_api_url) = args.validator_api_url.as_ref() {
+        std::env::set_var(API_VALIDATOR, validator_api_url);
+    }
+    if let Some(mixnet_contract_address) = args.mixnet_contract_address.as_ref() {
+        std::env::set_var(MIXNET_CONTRACT_ADDRESS, mixnet_contract_address.to_string());
+    }
+    if let Some(vesting_contract_address) = args.vesting_contract_address.as_ref() {
+        std::env::set_var(
+            VESTING_CONTRACT_ADDRESS,
+            vesting_contract_address.to_string(),
+        );
+    }
+
+    Ok(NymNetworkDetails::new_from_env())
+}
+
+pub fn create_signing_client(
+    args: ClientArgs,
+    network_details: &NymNetworkDetails,
+) -> Result<SigningClient, ContextError> {
+    let client_config = nymd::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    // get mnemonic
+    let mnemonic = match std::env::var("MNEMONIC") {
+        Ok(value) => bip39::Mnemonic::parse(value)?,
+        // env var MNEMONIC is not present, so try to fall back to arg --mnemonic ...
+        Err(_) => match args.mnemonic {
+            Some(value) => value,
+            None => return Err(ContextError::MnemonicNotProvided), // no env var or arg provided
+        },
+    };
+
+    let nymd_url = network_details
+        .endpoints
+        .first()
+        .expect("network details are not defined")
+        .nymd_url
+        .as_str();
+
+    match NymdClient::connect_with_mnemonic(client_config, nymd_url, mnemonic, None) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}
+
+pub fn create_query_client(
+    network_details: &NymNetworkDetails,
+) -> Result<QueryClient, ContextError> {
+    let client_config = nymd::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    let nymd_url = network_details
+        .endpoints
+        .first()
+        .expect("network details are not defined")
+        .nymd_url
+        .as_str();
+
+    match NymdClient::connect(client_config, nymd_url) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}
+
+pub fn create_signing_client_with_validator_api(
+    args: ClientArgs,
+    network_details: &NymNetworkDetails,
+) -> Result<SigningClientWithValidatorAPI, ContextError> {
+    let client_config = validator_client::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    // get mnemonic
+    let mnemonic = match std::env::var("MNEMONIC") {
+        Ok(value) => bip39::Mnemonic::parse(value)?,
+        // env var MNEMONIC is not present, so try to fall back to arg --mnemonic ...
+        Err(_) => match args.mnemonic {
+            Some(value) => value,
+            None => return Err(ContextError::MnemonicNotProvided), // no env var or arg provided
+        },
+    };
+
+    match validator_client::client::Client::new_signing(client_config, mnemonic) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}
+
+pub fn create_query_client_with_validator_api(
+    network_details: &NymNetworkDetails,
+) -> Result<QueryClientWithValidatorAPI, ContextError> {
+    let client_config = validator_client::Config::try_from_nym_network_details(network_details)
+        .expect("failed to construct valid validator client config with the provided network");
+
+    match validator_client::client::Client::new_query(client_config) {
+        Ok(client) => Ok(client),
+        Err(e) => Err(ContextError::NymdError(format!("{:?}", e))),
+    }
+}
@@ -0,0 +1,7 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod coconut;
+pub mod context;
+pub mod utils;
+pub mod validator;
@@ -0,0 +1,44 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::error::Error;
+use std::fmt::Display;
+
+use cosmwasm_std::{Coin as CosmWasmCoin, Decimal};
+use log::error;
+use validator_client::nymd::Coin;
+
+pub fn pretty_coin(coin: &Coin) -> String {
+    let amount = Decimal::from_ratio(coin.amount, 1_000_000u128);
+    let denom = if coin.denom.starts_with('u') {
+        &coin.denom[1..]
+    } else {
+        &coin.denom
+    };
+    format!("{} {}", amount, denom)
+}
+
+pub fn pretty_cosmwasm_coin(coin: &CosmWasmCoin) -> String {
+    let amount = Decimal::from_ratio(coin.amount, 1_000_000u128);
+    let denom = if coin.denom.starts_with('u') {
+        &coin.denom[1..]
+    } else {
+        &coin.denom
+    };
+    format!("{} {}", amount, denom)
+}
+
+pub fn show_error<E>(e: E)
+where
+    E: Display,
+{
+    error!("{}", e);
+}
+
+pub fn show_error_passthrough<E>(e: E) -> E
+where
+    E: Error + Display,
+{
+    error!("{}", e);
+    e
+}
@@ -0,0 +1,72 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{error, info};
+
+use validator_client::nymd::AccountId;
+
+use crate::context::QueryClient;
+use crate::utils::{pretty_coin, show_error};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The account address to get the balance for")]
+    pub address: Option<AccountId>,
+
+    #[clap(long)]
+    #[clap(help = "Optional currency to show balance for")]
+    pub denom: Option<String>,
+
+    #[clap(long, requires = "denom")]
+    #[clap(help = "Optionally hide the denom")]
+    pub hide_denom: bool,
+
+    #[clap(long)]
+    #[clap(help = "Show as a raw value")]
+    pub raw: bool,
+}
+
+pub async fn query_balance(
+    args: Args,
+    client: &QueryClient,
+    address_from_mnemonic: Option<AccountId>,
+) {
+    if args.address.is_none() && address_from_mnemonic.is_none() {
+        error!("Please specify an account address or a mnemonic to get the balance for");
+        return;
+    }
+
+    let address = args
+        .address
+        .unwrap_or_else(|| address_from_mnemonic.expect("please provide a mnemonic"));
+
+    info!("Getting balance for {}...", address);
+
+    match client.get_all_balances(&address).await {
+        Ok(coins) => {
+            if coins.is_empty() {
+                println!("No balance");
+                return;
+            }
+
+            let denom = args.denom.unwrap_or_else(|| "".to_string());
+
+            for coin in coins {
+                if denom.is_empty() || denom.eq_ignore_ascii_case(&coin.denom) {
+                    if args.raw {
+                        if !args.hide_denom {
+                            println!("{}", coin);
+                        } else {
+                            println!("{}", coin.amount);
+                        }
+                    } else {
+                        println!("{}", pretty_coin(&coin));
+                    }
+                }
+            }
+        }
+        Err(e) => show_error(e),
+    }
+}
@@ -0,0 +1,24 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use validator_client::nymd::wallet::DirectSecp256k1HdWallet;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    // allowed values are 12, 18 or 24
+    pub word_count: Option<usize>,
+}
+
+pub fn create_account(args: Args, prefix: &str) {
+    let word_count = args.word_count.unwrap_or(24);
+    let mnemonic = bip39::Mnemonic::generate(word_count).expect("failed to generate mnemonic!");
+
+    let wallet =
+        DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic).expect("failed to build wallet!");
+
+    // Output address and mnemonics into separate lines for easier parsing
+    println!("{}", wallet.mnemonic());
+    println!("{}", wallet.try_derive_accounts().unwrap()[0].address());
+}
@@ -0,0 +1,28 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod balance;
+pub mod create;
+pub mod pubkey;
+pub mod send;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Account {
+    #[clap(subcommand)]
+    pub command: Option<AccountCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum AccountCommands {
+    /// Create a new mnemonic - note, this account does not appear on the chain until the account id is used in a transaction
+    Create(crate::validator::account::create::Args),
+    /// Gets the balance of an account
+    Balance(crate::validator::account::balance::Args),
+    /// Gets the public key of an account
+    PubKey(crate::validator::account::pubkey::Args),
+    /// Sends tokens to another account
+    Send(crate::validator::account::send::Args),
+}
@@ -0,0 +1,89 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::{error, info};
+
+use validator_client::nymd::wallet::DirectSecp256k1HdWallet;
+use validator_client::nymd::AccountId;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(
+        help = "Optionally, show the public key for this account address, otherwise generate the account address from the mnemonic"
+    )]
+    pub address: Option<AccountId>,
+
+    #[clap(long)]
+    #[clap(help = "If set, get the public key from the mnemonic, rather than querying for it")]
+    pub from_mnemonic: bool,
+}
+
+pub async fn get_pubkey(
+    args: Args,
+    client: &QueryClient,
+    mnemonic: Option<bip39::Mnemonic>,
+    address_from_mnemonic: Option<AccountId>,
+) {
+    if args.address.is_none() && address_from_mnemonic.is_none() {
+        error!("Please specify an account address or a mnemonic to get the balance for");
+        return;
+    }
+
+    let address = args
+        .address
+        .unwrap_or_else(|| address_from_mnemonic.expect("please provide a mnemonic"));
+
+    if args.from_mnemonic {
+        let prefix = client
+            .current_chain_details()
+            .bech32_account_prefix
+            .as_str();
+        get_pubkey_from_mnemonic(address, prefix, mnemonic.expect("mnemonic not set"));
+        return;
+    }
+
+    get_pubkey_from_chain(address, client).await;
+}
+
+pub fn get_pubkey_from_mnemonic(address: AccountId, prefix: &str, mnemonic: bip39::Mnemonic) {
+    match DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic) {
+        Ok(wallet) => match wallet.try_derive_accounts() {
+            Ok(accounts) => match accounts.iter().find(|a| *a.address() == address) {
+                Some(account) => {
+                    println!("{}", account.public_key().to_string());
+                }
+                None => {
+                    error!("Could not derive key that matches {}", address)
+                }
+            },
+            Err(e) => {
+                error!("Failed to derive accounts. {}", e);
+            }
+        },
+        Err(e) => show_error(e),
+    }
+}
+
+pub async fn get_pubkey_from_chain(address: AccountId, client: &QueryClient) {
+    info!("Getting public key for address {} from chain...", address);
+    match client.get_account_details(&address).await {
+        Ok(Some(account)) => {
+            if let Ok(base_account) = account.try_get_base_account() {
+                if let Some(pubkey) = base_account.pubkey {
+                    println!("{}", pubkey.to_string());
+                } else {
+                    println!("No account associated with address {}", address);
+                }
+            }
+        }
+        Ok(None) => {
+            println!("No account associated with address {}", address);
+        }
+        Err(e) => show_error(e),
+    }
+}
@@ -0,0 +1,66 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+use serde_json::json;
+
+use validator_client::nymd::{AccountId, Coin};
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser, help = "The recipient account address")]
+    pub recipient: AccountId,
+
+    #[clap(
+        value_parser,
+        help = "Amount to transfer in micro denomination (e.g. unym or unyx)"
+    )]
+    pub amount: u128,
+
+    #[clap(long, help = "Override the denomination")]
+    pub denom: Option<String>,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+}
+
+pub async fn send(args: Args, client: &SigningClient) {
+    let memo = args
+        .memo
+        .unwrap_or_else(|| "Sending tokens with nym-cli".to_owned());
+    let denom = args
+        .denom
+        .unwrap_or_else(|| client.current_chain_details().mix_denom.base.clone());
+
+    let coin = Coin {
+        denom,
+        amount: args.amount,
+    };
+
+    info!(
+        "Sending {} {} from {} to {}...",
+        coin.amount,
+        coin.denom,
+        client.address(),
+        args.recipient
+    );
+
+    let res = client
+        .send(&args.recipient, vec![coin], memo, None)
+        .await
+        .expect("failed to send tokens!");
+
+    info!("Sending result: {}", json!(res));
+
+    println!();
+    println!(
+        "Nodesguru: https://nym.explorers.guru/transaction/{}",
+        &res.hash
+    );
+    println!("Mintscan: https://www.mintscan.io/nyx/txs/{}", &res.hash);
+    println!("Transaction result code: {}", &res.tx_result.code.value());
+    println!("Transaction hash: {}", &res.hash);
+}
@@ -0,0 +1,23 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The block height")]
+    pub height: u32,
+}
+
+pub async fn query_for_block_time(args: Args, client: &QueryClient) {
+    match client.get_block_timestamp(Some(args.height)).await {
+        Ok(res) => {
+            println!("{}", res.to_rfc3339())
+        }
+        Err(e) => show_error(e),
+    }
+}
@@ -0,0 +1,19 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+
+#[derive(Debug, Parser)]
+pub struct Args {}
+
+pub async fn query_current_block_height(client: &QueryClient) {
+    match client.get_current_block_height().await {
+        Ok(res) => {
+            println!("Current block height:\n{}", res.value())
+        }
+        Err(e) => show_error(e),
+    }
+}
@@ -0,0 +1,24 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;
+use serde_json::json;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The block height")]
+    pub height: u32,
+}
+
+pub async fn query_for_block(args: Args, client: &QueryClient) {
+    match client.get_block(Some(args.height)).await {
+        Ok(res) => {
+            println!("{}", json!(res))
+        }
+        Err(e) => show_error(e),
+    }
+}
@@ -0,0 +1,25 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod block_time;
+pub mod current_height;
+pub mod get;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Block {
+    #[clap(subcommand)]
+    pub command: Option<BlockCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum BlockCommands {
+    /// Gets a block's details and prints as JSON
+    Get(crate::validator::block::get::Args),
+    /// Gets the block time at a height
+    Time(crate::validator::block::block_time::Args),
+    /// Gets the current block height
+    CurrentHeight(crate::validator::block::current_height::Args),
+}
@@ -0,0 +1,60 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use cosmrs::AccountId;
+use log::{error, info};
+use serde_json::{json, Value};
+use validator_client::nymd::Coin;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    #[clap(help = "The address of contract to execute")]
+    pub contract_address: AccountId,
+
+    #[clap(value_parser)]
+    #[clap(help = "JSON encoded method arguments")]
+    pub json_args: String,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(
+        value_parser,
+        requires = "fundsDenom",
+        help = "Amount to supply as funds in micro denomination (e.g. unym or unyx)"
+    )]
+    pub funds: Option<u128>,
+
+    #[clap(long, requires = "funds", help = "Set the denomination for the funds")]
+    pub funds_denom: Option<String>,
+}
+
+pub async fn execute(args: Args, client: SigningClient) {
+    info!("Starting contract method execution!");
+
+    let json_args: Value =
+        serde_json::from_str(&args.json_args).expect("Unable to parse JSON args");
+
+    let memo = args
+        .memo
+        .unwrap_or_else(|| "nym-cli execute contract method".to_owned());
+
+    let funds = match args.funds {
+        Some(funds) => vec![Coin::new(
+            funds,
+            args.funds_denom.expect("denom for funds not set"),
+        )],
+        None => vec![],
+    };
+
+    match client
+        .execute(&args.contract_address, &json_args, None, memo, funds)
+        .await
+    {
+        Ok(res) => info!("SUCCESS ✅\n{}", json!(res)),
+        Err(e) => error!("FAILURE ❌\n{}", e),
+    }
+}
@@ -0,0 +1,78 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use cosmrs::{AccountId, Coin as CosmosCoin};
+use log::info;
+use network_defaults::NymNetworkDetails;
+use validator_client::nymd::cosmwasm_client::types::{ContractCodeId, InstantiateOptions};
+use validator_client::nymd::Coin;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    pub code_id: ContractCodeId,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(long)]
+    pub label: Option<String>,
+
+    #[clap(long)]
+    pub init_message: String,
+
+    #[clap(long)]
+    pub admin: Option<AccountId>,
+
+    #[clap(
+        long,
+        requires = "fundsDenom",
+        help = "Amount to supply as funds in micro denomination (e.g. unym or unyx)"
+    )]
+    pub funds: Option<u128>,
+
+    #[clap(long, requires = "funds", help = "Set the denomination for the funds")]
+    pub funds_denom: Option<String>,
+}
+
+pub async fn init(args: Args, client: SigningClient, network_details: &NymNetworkDetails) {
+    info!("Starting contract instantiation!");
+
+    let memo = args
+        .memo
+        .unwrap_or_else(|| "contract instantiation".to_owned());
+    let label = args
+        .label
+        .unwrap_or_else(|| "Nym mixnet smart contract".to_owned());
+
+    let funds: Vec<CosmosCoin> = match args.funds {
+        Some(funds) => vec![Coin::new(
+            funds,
+            args.funds_denom
+                .unwrap_or_else(|| network_details.chain_details.mix_denom.base.to_string()),
+        )
+        .into()],
+        None => vec![],
+    };
+
+    // by default we make ourselves an admin, let me know if you don't like that behaviour
+    let opts = Some(InstantiateOptions {
+        funds,
+        admin: Some(args.admin.unwrap_or_else(|| client.address().clone())),
+    });
+
+    let msg: serde_json::Value =
+        serde_json::from_str(&args.init_message).expect("failed to parse init message");
+
+    // the EmptyMsg{} argument is equivalent to `--init-message='{}'`
+    let res = client
+        .instantiate(args.code_id, &msg, label, memo, opts, None)
+        .await
+        .expect("failed to instantiate the contract!");
+
+    info!("Init result: {:?}", res);
+
+    println!("{}", res.contract_address)
+}
@@ -0,0 +1,51 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use crate::utils::show_error_passthrough;
+use clap::Parser;
+use cosmrs::AccountId;
+use log::info;
+use validator_client::nymd::cosmwasm_client::types::{ContractCodeId, EmptyMsg};
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(value_parser)]
+    pub contract_address: AccountId,
+
+    #[clap(long)]
+    pub code_id: ContractCodeId,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+
+    #[clap(long)]
+    pub init_message: Option<String>,
+}
+
+pub async fn migrate(args: Args, client: SigningClient) {
+    println!("Starting contract migration!");
+
+    let memo = args.memo.unwrap_or_else(|| "contract migration".to_owned());
+    let contract_address = args.contract_address;
+
+    // the EmptyMsg{} argument is equivalent to `--init-message='{}'`
+    let res = if let Some(raw_msg) = args.init_message {
+        let msg: serde_json::Value =
+            serde_json::from_str(&raw_msg).expect("failed to parse init message");
+
+        client
+            .migrate(&contract_address, args.code_id, &msg, memo, None)
+            .await
+            .map_err(show_error_passthrough)
+            .expect("failed to migrate the contract!")
+    } else {
+        client
+            .migrate(&contract_address, args.code_id, &EmptyMsg {}, memo, None)
+            .await
+            .map_err(show_error_passthrough)
+            .expect("failed to migrate the contract!")
+    };
+
+    info!("Migrate result: {:?}", res);
+}
@@ -0,0 +1,28 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod execute_contract;
+pub mod init_contract;
+pub mod migrate_contract;
+pub mod upload_contract;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Cosmwasm {
+    #[clap(subcommand)]
+    pub command: Option<CosmwasmCommands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum CosmwasmCommands {
+    /// Upload a smart contract WASM blob
+    Upload(crate::validator::cosmwasm::upload_contract::Args),
+    /// Init a WASM smart contract
+    Init(crate::validator::cosmwasm::init_contract::Args),
+    /// Migrate a WASM smart contract
+    Migrate(crate::validator::cosmwasm::migrate_contract::Args),
+    /// Execute a WASM smart contract method
+    Execute(crate::validator::cosmwasm::execute_contract::Args),
+}
@@ -0,0 +1,37 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use std::io::Read;
+use std::path::PathBuf;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub wasm_path: PathBuf,
+
+    #[clap(long)]
+    pub memo: Option<String>,
+}
+
+pub async fn upload(args: Args, client: SigningClient) {
+    info!("Starting contract upload!");
+
+    let mut file = std::fs::File::open(args.wasm_path).expect("failed to open the wasm blob");
+    let mut data = Vec::new();
+
+    file.read_to_end(&mut data).unwrap();
+
+    let memo = args.memo.unwrap_or_else(|| "contract upload".to_owned());
+
+    let res = client
+        .upload(data, memo, None)
+        .await
+        .expect("failed to upload the contract!");
+
+    info!("Upload result: {:?}", res);
+
+    println!("{}", res.code_id)
+}
@@ -0,0 +1,31 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+use mixnet_contract_common::Coin;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub amount: u128,
+}
+
+pub async fn delegate_to_mixnode(args: Args, client: SigningClient) {
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!("Starting delegation to mixnode");
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .delegate_to_mixnode(&*args.identity_key, coin.into(), None)
+        .await
+        .expect("failed to delegate to mixnode!");
+
+    info!("delegating to mixnode: {:?}", res);
+}
@@ -0,0 +1,35 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod rewards;
+
+pub mod delegate_to_mixnode;
+pub mod query_for_delegations;
+pub mod undelegate_from_mixnode;
+pub mod vesting_delegate_to_mixnode;
+pub mod vesting_undelegate_from_mixnode;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetDelegators {
+    #[clap(subcommand)]
+    pub command: MixnetDelegatorsCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetDelegatorsCommands {
+    /// Lists current delegations
+    List(query_for_delegations::Args),
+    /// Manage rewards from delegations
+    Rewards(rewards::MixnetDelegatorsReward),
+    /// Delegate to a mixnode
+    Delegate(delegate_to_mixnode::Args),
+    /// Undelegate from a mixnode
+    Undelegate(undelegate_from_mixnode::Args),
+    /// Delegate to a mixnode with locked tokens
+    DelegateVesting(vesting_delegate_to_mixnode::Args),
+    /// Undelegate from a mixnode (when originally using locked tokens)
+    UndelegateVesting(vesting_undelegate_from_mixnode::Args),
+}
@@ -0,0 +1,129 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+
+use crate::context::SigningClientWithValidatorAPI;
+use crate::utils::{pretty_cosmwasm_coin, show_error_passthrough};
+
+use comfy_table::Table;
+use mixnet_contract_common::mixnode::DelegationEvent;
+use mixnet_contract_common::Delegation;
+
+#[derive(Debug, Parser)]
+pub struct Args {}
+
+pub async fn execute(_args: Args, client: SigningClientWithValidatorAPI) {
+    info!(
+        "Getting delegations for account {}...",
+        client.nymd.address()
+    );
+
+    let delegations = client
+        .get_all_delegator_delegations(client.nymd.address())
+        .await
+        .map_err(show_error_passthrough);
+
+    let mixnet_contract_events = client
+        .nymd
+        .get_pending_delegation_events(client.nymd.address().to_string(), None)
+        .await
+        .map_err(show_error_passthrough);
+
+    let vesting_contract = client.nymd.vesting_contract_address();
+
+    let vesting_contract_events = client
+        .nymd
+        .get_pending_delegation_events(
+            client.nymd.address().to_string(),
+            Some(vesting_contract.to_string()),
+        )
+        .await
+        .map_err(show_error_passthrough);
+
+    if let Ok(res) = delegations {
+        println!();
+        if res.is_empty() {
+            println!("This account has not delegated any tokens to mixnodes");
+        } else {
+            println!("Delegations:");
+            print_delegations(res, &client).await;
+        }
+    }
+    if let Ok(res) = mixnet_contract_events {
+        if !res.is_empty() {
+            println!();
+            println!("Pending delegations (liquid tokens):");
+            print_delegation_events(res, &client).await;
+        }
+    }
+    if let Ok(res) = vesting_contract_events {
+        if !res.is_empty() {
+            println!();
+            println!("Pending delegations (locked tokens):");
+            print_delegation_events(res, &client).await;
+        }
+    }
+}
+
+async fn to_iso_timestamp(block_height: u32, client: &SigningClientWithValidatorAPI) -> String {
+    match client.nymd.get_block_timestamp(Some(block_height)).await {
+        Ok(res) => res.to_rfc3339(),
+        Err(_e) => "-".to_string(),
+    }
+}
+
+async fn print_delegations(delegations: Vec<Delegation>, client: &SigningClientWithValidatorAPI) {
+    let mut table = Table::new();
+
+    table.set_header(vec!["Timestamp", "Identity Key", "Delegation", "Proxy"]);
+
+    for delegation in delegations {
+        table.add_row(vec![
+            to_iso_timestamp(delegation.block_height as u32, client).await,
+            delegation.node_identity.to_string(),
+            pretty_cosmwasm_coin(&delegation.amount),
+            format!("{:?}", delegation.proxy),
+        ]);
+    }
+
+    println!("{table}");
+}
+
+async fn print_delegation_events(
+    events: Vec<DelegationEvent>,
+    client: &SigningClientWithValidatorAPI,
+) {
+    let mut table = Table::new();
+
+    table.set_header(vec![
+        "Timestamp",
+        "Identity Key",
+        "Delegation",
+        "Event Type",
+    ]);
+
+    for event in events {
+        match event {
+            DelegationEvent::Delegate(delegation) => {
+                table.add_row(vec![
+                    to_iso_timestamp(delegation.block_height as u32, client).await,
+                    delegation.node_identity.to_string(),
+                    pretty_cosmwasm_coin(&delegation.amount),
+                    "Delegate".to_string(),
+                ]);
+            }
+            DelegationEvent::Undelegate(undelegate) => {
+                table.add_row(vec![
+                    to_iso_timestamp(undelegate.block_height() as u32, client).await,
+                    undelegate.mix_identity().to_string(),
+                    "-".to_string(),
+                    "Undelegate".to_string(),
+                ]);
+            }
+        }
+    }
+
+    println!("{table}");
+}
@@ -0,0 +1,23 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+}
+
+pub async fn claim_delegator_reward(args: Args, client: SigningClient) {
+    info!("Claim delegator reward");
+
+    let res = client
+        .execute_claim_delegator_reward(args.identity_key, None)
+        .await
+        .expect("failed to claim delegator-reward");
+
+    info!("Claiming delegator reward: {:?}", res)
+}
@@ -0,0 +1,22 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod claim_delegator_reward;
+pub mod vesting_claim_delegator_reward;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetDelegatorsReward {
+    #[clap(subcommand)]
+    pub command: MixnetDelegatorsRewardCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetDelegatorsRewardCommands {
+    /// Claim rewards accumulated during the delegation of unlocked tokens
+    Claim(claim_delegator_reward::Args),
+    /// Claim rewards accumulated during the delegation of locked tokens
+    VestingClaim(vesting_claim_delegator_reward::Args),
+}
@@ -0,0 +1,23 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity: String,
+}
+
+pub async fn vesting_claim_delegator_reward(args: Args, client: SigningClient) {
+    info!("Claim vesting delegator reward");
+
+    let res = client
+        .execute_vesting_claim_delegator_reward(args.identity, None)
+        .await
+        .expect("failed to claim vesting delegator-reward");
+
+    info!("Claiming vesting delegator reward: {:?}", res)
+}
@@ -0,0 +1,23 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::context::SigningClient;
+use clap::Parser;
+use log::info;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+}
+
+pub async fn undelegate_from_mixnode(args: Args, client: SigningClient) {
+    info!("removing stake from mix-node");
+
+    let res = client
+        .remove_mixnode_delegation(&*args.identity_key, None)
+        .await
+        .expect("failed to remove stake from mixnode!");
+
+    info!("removing stake from mixnode: {:?}", res)
+}
@@ -0,0 +1,34 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::info;
+
+use mixnet_contract_common::Coin;
+use validator_client::nymd::VestingSigningClient;
+
+use crate::context::SigningClient;
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    #[clap(long)]
+    pub identity_key: String,
+
+    #[clap(long)]
+    pub amount: u128,
+}
+
+pub async fn vesting_delegate_to_mixnode(args: Args, client: SigningClient) {
+    let denom = client.current_chain_details().mix_denom.base.as_str();
+
+    info!("Starting vesting delegation to mixnode");
+
+    let coin = Coin::new(args.amount, denom);
+
+    let res = client
+        .vesting_delegate_to_mixnode(&*args.identity_key, coin.into(), None)
+        .await
+        .expect("failed to delegate to mixnode!");
+
+    info!("vesting delegating to mixnode: {:?}", res);
+}
--- a/Show More
+++ b/Show More