Update contracts-build.yml

* feat: add a release step to nym contracts GH action

* feat: add shrinking the size of wasm

.env.sample-dev

@@ -3,3 +3,21 @@
 
 RUST_LOG=info
 RUST_BACKTRACE=1
+
+#########################################
+# geoipupdate (needed for explorer-api) #
+#########################################
+# MaxMind account ID (change it to a valid account ID)
+GEOIPUPDATE_ACCOUNT_ID=xxx
+# MaxMind license key (change it to a valid license key)
+GEOIPUPDATE_LICENSE_KEY=xxx
+# List of space-separated database edition IDs. Edition IDs may
+# consist of letters, digits, and dashes. For example, GeoIP2-City
+# would download the GeoIP2 City database (GeoIP2-City).
+GEOIPUPDATE_EDITION_IDS=GeoLite2-Country
+# The number of hours between geoipupdate runs. If this is not set
+# or is set to 0, geoipupdate will run once and exit.
+GEOIPUPDATE_FREQUENCY=72
+# The path to the directory where geoipupdate will download the
+# database.
+GEOIP_DB_DIRECTORY=./explorer-api/geo_ip

.github/workflows/audit.yml

@@ -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

.github/workflows/build.yml

@@ -16,7 +16,7 @@ jobs:
       RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
     steps:
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
 
       - name: Check out repository code
         uses: actions/checkout@v2

.github/workflows/contracts-build.yml

@@ -1,16 +1,21 @@
 name: Build release of Nym smart contracts
 on:
   workflow_dispatch:
-
-defaults:
-  run:
-    working-directory: contracts
+  release:
+    types: [created]
 
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      
+      - name: Check the release tag starts with `nym-contracts-`
+        if: startsWith(github.ref, 'refs/tags/nym-contracts-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-contracts-...')      
 
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
@@ -21,7 +26,7 @@ jobs:
           components: rustfmt, clippy
 
       - name: Build release contracts
-        run: RUSTFLAGS='-C link-arg=-s' cargo build --release --target wasm32-unknown-unknown
+        run: make wasm
 
       - name: Upload Mixnet Contract Artifact
         uses: actions/upload-artifact@v3
@@ -36,3 +41,11 @@ jobs:
           name: vesting_contract.wasm
           path: contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
           retention-days: 5
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
+            contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm

.github/workflows/network-explorer-api.yml

@@ -0,0 +1,56 @@
+name: CI for Network Explorer API
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet    
+
+jobs:
+  publish-nym:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
+
+      - name: Check the release tag starts with `nym-explorer-api-`
+        if: startsWith(github.ref, 'refs/tags/nym-explorer-api-') == false && github.event_name != 'workflow_dispatch'
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-explorer-api-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build all explorer-api
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path explorer-api/Cargo.toml --workspace --release
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: my-artifact
+          path: |
+            target/release/explorer-api
+          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/explorer-api

.github/workflows/nightly_build.yml

@@ -24,7 +24,7 @@ jobs:
     continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
     steps:
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
         if: matrix.os == 'ubuntu-latest'
 
       - name: Check out repository code
@@ -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:
@@ -101,6 +107,12 @@ jobs:
           command: build
           args: --workspace --features=coconut
 
+      - name: Reclaim some disk space (because Windows is being annoying)
+        uses: actions-rs/cargo@v1
+        if: ${{ matrix.os == 'windows-latest' }}
+        with:
+          command: clean
+
       - name: Run all tests with coconut enabled
         uses: actions-rs/cargo@v1
         with:

.github/workflows/nightly_build_on_dispatch.yml

@@ -166,8 +166,8 @@ jobs:
           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"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMTECH_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "${{ secrets.KEYBASE_CHANNEL_DEV_CORE_ID }}"
           IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
         uses: docker://keybaseio/client:stable-node
         with:

.github/workflows/nym-cli-publish.yml

@@ -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

.github/workflows/nym-release-publish.yml

@@ -1,5 +1,13 @@
 name: Publish Nym binaries
+
 on:
+  workflow_dispatch:
+    inputs:  
+      add_tokio_unstable:
+        description: 'True to add RUSTFLAGS="--cfg tokio_unstable"'
+        required: true
+        default: false
+        type: boolean 
   release:
     types: [created]
     
@@ -17,12 +25,20 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
+
       - 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: |
             core.setFailed('Release tag did not start with nym-binaries-...')
+            
+      - name: Sets env vars for tokio if set in manual dispatch inputs
+        run: |
+          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
+        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true
 
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
@@ -35,8 +51,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 +77,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

.github/workflows/support-files/notifications/send_message.js

@@ -89,7 +89,7 @@ async function sendKeybaseMessage(messageBody) {
     });
 
     const channel = {
-      name: 'nymtech_bot',
+      name: context.env.KEYBASE_NYMBOT_TEAM || 'nymtech_bot',
       membersType: 'team',
       topicName: context.keybase.channel,
       topic_type: 'CHAT',

CHANGELOG.md

@@ -2,8 +2,62 @@
 
 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v1.1.0](https://github.com/nymtech/nym/tree/v1.1.0) (2022-11-09)
 
-## [Unreleased]
+### Added
+
+- clients: add testing-only support for two more extended packet sizes (8kb and 16kb).
+- common/ledger: new library for communicating with a Ledger device ([#1640])
+- native-client/socks5-client/wasm-client: `disable_loop_cover_traffic_stream` Debug config option to disable the separate loop cover traffic stream ([#1666])
+- native-client/socks5-client/wasm-client: `disable_main_poisson_packet_distribution` Debug config option to make the client ignore poisson distribution in the main packet stream and ONLY send real message (and as fast as they come) ([#1664])
+- native-client/socks5-client/wasm-client: `use_extended_packet_size` Debug config option to make the client use 'ExtendedPacketSize' for its traffic (32kB as opposed to 2kB in 1.0.2) ([#1671])
+- network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611])
+- validator-api: add `interval_operating_cost` and `profit_margin_percent` to compute reward estimation endpoint
+- validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
+- wasm-client: uses updated wasm-compatible `client-core` so that it's now capable of packet retransmission, cover traffic and poisson delay (among other things!) ([#1673])
+
+### Fixed
+
+- socks5-client: fix bug where in some cases packet reordering could trigger a connection being closed too early ([#1702],[#1724])
+- validator-api: mixnode, gateway should now prefer values in config.toml over mainnet defaults ([#1645])
+- validator-api: should now correctly update historical uptimes for all mixnodes and gateways every 24h ([#1721])
+
+### Changed
+
+- clients: bound the sphinx packet channel and reduce sending rate if gateway can't keep up ([#1703],[#1725])
+- gateway-client: will attempt to read now as many as 8 websocket messages at once, assuming they're already available on the socket ([#1669])
+- moved `Percent` struct to `contracts-common`, change affects explorer-api
+- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
+- validator-api: changed error serialization on `inclusion_probability`, `stake-saturation` and `reward-estimation` endpoints to provide more accurate information ([#1681]) 
+- validator-client: made `fee` argument optional for `execute` and `execute_multiple` ([#1541])
+- wasm-client: fixed build errors on MacOS and changed example JS code to use mainnet ([#1585])
+- validator-api: changes to internal SQL schema due to the mixnet contract revamp ([#1472])
+- validator-api: changes to internal data structures due to the mixnet contract revamp ([#1472])
+- validator-api: split epoch-operations into multiple separate transactions ([#1472])
+
+[#1472]: https://github.com/nymtech/nym/pull/1472
+[#1541]: https://github.com/nymtech/nym/pull/1541
+[#1558]: https://github.com/nymtech/nym/pull/1558
+[#1577]: https://github.com/nymtech/nym/pull/1577
+[#1585]: https://github.com/nymtech/nym/pull/1585
+[#1591]: https://github.com/nymtech/nym/pull/1591
+[#1640]: https://github.com/nymtech/nym/pull/1640
+[#1645]: https://github.com/nymtech/nym/pull/1645
+[#1611]: https://github.com/nymtech/nym/pull/1611
+[#1664]: https://github.com/nymtech/nym/pull/1664
+[#1666]: https://github.com/nymtech/nym/pull/1645
+[#1669]: https://github.com/nymtech/nym/pull/1669
+[#1671]: https://github.com/nymtech/nym/pull/1671
+[#1673]: https://github.com/nymtech/nym/pull/1673
+[#1681]: https://github.com/nymtech/nym/pull/1681
+[#1702]: https://github.com/nymtech/nym/pull/1702
+[#1703]: https://github.com/nymtech/nym/pull/1703
+[#1721]: https://github.com/nymtech/nym/pull/1721
+[#1724]: https://github.com/nymtech/nym/pull/1724
+[#1725]: https://github.com/nymtech/nym/pull/1725
+
+
+## [nym-binaries-1.0.2](https://github.com/nymtech/nym/tree/nym-binaries-1.0.2)
 
 ### Added
 
@@ -19,13 +73,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])
-- add validator-client script rust binary /tools/validator-client-scripts
+- inclusion-probability: add simulator for active set inclusion probability
 
 ### Fixed
 
@@ -38,6 +93,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - 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
 
@@ -52,6 +108,9 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 - 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
@@ -78,90 +137,11 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#1478]: https://github.com/nymtech/nym/pull/1478
 [#1482]: https://github.com/nymtech/nym/pull/1482
 [#1487]: https://github.com/nymtech/nym/pull/1487
-
-## [nym-connect-v1.0.1](https://github.com/nymtech/nym/tree/nym-connect-v1.0.1) (2022-07-22)
-
-### Added
-
-- 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
-
-### Changed
-
-- nym-connect: reuse config id instead of creating a new id on each connection
-
-[#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])
+[#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)
 
@@ -194,77 +174,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)
@@ -343,108 +256,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)
 

Cargo.toml

@@ -22,22 +22,26 @@ 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/ledger",
+    "common/logging",
     "common/mixnode-common",
     "common/network-defaults",
     "common/nonexhaustive-delayqueue",
@@ -53,23 +57,25 @@ 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",
     "common/wasm-utils",
+    "common/completions",
     "explorer-api",
     "gateway",
     "gateway/gateway-requests",
+    "integrations/bity",
     "mixnode",
     "service-providers/network-requester",
     "service-providers/network-statistics",
     "validator-api",
     "validator-api/validator-api-requests",
-    "tools/ts-rs-cli",
-    "tools/validator-client-scripts"
+    "tools/nym-cli",
+    "tools/ts-rs-cli"
 ]
 
 default-members = [
@@ -77,9 +83,10 @@ default-members = [
     "clients/socks5",
     "gateway",
     "service-providers/network-requester",
+    "service-providers/network-statistics",
     "mixnode",
     "validator-api",
     "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "tokenomics-py", "clients/webassembly", "nym-wallet", "nym-connect"]
+exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect"]

Makefile

@@ -2,12 +2,12 @@ test: clippy-all cargo-test wasm fmt
 test-all: test cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-all-main clippy-all-contracts clippy-all-wallet clippy-all-connect
+clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
 clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
-cargo-test: test-main test-contracts test-wallet test-connect
-cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
-build: build-contracts build-wallet build-main build-connect
-fmt: fmt-main fmt-contracts fmt-wallet fmt-connect
+cargo-test: test-main test-contracts test-wallet test-connect test-coconut test-wasm-client
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive test-coconut-expensive
+build: build-contracts build-wallet build-main build-connect build-wasm-client
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client
 
 clippy-happy-main:
 	cargo clippy
@@ -21,8 +21,15 @@ clippy-happy-wallet:
 clippy-happy-connect:
 	cargo clippy --manifest-path nym-connect/Cargo.toml
 
-clippy-all-main:
-	cargo clippy --workspace --all-features -- -D warnings
+clippy-main:
+	cargo clippy --workspace -- -D warnings
+
+clippy-coconut:
+	cargo clippy --workspace --features coconut -- -D warnings
+
+clippy-wasm:
+	cargo clippy --workspace --features wasm -- -D warnings
+
 
 clippy-all-contracts:
 	cargo clippy --workspace --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
@@ -33,11 +40,24 @@ clippy-all-wallet:
 clippy-all-connect:
 	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings
 
+clippy-all-wasm-client:
+	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
+
 test-main:
-	cargo test --all-features --workspace
+	cargo test --workspace
+
+test-coconut:
+	cargo test --workspace --features coconut
+
+test-wasm:
+	cargo test --workspace --features wasm
+
 
 test-main-expensive:
-	cargo test --all-features --workspace -- --ignored
+	cargo test --workspace -- --ignored
+
+test-coconut-expensive:
+	cargo test --workspace --features coconut -- --ignored
 
 test-contracts:
 	cargo test --manifest-path contracts/Cargo.toml --all-features
@@ -51,6 +71,9 @@ test-wallet:
 test-wallet-expensive:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored
 
+test-wasm-client:
+	cargo test --workspace --manifest-path clients/webassembly/Cargo.toml --all-features
+
 test-connect:
 	cargo test --manifest-path nym-connect/Cargo.toml --all-features
 
@@ -69,8 +92,14 @@ build-wallet:
 build-connect:
 	cargo build --manifest-path nym-connect/Cargo.toml --workspace
 
-build-validator-scripts:
-	cargo build --release --manifest-path tools/validator-client-scripts/Cargo.toml
+build-explorer-api:
+	cargo build --manifest-path explorer-api/Cargo.toml --workspace
+
+build-wasm-client:
+	cargo build --manifest-path clients/webassembly/Cargo.toml --workspace --target wasm32-unknown-unknown
+
+build-nym-cli:
+	cargo build --release --manifest-path tools/nym-cli/Cargo.toml
 
 fmt-main:
 	cargo fmt --all
@@ -84,9 +113,15 @@ fmt-wallet:
 fmt-connect:
 	cargo fmt --manifest-path nym-connect/Cargo.toml --all
 
+fmt-wasm-client:
+	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all
+
 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
 
+mixnet-opt: wasm
+	cd contracts/mixnet && make opt
+
 generate-typescript:
 	cd tools/ts-rs-cli && cargo run && cd ../..
 	yarn types:lint:fix

clients/client-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.0.1"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 
@@ -13,23 +13,47 @@ humantime-serde = "1.0"
 log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
-sled = "0.34"
-tokio = { version = "1.19.1", features = ["macros"] }
+sled = { version = "0.34", optional = true }
+thiserror = "1.0.34"
 url = { version ="2.2", features = ["serde"] }
 
 # internal
 config = { path = "../../common/config" }
 crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
+#gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 nonexhaustive-delayqueue = { path = "../../common/nonexhaustive-delayqueue" }
 nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
 topology = { path = "../../common/topology" }
-validator-client = { path = "../../common/client-libs/validator-client" }
+validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
+tap = "1.0.1"
+
+tokio = { version = "1.21.2", features = ["time", "macros"]}
+
+[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
+version = "0.4"
+
+[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
+version = "0.2.83"
+
+[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-timer]
+git = "https://github.com/mmsinclair/wasm-timer"
+rev = "b9d1a54ad514c2f230a026afe0dde341e98cd7b6"
+
+[target."cfg(target_arch = \"wasm32\")".dependencies.gloo-timers]
+version = "0.2.4"
+features = ["futures"]
+
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.task]
+path = "../../common/task"
 
 [dev-dependencies]
 tempfile = "3.1.0"
 
 [features]
+default = ["reply-surb"]
+wasm = ["gateway-client/wasm"]
 coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
+reply-surb = ["sled"]

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

@@ -3,19 +3,27 @@
 
 use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::topology_control::TopologyAccessor;
+use crate::spawn_future;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::cover::generate_loop_cover_packet;
+use nymsphinx::params::PacketSize;
 use nymsphinx::utils::sample_poisson_duration;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
-use tokio::task::JoinHandle;
+use std::time::Duration;
+use tokio::sync::mpsc::error::TrySendError;
+
+#[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
 
+#[cfg(target_arch = "wasm32")]
+use wasm_timer;
+
 pub struct LoopCoverTrafficStream<R>
 where
     R: CryptoRng + Rng,
@@ -24,18 +32,22 @@ where
     ack_key: Arc<AckKey>,
 
     /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
-    average_ack_delay: time::Duration,
+    average_ack_delay: Duration,
 
     /// Average delay a data packet is going to get delay at a single mixnode.
-    average_packet_delay: time::Duration,
+    average_packet_delay: Duration,
 
     /// Average delay between sending subsequent cover packets.
-    average_cover_message_sending_delay: time::Duration,
+    average_cover_message_sending_delay: Duration,
 
     /// Internal state, determined by `average_message_sending_delay`,
     /// used to keep track of when a next packet should be sent out.
+    #[cfg(not(target_arch = "wasm32"))]
     next_delay: Pin<Box<time::Sleep>>,
 
+    #[cfg(target_arch = "wasm32")]
+    next_delay: Pin<Box<wasm_timer::Delay>>,
+
     /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
     /// out to the network without any further delays.
     mix_tx: BatchMixMessageSender,
@@ -48,6 +60,9 @@ where
 
     /// Accessor to the common instance of network topology.
     topology_access: TopologyAccessor,
+
+    /// Predefined packet size used for the loop cover messages.
+    packet_size: PacketSize,
 }
 
 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -69,13 +84,21 @@ where
         // we know it's time to send a message, so let's prepare delay for the next one
         // Get the `now` by looking at the current `delay` deadline
         let avg_delay = self.average_cover_message_sending_delay;
-        let now = self.next_delay.deadline();
         let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
 
         // The next interval value is `next_poisson_delay` after the one that just
         // yielded.
-        let next = now + next_poisson_delay;
-        self.next_delay.as_mut().reset(next);
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let now = self.next_delay.deadline();
+            let next = now + next_poisson_delay;
+            self.next_delay.as_mut().reset(next);
+        }
+
+        #[cfg(target_arch = "wasm32")]
+        {
+            self.next_delay.as_mut().reset(next_poisson_delay);
+        }
 
         Poll::Ready(Some(()))
     }
@@ -84,30 +107,42 @@ 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,
-        average_packet_delay: time::Duration,
-        average_cover_message_sending_delay: time::Duration,
+        average_ack_delay: Duration,
+        average_packet_delay: Duration,
+        average_cover_message_sending_delay: Duration,
         mix_tx: BatchMixMessageSender,
         our_full_destination: Recipient,
         topology_access: TopologyAccessor,
     ) -> Self {
         let rng = OsRng;
 
+        #[cfg(not(target_arch = "wasm32"))]
+        let next_delay = Box::pin(time::sleep(Default::default()));
+
+        #[cfg(target_arch = "wasm32")]
+        let next_delay = Box::pin(wasm_timer::Delay::new(Default::default()));
+
         LoopCoverTrafficStream {
             ack_key,
             average_ack_delay,
             average_packet_delay,
             average_cover_message_sending_delay,
-            next_delay: Box::pin(time::sleep(Default::default())),
+            next_delay,
             mix_tx,
             our_full_destination,
             rng,
             topology_access,
+            packet_size: Default::default(),
         }
     }
 
+    pub fn set_custom_packet_size(&mut self, packet_size: PacketSize) {
+        self.packet_size = packet_size;
+    }
+
     async fn on_new_message(&mut self) {
         trace!("next cover message!");
 
@@ -129,18 +164,26 @@ impl LoopCoverTrafficStream<OsRng> {
         let cover_message = generate_loop_cover_packet(
             &mut self.rng,
             topology_ref,
-            &*self.ack_key,
+            &self.ack_key,
             &self.our_full_destination,
             self.average_ack_delay,
             self.average_packet_delay,
+            self.packet_size,
         )
         .expect("Somehow failed to generate a loop cover message with a valid topology");
 
-        // if this one fails, there's no retrying because it means that either:
-        // - 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![cover_message]).unwrap();
+        if let Err(err) = self.mix_tx.try_send(vec![cover_message]) {
+            match err {
+                TrySendError::Full(_) => {
+                    // This isn't a problem, if the channel is full means we're already sending the
+                    // max amount of messages downstream can handle.
+                    log::debug!("Failed to send cover message - channel full");
+                }
+                TrySendError::Closed(_) => {
+                    log::warn!("Failed to send cover message - channel closed");
+                }
+            }
+        }
 
         // TODO: I'm not entirely sure whether this is really required, because I'm not 100%
         // sure how `yield_now()` works - whether it just notifies the scheduler or whether it
@@ -149,24 +192,56 @@ impl LoopCoverTrafficStream<OsRng> {
 
         // JS: due to identical logical structure to OutQueueControl::on_message(), this is also
         // presumably required to prevent bugs in the future. Exact reason is still unknown to me.
+
+        // TODO: temporary and BAD workaround for wasm (we should find a way to yield here in wasm)
+        #[cfg(not(target_arch = "wasm32"))]
         tokio::task::yield_now().await;
     }
 
-    async fn run(&mut self) {
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn start_with_shutdown(mut self, mut shutdown: task::ShutdownListener) {
         // we should set initial delay only when we actually start the stream
-        self.next_delay = Box::pin(time::sleep(sample_poisson_duration(
-            &mut self.rng,
-            self.average_cover_message_sending_delay,
-        )));
+        let sampled =
+            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
+        self.next_delay = Box::pin(time::sleep(sampled));
 
-        while self.next().await.is_some() {
-            self.on_new_message().await;
-        }
+        spawn_future(async move {
+            debug!("Started LoopCoverTrafficStream with graceful shutdown support");
+
+            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!(shutdown.is_shutdown_poll());
+            log::debug!("LoopCoverTrafficStream: Exiting");
+        })
     }
 
-    pub fn start(mut self) -> JoinHandle<()> {
-        tokio::spawn(async move {
-            self.run().await;
+    #[cfg(target_arch = "wasm32")]
+    pub fn start(mut self) {
+        // we should set initial delay only when we actually start the stream
+        let sampled =
+            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
+        self.next_delay = Box::pin(wasm_timer::Delay::new(sampled));
+
+        spawn_future(async move {
+            debug!("Started LoopCoverTrafficStream without graceful shutdown support");
+
+            while self.next().await.is_some() {
+                self.on_new_message().await;
+            }
         })
     }
 }

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

@@ -1,16 +1,16 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use futures::channel::mpsc;
-use futures::StreamExt;
+use crate::spawn_future;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;
-use tokio::task::JoinHandle;
 
-pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
-pub type BatchMixMessageReceiver = mpsc::UnboundedReceiver<Vec<MixPacket>>;
+pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
+pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
 
+// We remind ourselves that 32 x 32kb = 1024kb, a reasonable size for a network buffer.
+pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
 const MAX_FAILURE_COUNT: usize = 100;
 
 pub struct MixTrafficController {
@@ -25,15 +25,17 @@ pub struct MixTrafficController {
 }
 
 impl MixTrafficController {
-    pub fn new(
-        mix_rx: BatchMixMessageReceiver,
-        gateway_client: GatewayClient,
-    ) -> MixTrafficController {
-        MixTrafficController {
-            gateway_client,
-            mix_rx,
-            consecutive_gateway_failure_count: 0,
-        }
+    pub fn new(gateway_client: GatewayClient) -> (MixTrafficController, BatchMixMessageSender) {
+        let (sphinx_message_sender, sphinx_message_receiver) =
+            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
+        (
+            MixTrafficController {
+                gateway_client,
+                mix_rx: sphinx_message_receiver,
+                consecutive_gateway_failure_count: 0,
+            },
+            sphinx_message_sender,
+        )
     }
 
     async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
@@ -65,15 +67,40 @@ impl MixTrafficController {
         }
     }
 
-    pub async fn run(&mut self) {
-        while let Some(mix_packets) = self.mix_rx.next().await {
-            self.on_messages(mix_packets).await;
-        }
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn start_with_shutdown(mut self, mut shutdown: task::ShutdownListener) {
+        spawn_future(async move {
+            debug!("Started MixTrafficController with graceful shutdown support");
+
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    mix_packets = self.mix_rx.recv() => match mix_packets {
+                        Some(mix_packets) => {
+                            self.on_messages(mix_packets).await;
+                        },
+                        None => {
+                            log::trace!("MixTrafficController: Stopping since channel closed");
+                            break;
+                        }
+                    },
+                    _ = shutdown.recv() => {
+                        log::trace!("MixTrafficController: Received shutdown");
+                    }
+                }
+            }
+            assert!(shutdown.is_shutdown_poll());
+            log::debug!("MixTrafficController: Exiting");
+        })
     }
 
-    pub fn start(mut self) -> JoinHandle<()> {
-        tokio::spawn(async move {
-            self.run().await;
+    #[cfg(target_arch = "wasm32")]
+    pub fn start(mut self) {
+        spawn_future(async move {
+            debug!("Started MixTrafficController without graceful shutdown support");
+
+            while let Some(mix_packets) = self.mix_rx.recv().await {
+                self.on_messages(mix_packets).await;
+            }
         })
     }
 }

clients/client-core/src/client/mod.rs

@@ -1,8 +1,18 @@
+use std::sync::atomic::AtomicBool;
+
 pub mod cover_traffic_stream;
 pub mod inbound_messages;
 pub mod key_manager;
 pub mod mix_traffic;
 pub mod real_messages_control;
 pub mod received_buffer;
+#[cfg(feature = "reply-surb")]
 pub mod reply_key_storage;
 pub mod topology_control;
+
+// This is *NOT* used to signal shutdown.
+// It's critical that we don't have any tasks finishing early, this is an additional safety check
+// that tasks exiting are doing so because shutdown has been signalled, and no other reason.
+// In particular for tasks that rely on their associated channel being closed to signal shutdown,
+// and don't have access to a shutdown listener channel.
+pub static SHUTDOWN_HAS_BEEN_SIGNALLED: AtomicBool = AtomicBool::new(false);

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

@@ -63,14 +63,41 @@ impl AcknowledgementListener {
             .unwrap();
     }
 
-    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;
+    async fn handle_ack_receiver_item(&mut self, item: Vec<Vec<u8>>) {
+        // realistically we would only be getting one ack at the time
+        for ack in item {
+            self.on_ack(ack).await;
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started AcknowledgementListener with graceful shutdown support");
+
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                acks = self.ack_receiver.next() => match acks {
+                    Some(acks) => self.handle_ack_receiver_item(acks).await,
+                    None => {
+                        log::trace!("AcknowledgementListener: Stopping since channel closed");
+                        break;
+                    }
+                },
+                _ = shutdown.recv() => {
+                    log::trace!("AcknowledgementListener: Received shutdown");
+                }
             }
         }
-        error!("TODO: error msg. Or maybe panic?")
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("AcknowledgementListener: Exiting");
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub(super) async fn run(&mut self) {
+        debug!("Started AcknowledgementListener without graceful shutdown support");
+
+        while let Some(acks) = self.ack_receiver.next().await {
+            self.handle_ack_receiver_item(acks).await
+        }
     }
 }

clients/client-core/src/client/real_messages_control/acknowledgement_control/action_controller.rs

@@ -245,13 +245,44 @@ 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
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started ActionController with graceful shutdown support");
+
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                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;
+                    }
+                },
+                _ = shutdown.recv() => {
+                    log::trace!("ActionController: Received shutdown");
+                }
+            }
+        }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("ActionController: Exiting");
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub(super) async fn run(&mut self) {
+        debug!("Started ActionController without graceful shutdown support");
+
+        loop {
             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())
             }
         }

clients/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -3,7 +3,6 @@
 
 use super::action_controller::{Action, ActionSender};
 use super::PendingAcknowledgement;
-use crate::client::reply_key_storage::ReplyKeyStorage;
 use crate::client::{
     inbound_messages::{InputMessage, InputMessageReceiver},
     real_messages_control::real_traffic_stream::{BatchRealMessageSender, RealMessage},
@@ -17,6 +16,9 @@ use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
 use std::sync::Arc;
 
+#[cfg(feature = "reply-surb")]
+use crate::client::reply_key_storage::ReplyKeyStorage;
+
 /// Module responsible for dealing with the received messages: splitting them, creating acknowledgements,
 /// putting everything into sphinx packets, etc.
 /// It also makes an initial sending attempt for said messages.
@@ -31,6 +33,7 @@ where
     action_sender: ActionSender,
     real_message_sender: BatchRealMessageSender,
     topology_access: TopologyAccessor,
+    #[cfg(feature = "reply-surb")]
     reply_key_storage: ReplyKeyStorage,
 }
 
@@ -49,7 +52,7 @@ where
         action_sender: ActionSender,
         real_message_sender: BatchRealMessageSender,
         topology_access: TopologyAccessor,
-        reply_key_storage: ReplyKeyStorage,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
     ) -> Self {
         InputMessageListener {
             ack_key,
@@ -59,6 +62,7 @@ where
             action_sender,
             real_message_sender,
             topology_access,
+            #[cfg(feature = "reply-surb")]
             reply_key_storage,
         }
     }
@@ -117,12 +121,16 @@ where
             .prepare_and_split_message(content, with_reply_surb, topology)
             .expect("somehow the topology was invalid after all!");
 
+        #[cfg(feature = "reply-surb")]
         if let Some(reply_key) = reply_key {
             self.reply_key_storage
                 .insert_encryption_key(reply_key)
                 .expect("Failed to insert surb reply key to the store!")
         }
 
+        #[cfg(not(feature = "reply-surb"))]
+        let _reply_key = reply_key;
+
         // encrypt chunks, put them inside sphinx packets and generate acks
         let mut pending_acks = Vec::with_capacity(split_message.len());
         let mut real_messages = Vec::with_capacity(split_message.len());
@@ -133,7 +141,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(
@@ -181,11 +188,35 @@ where
         }
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started InputMessageListener with graceful shutdown support");
+
+        while !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;
+                    }
+                },
+                _ = shutdown.recv() => {
+                    log::trace!("InputMessageListener: Received shutdown");
+                }
+            }
+        }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("InputMessageListener: Exiting");
+    }
+
+    #[cfg(target_arch = "wasm32")]
     pub(super) async fn run(&mut self) {
-        debug!("Started InputMessageListener");
+        debug!("Started InputMessageListener without graceful shutdown support");
         while let Some(input_msg) = self.input_receiver.next().await {
             self.on_input_message(input_msg).await;
         }
-        error!("TODO: error msg. Or maybe panic?")
     }
 }

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

@@ -8,11 +8,12 @@ use self::{
     sent_notification_listener::SentNotificationListener,
 };
 use super::real_traffic_stream::BatchRealMessageSender;
-use crate::client::reply_key_storage::ReplyKeyStorage;
 use crate::client::{inbound_messages::InputMessageReceiver, topology_control::TopologyAccessor};
+use crate::spawn_future;
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
+use nymsphinx::params::PacketSize;
 use nymsphinx::{
     acknowledgements::AckKey,
     addressing::clients::Recipient,
@@ -25,7 +26,9 @@ use std::{
     sync::{Arc, Weak},
     time::Duration,
 };
-use tokio::task::JoinHandle;
+
+#[cfg(feature = "reply-surb")]
+use crate::client::reply_key_storage::ReplyKeyStorage;
 
 mod acknowledgement_listener;
 mod action_controller;
@@ -119,6 +122,9 @@ pub(super) struct Config {
 
     /// Average delay a data packet is going to get delayed at a single mixnode.
     average_packet_delay: Duration,
+
+    /// Predefined packet size used for the encapsulated messages.
+    packet_size: PacketSize,
 }
 
 impl Config {
@@ -133,33 +139,40 @@ impl Config {
             ack_wait_multiplier,
             average_ack_delay,
             average_packet_delay,
+            packet_size: Default::default(),
         }
     }
+
+    pub fn with_custom_packet_size(mut self, packet_size: PacketSize) -> Self {
+        self.packet_size = packet_size;
+        self
+    }
 }
 
 pub(super) struct AcknowledgementController<R>
 where
     R: CryptoRng + Rng,
 {
-    acknowledgement_listener: Option<AcknowledgementListener>,
-    input_message_listener: Option<InputMessageListener<R>>,
-    retransmission_request_listener: Option<RetransmissionRequestListener<R>>,
-    sent_notification_listener: Option<SentNotificationListener>,
-    action_controller: Option<ActionController>,
+    acknowledgement_listener: AcknowledgementListener,
+    input_message_listener: InputMessageListener<R>,
+    retransmission_request_listener: RetransmissionRequestListener<R>,
+    sent_notification_listener: SentNotificationListener,
+    action_controller: ActionController,
 }
 
 impl<R> AcknowledgementController<R>
 where
     R: 'static + CryptoRng + Rng + Clone + Send,
 {
+    #[allow(clippy::too_many_arguments)]
     pub(super) fn new(
         config: Config,
         rng: R,
         topology_access: TopologyAccessor,
         ack_key: Arc<AckKey>,
         ack_recipient: Recipient,
-        reply_key_storage: ReplyKeyStorage,
         connectors: AcknowledgementControllerConnectors,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
     ) -> Self {
         let (retransmission_tx, retransmission_rx) = mpsc::unbounded();
 
@@ -173,7 +186,8 @@ where
             ack_recipient,
             config.average_packet_delay,
             config.average_ack_delay,
-        );
+        )
+        .with_custom_real_message_packet_size(config.packet_size);
 
         // will listen for any acks coming from the network
         let acknowledgement_listener = AcknowledgementListener::new(
@@ -191,6 +205,7 @@ where
             action_sender.clone(),
             connectors.real_message_sender.clone(),
             topology_access.clone(),
+            #[cfg(feature = "reply-surb")]
             reply_key_storage,
         );
 
@@ -211,66 +226,87 @@ where
             SentNotificationListener::new(connectors.sent_notifier, action_sender);
 
         AcknowledgementController {
-            acknowledgement_listener: Some(acknowledgement_listener),
-            input_message_listener: Some(input_message_listener),
-            retransmission_request_listener: Some(retransmission_request_listener),
-            sent_notification_listener: Some(sent_notification_listener),
-            action_controller: Some(action_controller),
+            acknowledgement_listener,
+            input_message_listener,
+            retransmission_request_listener,
+            sent_notification_listener,
+            action_controller,
         }
     }
 
-    pub(super) async fn run(&mut self) {
-        let mut acknowledgement_listener = self.acknowledgement_listener.take().unwrap();
-        let mut input_message_listener = self.input_message_listener.take().unwrap();
-        let mut retransmission_request_listener =
-            self.retransmission_request_listener.take().unwrap();
-        let mut sent_notification_listener = self.sent_notification_listener.take().unwrap();
-        let mut action_controller = self.action_controller.take().unwrap();
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) fn start_with_shutdown(self, shutdown: task::ShutdownListener) {
+        let mut acknowledgement_listener = self.acknowledgement_listener;
+        let mut input_message_listener = self.input_message_listener;
+        let mut retransmission_request_listener = self.retransmission_request_listener;
+        let mut sent_notification_listener = self.sent_notification_listener;
+        let mut action_controller = self.action_controller;
 
-        // the below are log messages are errors as at the current stage we do not expect any of
-        // the task to ever finish. This will of course change once we introduce
-        // graceful shutdowns.
-        let ack_listener_fut = tokio::spawn(async move {
+        let shutdown_handle = shutdown.clone();
+        spawn_future(async move {
+            acknowledgement_listener
+                .run_with_shutdown(shutdown_handle)
+                .await;
+            debug!("The acknowledgement listener has finished execution!");
+        });
+
+        let shutdown_handle = shutdown.clone();
+        spawn_future(async move {
+            input_message_listener
+                .run_with_shutdown(shutdown_handle)
+                .await;
+            debug!("The input listener has finished execution!");
+        });
+
+        let shutdown_handle = shutdown.clone();
+        spawn_future(async move {
+            retransmission_request_listener
+                .run_with_shutdown(shutdown_handle)
+                .await;
+            debug!("The retransmission request listener has finished execution!");
+        });
+
+        let shutdown_handle = shutdown.clone();
+        spawn_future(async move {
+            sent_notification_listener
+                .run_with_shutdown(shutdown_handle)
+                .await;
+            debug!("The sent notification listener has finished execution!");
+        });
+
+        spawn_future(async move {
+            action_controller.run_with_shutdown(shutdown).await;
+            debug!("The controller has finished execution!");
+        });
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub(super) fn start(self) {
+        let mut acknowledgement_listener = self.acknowledgement_listener;
+        let mut input_message_listener = self.input_message_listener;
+        let mut retransmission_request_listener = self.retransmission_request_listener;
+        let mut sent_notification_listener = self.sent_notification_listener;
+        let mut action_controller = self.action_controller;
+
+        spawn_future(async move {
             acknowledgement_listener.run().await;
             error!("The acknowledgement listener has finished execution!");
-            acknowledgement_listener
         });
-        let input_listener_fut = tokio::spawn(async move {
+        spawn_future(async move {
             input_message_listener.run().await;
             error!("The input listener has finished execution!");
-            input_message_listener
         });
-        let retransmission_req_fut = tokio::spawn(async move {
+        spawn_future(async move {
             retransmission_request_listener.run().await;
             error!("The retransmission request listener has finished execution!");
-            retransmission_request_listener
         });
-        let sent_notification_fut = tokio::spawn(async move {
+        spawn_future(async move {
             sent_notification_listener.run().await;
             error!("The sent notification listener has finished execution!");
-            sent_notification_listener
         });
-        let action_controller_fut = tokio::spawn(async move {
+        spawn_future(async move {
             action_controller.run().await;
             error!("The controller has finished execution!");
-            action_controller
         });
-
-        // technically we don't have to bring `AcknowledgementController` back to a valid state
-        // but we can do it, so why not? Perhaps it might be useful if we wanted to allow
-        // for restarts of certain modules without killing the entire process.
-        self.acknowledgement_listener = Some(ack_listener_fut.await.unwrap());
-        self.input_message_listener = Some(input_listener_fut.await.unwrap());
-        self.retransmission_request_listener = Some(retransmission_req_fut.await.unwrap());
-        self.sent_notification_listener = Some(sent_notification_fut.await.unwrap());
-        self.action_controller = Some(action_controller_fut.await.unwrap());
-    }
-
-    #[allow(dead_code)]
-    pub(super) fn start(mut self) -> JoinHandle<Self> {
-        tokio::spawn(async move {
-            self.run().await;
-            self
-        })
     }
 }

clients/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs

@@ -33,6 +33,7 @@ impl<R> RetransmissionRequestListener<R>
 where
     R: CryptoRng + Rng,
 {
+    #[allow(clippy::too_many_arguments)]
     pub(super) fn new(
         ack_key: Arc<AckKey>,
         ack_recipient: Recipient,
@@ -83,7 +84,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
@@ -120,11 +120,34 @@ where
             .unwrap();
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started RetransmissionRequestListener with graceful shutdown support");
+
+        while !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;
+                    }
+                },
+                _ = shutdown.recv() => {
+                    log::trace!("RetransmissionRequestListener: Received shutdown");
+                }
+            }
+        }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("RetransmissionRequestListener: Exiting");
+    }
+
+    #[cfg(target_arch = "wasm32")]
     pub(super) async fn run(&mut self) {
-        debug!("Started RetransmissionRequestListener");
+        debug!("Started RetransmissionRequestListener without graceful shutdown support");
+
         while let Some(timed_out_ack) = self.request_receiver.next().await {
             self.on_retransmission_request(timed_out_ack).await;
         }
-        error!("TODO: error msg. Or maybe panic?")
     }
 }

clients/client-core/src/client/real_messages_control/acknowledgement_control/sent_notification_listener.rs

@@ -42,11 +42,36 @@ impl SentNotificationListener {
             .unwrap();
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started SentNotificationListener with graceful shutdown support");
+
+        while !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;
+                    }
+                },
+                _ = shutdown.recv() => {
+                    log::trace!("SentNotificationListener: Received shutdown");
+                }
+            }
+        }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("SentNotificationListener: Exiting");
+    }
+
+    #[cfg(target_arch = "wasm32")]
     pub(super) async fn run(&mut self) {
-        debug!("Started SentNotificationListener");
+        debug!("Started SentNotificationListener without graceful shutdown support");
+
         while let Some(frag_id) = self.sent_notifier.next().await {
             self.on_sent_message(frag_id).await;
         }
-        error!("TODO: error msg. Or maybe panic?")
     }
 }

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

@@ -9,20 +9,23 @@ use self::{
     acknowledgement_control::AcknowledgementController, real_traffic_stream::OutQueueControl,
 };
 use crate::client::real_messages_control::acknowledgement_control::AcknowledgementControllerConnectors;
-use crate::client::reply_key_storage::ReplyKeyStorage;
 use crate::client::{
     inbound_messages::InputMessageReceiver, mix_traffic::BatchMixMessageSender,
     topology_control::TopologyAccessor,
 };
+use crate::spawn_future;
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::params::PacketSize;
 use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::task::JoinHandle;
+
+#[cfg(feature = "reply-surb")]
+use crate::client::reply_key_storage::ReplyKeyStorage;
 
 mod acknowledgement_control;
 mod real_traffic_stream;
@@ -49,9 +52,18 @@ pub struct Config {
 
     /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
     average_ack_delay_duration: Duration,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    disable_main_poisson_packet_distribution: bool,
+
+    /// Predefined packet size used for the encapsulated messages.
+    packet_size: PacketSize,
 }
 
 impl Config {
+    // TODO: change the config into a builder
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         ack_key: Arc<AckKey>,
         ack_wait_multiplier: f64,
@@ -59,6 +71,7 @@ impl Config {
         average_ack_delay_duration: Duration,
         average_message_sending_delay: Duration,
         average_packet_delay_duration: Duration,
+        disable_main_poisson_packet_distribution: bool,
         self_recipient: Recipient,
     ) -> Self {
         Config {
@@ -69,16 +82,22 @@ impl Config {
             average_message_sending_delay,
             average_packet_delay_duration,
             average_ack_delay_duration,
+            disable_main_poisson_packet_distribution,
+            packet_size: Default::default(),
         }
     }
+
+    pub fn set_custom_packet_size(&mut self, packet_size: PacketSize) {
+        self.packet_size = packet_size;
+    }
 }
 
 pub struct RealMessagesController<R>
 where
     R: CryptoRng + Rng,
 {
-    out_queue_control: Option<OutQueueControl<R>>,
-    ack_control: Option<AcknowledgementController<R>>,
+    out_queue_control: OutQueueControl<R>,
+    ack_control: AcknowledgementController<R>,
 }
 
 // obviously when we finally make shared rng that is on 'higher' level, this should become
@@ -90,7 +109,7 @@ impl RealMessagesController<OsRng> {
         input_receiver: InputMessageReceiver,
         mix_sender: BatchMixMessageSender,
         topology_access: TopologyAccessor,
-        reply_key_storage: ReplyKeyStorage,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
     ) -> Self {
         let rng = OsRng;
 
@@ -109,7 +128,8 @@ impl RealMessagesController<OsRng> {
             config.ack_wait_multiplier,
             config.average_ack_delay_duration,
             config.average_packet_delay_duration,
-        );
+        )
+        .with_custom_packet_size(config.packet_size);
 
         let ack_control = AcknowledgementController::new(
             ack_control_config,
@@ -117,15 +137,18 @@ impl RealMessagesController<OsRng> {
             topology_access.clone(),
             Arc::clone(&config.ack_key),
             config.self_recipient,
-            reply_key_storage,
             ack_controller_connectors,
+            #[cfg(feature = "reply-surb")]
+            reply_key_storage,
         );
 
         let out_queue_config = real_traffic_stream::Config::new(
             config.average_ack_delay_duration,
             config.average_packet_delay_duration,
             config.average_message_sending_delay,
-        );
+            config.disable_main_poisson_packet_distribution,
+        )
+        .with_custom_cover_packet_size(config.packet_size);
 
         let out_queue_control = OutQueueControl::new(
             out_queue_config,
@@ -139,40 +162,33 @@ impl RealMessagesController<OsRng> {
         );
 
         RealMessagesController {
-            out_queue_control: Some(out_queue_control),
-            ack_control: Some(ack_control),
+            out_queue_control,
+            ack_control,
         }
     }
 
-    pub(super) async fn run(&mut self) {
-        let mut out_queue_control = self.out_queue_control.take().unwrap();
-        let mut ack_control = self.ack_control.take().unwrap();
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn start_with_shutdown(self, shutdown: task::ShutdownListener) {
+        let mut out_queue_control = self.out_queue_control;
+        let ack_control = self.ack_control;
 
-        // the below are log messages are errors as at the current stage we do not expect any of
-        // the task to ever finish. This will of course change once we introduce
-        // 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!");
-            out_queue_control
+        let shutdown_handle = shutdown.clone();
+        spawn_future(async move {
+            out_queue_control.run_with_shutdown(shutdown_handle).await;
+            debug!("The out queue controller has finished execution!");
         });
-        let ack_control_fut = tokio::spawn(async move {
-            ack_control.run().await;
-            error!("The acknowledgement controller has finished execution!");
-            ack_control
-        });
-
-        // technically we don't have to bring `RealMessagesController` back to a valid state
-        // but we can do it, so why not? Perhaps it might be useful if we wanted to allow
-        // for restarts of certain modules without killing the entire process.
-        self.out_queue_control = Some(out_queue_control_fut.await.unwrap());
-        self.ack_control = Some(ack_control_fut.await.unwrap());
+        ack_control.start_with_shutdown(shutdown);
     }
 
-    pub fn start(mut self) -> JoinHandle<Self> {
-        tokio::spawn(async move {
-            self.run().await;
-            self
-        })
+    #[cfg(target_arch = "wasm32")]
+    pub fn start(self) {
+        let mut out_queue_control = self.out_queue_control;
+        let ack_control = self.ack_control;
+
+        spawn_future(async move {
+            out_queue_control.run().await;
+            debug!("The out queue controller has finished execution!");
+        });
+        ack_control.start();
     }
 }

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

@@ -13,14 +13,37 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::chunking::fragment::FragmentIdentifier;
 use nymsphinx::cover::generate_loop_cover_packet;
 use nymsphinx::forwarding::packet::MixPacket;
+use nymsphinx::params::PacketSize;
 use nymsphinx::utils::sample_poisson_duration;
 use rand::{CryptoRng, Rng};
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
+
+#[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
 
+#[cfg(target_arch = "wasm32")]
+use wasm_timer;
+
+// The minimum time between increasing the average delay between packets. If we hit the ceiling in
+// the available buffer space we want to take somewhat swift action, but we still need to give a
+// short time to give the channel a chance reduce pressure.
+const INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 1;
+// The minimum time between decreasing the average delay between packets. We don't want to change
+// to quickly to keep things somewhat stable. Also there are buffers downstreams meaning we need to
+// wait a little to see the effect before we decrease further.
+const DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 30;
+// If we enough time passes without any sign of backpressure in the channel, we can consider
+// lowering the average delay. The goal is to keep somewhat stable, rather than maxing out
+// bandwidth at all times.
+const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 30;
+// The maximum multiplier we apply to the base average Poisson delay.
+const MAX_DELAY_MULTIPLIER: u32 = 6;
+// The minium multiplier we apply to the base average Poisson delay.
+const MIN_DELAY_MULTIPLIER: u32 = 1;
+
 /// Configurable parameters of the `OutQueueControl`
 pub(crate) struct Config {
     /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
@@ -31,6 +54,13 @@ pub(crate) struct Config {
 
     /// Average delay between sending subsequent packets.
     average_message_sending_delay: Duration,
+
+    /// Controls whether the stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    disable_poisson_packet_distribution: bool,
+
+    /// Predefined packet size used for the loop cover messages.
+    cover_packet_size: PacketSize,
 }
 
 impl Config {
@@ -38,13 +68,116 @@ impl Config {
         average_ack_delay: Duration,
         average_packet_delay: Duration,
         average_message_sending_delay: Duration,
+        disable_poisson_packet_distribution: bool,
     ) -> Self {
         Config {
             average_ack_delay,
             average_packet_delay,
             average_message_sending_delay,
+            disable_poisson_packet_distribution,
+            cover_packet_size: Default::default(),
         }
     }
+
+    pub fn with_custom_cover_packet_size(mut self, packet_size: PacketSize) -> Self {
+        self.cover_packet_size = packet_size;
+        self
+    }
+}
+
+struct SendingDelayController {
+    /// Multiply the average sending delay.
+    /// This is normally set to unity, but if we detect backpressure we increase this
+    /// multiplier. We use discrete steps.
+    current_multiplier: u32,
+
+    /// Maximum delay multiplier
+    upper_bound: u32,
+
+    /// Minimum delay multiplier
+    lower_bound: u32,
+
+    /// To make sure we don't change the multiplier to fast, we limit a change to some duration
+    #[cfg(not(target_arch = "wasm32"))]
+    time_when_changed: time::Instant,
+
+    #[cfg(target_arch = "wasm32")]
+    time_when_changed: wasm_timer::Instant,
+
+    /// If we have a long enough time without any backpressure detected we try reducing the sending
+    /// delay multiplier
+    #[cfg(not(target_arch = "wasm32"))]
+    time_when_backpressure_detected: time::Instant,
+
+    #[cfg(target_arch = "wasm32")]
+    time_when_backpressure_detected: wasm_timer::Instant,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn get_time_now() -> time::Instant {
+    time::Instant::now()
+}
+
+#[cfg(target_arch = "wasm32")]
+fn get_time_now() -> wasm_timer::Instant {
+    wasm_timer::Instant::now()
+}
+
+impl SendingDelayController {
+    fn new(lower_bound: u32, upper_bound: u32) -> Self {
+        assert!(lower_bound <= upper_bound);
+        let now = get_time_now();
+        SendingDelayController {
+            current_multiplier: MIN_DELAY_MULTIPLIER,
+            upper_bound,
+            lower_bound,
+            time_when_changed: now,
+            time_when_backpressure_detected: now,
+        }
+    }
+
+    fn current_multiplier(&self) -> u32 {
+        self.current_multiplier
+    }
+
+    fn increase_delay_multiplier(&mut self) {
+        self.current_multiplier =
+            (self.current_multiplier + 1).clamp(self.lower_bound, self.upper_bound);
+        self.time_when_changed = get_time_now();
+        log::debug!(
+            "Increasing sending delay multiplier to: {}",
+            self.current_multiplier
+        );
+    }
+
+    fn decrease_delay_multiplier(&mut self) {
+        self.current_multiplier =
+            (self.current_multiplier - 1).clamp(self.lower_bound, self.upper_bound);
+        self.time_when_changed = get_time_now();
+        log::debug!(
+            "Decreasing sending delay multiplier to: {}",
+            self.current_multiplier
+        );
+    }
+
+    fn record_backpressure_detected(&mut self) {
+        self.time_when_backpressure_detected = get_time_now();
+    }
+
+    fn not_increased_delay_recently(&self) -> bool {
+        get_time_now()
+            > self.time_when_changed + Duration::from_secs(INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
+    }
+
+    fn is_sending_reliable(&self) -> bool {
+        let now = get_time_now();
+        let delay_change_interval = Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS);
+        let acceptable_time_without_backpressure =
+            Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS);
+
+        now > self.time_when_backpressure_detected + acceptable_time_without_backpressure
+            && now > self.time_when_changed + delay_change_interval
+    }
 }
 
 pub(crate) struct OutQueueControl<R>
@@ -62,7 +195,15 @@ where
 
     /// Internal state, determined by `average_message_sending_delay`,
     /// used to keep track of when a next packet should be sent out.
-    next_delay: Pin<Box<time::Sleep>>,
+    #[cfg(not(target_arch = "wasm32"))]
+    next_delay: Option<Pin<Box<time::Sleep>>>,
+
+    #[cfg(target_arch = "wasm32")]
+    next_delay: Option<Pin<Box<wasm_timer::Delay>>>,
+
+    // To make sure we don't overload the mix_tx channel, we limit the rate we are pushing
+    // messages.
+    sending_rate_controller: SendingDelayController,
 
     /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
     /// out to the network without any further delays.
@@ -109,55 +250,6 @@ pub(crate) enum StreamMessage {
     Real(Box<RealMessage>),
 }
 
-impl<R> Stream for OutQueueControl<R>
-where
-    R: CryptoRng + Rng + Unpin,
-{
-    type Item = StreamMessage;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        // it is not yet time to return a message
-        if self.next_delay.as_mut().poll(cx).is_pending() {
-            return Poll::Pending;
-        };
-
-        // we know it's time to send a message, so let's prepare delay for the next one
-        // Get the `now` by looking at the current `delay` deadline
-        let avg_delay = self.config.average_message_sending_delay;
-        let now = self.next_delay.deadline();
-        let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
-
-        // The next interval value is `next_poisson_delay` after the one that just
-        // yielded.
-        let next = now + next_poisson_delay;
-        self.next_delay.as_mut().reset(next);
-
-        // check if we have anything immediately available
-        if let Some(real_available) = self.received_buffer.pop_front() {
-            return Poll::Ready(Some(StreamMessage::Real(Box::new(real_available))));
-        }
-
-        // decide what kind of message to send
-        match Pin::new(&mut self.real_receiver).poll_next(cx) {
-            // in the case our real message channel stream was closed, we should also indicate we are closed
-            // (and whoever is using the stream should panic)
-            Poll::Ready(None) => Poll::Ready(None),
-
-            // if there are more messages available, return first one and store the rest
-            Poll::Ready(Some(real_messages)) => {
-                self.received_buffer = real_messages.into();
-                // we MUST HAVE received at least ONE message
-                Poll::Ready(Some(StreamMessage::Real(Box::new(
-                    self.received_buffer.pop_front().unwrap(),
-                ))))
-            }
-
-            // otherwise construct a dummy one
-            Poll::Pending => Poll::Ready(Some(StreamMessage::Cover)),
-        }
-    }
-}
-
 impl<R> OutQueueControl<R>
 where
     R: CryptoRng + Rng + Unpin,
@@ -179,7 +271,11 @@ where
             config,
             ack_key,
             sent_notifier,
-            next_delay: Box::pin(time::sleep(Default::default())),
+            next_delay: None,
+            sending_rate_controller: SendingDelayController::new(
+                MIN_DELAY_MULTIPLIER,
+                MAX_DELAY_MULTIPLIER,
+            ),
             mix_tx,
             real_receiver,
             our_full_destination,
@@ -222,10 +318,11 @@ where
                 generate_loop_cover_packet(
                     &mut self.rng,
                     topology_ref,
-                    &*self.ack_key,
+                    &self.ack_key,
                     &self.our_full_destination,
                     self.config.average_ack_delay,
                     self.config.average_packet_delay,
+                    self.config.cover_packet_size,
                 )
                 .expect("Somehow failed to generate a loop cover message with a valid topology")
             }
@@ -235,35 +332,208 @@ where
             }
         };
 
-        // if this one fails, there's no retrying because it means that either:
-        // - 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.send(vec![next_message]).await {
+            log::error!("Failed to send - channel closed: {}", 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
         // JS2: Basically it was the case that with high enough rate, the stream had already a next value
         // ready and hence was immediately re-scheduled causing other tasks to be starved;
         // yield makes it go back the scheduling queue regardless of its value availability
+
+        // TODO: temporary and BAD workaround for wasm (we should find a way to yield here in wasm)
+        #[cfg(not(target_arch = "wasm32"))]
         tokio::task::yield_now().await;
     }
 
-    // Send messages at certain rate and if no real traffic is available, send cover message.
-    async fn run_normal_out_queue(&mut self) {
-        // we should set initial delay only when we actually start the stream
-        self.next_delay = Box::pin(time::sleep(sample_poisson_duration(
-            &mut self.rng,
-            self.config.average_message_sending_delay,
-        )));
+    fn current_average_message_sending_delay(&self) -> Duration {
+        self.config.average_message_sending_delay
+            * self.sending_rate_controller.current_multiplier()
+    }
+
+    fn adjust_current_average_message_sending_delay(&mut self) {
+        let used_slots = self.mix_tx.max_capacity() - self.mix_tx.capacity();
+        log::trace!(
+            "used_slots: {used_slots}, current_multiplier: {}",
+            self.sending_rate_controller.current_multiplier()
+        );
+
+        // Even just a single used slot is enough to signal backpressure
+        if used_slots > 0 {
+            log::trace!("Backpressure detected");
+            self.sending_rate_controller.record_backpressure_detected();
+        }
+
+        // If the buffer is running out, slow down the sending rate
+        if self.mix_tx.capacity() == 0
+            && self.sending_rate_controller.not_increased_delay_recently()
+        {
+            self.sending_rate_controller.increase_delay_multiplier();
+        }
+
+        // Very carefully step up the sending rate in case it seems like we can solidly handle the
+        // current rate.
+        if self.sending_rate_controller.is_sending_reliable() {
+            self.sending_rate_controller.decrease_delay_multiplier();
+        }
+    }
+
+    fn poll_poisson(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
+        // The average delay could change depending on if backpressure in the downstream channel
+        // (mix_tx) was detected.
+        self.adjust_current_average_message_sending_delay();
+        let avg_delay = self.current_average_message_sending_delay();
+
+        if let Some(ref mut next_delay) = &mut self.next_delay {
+            // it is not yet time to return a message
+            if next_delay.as_mut().poll(cx).is_pending() {
+                return Poll::Pending;
+            };
+
+            // we know it's time to send a message, so let's prepare delay for the next one
+            // Get the `now` by looking at the current `delay` deadline
+            let next_poisson_delay = sample_poisson_duration(&mut self.rng, avg_delay);
+
+            // The next interval value is `next_poisson_delay` after the one that just
+            // yielded.
+            #[cfg(not(target_arch = "wasm32"))]
+            {
+                let now = next_delay.deadline();
+                let next = now + next_poisson_delay;
+                next_delay.as_mut().reset(next);
+            }
+
+            #[cfg(target_arch = "wasm32")]
+            {
+                next_delay.as_mut().reset(next_poisson_delay);
+            }
+
+            // check if we have anything immediately available
+            if let Some(real_available) = self.received_buffer.pop_front() {
+                return Poll::Ready(Some(StreamMessage::Real(Box::new(real_available))));
+            }
+
+            // decide what kind of message to send
+            match Pin::new(&mut self.real_receiver).poll_next(cx) {
+                // in the case our real message channel stream was closed, we should also indicate we are closed
+                // (and whoever is using the stream should panic)
+                Poll::Ready(None) => Poll::Ready(None),
+
+                // if there are more messages available, return first one and store the rest
+                Poll::Ready(Some(real_messages)) => {
+                    self.received_buffer = real_messages.into();
+                    // we MUST HAVE received at least ONE message
+                    Poll::Ready(Some(StreamMessage::Real(Box::new(
+                        self.received_buffer.pop_front().unwrap(),
+                    ))))
+                }
+
+                // otherwise construct a dummy one
+                Poll::Pending => Poll::Ready(Some(StreamMessage::Cover)),
+            }
+        } else {
+            // we never set an initial delay - let's do it now
+            cx.waker().wake_by_ref();
+
+            let sampled =
+                sample_poisson_duration(&mut self.rng, self.config.average_message_sending_delay);
+
+            #[cfg(not(target_arch = "wasm32"))]
+            let next_delay = Box::pin(time::sleep(sampled));
+
+            #[cfg(target_arch = "wasm32")]
+            let next_delay = Box::pin(wasm_timer::Delay::new(sampled));
+
+            self.next_delay = Some(next_delay);
+
+            Poll::Pending
+        }
+    }
+
+    fn poll_immediate(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
+        // check if we have anything immediately available
+        if let Some(real_available) = self.received_buffer.pop_front() {
+            // if there are more messages immediately available, notify the runtime
+            // because we should be polled again
+            if !self.received_buffer.is_empty() {
+                cx.waker().wake_by_ref()
+            }
+            return Poll::Ready(Some(StreamMessage::Real(Box::new(real_available))));
+        }
+
+        match Pin::new(&mut self.real_receiver).poll_next(cx) {
+            // in the case our real message channel stream was closed, we should also indicate we are closed
+            // (and whoever is using the stream should panic)
+            Poll::Ready(None) => Poll::Ready(None),
+
+            // if there are more messages available, return first one and store the rest
+            Poll::Ready(Some(real_messages)) => {
+                self.received_buffer = real_messages.into();
+                // we MUST HAVE received at least ONE message
+                Poll::Ready(Some(StreamMessage::Real(Box::new(
+                    self.received_buffer.pop_front().unwrap(),
+                ))))
+            }
+
+            // if there's nothing, then there's nothing
+            Poll::Pending => Poll::Pending,
+        }
+    }
+
+    fn poll_next_message(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<StreamMessage>> {
+        if self.config.disable_poisson_packet_distribution {
+            self.poll_immediate(cx)
+        } else {
+            self.poll_poisson(cx)
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started OutQueueControl with graceful shutdown support");
+
+        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");
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub(super) async fn run(&mut self) {
+        debug!("Started OutQueueControl without graceful shutdown support");
 
         while let Some(next_message) = self.next().await {
             self.on_message(next_message).await;
         }
     }
+}
 
-    pub(crate) async fn run_out_queue_control(&mut self) {
-        debug!("Starting out queue controller...");
-        self.run_normal_out_queue().await
+impl<R> Stream for OutQueueControl<R>
+where
+    R: CryptoRng + Rng + Unpin,
+{
+    type Item = StreamMessage;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        self.poll_next_message(cx)
     }
 }

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

@@ -1,21 +1,25 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::reply_key_storage::ReplyKeyStorage;
+use crate::spawn_future;
 use crypto::asymmetric::encryption;
-use crypto::symmetric::stream_cipher;
-use crypto::Digest;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
 use futures::StreamExt;
 use gateway_client::MixnetMessageReceiver;
 use log::*;
-use nymsphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncryptionKey};
-use nymsphinx::params::{ReplySurbEncryptionAlgorithm, ReplySurbKeyDigestAlgorithm};
 use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
 use std::sync::Arc;
-use tokio::task::JoinHandle;
+
+#[cfg(feature = "reply-surb")]
+use crate::client::reply_key_storage::ReplyKeyStorage;
+#[cfg(feature = "reply-surb")]
+use crypto::{symmetric::stream_cipher, Digest};
+#[cfg(feature = "reply-surb")]
+use nymsphinx::anonymous_replies::{encryption_key::EncryptionKeyDigest, SurbEncryptionKey};
+#[cfg(feature = "reply-surb")]
+use nymsphinx::params::{ReplySurbEncryptionAlgorithm, ReplySurbKeyDigestAlgorithm};
 
 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
 // or to say "hey, I'm going offline, don't send anything more to me. Just buffer them instead"
@@ -113,13 +117,14 @@ struct ReceivedMessagesBuffer {
 
     /// Storage containing keys to all [`ReplySURB`]s ever sent out that we did not receive back.
     // There's no need to put it behind a Mutex since it's already properly concurrent
+    #[cfg(feature = "reply-surb")]
     reply_key_storage: ReplyKeyStorage,
 }
 
 impl ReceivedMessagesBuffer {
     fn new(
         local_encryption_keypair: Arc<encryption::KeyPair>,
-        reply_key_storage: ReplyKeyStorage,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
     ) -> Self {
         ReceivedMessagesBuffer {
             inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
@@ -129,6 +134,7 @@ impl ReceivedMessagesBuffer {
                 message_sender: None,
                 recently_reconstructed: HashSet::new(),
             })),
+            #[cfg(feature = "reply-surb")]
             reply_key_storage,
         }
     }
@@ -177,6 +183,7 @@ impl ReceivedMessagesBuffer {
         self.inner.lock().await.messages.extend(msgs)
     }
 
+    #[cfg(feature = "reply-surb")]
     fn process_received_reply(
         reply_ciphertext: &[u8],
         reply_key: SurbEncryptionKey,
@@ -209,38 +216,50 @@ impl ReceivedMessagesBuffer {
         let mut completed_messages = Vec::new();
         let mut inner_guard = self.inner.lock().await;
 
-        let reply_surb_digest_size = ReplySurbKeyDigestAlgorithm::output_size();
-
         // first check if this is a reply or a chunked message
         // TODO: verify with @AP if this way of doing it is safe or whether it could
         // cause some attacks due to, I don't know, stupid edge case collisions?
         // Update: this DOES introduce a possible leakage: https://github.com/nymtech/nym/issues/296
         for msg in msgs {
-            let possible_key_digest =
-                EncryptionKeyDigest::clone_from_slice(&msg[..reply_surb_digest_size]);
+            // TODO:
+            // 1. make it nicer
+            // 2. make it not feature-locked
 
-            // check first `HasherOutputSize` bytes if they correspond to known encryption key
-            // if yes - this is a reply message
-
-            // TODO: this might be a bottleneck - since the keys are stored on disk we, presumably,
-            // are doing a disk operation every single received fragment
-            if let Some(reply_encryption_key) = self
-                .reply_key_storage
-                .get_and_remove_encryption_key(possible_key_digest)
-                .expect("storage operation failed!")
+            #[cfg(feature = "reply-surb")]
             {
-                if let Some(completed_message) = Self::process_received_reply(
-                    &msg[reply_surb_digest_size..],
-                    reply_encryption_key,
-                ) {
-                    completed_messages.push(completed_message)
-                }
-            } else {
-                // otherwise - it's a 'normal' message
-                if let Some(completed_message) = inner_guard.process_received_fragment(msg) {
-                    completed_messages.push(completed_message)
+                let reply_surb_digest_size = ReplySurbKeyDigestAlgorithm::output_size();
+
+                let possible_key_digest =
+                    EncryptionKeyDigest::clone_from_slice(&msg[..reply_surb_digest_size]);
+
+                // check first `HasherOutputSize` bytes if they correspond to known encryption key
+                // if yes - this is a reply message
+
+                // TODO: this might be a bottleneck - since the keys are stored on disk we, presumably,
+                // are doing a disk operation every single received fragment
+                if let Some(reply_encryption_key) = self
+                    .reply_key_storage
+                    .get_and_remove_encryption_key(possible_key_digest)
+                    .expect("storage operation failed!")
+                {
+                    if let Some(completed_message) = Self::process_received_reply(
+                        &msg[reply_surb_digest_size..],
+                        reply_encryption_key,
+                    ) {
+                        completed_messages.push(completed_message)
+                    }
+                } else {
+                    // otherwise - it's a 'normal' message
+                    if let Some(completed_message) = inner_guard.process_received_fragment(msg) {
+                        completed_messages.push(completed_message)
+                    }
                 }
             }
+
+            #[cfg(not(feature = "reply-surb"))]
+            if let Some(completed_message) = inner_guard.process_received_fragment(msg) {
+                completed_messages.push(completed_message)
+            }
         }
 
         if !completed_messages.is_empty() {
@@ -290,19 +309,48 @@ 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
-                    }
-                }
+    async fn handle_message(&mut self, message: ReceivedBufferMessage) {
+        match message {
+            ReceivedBufferMessage::ReceiverAnnounce(sender) => {
+                self.received_buffer.connect_sender(sender).await;
             }
-        })
+            ReceivedBufferMessage::ReceiverDisconnect => {
+                self.received_buffer.disconnect_sender().await
+            }
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started RequestReceiver with graceful shutdown support");
+        while !shutdown.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = shutdown.recv() => {
+                    log::trace!("RequestReceiver: Received shutdown");
+                }
+                request = self.query_receiver.next() => {
+                    match request {
+                        Some(message) => self.handle_message(message).await,
+                        None => {
+                            log::trace!("RequestReceiver: Stopping since channel closed");
+                            break;
+                        },
+                    }
+                },
+            }
+        }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("RequestReceiver: Exiting");
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    async fn run(&mut self) {
+        debug!("Started RequestReceiver without graceful shutdown support");
+
+        while let Some(message) = self.query_receiver.next().await {
+            self.handle_message(message).await
+        }
     }
 }
 
@@ -321,12 +369,37 @@ impl FragmentedMessageReceiver {
             mixnet_packet_receiver,
         }
     }
-    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;
+
+    #[cfg(not(target_arch = "wasm32"))]
+    async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
+        debug!("Started FragmentedMessageReceiver with graceful shutdown support");
+        while !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;
+                    }
+                },
+                _ = shutdown.recv() => {
+                    log::trace!("FragmentedMessageReceiver: Received shutdown");
+                }
             }
-        })
+        }
+        assert!(shutdown.is_shutdown_poll());
+        log::debug!("FragmentedMessageReceiver: Exiting");
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    async fn run(&mut self) {
+        debug!("Started FragmentedMessageReceiver without graceful shutdown support");
+
+        while let Some(new_messages) = self.mixnet_packet_receiver.next().await {
+            self.received_buffer.handle_new_received(new_messages).await;
+        }
     }
 }
 
@@ -340,10 +413,13 @@ impl ReceivedMessagesBufferController {
         local_encryption_keypair: Arc<encryption::KeyPair>,
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_packet_receiver: MixnetMessageReceiver,
-        reply_key_storage: ReplyKeyStorage,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
     ) -> Self {
-        let received_buffer =
-            ReceivedMessagesBuffer::new(local_encryption_keypair, reply_key_storage);
+        let received_buffer = ReceivedMessagesBuffer::new(
+            local_encryption_keypair,
+            #[cfg(feature = "reply-surb")]
+            reply_key_storage,
+        );
 
         ReceivedMessagesBufferController {
             fragmented_message_receiver: FragmentedMessageReceiver::new(
@@ -354,9 +430,31 @@ impl ReceivedMessagesBufferController {
         }
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn start_with_shutdown(self, shutdown: task::ShutdownListener) {
+        let mut fragmented_message_receiver = self.fragmented_message_receiver;
+        let mut request_receiver = self.request_receiver;
+
+        let shutdown_handle = shutdown.clone();
+        spawn_future(async move {
+            fragmented_message_receiver
+                .run_with_shutdown(shutdown_handle)
+                .await;
+        });
+        spawn_future(async move {
+            request_receiver.run_with_shutdown(shutdown).await;
+        });
+    }
+
+    #[cfg(target_arch = "wasm32")]
     pub fn start(self) {
-        // TODO: should we do anything with JoinHandle(s) returned by start methods?
-        self.fragmented_message_receiver.start();
-        self.request_receiver.start();
+        let mut fragmented_message_receiver = self.fragmented_message_receiver;
+        let mut request_receiver = self.request_receiver;
+        spawn_future(async move {
+            fragmented_message_receiver.run().await;
+        });
+        spawn_future(async move {
+            request_receiver.run().await;
+        });
     }
 }

clients/client-core/src/client/topology_control.rs

@@ -1,6 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use crate::spawn_future;
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::params::DEFAULT_NUM_MIX_HOPS;
@@ -11,8 +12,7 @@ use std::sync::Arc;
 use std::time;
 use std::time::Duration;
 use tokio::sync::{RwLock, RwLockReadGuard};
-use tokio::task::JoinHandle;
-use topology::{nym_topology_from_bonds, NymTopology};
+use topology::{nym_topology_from_detailed, NymTopology};
 use url::Url;
 
 // I'm extremely curious why compiler NEVER complained about lack of Debug here before
@@ -265,8 +265,8 @@ impl TopologyRefresher {
         };
 
         let mixnodes_count = mixnodes.len();
-        let topology =
-            nym_topology_from_bonds(mixnodes, gateways).filter_system_version(&self.client_version);
+        let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .filter_system_version(&self.client_version);
 
         if !self.check_layer_distribution(&topology, mixnodes_count) {
             warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
@@ -303,10 +303,34 @@ impl TopologyRefresher {
         self.topology_accessor.is_routable().await
     }
 
-    pub fn start(mut self) -> JoinHandle<()> {
-        tokio::spawn(async move {
-            loop {
-                tokio::time::sleep(self.refresh_rate).await;
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn start_with_shutdown(mut self, mut shutdown: task::ShutdownListener) {
+        spawn_future(async move {
+            debug!("Started TopologyRefresher with graceful shutdown support");
+
+            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");
+        })
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn start(mut self) {
+        use futures::StreamExt;
+
+        spawn_future(async move {
+            let mut interval =
+                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
+            while let Some(_) = interval.next().await {
                 self.refresh().await;
             }
         })

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

@@ -2,12 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use config::NymConfig;
+use nymsphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
 use std::path::PathBuf;
 use std::time::Duration;
 use url::Url;
 
+#[cfg(target_arch = "wasm32")]
+use wasm_bindgen::prelude::*;
+
 pub mod persistence;
 
 pub const MISSING_VALUE: &str = "MISSING VALUE";
@@ -121,16 +125,6 @@ impl<T: NymConfig> Config<T> {
         self.client.gateway_endpoint.gateway_id = id.into();
     }
 
-    #[cfg(not(feature = "coconut"))]
-    pub fn with_eth_private_key<S: Into<String>>(&mut self, eth_private_key: S) {
-        self.client.eth_private_key = eth_private_key.into();
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    pub fn with_eth_endpoint<S: Into<String>>(&mut self, eth_endpoint: S) {
-        self.client.eth_endpoint = eth_endpoint.into();
-    }
-
     pub fn set_custom_validator_apis(&mut self, validator_api_urls: Vec<Url>) {
         self.client.validator_api_urls = validator_api_urls;
     }
@@ -209,16 +203,6 @@ impl<T: NymConfig> Config<T> {
         self.client.database_path.clone()
     }
 
-    #[cfg(not(feature = "coconut"))]
-    pub fn get_eth_endpoint(&self) -> String {
-        self.client.eth_endpoint.clone()
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    pub fn get_eth_private_key(&self) -> String {
-        self.client.eth_private_key.clone()
-    }
-
     // Debug getters
     pub fn get_average_packet_delay(&self) -> Duration {
         self.debug.average_packet_delay
@@ -256,6 +240,18 @@ impl<T: NymConfig> Config<T> {
         self.debug.topology_resolution_timeout
     }
 
+    pub fn get_disabled_loop_cover_traffic_stream(&self) -> bool {
+        self.debug.disable_loop_cover_traffic_stream
+    }
+
+    pub fn get_disabled_main_poisson_packet_distribution(&self) -> bool {
+        self.debug.disable_main_poisson_packet_distribution
+    }
+
+    pub fn get_use_extended_packet_size(&self) -> Option<ExtendedPacketSize> {
+        self.debug.use_extended_packet_size.clone()
+    }
+
     pub fn get_version(&self) -> &str {
         &self.client.version
     }
@@ -272,6 +268,7 @@ impl<T: NymConfig> Default for Config<T> {
 }
 
 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
+#[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter_with_clone))]
 pub struct GatewayEndpoint {
     /// gateway_id specifies ID of the gateway to which the client should send messages.
     /// If initially omitted, a random gateway will be chosen from the available topology.
@@ -342,14 +339,6 @@ pub struct Client<T> {
     /// Path to the database containing bandwidth credentials of this client.
     database_path: PathBuf,
 
-    /// Ethereum private key.
-    #[cfg(not(feature = "coconut"))]
-    eth_private_key: String,
-
-    /// Address to an Ethereum full node.
-    #[cfg(not(feature = "coconut"))]
-    eth_endpoint: String,
-
     /// nym_home_directory specifies absolute path to the home nym Clients directory.
     /// It is expected to use default value and hence .toml file should not redefine this field.
     nym_root_directory: PathBuf,
@@ -375,10 +364,6 @@ impl<T: NymConfig> Default for Client<T> {
             reply_encryption_key_store_path: Default::default(),
             gateway_endpoint: Default::default(),
             database_path: Default::default(),
-            #[cfg(not(feature = "coconut"))]
-            eth_private_key: "".to_string(),
-            #[cfg(not(feature = "coconut"))]
-            eth_endpoint: "".to_string(),
             nym_root_directory: T::default_root_directory(),
             super_struct: Default::default(),
         }
@@ -430,53 +415,72 @@ pub struct Debug {
     /// So for a packet going through three mix nodes, on average, it will take three times this value
     /// until the packet reaches its destination.
     #[serde(with = "humantime_serde")]
-    average_packet_delay: Duration,
+    pub average_packet_delay: Duration,
 
     /// The parameter of Poisson distribution determining how long, on average,
     /// sent acknowledgement is going to be delayed at any given mix node.
     /// So for an ack going through three mix nodes, on average, it will take three times this value
     /// until the packet reaches its destination.
     #[serde(with = "humantime_serde")]
-    average_ack_delay: Duration,
+    pub average_ack_delay: Duration,
 
     /// Value multiplied with the expected round trip time of an acknowledgement packet before
     /// it is assumed it was lost and retransmission of the data packet happens.
     /// In an ideal network with 0 latency, this value would have been 1.
-    ack_wait_multiplier: f64,
+    pub ack_wait_multiplier: f64,
 
     /// Value added to the expected round trip time of an acknowledgement packet before
     /// it is assumed it was lost and retransmission of the data packet happens.
     /// In an ideal network with 0 latency, this value would have been 0.
     #[serde(with = "humantime_serde")]
-    ack_wait_addition: Duration,
+    pub ack_wait_addition: Duration,
 
     /// The parameter of Poisson distribution determining how long, on average,
     /// it is going to take for another loop cover traffic message to be sent.
     #[serde(with = "humantime_serde")]
-    loop_cover_traffic_average_delay: Duration,
+    pub loop_cover_traffic_average_delay: Duration,
 
     /// The parameter of Poisson distribution determining how long, on average,
     /// it is going to take another 'real traffic stream' message to be sent.
     /// If no real packets are available and cover traffic is enabled,
     /// a loop cover message is sent instead in order to preserve the rate.
     #[serde(with = "humantime_serde")]
-    message_sending_average_delay: Duration,
+    pub message_sending_average_delay: Duration,
 
     /// How long we're willing to wait for a response to a message sent to the gateway,
     /// before giving up on it.
     #[serde(with = "humantime_serde")]
-    gateway_response_timeout: Duration,
+    pub gateway_response_timeout: Duration,
 
     /// The uniform delay every which clients are querying the directory server
     /// to try to obtain a compatible network topology to send sphinx packets through.
     #[serde(with = "humantime_serde")]
-    topology_refresh_rate: Duration,
+    pub topology_refresh_rate: Duration,
 
     /// During topology refresh, test packets are sent through every single possible network
     /// path. This timeout determines waiting period until it is decided that the packet
     /// did not reach its destination.
     #[serde(with = "humantime_serde")]
-    topology_resolution_timeout: Duration,
+    pub topology_resolution_timeout: Duration,
+
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
+    pub disable_loop_cover_traffic_stream: bool,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
+    pub use_extended_packet_size: Option<ExtendedPacketSize>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ExtendedPacketSize {
+    Extended8,
+    Extended16,
+    Extended32,
 }
 
 impl Default for Debug {
@@ -491,6 +495,19 @@ impl Default for Debug {
             gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
             topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
+            disable_loop_cover_traffic_stream: false,
+            disable_main_poisson_packet_distribution: false,
+            use_extended_packet_size: None,
+        }
+    }
+}
+
+impl From<ExtendedPacketSize> for PacketSize {
+    fn from(size: ExtendedPacketSize) -> PacketSize {
+        match size {
+            ExtendedPacketSize::Extended8 => PacketSize::ExtendedPacket8,
+            ExtendedPacketSize::Extended16 => PacketSize::ExtendedPacket16,
+            ExtendedPacketSize::Extended32 => PacketSize::ExtendedPacket32,
         }
     }
 }

clients/client-core/src/error.rs

@@ -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),
+}

clients/client-core/src/init.rs

@@ -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,60 @@ async fn register_with_gateway(
         gateway.owner.clone(),
         our_identity.clone(),
         timeout,
+        #[cfg(not(target_arch = "wasm32"))]
+        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(())
 }

clients/client-core/src/lib.rs

@@ -1,3 +1,23 @@
+use std::future::Future;
+
 pub mod client;
 pub mod config;
+pub mod error;
 pub mod init;
+
+#[cfg(target_arch = "wasm32")]
+pub(crate) fn spawn_future<F>(future: F)
+where
+    F: Future<Output = ()> + 'static,
+{
+    wasm_bindgen_futures::spawn_local(future);
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub(crate) fn spawn_future<F>(future: F)
+where
+    F: Future + Send + 'static,
+    F::Output: Send + 'static,
+{
+    tokio::spawn(future);
+}

clients/credential/Cargo.toml

@@ -9,15 +9,17 @@ edition = "2021"
 async-trait = "0.1.52"
 bip39 = "1.0.1"
 cfg-if = "0.1"
-clap = { version = "3.0.10", features = ["cargo", "derive"] }
+clap = { version = "3.2", features = ["cargo", "derive"] }
 pickledb = "0.4.1"
 rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
 url = "2.2"
-tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
+tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
 
 coconut-interface = { path = "../../common/coconut-interface" }
+config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
 credentials = { path = "../../common/credentials" }
 credential-storage = { path = "../../common/credential-storage" }
 crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }

clients/credential/src/client.rs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::Result;
-use crate::{MNEMONIC, NYMD_URL};
 use bip39::Mnemonic;
 use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
 use std::str::FromStr;
@@ -17,9 +16,9 @@ pub(crate) struct Client {
 }
 
 impl Client {
-    pub fn new() -> Self {
-        let nymd_url = Url::from_str(NYMD_URL).unwrap();
-        let mnemonic = Mnemonic::from_str(MNEMONIC).unwrap();
+    pub fn new(nymd_url: &str, mnemonic: &str) -> Self {
+        let nymd_url = Url::from_str(nymd_url).unwrap();
+        let mnemonic = Mnemonic::from_str(mnemonic).unwrap();
         let network_details = NymNetworkDetails::new_from_env();
         let config = nymd::Config::try_from_nym_network_details(&network_details)
             .expect("failed to construct valid validator client config with the provided network");

clients/credential/src/commands.rs

@@ -3,10 +3,10 @@
 
 use async_trait::async_trait;
 use clap::{Args, Subcommand};
+use completions::ArgShell;
 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 +20,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 {
@@ -30,6 +29,12 @@ pub(crate) enum Commands {
     ListDeposits(ListDeposits),
     /// Get a credential for a given deposit
     GetCredential(GetCredential),
+
+    /// Generate shell completions
+    Completions(ArgShell),
+
+    /// Generate Fig specification
+    GenerateFigSpec,
 }
 
 #[async_trait]
@@ -39,6 +44,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 +62,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 +107,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 +123,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 {

clients/credential/src/main.rs

@@ -11,20 +11,26 @@ cfg_if::cfg_if! {
 
         use commands::{Commands, Execute};
         use error::Result;
+        use network_defaults::setup_env;
+        use clap::CommandFactory;
+        use completions::fig_generate;
 
         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 +38,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,
@@ -47,10 +54,14 @@ cfg_if::cfg_if! {
                 ),
             };
 
+            let bin_name = "nym-credential-client";
+
             match &args.command {
                 Commands::Deposit(m) => m.execute(&mut db, shared_storage).await?,
                 Commands::ListDeposits(m) => m.execute(&mut db, shared_storage).await?,
                 Commands::GetCredential(m) => m.execute(&mut db, shared_storage).await?,
+                Commands::Completions(s) => s.generate(&mut crate::Cli::into_app(), bin_name),
+                Commands::GenerateFigSpec => fig_generate(&mut crate::Cli::into_app(), bin_name)
             }
 
             Ok(())

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.0.1"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -20,36 +20,38 @@ futures = "0.3" # bunch of futures stuff, however, now that I think about it, it
 # and the single instance of abortable we have should really be refactored anyway
 url = "2.2"
 
-clap = { version = "3.2.8", features = ["cargo", "derive"] }
+clap = { version = "3.2", features = ["cargo", "derive"] }
 dirs = "4.0"
 log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
 rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
 sled = "0.34" # for storage of replySURB decryption keys
-tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal"] } # async runtime
+tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket
 
 ## internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
+logging = { path = "../../common/logging"}
 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"]
-eth = []
 
 [dev-dependencies]
 serde_json = "1.0" # for the "textsend" example

clients/native/examples/js-examples/websocket/package-lock.json

@@ -27,6 +27,58 @@
         "node": ">=10.0.0"
       }
     },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "dependencies": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "node_modules/@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -3529,13 +3581,13 @@
       }
     },
     "node_modules/terser": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
-      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "dependencies": {
+        "@jridgewell/source-map": "^0.3.2",
         "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
         "source-map-support": "~0.5.20"
       },
       "bin": {
@@ -3583,14 +3635,6 @@
       "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
       "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
     },
-    "node_modules/terser/node_modules/source-map": {
-      "version": "0.7.3",
-      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-      "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ==",
-      "engines": {
-        "node": ">= 8"
-      }
-    },
     "node_modules/thunky": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz",
@@ -4330,6 +4374,49 @@
       "integrity": "sha512-dBVuXR082gk3jsFp7Rd/JI4kytwGHecnCoTtXFb7DB6CNHp4rg5k1bhg0nWdLGLnOV71lmDzGQaLMy8iPLY0pw==",
       "dev": true
     },
+    "@jridgewell/gen-mapping": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz",
+      "integrity": "sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A==",
+      "requires": {
+        "@jridgewell/set-array": "^1.0.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/resolve-uri": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz",
+      "integrity": "sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w=="
+    },
+    "@jridgewell/set-array": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.1.2.tgz",
+      "integrity": "sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw=="
+    },
+    "@jridgewell/source-map": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.2.tgz",
+      "integrity": "sha512-m7O9o2uR8k2ObDysZYzdfhb08VuEml5oWGiosa1VdaPZ/A6QyPkAJuwN0Q1lhULOf6B7MtQmHENS743hWtCrgw==",
+      "requires": {
+        "@jridgewell/gen-mapping": "^0.3.0",
+        "@jridgewell/trace-mapping": "^0.3.9"
+      }
+    },
+    "@jridgewell/sourcemap-codec": {
+      "version": "1.4.14",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz",
+      "integrity": "sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw=="
+    },
+    "@jridgewell/trace-mapping": {
+      "version": "0.3.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.15.tgz",
+      "integrity": "sha512-oWZNOULl+UbhsgB51uuZzglikfIKSUBO/M9W2OfEjn7cmqoAiCgmv9lyACTUacZwBz0ITnJ2NqjU8Tx0DHL88g==",
+      "requires": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
     "@nodelib/fs.scandir": {
       "version": "2.1.5",
       "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
@@ -7058,13 +7145,13 @@
       "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ=="
     },
     "terser": {
-      "version": "5.12.1",
-      "resolved": "https://registry.npmjs.org/terser/-/terser-5.12.1.tgz",
-      "integrity": "sha512-NXbs+7nisos5E+yXwAD+y7zrcTkMqb0dEJxIGtSKPdCBzopf7ni4odPul2aechpV7EXNvOudYOX2bb5tln1jbQ==",
+      "version": "5.15.0",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.15.0.tgz",
+      "integrity": "sha512-L1BJiXVmheAQQy+as0oF3Pwtlo4s3Wi1X2zNZ2NxOB4wx9bdS9Vk67XQENLFdLYGCK/Z2di53mTj/hBafR+dTA==",
       "requires": {
+        "@jridgewell/source-map": "^0.3.2",
         "acorn": "^8.5.0",
         "commander": "^2.20.0",
-        "source-map": "~0.7.2",
         "source-map-support": "~0.5.20"
       },
       "dependencies": {
@@ -7072,11 +7159,6 @@
           "version": "2.20.3",
           "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
           "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ=="
-        },
-        "source-map": {
-          "version": "0.7.3",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.3.tgz",
-          "integrity": "sha512-CkCj6giN3S+n9qrYiBTX5gystlENnRW5jZeNLHpe6aue+SrHcG5VYwujhW9s4dY31mEGsxBDrHR6oI69fTXsaQ=="
         }
       }
     },

clients/native/src/client/config/mod.rs

@@ -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()
     }

clients/native/src/client/config/template.rs

@@ -49,12 +49,6 @@ reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
 # Path to the database containing bandwidth credentials
 database_path = '{{ client.database_path }}'
 
-# Ethereum private key.
-eth_private_key = '{{ client.eth_private_key }}'
-
-# Addess to an Ethereum full node.
-eth_endpoint = '{{ client.eth_endpoint }}'
-
 ##### additional client config options #####
 
 # A gateway specific, optional, base58 stringified shared key used for

clients/native/src/client/mod.rs

@@ -6,9 +6,7 @@ use client_core::client::inbound_messages::{
     InputMessage, InputMessageReceiver, InputMessageSender,
 };
 use client_core::client::key_manager::KeyManager;
-use client_core::client::mix_traffic::{
-    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
-};
+use client_core::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
 use client_core::client::real_messages_control;
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
@@ -32,6 +30,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,10 +84,11 @@ impl NymClient {
         &self,
         topology_accessor: TopologyAccessor,
         mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting loop cover traffic stream...");
 
-        LoopCoverTrafficStream::new(
+        let mut stream = LoopCoverTrafficStream::new(
             self.key_manager.ack_key(),
             self.config.get_base().get_average_ack_delay(),
             self.config.get_base().get_average_packet_delay(),
@@ -98,8 +98,14 @@ impl NymClient {
             mix_tx,
             self.as_mix_recipient(),
             topology_accessor,
-        )
-        .start();
+        );
+
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            stream.set_custom_packet_size(size.into());
+        }
+
+        stream.start_with_shutdown(shutdown);
     }
 
     fn start_real_traffic_controller(
@@ -109,17 +115,26 @@ impl NymClient {
         ack_receiver: AcknowledgementReceiver,
         input_receiver: InputMessageReceiver,
         mix_sender: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
-        let controller_config = real_messages_control::Config::new(
+        let mut controller_config = real_messages_control::Config::new(
             self.key_manager.ack_key(),
             self.config.get_base().get_ack_wait_multiplier(),
             self.config.get_base().get_ack_wait_addition(),
             self.config.get_base().get_average_ack_delay(),
             self.config.get_base().get_message_sending_average_delay(),
             self.config.get_base().get_average_packet_delay(),
+            self.config
+                .get_base()
+                .get_disabled_main_poisson_packet_distribution(),
             self.as_mix_recipient(),
         );
 
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            controller_config.set_custom_packet_size(size.into());
+        }
+
         info!("Starting real traffic stream...");
 
         RealMessagesController::new(
@@ -130,7 +145,7 @@ impl NymClient {
             topology_accessor,
             reply_key_storage,
         )
-        .start();
+        .start_with_shutdown(shutdown);
     }
 
     // buffer controlling all messages fetched from provider
@@ -140,6 +155,7 @@ impl NymClient {
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_receiver: MixnetMessageReceiver,
         reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting received messages buffer controller...");
         ReceivedMessagesBufferController::new(
@@ -148,13 +164,14 @@ impl NymClient {
             mixnet_receiver,
             reply_key_storage,
         )
-        .start()
+        .start_with_shutdown(shutdown)
     }
 
     async fn start_gateway_client(
         &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() {
@@ -182,8 +199,6 @@ impl NymClient {
         let bandwidth_controller = BandwidthController::new(
             credential_storage::initialise_storage(self.config.get_base().get_database_path())
                 .await,
-            self.config.get_base().get_eth_endpoint(),
-            self.config.get_base().get_eth_private_key(),
         )
         .expect("Could not create bandwidth controller");
 
@@ -197,11 +212,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 +228,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 +254,7 @@ impl NymClient {
         }
 
         info!("Starting topology refresher...");
-        topology_refresher.start();
+        topology_refresher.start_with_shutdown(shutdown);
     }
 
     // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -242,12 +262,13 @@ impl NymClient {
     // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
     // requests?
     fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
         gateway_client: GatewayClient,
-    ) {
+        shutdown: ShutdownListener,
+    ) -> BatchMixMessageSender {
         info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
     }
 
     fn start_websocket_listener(
@@ -308,31 +329,32 @@ 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
         // rather than creating them here, so say for example the buffer controller would create the request channels
         // and would allow anyone to clone the sender channel
 
-        // sphinx_message_sender is the transmitter for any component generating sphinx packets that are to be sent to the mixnet
-        // they are used by cover traffic stream and real traffic stream
-        // sphinx_message_receiver is the receiver used by MixTrafficController that sends the actual traffic
-        let (sphinx_message_sender, sphinx_message_receiver) = mpsc::unbounded();
-
         // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
         // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
         let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
@@ -351,30 +373,51 @@ 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);
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender =
+            Self::start_mix_traffic_controller(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);
+        if !self
+            .config
+            .get_base()
+            .get_disabled_loop_cover_traffic_stream()
+        {
+            self.start_cover_traffic_stream(
+                shared_topology_accessor,
+                sphinx_message_sender,
+                shutdown.subscribe(),
+            );
+        }
 
         match self.config.get_socket_type() {
             SocketType::WebSocket => {
@@ -399,5 +442,7 @@ impl NymClient {
 
         info!("Client startup finished!");
         info!("The address of this client is: {}", self.as_mix_recipient());
+
+        shutdown
     }
 }

clients/native/src/commands/init.rs

@@ -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::{
@@ -10,9 +10,6 @@ use crate::{
     commands::{override_config, OverrideConfig},
 };
 
-#[cfg(all(feature = "eth", not(feature = "coconut")))]
-use crate::commands::{DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY};
-
 #[derive(Args, Clone)]
 pub(crate) struct Init {
     /// Id of the nym-mixnet-client we want to create config for.
@@ -46,29 +43,10 @@ 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(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
-    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_ENDPOINT))
-    )]
-    eth_endpoint: String,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead")
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_PRIVATE_KEY))
-    )]
-    eth_private_key: String,
 }
 
 impl From<Init> for OverrideConfig {
@@ -79,14 +57,8 @@ impl From<Init> for OverrideConfig {
             port: init_config.port,
             fastmode: init_config.fastmode,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: init_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: Some(init_config.eth_private_key),
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: Some(init_config.eth_endpoint),
         }
     }
 }
@@ -121,7 +93,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 +116,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 +127,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 +136,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 +155,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())
     }
 }

clients/native/src/commands/mod.rs

@@ -2,15 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::config::{Config, SocketType};
+use clap::CommandFactory;
 use clap::{Parser, Subcommand};
-use url::Url;
-
-#[cfg(not(feature = "coconut"))]
-pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
-    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
-#[cfg(not(feature = "coconut"))]
-pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
-    "0000000000000000000000000000000000000000000000000000000000000001";
+use completions::{fig_generate, ArgShell};
 
 pub(crate) mod init;
 pub(crate) mod run;
@@ -70,6 +64,12 @@ pub(crate) enum Commands {
     Run(run::Run),
     /// Try to upgrade the client
     Upgrade(upgrade::Upgrade),
+
+    /// Generate shell completions
+    Completions(ArgShell),
+
+    /// Generate Fig specification
+    GenerateFigSpec,
 }
 
 // Configuration that can be overridden.
@@ -79,46 +79,33 @@ pub(crate) struct OverrideConfig {
     port: Option<u16>,
     fastmode: bool,
 
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     enabled_credentials_mode: bool,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_private_key: Option<String>,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_endpoint: Option<String>,
 }
 
 pub(crate) async fn execute(args: &Cli) {
+    let bin_name = "nym-native-client";
+
     match &args.command {
         Commands::Init(m) => init::execute(m).await,
         Commands::Run(m) => run::execute(m).await,
         Commands::Upgrade(m) => upgrade::execute(m),
+        Commands::Completions(s) => s.generate(&mut Cli::into_app(), bin_name),
+        Commands::GenerateFigSpec => fig_generate(&mut Cli::into_app(), bin_name),
     }
 }
 
-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(parse_validators(&raw_validators));
+            .set_custom_validator_apis(config::parse_validators(&raw_validators));
     }
 
     if args.disable_socket {
@@ -129,27 +116,11 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
         config = config.with_port(port);
     }
 
-    #[cfg(all(not(feature = "eth"), not(feature = "coconut")))]
-    {
-        config
-            .get_base_mut()
-            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT.to_string());
-        config
-            .get_base_mut()
-            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
-    }
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     {
         if args.enabled_credentials_mode {
             config.get_base_mut().with_disabled_credentials(false)
         }
-        if let Some(eth_endpoint) = args.eth_endpoint {
-            config.get_base_mut().with_eth_endpoint(eth_endpoint);
-        }
-        if let Some(eth_private_key) = args.eth_private_key {
-            config.get_base_mut().with_eth_private_key(eth_private_key);
-        }
     }
 
     if args.fastmode {

clients/native/src/commands/run.rs

@@ -35,23 +35,10 @@ 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(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
-    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_endpoint: Option<String>,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead")
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_private_key: Option<String>,
 }
 
 impl From<Run> for OverrideConfig {
@@ -61,15 +48,8 @@ impl From<Run> for OverrideConfig {
             disable_socket: run_config.disable_socket,
             port: run_config.port,
             fastmode: false,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: run_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: run_config.eth_private_key,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: run_config.eth_endpoint,
         }
     }
 }
@@ -82,7 +62,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

clients/native/src/commands/upgrade.rs

@@ -103,7 +103,7 @@ fn minor_0_12_upgrade(
         Version::new(0, 12, 0)
     };
 
-    print_start_upgrade(&config_version, &to_version);
+    print_start_upgrade(config_version, &to_version);
 
     config
         .get_base_mut()
@@ -111,7 +111,7 @@ fn minor_0_12_upgrade(
 
     config.save_to_file(None).unwrap_or_else(|err| {
         eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
+        print_failed_upgrade(config_version, &to_version);
         process::exit(1);
     });
 

clients/native/src/main.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use clap::{crate_version, Parser};
+use logging::setup_logging;
 use network_defaults::setup_env;
 
 pub mod client;
@@ -34,25 +35,3 @@ fn banner() -> String {
         crate_version!()
     )
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .filter_module("handlebars", log::LevelFilter::Warn)
-        .filter_module("sled", log::LevelFilter::Warn)
-        .init();
-}

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.0.1"
+version = "1.1.0"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -11,7 +11,7 @@ name = "nym_socks5"
 path = "src/lib.rs"
 
 [dependencies]
-clap = { version = "3.2.8", features = ["cargo", "derive"] }
+clap = { version = "3.2", features = ["cargo", "derive"] }
 dirs = "4.0"
 futures = "0.3"
 log = "0.4"
@@ -20,27 +20,30 @@ pretty_env_logger = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] } # for config serialization/deserialization
 snafu = "0.6"
-tokio = { version = "1.19.1", features = ["rt-multi-thread", "net", "signal"] }
+tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] }
 url = "2.2"
 
 # internal
 client-core = { path = "../client-core" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
-credentials = { path = "../../common/credentials", optional = true }
-credential-storage = { path = "../../common/credential-storage" }
 config = { path = "../../common/config" }
+completions = { path = "../../common/completions" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
+logging = { path = "../../common/logging"}
 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"]

clients/socks5/src/client/config/mod.rs

@@ -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()
     }

clients/socks5/src/client/config/template.rs

@@ -49,12 +49,6 @@ reply_encryption_key_store_path = '{{ client.reply_encryption_key_store_path }}'
 # Path to the database containing bandwidth credentials
 database_path = '{{ client.database_path }}'
 
-# Ethereum private key.
-eth_private_key = '{{ client.eth_private_key }}'
-
-# Addess to an Ethereum full node.
-eth_endpoint = '{{ client.eth_endpoint }}'
-
 ##### additional client config options #####
 
 # A gateway specific, optional, base58 stringified shared key used for

clients/socks5/src/client/mod.rs

@@ -1,14 +1,19 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+use std::sync::atomic::Ordering;
+
+use crate::client::config::Config;
+use crate::socks::{
+    authentication::{AuthenticationMethods, Authenticator, User},
+    server::SphinxSocksServer,
+};
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
     InputMessage, InputMessageReceiver, InputMessageSender,
 };
 use client_core::client::key_manager::KeyManager;
-use client_core::client::mix_traffic::{
-    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
-};
+use client_core::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
     ReceivedBufferRequestReceiver, ReceivedBufferRequestSender, ReceivedMessagesBufferController,
@@ -29,12 +34,7 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
-
-use crate::client::config::Config;
-use crate::socks::{
-    authentication::{AuthenticationMethods, Authenticator, User},
-    server::SphinxSocksServer,
-};
+use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};
 
 pub mod config;
 
@@ -84,10 +84,11 @@ impl NymClient {
         &self,
         topology_accessor: TopologyAccessor,
         mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting loop cover traffic stream...");
 
-        LoopCoverTrafficStream::new(
+        let mut stream = LoopCoverTrafficStream::new(
             self.key_manager.ack_key(),
             self.config.get_base().get_average_ack_delay(),
             self.config.get_base().get_average_packet_delay(),
@@ -97,8 +98,14 @@ impl NymClient {
             mix_tx,
             self.as_mix_recipient(),
             topology_accessor,
-        )
-        .start();
+        );
+
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            stream.set_custom_packet_size(size.into());
+        }
+
+        stream.start_with_shutdown(shutdown);
     }
 
     fn start_real_traffic_controller(
@@ -108,17 +115,26 @@ impl NymClient {
         ack_receiver: AcknowledgementReceiver,
         input_receiver: InputMessageReceiver,
         mix_sender: BatchMixMessageSender,
+        shutdown: ShutdownListener,
     ) {
-        let controller_config = client_core::client::real_messages_control::Config::new(
+        let mut controller_config = client_core::client::real_messages_control::Config::new(
             self.key_manager.ack_key(),
             self.config.get_base().get_ack_wait_multiplier(),
             self.config.get_base().get_ack_wait_addition(),
             self.config.get_base().get_average_ack_delay(),
             self.config.get_base().get_message_sending_average_delay(),
             self.config.get_base().get_average_packet_delay(),
+            self.config
+                .get_base()
+                .get_disabled_main_poisson_packet_distribution(),
             self.as_mix_recipient(),
         );
 
+        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
+            log::debug!("Setting extended packet size: {:?}", size);
+            controller_config.set_custom_packet_size(size.into());
+        }
+
         info!("Starting real traffic stream...");
 
         RealMessagesController::new(
@@ -129,7 +145,7 @@ impl NymClient {
             topology_accessor,
             reply_key_storage,
         )
-        .start();
+        .start_with_shutdown(shutdown);
     }
 
     // buffer controlling all messages fetched from provider
@@ -139,6 +155,7 @@ impl NymClient {
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_receiver: MixnetMessageReceiver,
         reply_key_storage: ReplyKeyStorage,
+        shutdown: ShutdownListener,
     ) {
         info!("Starting received messages buffer controller...");
         ReceivedMessagesBufferController::new(
@@ -147,13 +164,14 @@ impl NymClient {
             mixnet_receiver,
             reply_key_storage,
         )
-        .start()
+        .start_with_shutdown(shutdown);
     }
 
     async fn start_gateway_client(
         &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() {
@@ -181,8 +199,6 @@ impl NymClient {
         let bandwidth_controller = BandwidthController::new(
             credential_storage::initialise_storage(self.config.get_base().get_database_path())
                 .await,
-            self.config.get_base().get_eth_endpoint(),
-            self.config.get_base().get_eth_private_key(),
         )
         .expect("Could not create bandwidth controller");
 
@@ -196,11 +212,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 +228,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 +254,7 @@ impl NymClient {
         }
 
         info!("Starting topology refresher...");
-        topology_refresher.start();
+        topology_refresher.start_with_shutdown(shutdown);
     }
 
     // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -241,18 +262,20 @@ impl NymClient {
     // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
     // requests?
     fn start_mix_traffic_controller(
-        &mut self,
-        mix_rx: BatchMixMessageReceiver,
         gateway_client: GatewayClient,
-    ) {
+        shutdown: ShutdownListener,
+    ) -> BatchMixMessageSender {
         info!("Starting mix traffic controller...");
-        MixTrafficController::new(mix_rx, gateway_client).start();
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start_with_shutdown(shutdown);
+        mix_tx
     }
 
     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,54 +287,63 @@ 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
         // rather than creating them here, so say for example the buffer controller would create the request channels
         // and would allow anyone to clone the sender channel
 
-        // sphinx_message_sender is the transmitter for any component generating sphinx packets that are to be sent to the mixnet
-        // they are used by cover traffic stream and real traffic stream
-        // sphinx_message_receiver is the receiver used by MixTrafficController that sends the actual traffic
-        let (sphinx_message_sender, sphinx_message_receiver) = mpsc::unbounded();
-
         // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
         // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
         let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
@@ -330,33 +362,61 @@ 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);
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender =
+            Self::start_mix_traffic_controller(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);
+        if !self
+            .config
+            .get_base()
+            .get_disabled_loop_cover_traffic_stream()
+        {
+            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
     }
 }

clients/socks5/src/commands/init.rs

@@ -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::{
@@ -10,9 +10,6 @@ use crate::{
     commands::{override_config, OverrideConfig},
 };
 
-#[cfg(all(feature = "eth", not(feature = "coconut")))]
-use crate::commands::{DEFAULT_ETH_ENDPOINT, DEFAULT_ETH_PRIVATE_KEY};
-
 #[derive(Args, Clone)]
 pub(crate) struct Init {
     /// Id of the nym-mixnet-client we want to create config for.
@@ -46,29 +43,10 @@ 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(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
-    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_ENDPOINT))
-    )]
-    eth_endpoint: String,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead")
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(
-        long,
-        default_value_if("enabled-credentials-mode", None, Some(DEFAULT_ETH_PRIVATE_KEY))
-    )]
-    eth_private_key: String,
 }
 
 impl From<Init> for OverrideConfig {
@@ -77,15 +55,8 @@ impl From<Init> for OverrideConfig {
             validators: init_config.validators,
             port: init_config.port,
             fastmode: init_config.fastmode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: init_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: Some(init_config.eth_private_key),
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: Some(init_config.eth_endpoint),
         }
     }
 }
@@ -121,7 +92,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 +115,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 +126,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 +135,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 +154,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())
     }
 }

clients/socks5/src/commands/mod.rs

@@ -2,20 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::config::Config;
+use clap::CommandFactory;
 use clap::{Parser, Subcommand};
-use url::Url;
+use completions::{fig_generate, ArgShell};
+use config::parse_validators;
 
 pub mod init;
 pub(crate) mod run;
 pub(crate) mod upgrade;
 
-#[cfg(not(feature = "coconut"))]
-pub(crate) const DEFAULT_ETH_ENDPOINT: &str =
-    "https://rinkeby.infura.io/v3/00000000000000000000000000000000";
-#[cfg(not(feature = "coconut"))]
-pub(crate) const DEFAULT_ETH_PRIVATE_KEY: &str =
-    "0000000000000000000000000000000000000000000000000000000000000001";
-
 fn long_version() -> String {
     format!(
         r#"
@@ -70,6 +65,12 @@ pub(crate) enum Commands {
     Run(run::Run),
     /// Try to upgrade the client
     Upgrade(upgrade::Upgrade),
+
+    /// Generate shell completions
+    Completions(ArgShell),
+
+    /// Generate Fig specification
+    GenerateFigSpec,
 }
 
 // Configuration that can be overridden.
@@ -78,35 +79,22 @@ pub(crate) struct OverrideConfig {
     port: Option<u16>,
     fastmode: bool,
 
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     enabled_credentials_mode: bool,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_private_key: Option<String>,
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    eth_endpoint: Option<String>,
 }
 
 pub(crate) async fn execute(args: &Cli) {
+    let bin_name = "nym-socks5-client";
+
     match &args.command {
         Commands::Init(m) => init::execute(m).await,
         Commands::Run(m) => run::execute(m).await,
         Commands::Upgrade(m) => upgrade::execute(m),
+        Commands::Completions(s) => s.generate(&mut Cli::into_app(), bin_name),
+        Commands::GenerateFigSpec => fig_generate(&mut Cli::into_app(), bin_name),
     }
 }
 
-pub 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
@@ -122,27 +110,11 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
         config = config.with_port(port);
     }
 
-    #[cfg(all(not(feature = "eth"), not(feature = "coconut")))]
-    {
-        config
-            .get_base_mut()
-            .with_eth_endpoint(DEFAULT_ETH_ENDPOINT.to_string());
-        config
-            .get_base_mut()
-            .with_eth_private_key(DEFAULT_ETH_PRIVATE_KEY.to_string());
-    }
-
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
+    #[cfg(feature = "coconut")]
     {
         if args.enabled_credentials_mode {
             config.get_base_mut().with_disabled_credentials(false)
         }
-        if let Some(eth_endpoint) = args.eth_endpoint {
-            config.get_base_mut().with_eth_endpoint(eth_endpoint);
-        }
-        if let Some(eth_private_key) = args.eth_private_key {
-            config.get_base_mut().with_eth_private_key(eth_private_key);
-        }
     }
 
     if args.fastmode {

clients/socks5/src/commands/run.rs

@@ -39,23 +39,10 @@ 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(feature = "coconut")]
+    #[clap(long)]
     enabled_credentials_mode: bool,
-
-    /// URL of an Ethereum full node that we want to use for getting bandwidth tokens from ERC20
-    /// tokens. If you don't want to set this value, use --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_endpoint: Option<String>,
-
-    /// Ethereum private key used for obtaining bandwidth tokens from ERC20 tokens. If you don't
-    /// want to set this value, use --enabled-credentials-mode instead
-    #[cfg(all(feature = "eth", not(feature = "coconut")))]
-    #[clap(long)]
-    eth_private_key: Option<String>,
 }
 
 impl From<Run> for OverrideConfig {
@@ -65,14 +52,8 @@ impl From<Run> for OverrideConfig {
             port: run_config.port,
             fastmode: false,
 
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
+            #[cfg(feature = "coconut")]
             enabled_credentials_mode: run_config.enabled_credentials_mode,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_private_key: run_config.eth_private_key,
-
-            #[cfg(all(feature = "eth", not(feature = "coconut")))]
-            eth_endpoint: run_config.eth_endpoint,
         }
     }
 }

clients/socks5/src/commands/upgrade.rs

@@ -102,7 +102,7 @@ fn minor_0_12_upgrade(
         Version::new(0, 12, 0)
     };
 
-    print_start_upgrade(&config_version, &to_version);
+    print_start_upgrade(config_version, &to_version);
 
     config
         .get_base_mut()
@@ -110,7 +110,7 @@ fn minor_0_12_upgrade(
 
     config.save_to_file(None).unwrap_or_else(|err| {
         eprintln!("failed to overwrite config file! - {:?}", err);
-        print_failed_upgrade(&config_version, &to_version);
+        print_failed_upgrade(config_version, &to_version);
         process::exit(1);
     });
 

clients/socks5/src/lib.rs

@@ -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;

clients/socks5/src/main.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use clap::{crate_version, Parser};
+use logging::setup_logging;
 use network_defaults::setup_env;
 
 pub mod client;
@@ -34,23 +35,3 @@ fn banner() -> String {
         crate_version!()
     )
 }
-
-fn setup_logging() {
-    let mut log_builder = pretty_env_logger::formatted_timed_builder();
-    if let Ok(s) = ::std::env::var("RUST_LOG") {
-        log_builder.parse_filters(&s);
-    } else {
-        // default to 'Info'
-        log_builder.filter(None, log::LevelFilter::Info);
-    }
-
-    log_builder
-        .filter_module("hyper", log::LevelFilter::Warn)
-        .filter_module("tokio_reactor", log::LevelFilter::Warn)
-        .filter_module("reqwest", log::LevelFilter::Warn)
-        .filter_module("mio", log::LevelFilter::Warn)
-        .filter_module("want", log::LevelFilter::Warn)
-        .filter_module("tungstenite", log::LevelFilter::Warn)
-        .filter_module("tokio_tungstenite", log::LevelFilter::Warn)
-        .init();
-}

clients/socks5/src/socks/client.rs

@@ -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);

clients/socks5/src/socks/mixnet_responses.rs

@@ -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::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,
         }
     }
 
@@ -54,6 +59,13 @@ impl MixnetResponseListener {
                 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
@@ -66,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");
     }
 }

clients/socks5/src/socks/server.rs

@@ -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(());
+                }
             }
         }
     }

clients/validator/tests/query/balance.test.ts

@@ -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);
-})
+})

clients/webassembly/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
-version = "1.0.1"
+version = "1.0.0"
 edition = "2021"
 keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"
@@ -20,19 +20,21 @@ coconut = ["coconut-interface", "credentials", "gateway-client/coconut"]
 [dependencies]
 futures = "0.3"
 serde = { version = "1.0", features = ["derive"] }
-wasm-bindgen = { version = "=0.2.78", features = ["serde-serialize"]  }
+serde-wasm-bindgen = "0.4"
+wasm-bindgen = { version = "=0.2.83", features = ["serde-serialize"]  }
 wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 url = "2.2"
 
 # internal
+client-core = { path = "../client-core", default-features = false, features = ["wasm"] }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
 nymsphinx = { path = "../../common/nymsphinx" }
 topology = { path = "../../common/topology" }
-gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm"] }
+gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 wasm-utils = { path = "../../common/wasm-utils" }
 

clients/webassembly/README.md

@@ -11,6 +11,7 @@ This client is part of the [Nym](https://nymtech.net/docs) project. It's written
 ## Security Status 
 
 From a security point of view, this module is not yet complete. Key missing features include, but are not limited to: cover traffic, sending packets with delay according to Poisson distribution. 
+
 They should be implemented soon. You can build your applications, but don't rely on it for strong anonymity yet if your application needs cover traffic.
 
 ## Using it
@@ -37,6 +38,6 @@ To be clear, this is not something that most JS developers need to worry about,
 
 If you're a Nym platform developer who's made changes to the Rust (or JS) files and wants to re-publish the package to NPM, here's how you do it: 
 
-1. `wasm-pack build --scope nymproject` builds the wasm binaries into the `pkg` directory (not in source control)
-2. bump version numbers as necessary for SemVer
-3. `wasm-pack publish --access=public` will publish your changed package to NPM
+1. bump version numbers as necessary for SemVer
+2. `wasm-pack build --scope nymproject` builds the wasm binaries into the `pkg` directory (not in source control)
+3. `cd pkg && npm publish --access=public` will publish your changed package to NPM

clients/webassembly/js-example/README.md

@@ -4,6 +4,16 @@ This example application demonstrates how to use WebAssembly to create Sphinx pa
 
 ## 🚴 Usage
 
+Build the WASM package for bundling:
+
+```
+wasm-pack build --scope nymproject --target no-modules
+```
+
+in the `clients/webassembly` directory (one up).
+
+Start the webpack dev server:
+
 ```
 npm install         # set up dependencies
 npm run start       # starts a web server at http://localhost:8001
@@ -15,4 +25,4 @@ Check your dev console for output.
 
 Install `wasm-pack`. Instruction are at the [Rust WASM tutorial](https://rustwasm.github.io/docs/book/game-of-life/hello-world.html). 
 
-`wasm-pack build` in the `clients/webassembly` directory (one up) will rebuild the wasm package if you make changes to the Rust source. That will be automatically picked up (and reloaded, if need be) by the npm dev server.
+`wasm-pack build --scope nymproject --target no-modules` in the `clients/webassembly` directory (one up) will rebuild the wasm package if you make changes to the Rust source. That will be automatically picked up (and reloaded, if need be) by the npm dev server.

clients/webassembly/js-example/bootstrap.js

@@ -1,5 +1,5 @@
 // A dependency graph that contains any wasm must all be imported
 // asynchronously. This `bootstrap.js` file does the single async import, so
 // that no one else needs to worry about it again.
-import("./index.js")
-  .catch(e => console.error("Error importing `index.js`:", e));
+import('./index.js')
+  .catch(e => console.error('Error importing `index.js`:', e));

clients/webassembly/js-example/index.js

@@ -1,4 +1,4 @@
-// Copyright 2020 Nym Technologies SA
+// Copyright 2020-2022 Nym Technologies SA
 // 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,55 +12,67 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import {
-   NymClient,
-   set_panic_hook
-} from "@nymproject/nym-client-wasm"
+class WebWorkerClient {
+  worker = null;
 
-// current limitation of rust-wasm for async stuff : (
-let client = null
+  constructor() {
+    this.worker = new Worker('./worker.js');
+
+    this.worker.onmessage = (ev) => {
+      if (ev.data && ev.data.kind) {
+        switch (ev.data.kind) {
+          case 'Ready':
+            const { selfAddress } = ev.data.args;
+            displaySenderAddress(selfAddress);
+            break;
+          case 'ReceiveMessage':
+            const { message } = ev.data.args;
+            displayReceived(message);
+            break;
+        }
+      }
+    };
+  }
+
+  sendMessage = (message, recipient) => {
+    if (!this.worker) {
+      console.error('Could not send message because worker does not exist');
+      return;
+    }
+
+    this.worker.postMessage({
+      kind: 'SendMessage',
+      args: {
+        message, recipient,
+      },
+    });
+  };
+}
+
+let client = null;
 
 async function main() {
-    // sets up better stack traces in case of in-rust panics
-    set_panic_hook();
+  client = new WebWorkerClient();
 
-    // validator server we will use to get topology from
-    const validator = "https://sandbox-validator.nymtech.net/api"; //"http://localhost:8081";
-
-    client = new NymClient(validator);
-
-    const on_message = (msg) => displayReceived(msg);
-    const on_connect = () => console.log("Established (and authenticated) gateway connection!");
-
-    client.set_on_message(on_message);
-    client.set_on_gateway_connect(on_connect);
-
-    // this is current limitation of wasm in rust - for async methods you can't take self my reference...
-    // I'm trying to figure out if I can somehow hack my way around it, but for time being you have to re-assign
-    // the object (it's the same one)
-    client = await client.initial_setup();
-
-    const self_address = client.self_address();
-    displaySenderAddress(self_address);
-
-    const sendButton = document.querySelector('#send-button');
-    sendButton.onclick = function () {
-        sendMessageTo();
-    }
+  const sendButton = document.querySelector('#send-button');
+  sendButton.onclick = function() {
+    sendMessageTo();
+  };
 }
 
 /**
  * Create a Sphinx packet and send it to the mixnet through the gateway node.
- * 
+ *
  * Message and recipient are taken from the values in the user interface.
  *
  * @param {Client} nymClient the nym client to use for message sending
  */
 async function sendMessageTo() {
-    const message = document.getElementById("message").value;
-    const recipient = document.getElementById("recipient").value;
-    client = await client.send_message(message, recipient);
-    displaySend(message);
+  const message = document.getElementById('message').value;
+  const recipient = document.getElementById('recipient').value;
+
+  await client.sendMessage(message, recipient);
+  displaySend(message);
 }
 
 /**
@@ -69,16 +81,16 @@ async function sendMessageTo() {
  * @param {string} message
  */
 function displaySend(message) {
-    let timestamp = new Date().toISOString().substr(11, 12);
+  let timestamp = new Date().toISOString().substr(11, 12);
 
-    let sendDiv = document.createElement("div")
-    let paragraph = document.createElement("p")
-    paragraph.setAttribute('style', 'color: blue')
-    let paragraphContent = document.createTextNode(timestamp + " sent >>> " + message)
-    paragraph.appendChild(paragraphContent)
+  let sendDiv = document.createElement('div');
+  let paragraph = document.createElement('p');
+  paragraph.setAttribute('style', 'color: blue');
+  let paragraphContent = document.createTextNode(timestamp + ' sent >>> ' + message);
+  paragraph.appendChild(paragraphContent);
 
-    sendDiv.appendChild(paragraph)
-    document.getElementById("output").appendChild(sendDiv)
+  sendDiv.appendChild(paragraph);
+  document.getElementById('output').appendChild(sendDiv);
 }
 
 /**
@@ -87,17 +99,17 @@ function displaySend(message) {
  * @param {string} message
  */
 function displayReceived(message) {
-    const content = message.message
-    const replySurb = message.replySurb
+  const content = message;
 
-    let timestamp = new Date().toISOString().substr(11, 12);
-    let receivedDiv = document.createElement("div")
-    let paragraph = document.createElement("p")
-    paragraph.setAttribute('style', 'color: green')
-    let paragraphContent = document.createTextNode(timestamp + " received >>> " + content + ((replySurb != null) ? "Reply SURB was attached here (but we can't do anything with it yet" : " (NO REPLY-SURB AVAILABLE)"))
-    paragraph.appendChild(paragraphContent)
-    receivedDiv.appendChild(paragraph)
-    document.getElementById("output").appendChild(receivedDiv)
+  let timestamp = new Date().toISOString().substr(11, 12);
+  let receivedDiv = document.createElement('div');
+  let paragraph = document.createElement('p');
+  paragraph.setAttribute('style', 'color: green');
+  let paragraphContent = document.createTextNode(timestamp + ' received >>> ' + content);
+  // let paragraphContent = document.createTextNode(timestamp + " received >>> " + content + ((replySurb != null) ? "Reply SURB was attached here (but we can't do anything with it yet" : " (NO REPLY-SURB AVAILABLE)"))
+  paragraph.appendChild(paragraphContent);
+  receivedDiv.appendChild(paragraph);
+  document.getElementById('output').appendChild(receivedDiv);
 }
 
 
@@ -107,7 +119,7 @@ function displayReceived(message) {
  * @param {Client} nymClient
  */
 function displaySenderAddress(address) {
-    document.getElementById("sender").value = address;
+  document.getElementById('sender').value = address;
 }
 
 // Let's get started!

clients/webassembly/js-example/package.json

@@ -36,4 +36,4 @@
   "dependencies": {
     "@nymproject/nym-client-wasm": "file:../pkg"
   }
-}
+}

clients/webassembly/js-example/webpack.config.js

@@ -1,15 +1,27 @@
-const CopyWebpackPlugin = require("copy-webpack-plugin");
+const CopyWebpackPlugin = require('copy-webpack-plugin');
 const path = require('path');
 
 module.exports = {
-  entry: "./bootstrap.js",
-  output: {
-    path: path.resolve(__dirname, "dist"),
-    filename: "bootstrap.js",
+  entry: {
+    bootstrap: './bootstrap.js',
+    worker: './worker.js',
   },
-  mode: "development",
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: '[name].js',
+  },
+  // mode: 'development',
+  mode: 'production',
   plugins: [
-    new CopyWebpackPlugin({patterns: ['index.html']})
+    new CopyWebpackPlugin({
+      patterns: [
+        'index.html',
+        {
+          from: 'node_modules/@nymproject/nym-client-wasm/*.(js|wasm)',
+          to: '[name][ext]',
+        },
+      ],
+    }),
   ],
-  experiments: { asyncWebAssembly: true }
+  experiments: { syncWebAssembly: true },
 };

clients/webassembly/js-example/worker.js

@@ -0,0 +1,131 @@
+// Copyright 2020-2022 Nym Technologies SA
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// 
+//     http://www.apache.org/licenses/LICENSE-2.0
+// 
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+importScripts('nym_client_wasm.js');
+
+console.log('Initializing worker');
+
+// wasm_bindgen creates a global variable (with the exports attached) that is in scope after `importScripts`
+const { default_debug, get_gateway, NymClient, set_panic_hook, Config } = wasm_bindgen;
+
+class ClientWrapper {
+  constructor(config, onMessageHandler) {
+    this.rustClient = new NymClient(config);
+    this.rustClient.set_on_message(onMessageHandler);
+    this.rustClient.set_on_gateway_connect(this.onConnect);
+  }
+
+  selfAddress = () => {
+    return this.rustClient.self_address();
+  };
+
+  onConnect = () => {
+    console.log('Established (and authenticated) gateway connection!');
+  };
+
+  start = async () => {
+    // this is current limitation of wasm in rust - for async methods you can't take self by reference...
+    // I'm trying to figure out if I can somehow hack my way around it, but for time being you have to re-assign
+    // the object (it's the same one)
+    this.rustClient = await this.rustClient.start();
+  };
+
+  sendMessage = async (recipient, message) => {
+    this.rustClient = await this.rustClient.send_message(recipient, message);
+  };
+
+  sendBinaryMessage = async (recipient, message) => {
+    this.rustClient = await this.rustClient.send_binary_message(recipient, message);
+  };
+}
+
+let client = null;
+
+async function main() {
+  // load WASM package
+  await wasm_bindgen('nym_client_wasm_bg.wasm');
+
+  console.log('Loaded WASM');
+
+  // sets up better stack traces in case of in-rust panics
+  set_panic_hook();
+
+  console.error("the current mainnet is not compatible with v2! - either use the pre-merge branch or explicitly set the client to use one of V2 QA networks")
+  return
+
+  // validator server we will use to get topology from
+  // MAINNET (V1):
+  const validator = 'https://validator.nymtech.net/api'; //"http://localhost:8081";
+  const preferredGateway = 'E3mvZTHQCdBvhfr178Swx9g4QG3kkRUun7YnToLMcMbM';
+  // QA (V2):
+  // const validator = 'https://qa-validator-api.nymtech.net/api'; //"http://localhost:8081";
+  // const preferredGateway = 'CgQrYP8etksSBf4nALNqp93SHPpgFwEUyTsjBNNLj5WM';
+
+  const gatewayEndpoint = await get_gateway(validator, preferredGateway);
+
+  // only really useful if you want to adjust some settings like traffic rate
+  // (if not needed you can just pass a null)
+  const debug = default_debug();
+
+  debug.disable_main_poisson_packet_distribution = true;
+  debug.disable_loop_cover_traffic_stream = true;
+  debug.use_extended_packet_size = true;
+  // debug.average_packet_delay_ms = BigInt(10);
+  // debug.average_ack_delay_ms = BigInt(10);
+  // debug.ack_wait_addition_ms = BigInt(3000);
+  // debug.ack_wait_multiplier = 10;
+
+  debug.topology_refresh_rate_ms = BigInt(60000)
+
+  const config = new Config('my-awesome-wasm-client', validator, gatewayEndpoint, debug);
+
+  const onMessageHandler = (message) => {
+    self.postMessage({
+      kind: 'ReceiveMessage',
+      args: {
+        message,
+      },
+    });
+  };
+
+  console.log('Instantiating WASM client...');
+  client = new ClientWrapper(config, onMessageHandler);
+  console.log('Web worker creating WASM client...');
+  await client.start();
+  console.log('WASM client running!');
+
+  const selfAddress = client.rustClient.self_address();
+  console.log(`Client address is ${selfAddress}`);
+  self.postMessage({
+    kind: 'Ready',
+    args: {
+      selfAddress,
+    },
+  });
+
+  // Set callback to handle messages passed to the worker.
+  self.onmessage = async event => {
+    if (event.data && event.data.kind) {
+      switch (event.data.kind) {
+        case 'SendMessage': {
+          const { message, recipient } = event.data.args;
+          await client.sendMessage(message, recipient);
+        }
+      }
+    }
+  };
+}
+
+// Let's get started!
+main();

clients/webassembly/package-lock.json

@@ -1,11 +0,0 @@
-{
-    "requires": true,
-    "lockfileVersion": 1,
-    "dependencies": {
-        "semver": {
-            "version": "7.3.2",
-            "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.2.tgz",
-            "integrity": "sha512-OrOb32TeeambH6UrhtShmF7CRDqhL6/5XpPNp2DuRH6+9QLw/orhp72j87v8Qa1ScDkvrrBNpZcDejAirJmfXQ=="
-        }
-    }
-}

clients/webassembly/src/client/config.rs

@@ -0,0 +1,164 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+// due to expansion of #[wasm_bindgen] macro on `Debug` Config struct
+#![allow(clippy::drop_non_drop)]
+
+use client_core::config::{Debug as ConfigDebug, ExtendedPacketSize, GatewayEndpoint};
+use std::time::Duration;
+use url::Url;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub struct Config {
+    /// ID specifies the human readable ID of this particular client.
+    pub(crate) id: String,
+
+    pub(crate) validator_api_url: Url,
+
+    pub(crate) disabled_credentials_mode: bool,
+
+    /// Information regarding how the client should send data to gateway.
+    pub(crate) gateway_endpoint: GatewayEndpoint,
+
+    pub(crate) debug: ConfigDebug,
+}
+
+#[wasm_bindgen]
+impl Config {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        id: String,
+        validator_server: String,
+        gateway_endpoint: GatewayEndpoint,
+        debug: Option<Debug>,
+    ) -> Self {
+        Config {
+            id,
+            validator_api_url: validator_server
+                .parse()
+                .expect("provided url was malformed"),
+            disabled_credentials_mode: true,
+            gateway_endpoint,
+            debug: debug.map(Into::into).unwrap_or_default(),
+        }
+    }
+}
+
+// just a helper structure to more easily pass through the JS boundary
+#[wasm_bindgen]
+pub struct Debug {
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// sent packet is going to be delayed at any given mix node.
+    /// So for a packet going through three mix nodes, on average, it will take three times this value
+    /// until the packet reaches its destination.
+    pub average_packet_delay_ms: u64,
+
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// sent acknowledgement is going to be delayed at any given mix node.
+    /// So for an ack going through three mix nodes, on average, it will take three times this value
+    /// until the packet reaches its destination.
+    pub average_ack_delay_ms: u64,
+
+    /// Value multiplied with the expected round trip time of an acknowledgement packet before
+    /// it is assumed it was lost and retransmission of the data packet happens.
+    /// In an ideal network with 0 latency, this value would have been 1.
+    pub ack_wait_multiplier: f64,
+
+    /// Value added to the expected round trip time of an acknowledgement packet before
+    /// it is assumed it was lost and retransmission of the data packet happens.
+    /// In an ideal network with 0 latency, this value would have been 0.
+    pub ack_wait_addition_ms: u64,
+
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take for another loop cover traffic message to be sent.
+    pub loop_cover_traffic_average_delay_ms: u64,
+
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take another 'real traffic stream' message to be sent.
+    /// If no real packets are available and cover traffic is enabled,
+    /// a loop cover message is sent instead in order to preserve the rate.
+    pub message_sending_average_delay_ms: u64,
+
+    /// How long we're willing to wait for a response to a message sent to the gateway,
+    /// before giving up on it.
+    pub gateway_response_timeout_ms: u64,
+
+    /// The uniform delay every which clients are querying the directory server
+    /// to try to obtain a compatible network topology to send sphinx packets through.
+    pub topology_refresh_rate_ms: u64,
+
+    /// During topology refresh, test packets are sent through every single possible network
+    /// path. This timeout determines waiting period until it is decided that the packet
+    /// did not reach its destination.
+    pub topology_resolution_timeout_ms: u64,
+
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay_ms])
+    pub disable_loop_cover_traffic_stream: bool,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size.
+    pub use_extended_packet_size: bool,
+}
+
+impl From<Debug> for ConfigDebug {
+    fn from(debug: Debug) -> Self {
+        // For now we just always use the (older) 32kb extended size
+        let use_extended_packet_size = debug
+            .use_extended_packet_size
+            .then(|| ExtendedPacketSize::Extended32);
+
+        ConfigDebug {
+            average_packet_delay: Duration::from_millis(debug.average_packet_delay_ms),
+            average_ack_delay: Duration::from_millis(debug.average_ack_delay_ms),
+            ack_wait_multiplier: debug.ack_wait_multiplier,
+            ack_wait_addition: Duration::from_millis(debug.ack_wait_addition_ms),
+            loop_cover_traffic_average_delay: Duration::from_millis(
+                debug.loop_cover_traffic_average_delay_ms,
+            ),
+            message_sending_average_delay: Duration::from_millis(
+                debug.message_sending_average_delay_ms,
+            ),
+            gateway_response_timeout: Duration::from_millis(debug.gateway_response_timeout_ms),
+            topology_refresh_rate: Duration::from_millis(debug.topology_refresh_rate_ms),
+            topology_resolution_timeout: Duration::from_millis(
+                debug.topology_resolution_timeout_ms,
+            ),
+            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
+            disable_main_poisson_packet_distribution: debug
+                .disable_main_poisson_packet_distribution,
+            use_extended_packet_size,
+        }
+    }
+}
+
+impl From<ConfigDebug> for Debug {
+    fn from(debug: ConfigDebug) -> Self {
+        Debug {
+            average_packet_delay_ms: debug.average_packet_delay.as_millis() as u64,
+            average_ack_delay_ms: debug.average_ack_delay.as_millis() as u64,
+            ack_wait_multiplier: debug.ack_wait_multiplier,
+            ack_wait_addition_ms: debug.ack_wait_addition.as_millis() as u64,
+            loop_cover_traffic_average_delay_ms: debug.loop_cover_traffic_average_delay.as_millis()
+                as u64,
+            message_sending_average_delay_ms: debug.message_sending_average_delay.as_millis()
+                as u64,
+            gateway_response_timeout_ms: debug.gateway_response_timeout.as_millis() as u64,
+            topology_refresh_rate_ms: debug.topology_refresh_rate.as_millis() as u64,
+            topology_resolution_timeout_ms: debug.topology_resolution_timeout.as_millis() as u64,
+            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
+            disable_main_poisson_packet_distribution: debug
+                .disable_main_poisson_packet_distribution,
+            use_extended_packet_size: debug.use_extended_packet_size.is_some(),
+        }
+    }
+}
+
+#[wasm_bindgen]
+pub fn default_debug() -> Debug {
+    ConfigDebug::default().into()
+}

clients/webassembly/src/client/mod.rs

@@ -1,47 +1,46 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crypto::asymmetric::{encryption, identity};
+use self::config::Config;
+use client_core::client::{
+    cover_traffic_stream::LoopCoverTrafficStream,
+    inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender},
+    key_manager::KeyManager,
+    mix_traffic::{BatchMixMessageSender, MixTrafficController},
+    real_messages_control::{self, RealMessagesController},
+    received_buffer::{
+        ReceivedBufferMessage, ReceivedBufferRequestReceiver, ReceivedBufferRequestSender,
+        ReceivedMessagesBufferController,
+    },
+    topology_control::{TopologyAccessor, TopologyRefresher, TopologyRefresherConfig},
+};
+use crypto::asymmetric::identity;
 use futures::channel::mpsc;
-use gateway_client::GatewayClient;
-use nymsphinx::acknowledgements::AckKey;
+use futures::StreamExt;
+use gateway_client::{
+    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
+    MixnetMessageSender,
+};
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::preparer::MessagePreparer;
 use rand::rngs::OsRng;
-use received_processor::ReceivedMessagesProcessor;
-use std::sync::Arc;
-use std::time::Duration;
-use topology::{gateway, nym_topology_from_bonds, NymTopology};
-use url::Url;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
 use wasm_utils::{console_log, console_warn};
 
-pub(crate) mod received_processor;
-
-const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(200);
-const DEFAULT_AVERAGE_ACK_DELAY: Duration = Duration::from_millis(200);
-const DEFAULT_GATEWAY_RESPONSE_TIMEOUT: Duration = Duration::from_millis(1_500);
+pub mod config;
 
 #[wasm_bindgen]
 pub struct NymClient {
-    validator_server: Url,
-    disabled_credentials_mode: bool,
+    config: Config,
 
-    // TODO: technically this doesn't need to be an Arc since wasm is run on a single thread
-    // however, once we eventually combine this code with the native-client's, it will make things
-    // easier.
-    identity: Arc<identity::KeyPair>,
-    encryption_keys: Arc<encryption::KeyPair>,
-    ack_key: Arc<AckKey>,
-
-    message_preparer: Option<MessagePreparer<OsRng>>,
-    // message_receiver: MessageReceiver,
+    /// KeyManager object containing smart pointers to all relevant keys used by the client.
+    key_manager: KeyManager,
 
     // TODO: this should be stored somewhere persistently
     // received_keys: HashSet<SURBEncryptionKey>,
-    topology: Option<NymTopology>,
-    gateway_client: Option<GatewayClient>,
+    /// Channel used for transforming 'raw' messages into sphinx packets and sending them
+    /// through the mix network.
+    input_tx: Option<InputMessageSender>,
 
     // callbacks
     on_message: Option<js_sys::Function>,
@@ -51,31 +50,24 @@ pub struct NymClient {
 #[wasm_bindgen]
 impl NymClient {
     #[wasm_bindgen(constructor)]
-    pub fn new(validator_server: String) -> Self {
-        let mut rng = OsRng;
-        // for time being generate new keys each time...
-        let identity = identity::KeyPair::new(&mut rng);
-        let encryption_keys = encryption::KeyPair::new(&mut rng);
-        let ack_key = AckKey::new(&mut rng);
-
+    pub fn new(config: Config) -> Self {
         Self {
-            identity: Arc::new(identity),
-            encryption_keys: Arc::new(encryption_keys),
-            ack_key: Arc::new(ack_key),
-            validator_server: validator_server
-                .parse()
-                .expect("malformed validator server url provided"),
-            message_preparer: None,
-            // received_keys: Default::default(),
-            topology: None,
-            gateway_client: None,
-
+            config,
+            key_manager: Self::setup_key_manager(),
             on_message: None,
             on_gateway_connect: None,
-            disabled_credentials_mode: true,
+            input_tx: None,
         }
     }
 
+    // perhaps this should be public?
+    fn setup_key_manager() -> KeyManager {
+        let mut rng = OsRng;
+        // for time being generate new keys each time...
+        console_log!("generated new set of keys");
+        KeyManager::new(&mut rng)
+    }
+
     pub fn set_on_message(&mut self, on_message: js_sys::Function) {
         self.on_message = Some(on_message);
     }
@@ -85,64 +77,137 @@ impl NymClient {
         self.on_gateway_connect = Some(on_connect)
     }
 
-    pub fn set_disabled_credentials_mode(&mut self, disabled_credentials_mode: bool) {
-        console_log!(
-            "Setting disabled credentials mode to {}",
-            disabled_credentials_mode
-        );
-        self.disabled_credentials_mode = disabled_credentials_mode;
-    }
-
-    fn self_recipient(&self) -> Recipient {
+    fn as_mix_recipient(&self) -> Recipient {
         Recipient::new(
-            *self.identity.public_key(),
-            *self.encryption_keys.public_key(),
-            self.gateway_client
-                .as_ref()
-                .expect("gateway connection was not established!")
-                .gateway_identity(),
+            *self.key_manager.identity_keypair().public_key(),
+            *self.key_manager.encryption_keypair().public_key(),
+            identity::PublicKey::from_base58_string(&self.config.gateway_endpoint.gateway_id)
+                .expect("no gateway has been selected"),
         )
     }
 
     pub fn self_address(&self) -> String {
-        self.self_recipient().to_string()
+        self.as_mix_recipient().to_string()
     }
 
-    // Right now it's impossible to have async exported functions to take `&self` rather than self
-    pub async fn initial_setup(self) -> Self {
-        let disabled_credentials_mode = self.disabled_credentials_mode;
+    // future constantly pumping loop cover traffic at some specified average rate
+    // the pumped traffic goes to the MixTrafficController
+    fn start_cover_traffic_stream(
+        &self,
+        topology_accessor: TopologyAccessor,
+        mix_tx: BatchMixMessageSender,
+    ) {
+        console_log!("Starting loop cover traffic stream...");
 
-        let bandwidth_controller = None;
-
-        let mut client = self.get_and_update_topology().await;
-        let gateway = client.choose_gateway();
-
-        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
-        let (ack_sender, ack_receiver) = mpsc::unbounded();
-
-        let mut gateway_client = GatewayClient::new(
-            gateway.clients_address(),
-            Arc::clone(&client.identity),
-            gateway.identity_key,
-            gateway.owner.clone(),
-            None,
-            mixnet_messages_sender,
-            ack_sender,
-            DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-            bandwidth_controller,
+        let mut stream = LoopCoverTrafficStream::new(
+            self.key_manager.ack_key(),
+            self.config.debug.average_ack_delay,
+            self.config.debug.average_packet_delay,
+            self.config.debug.loop_cover_traffic_average_delay,
+            mix_tx,
+            self.as_mix_recipient(),
+            topology_accessor,
         );
 
-        if disabled_credentials_mode {
-            gateway_client.set_disabled_credentials_mode(true)
+        if let Some(size) = &self.config.debug.use_extended_packet_size {
+            stream.set_custom_packet_size(size.clone().into());
         }
 
-        gateway_client
+        stream.start();
+    }
+
+    fn start_real_traffic_controller(
+        &self,
+        topology_accessor: TopologyAccessor,
+        ack_receiver: AcknowledgementReceiver,
+        input_receiver: InputMessageReceiver,
+        mix_sender: BatchMixMessageSender,
+    ) {
+        let mut controller_config = real_messages_control::Config::new(
+            self.key_manager.ack_key(),
+            self.config.debug.ack_wait_multiplier,
+            self.config.debug.ack_wait_addition,
+            self.config.debug.average_ack_delay,
+            self.config.debug.message_sending_average_delay,
+            self.config.debug.average_packet_delay,
+            self.config.debug.disable_main_poisson_packet_distribution,
+            self.as_mix_recipient(),
+        );
+
+        if let Some(size) = &self.config.debug.use_extended_packet_size {
+            controller_config.set_custom_packet_size(size.clone().into());
+        }
+
+        console_log!("Starting real traffic stream...");
+
+        RealMessagesController::new(
+            controller_config,
+            ack_receiver,
+            input_receiver,
+            mix_sender,
+            topology_accessor,
+        )
+        .start();
+    }
+
+    // buffer controlling all messages fetched from provider
+    // required so that other components would be able to use them (say the websocket)
+    fn start_received_messages_buffer_controller(
+        &self,
+        query_receiver: ReceivedBufferRequestReceiver,
+        mixnet_receiver: MixnetMessageReceiver,
+    ) {
+        console_log!("Starting received messages buffer controller...");
+        ReceivedMessagesBufferController::new(
+            self.key_manager.encryption_keypair(),
+            query_receiver,
+            mixnet_receiver,
+        )
+        .start()
+    }
+
+    async fn start_gateway_client(
+        &mut self,
+        mixnet_message_sender: MixnetMessageSender,
+        ack_sender: AcknowledgementSender,
+    ) -> GatewayClient {
+        let gateway_id = self.config.gateway_endpoint.gateway_id.clone();
+        if gateway_id.is_empty() {
+            panic!("The identity of the gateway is unknown - did you run `get_gateway()`?")
+        }
+        let gateway_owner = self.config.gateway_endpoint.gateway_owner.clone();
+        if gateway_owner.is_empty() {
+            panic!("The owner of the gateway is unknown - did you run `get_gateway()`?")
+        }
+        let gateway_address = self.config.gateway_endpoint.gateway_listener.clone();
+        if gateway_address.is_empty() {
+            panic!("The address of the gateway is unknown - did you run `get_gateway()`?")
+        }
+
+        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
+            .expect("provided gateway id is invalid!");
+
+        let mut gateway_client = GatewayClient::new(
+            gateway_address,
+            self.key_manager.identity_keypair(),
+            gateway_identity,
+            gateway_owner,
+            None,
+            mixnet_message_sender,
+            ack_sender,
+            self.config.debug.gateway_response_timeout,
+            None,
+        );
+
+        gateway_client.set_disabled_credentials_mode(self.config.disabled_credentials_mode);
+
+        let shared_keys = gateway_client
             .authenticate_and_start()
             .await
             .expect("could not authenticate and start up the gateway connection");
+        self.key_manager.insert_gateway_shared_key(shared_keys);
 
-        client.gateway_client = Some(gateway_client);
-        match client.on_gateway_connect.as_ref() {
+        match self.on_gateway_connect.as_ref() {
             Some(callback) => {
                 callback
                     .call0(&JsValue::null())
@@ -151,125 +216,166 @@ impl NymClient {
             None => console_log!("Gateway connection established - no callback specified"),
         };
 
-        let rng = rand::rngs::OsRng;
-        let message_preparer = MessagePreparer::new(
-            rng,
-            client.self_recipient(),
-            DEFAULT_AVERAGE_PACKET_DELAY,
-            DEFAULT_AVERAGE_ACK_DELAY,
+        gateway_client
+    }
+
+    // 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) {
+        let topology_refresher_config = TopologyRefresherConfig::new(
+            vec![self.config.validator_api_url.clone()],
+            self.config.debug.topology_refresh_rate,
+            env!("CARGO_PKG_VERSION").to_string(),
         );
+        let mut topology_refresher =
+            TopologyRefresher::new(topology_refresher_config, topology_accessor);
+        // before returning, block entire runtime to refresh the current network view so that any
+        // components depending on topology would see a non-empty view
+        console_log!("Obtaining initial network topology");
+        topology_refresher.refresh().await;
 
-        let received_processor = ReceivedMessagesProcessor::new(
-            Arc::clone(&client.encryption_keys),
-            Arc::clone(&client.ack_key),
-        );
+        // TODO: a slightly more graceful termination here
+        if !topology_refresher.is_topology_routable().await {
+            panic!(
+                "The current network topology seem to be insufficient to route any packets through\
+                - check if enough nodes and a gateway are online"
+            );
+        }
 
-        client.message_preparer = Some(message_preparer);
+        console_log!("Starting topology refresher...");
 
-        spawn_local(received_processor.start_processing(
+        // TODO: re-enable
+        topology_refresher.start();
+    }
+
+    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
+    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
+    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
+    // requests?
+    fn start_mix_traffic_controller(gateway_client: GatewayClient) -> BatchMixMessageSender {
+        console_log!("Starting mix traffic controller...");
+        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
+        mix_traffic_controller.start();
+        mix_tx
+    }
+
+    // TODO: this procedure is extremely overcomplicated, because it's based off native client's behaviour
+    // which doesn't fully apply in this case
+    fn start_reconstructed_pusher(
+        &mut self,
+        received_buffer_request_sender: ReceivedBufferRequestSender,
+    ) {
+        let on_message = self.on_message.take();
+
+        spawn_local(async move {
+            let (reconstructed_sender, mut reconstructed_receiver) = mpsc::unbounded();
+
+            // tell the buffer to start sending stuff to us
+            received_buffer_request_sender
+                .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
+                    reconstructed_sender,
+                ))
+                .expect("the buffer request failed!");
+
+            let this = JsValue::null();
+
+            while let Some(reconstructed) = reconstructed_receiver.next().await {
+                if let Some(ref callback) = on_message {
+                    for msg in reconstructed {
+                        if msg.reply_surb.is_some() {
+                            console_log!("the received message contained a reply-surb that we do not know how to handle (yet)")
+                        }
+                        let stringified = String::from_utf8_lossy(&msg.message).into_owned();
+                        let arg1 = serde_wasm_bindgen::to_value(&stringified).unwrap();
+                        callback.call1(&this, &arg1).expect("on message failed!");
+                    }
+                } else {
+                    console_warn!("no on_message callback was specified. the received message content is getting dropped");
+                    console_log!("the raw messages: {:?}", reconstructed)
+                }
+            }
+        });
+    }
+
+    pub async fn start(mut self) -> NymClient {
+        console_log!("Starting wasm client '{}'", self.config.id);
+        // channels for inter-component communication
+        // TODO: make the channels be internally created by the relevant components
+        // rather than creating them here, so say for example the buffer controller would create the request channels
+        // and would allow anyone to clone the sender channel
+
+        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
+        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
+        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
+
+        // used for announcing connection or disconnection of a channel for pushing re-assembled messages to
+        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();
+
+        // channels responsible for controlling real messages
+        let (input_sender, input_receiver) = mpsc::unbounded::<InputMessage>();
+
+        // channels responsible for controlling ack messages
+        let (ack_sender, ack_receiver) = mpsc::unbounded();
+        let shared_topology_accessor = TopologyAccessor::new();
+
+        // 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())
+            .await;
+        self.start_received_messages_buffer_controller(
+            received_buffer_request_receiver,
             mixnet_messages_receiver,
-            ack_receiver,
-            client.on_message.take().expect("on_message was not set!"),
-        ));
+        );
 
-        client
+        let gateway_client = self
+            .start_gateway_client(mixnet_messages_sender, ack_sender)
+            .await;
+
+        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
+        // that are to be sent to the mixnet. They are used by cover traffic stream and real
+        // traffic stream.
+        // The MixTrafficController then sends the actual traffic
+        let sphinx_message_sender = Self::start_mix_traffic_controller(gateway_client);
+
+        self.start_real_traffic_controller(
+            shared_topology_accessor.clone(),
+            ack_receiver,
+            input_receiver,
+            sphinx_message_sender.clone(),
+        );
+
+        if !self.config.debug.disable_loop_cover_traffic_stream {
+            self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
+        }
+
+        self.start_reconstructed_pusher(received_buffer_request_sender);
+        self.input_tx = Some(input_sender);
+
+        self
     }
 
     // Right now it's impossible to have async exported functions to take `&mut self` rather than mut self
     // TODO: try Rc<RefCell<Self>> approach?
-    pub async fn send_message(mut self, message: String, recipient: String) -> Self {
+    pub async fn send_message(self, message: String, recipient: String) -> Self {
         console_log!("Sending {} to {}", message, recipient);
 
         let message_bytes = message.into_bytes();
+        self.send_binary_message(message_bytes, recipient).await
+    }
+
+    pub async fn send_binary_message(self, message: Vec<u8>, recipient: String) -> Self {
+        console_log!("Sending {} bytes to {}", message.len(), recipient);
+
         let recipient = Recipient::try_from_base58_string(recipient).unwrap();
 
-        let topology = self
-            .topology
+        let input_msg = InputMessage::new_fresh(recipient, message, false);
+
+        self.input_tx
             .as_ref()
-            .expect("did not obtain topology before");
-
-        let message_preparer = self.message_preparer.as_mut().unwrap();
-
-        let (split_message, _reply_keys) = message_preparer
-            .prepare_and_split_message(message_bytes, false, topology)
-            .expect("failed to split the message");
-
-        let mut mix_packets = Vec::with_capacity(split_message.len());
-        for message_chunk in split_message {
-            // 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);
-            mix_packets.push(prepared_fragment.mix_packet);
-        }
-        self.gateway_client
-            .as_mut()
-            .unwrap()
-            .batch_send_mix_packets(mix_packets)
-            .await
+            .expect("start method was not called before!")
+            .unbounded_send(input_msg)
             .unwrap();
+
         self
     }
-
-    pub(crate) fn choose_gateway(&self) -> &gateway::Node {
-        let topology = self
-            .topology
-            .as_ref()
-            .expect("did not obtain topology before");
-
-        // choose the first one available
-        assert!(!topology.gateways().is_empty());
-        topology.gateways().first().unwrap()
-    }
-
-    // Right now it's impossible to have async exported functions to take `&mut self` rather than mut self
-    // self: Rc<Self>
-    // or this: Rc<RefCell<Self>>
-    pub async fn get_and_update_topology(mut self) -> Self {
-        let new_topology = self.get_nym_topology().await;
-        self.update_topology(new_topology);
-        self
-    }
-
-    pub(crate) fn update_topology(&mut self, topology: NymTopology) {
-        self.topology = Some(topology)
-    }
-
-    // when updated to 0.10.0, to prevent headache later on, this function requires those two imports:
-    // use js_sys::Promise;
-    // use wasm_bindgen_futures::future_to_promise;
-    //
-    // pub fn get_full_topology_json(&self) -> Promise {
-    //     let validator_client_config = validator_client::Config::new(
-    //         vec![self.validator_server.clone()],
-    //         &self.mixnet_contract_address,
-    //     );
-    //     let validator_client = validator_client::Client::new(validator_client_config);
-    //
-    //     future_to_promise(async move {
-    //         let topology = &validator_client.get_active_topology().await.unwrap();
-    //         Ok(JsValue::from_serde(&topology).unwrap())
-    //     })
-    // }
-
-    pub(crate) async fn get_nym_topology(&self) -> NymTopology {
-        let validator_client = validator_client::ApiClient::new(self.validator_server.clone());
-
-        let mixnodes = match validator_client.get_cached_active_mixnodes().await {
-            Err(err) => panic!("{:?}", err),
-            Ok(mixes) => mixes,
-        };
-
-        let gateways = match validator_client.get_cached_gateways().await {
-            Err(err) => panic!("{}", err),
-            Ok(gateways) => gateways,
-        };
-
-        let topology = nym_topology_from_bonds(mixnodes, gateways);
-        let version = env!("CARGO_PKG_VERSION");
-        topology.filter_system_version(version)
-    }
 }

clients/webassembly/src/client/received_processor.rs

@@ -1,183 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crypto::asymmetric::encryption;
-use futures::StreamExt;
-use gateway_client::{AcknowledgementReceiver, MixnetMessageReceiver};
-use nymsphinx::acknowledgements::identifier::recover_identifier;
-use nymsphinx::acknowledgements::AckKey;
-use nymsphinx::chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID};
-use nymsphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
-use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
-use std::sync::Arc;
-use wasm_bindgen::JsValue;
-use wasm_utils::{console_error, console_log, console_warn};
-
-#[derive(Serialize, Deserialize)]
-pub struct ProcessedMessage {
-    pub message: String,
-    pub reply_surb: Option<String>,
-}
-
-impl From<ReconstructedMessage> for ProcessedMessage {
-    fn from(reconstructed: ReconstructedMessage) -> Self {
-        ProcessedMessage {
-            message: String::from_utf8_lossy(&reconstructed.message).into_owned(),
-            reply_surb: reconstructed
-                .reply_surb
-                .map(|reply_surb| reply_surb.to_base58_string()),
-        }
-    }
-}
-
-pub(crate) struct ReceivedMessagesProcessor {
-    local_encryption_keypair: Arc<encryption::KeyPair>,
-    ack_key: Arc<AckKey>,
-    message_receiver: MessageReceiver,
-
-    recently_reconstructed: HashSet<i32>,
-}
-
-impl ReceivedMessagesProcessor {
-    pub(crate) fn new(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
-        ack_key: Arc<AckKey>,
-    ) -> Self {
-        ReceivedMessagesProcessor {
-            local_encryption_keypair,
-            ack_key,
-            message_receiver: MessageReceiver::new(),
-            recently_reconstructed: HashSet::new(),
-        }
-    }
-
-    // TODO: duplicate code from received_buffer.rs in client-core....
-    fn process_received_fragment(&mut self, raw_fragment: Vec<u8>) -> Option<ProcessedMessage> {
-        let fragment_data = match self
-            .message_receiver
-            .recover_plaintext(self.local_encryption_keypair.private_key(), raw_fragment)
-        {
-            Err(e) => {
-                console_warn!("failed to recover fragment data: {:?}. The whole underlying message might be corrupted and unrecoverable!", e);
-                return None;
-            }
-            Ok(frag_data) => frag_data,
-        };
-
-        if nymsphinx::cover::is_cover(&fragment_data) {
-            // currently won't be the case for a loooong time
-            console_log!("The message was a loop cover message! Skipping it");
-            return None;
-        }
-
-        let fragment = match self.message_receiver.recover_fragment(&fragment_data) {
-            Err(e) => {
-                console_warn!("failed to recover fragment from raw data: {:?}. The whole underlying message might be corrupted and unrecoverable!", e);
-                return None;
-            }
-            Ok(frag) => frag,
-        };
-
-        if self.recently_reconstructed.contains(&fragment.id()) {
-            console_warn!("Received a chunk of already re-assembled message ({:?})! It probably got here because the ack got lost", fragment.id());
-            return None;
-        }
-
-        // if we returned an error the underlying message is malformed in some way
-        match self.message_receiver.insert_new_fragment(fragment) {
-            Err(err) => match err {
-                MessageRecoveryError::MalformedReconstructedMessage(message_sets) => {
-                    // TODO: should we really insert reconstructed sets? could this be abused for some attack?
-                    for set_id in message_sets {
-                        if !self.recently_reconstructed.insert(set_id) {
-                            // or perhaps we should even panic at this point?
-                            console_error!(
-                                "Reconstructed another message containing already used set id!"
-                            )
-                        }
-                    }
-                    None
-                }
-                _ => unreachable!(
-                    "no other error kind should have been returned here! If so, it's a bug!"
-                ),
-            },
-            Ok(reconstruction_result) => match reconstruction_result {
-                Some((reconstructed_message, used_sets)) => {
-                    for set_id in used_sets {
-                        if !self.recently_reconstructed.insert(set_id) {
-                            // or perhaps we should even panic at this point?
-                            console_error!(
-                                "Reconstructed another message containing already used set id!"
-                            )
-                        }
-                    }
-                    Some(reconstructed_message.into())
-                }
-                None => None,
-            },
-        }
-    }
-
-    // TODO: duplicate code from acknowledgement listener...
-    fn process_received_ack(&self, ack_content: Vec<u8>) {
-        let frag_id = match recover_identifier(&self.ack_key, &ack_content)
-            .map(FragmentIdentifier::try_from_bytes)
-        {
-            Some(Ok(frag_id)) => frag_id,
-            _ => {
-                console_warn!("Received invalid ACK!"); // should we do anything else about that?
-                return;
-            }
-        };
-
-        // if we received an ack for cover message or a reply there will be nothing to remove,
-        // because nothing was inserted in the first place
-        if frag_id == COVER_FRAG_ID {
-            return;
-        } else if frag_id.is_reply() {
-            console_warn!("Received an ack for a reply message - no need to do anything! (don't know what to do!)");
-            // TODO: probably there will need to be some extra procedure here, something to notify
-            // user that his reply reached the recipient (since we got an ack)
-            return;
-        }
-
-        console_log!(
-            "Received an ack for fragment {:?} but can't do anything more about it just yet...",
-            frag_id
-        );
-
-        // here be ack handling...
-    }
-
-    // TODO: this needs to have a shutdown signal!
-    pub(crate) async fn start_processing(
-        mut self,
-        mixnet_messages_receiver: MixnetMessageReceiver,
-        ack_receiver: AcknowledgementReceiver,
-        on_message: js_sys::Function,
-    ) {
-        let mut fused_mixnet_messages_receiver = mixnet_messages_receiver.fuse();
-        let mut fused_ack_receiver = ack_receiver.fuse();
-        let this = JsValue::null();
-
-        loop {
-            futures::select! {
-                mix_msgs = fused_mixnet_messages_receiver.next() => {
-                    for mix_msg in mix_msgs.unwrap() {
-                        if let Some(processed) = self.process_received_fragment(mix_msg) {
-                            let arg1 = JsValue::from_serde(&processed).unwrap();
-                            on_message.call1(&this, &arg1).expect("on message failed!");
-                        }
-                    }
-                }
-                acks = fused_ack_receiver.next() => {
-                    for ack in acks.unwrap() {
-                        self.process_received_ack(ack);
-                    }
-                }
-            }
-        }
-    }
-}

clients/webassembly/src/gateway_selector.rs

@@ -0,0 +1,44 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use client_core::config::GatewayEndpoint;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub async fn get_gateway(api_server: String, preferred: Option<String>) -> GatewayEndpoint {
+    let validator_client = validator_client::ApiClient::new(api_server.parse().unwrap());
+
+    let gateways = match validator_client.get_cached_gateways().await {
+        Err(err) => panic!("failed to obtain list of all gateways - {}", err),
+        Ok(gateways) => gateways,
+    };
+
+    if let Some(preferred) = preferred {
+        if let Some(details) = gateways
+            .iter()
+            .find(|g| g.gateway.identity_key == preferred)
+        {
+            return GatewayEndpoint {
+                gateway_id: details.gateway.identity_key.clone(),
+                gateway_owner: details.owner.to_string(),
+                gateway_listener: format!(
+                    "ws://{}:{}",
+                    details.gateway.host, details.gateway.clients_port
+                ),
+            };
+        }
+    }
+
+    let details = gateways
+        .first()
+        .expect("current topology holds no gateways");
+
+    GatewayEndpoint {
+        gateway_id: details.gateway.identity_key.clone(),
+        gateway_owner: details.owner.to_string(),
+        gateway_listener: format!(
+            "ws://{}:{}",
+            details.gateway.host, details.gateway.clients_port
+        ),
+    }
+}

clients/webassembly/src/lib.rs

@@ -5,6 +5,8 @@ use wasm_bindgen::prelude::*;
 
 #[cfg(target_arch = "wasm32")]
 mod client;
+#[cfg(target_arch = "wasm32")]
+pub mod gateway_selector;
 
 #[wasm_bindgen]
 pub fn set_panic_hook() {

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

@@ -10,40 +10,46 @@ edition = "2021"
 # TODO: (for this and other crates), similarly to 'tokio', import only required "futures" modules rather than
 # the entire crate
 futures = "0.3"
-json = "0.12.4"
 log = "0.4"
 thiserror = "1.0"
 url = "2.2"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-secp256k1 = "0.20.3"
-web3 = { version = "0.17.0", default-features = false }
 async-trait = { version = "0.1.51" }
+tokio = { version = "1.21.2", features = ["macros"] }
 
 # 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]
 version = "0.13"
 default-features = false
 
 # non-wasm-only dependencies
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-version = "1.19.1"
+version = "1.21.2"
 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"
@@ -55,8 +61,9 @@ version = "0.4"
 path = "../../wasm-utils"
 
 # only import it in wasm. Prefer proper tokio timer in non-wasm
-[target."cfg(target_arch = \"wasm32\")".dependencies.fluvio-wasm-timer]
-version = "0.2.5"
+[target."cfg(target_arch = \"wasm32\")".dependencies.wasm-timer]
+git = "https://github.com/mmsinclair/wasm-timer"
+rev = "b9d1a54ad514c2f230a026afe0dde341e98cd7b6"
 
 # this is due to tungstenite using `rand` 0.8 and associated changes in `getrandom` crate
 # which now does not support wasm32-unknown-unknown target by default.
@@ -73,5 +80,4 @@ features = ["js"]
 
 [features]
 coconut = ["gateway-requests/coconut", "coconut-interface", "validator-client", "credentials/coconut"]
-wasm = ["web3/wasm", "web3/http", "web3/signing"]
-default = ["web3/default"]
+wasm = []

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

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::GatewayClientError;
-use std::str::FromStr;
 
 #[cfg(target_arch = "wasm32")]
 use crate::wasm_storage::Storage;
@@ -15,6 +14,8 @@ use crate::wasm_storage::StorageError;
 #[cfg(all(not(target_arch = "wasm32"), feature = "coconut"))]
 use credential_storage::error::StorageError;
 
+#[cfg(feature = "coconut")]
+use std::str::FromStr;
 #[cfg(feature = "coconut")]
 use {
     coconut_interface::Base58,
@@ -23,65 +24,12 @@ use {
     },
 };
 
-#[cfg(not(feature = "coconut"))]
-use {
-    credentials::token::bandwidth::TokenCredential,
-    crypto::asymmetric::identity,
-    network_defaults::{
-        eth_contract::ETH_ERC20_JSON_ABI, eth_contract::ETH_JSON_ABI, BANDWIDTH_VALUE,
-        ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_ERC20_APPROVE_FUNCTION_NAME,
-        ETH_ERC20_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN, UTOKENS_TO_BURN,
-    },
-    pemstore::traits::PemStorableKeyPair,
-    rand::rngs::OsRng,
-    secp256k1::SecretKey,
-    web3::{
-        contract::{Contract, Options},
-        ethabi::Token,
-        signing::{Key, SecretKeyRef},
-        transports::Http,
-        types::{Address, U256, U64},
-        Web3,
-    },
-};
-
-#[cfg(not(feature = "coconut"))]
-pub fn eth_contract(web3: Web3<Http>) -> Contract<Http> {
-    Contract::from_json(
-        web3.eth(),
-        Address::from(ETH_CONTRACT_ADDRESS),
-        json::parse(ETH_JSON_ABI)
-            .expect("Invalid json abi")
-            .dump()
-            .as_bytes(),
-    )
-    .expect("Invalid json abi")
-}
-
-#[cfg(not(feature = "coconut"))]
-pub fn eth_erc20_contract(web3: Web3<Http>) -> Contract<Http> {
-    Contract::from_json(
-        web3.eth(),
-        Address::from(ETH_ERC20_CONTRACT_ADDRESS),
-        json::parse(ETH_ERC20_JSON_ABI)
-            .expect("Invalid json abi")
-            .dump()
-            .as_bytes(),
-    )
-    .expect("Invalid json abi")
-}
-
 #[derive(Clone)]
 pub struct BandwidthController<St: Storage> {
+    #[allow(dead_code)]
     storage: St,
     #[cfg(feature = "coconut")]
     validator_endpoints: Vec<url::Url>,
-    #[cfg(not(feature = "coconut"))]
-    contract: Contract<Http>,
-    #[cfg(not(feature = "coconut"))]
-    erc20_contract: Contract<Http>,
-    #[cfg(not(feature = "coconut"))]
-    eth_private_key: SecretKey,
 }
 
 impl<St> BandwidthController<St>
@@ -97,60 +45,8 @@ where
     }
 
     #[cfg(not(feature = "coconut"))]
-    pub fn new(
-        storage: St,
-        eth_endpoint: String,
-        eth_private_key: String,
-    ) -> Result<Self, GatewayClientError> {
-        // Fail early, on invalid url
-        let transport =
-            Http::new(&eth_endpoint).map_err(|_| GatewayClientError::InvalidURL(eth_endpoint))?;
-        let web3 = web3::Web3::new(transport);
-        // Fail early, on invalid abi
-        let contract = eth_contract(web3.clone());
-        let erc20_contract = eth_erc20_contract(web3);
-        let eth_private_key = secp256k1::SecretKey::from_str(&eth_private_key)
-            .map_err(|_| GatewayClientError::InvalidEthereumPrivateKey)?;
-
-        Ok(BandwidthController {
-            storage,
-            contract,
-            erc20_contract,
-            eth_private_key,
-        })
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    async fn backup_keypair(&self, keypair: &identity::KeyPair) -> Result<(), GatewayClientError> {
-        self.storage
-            .insert_erc20_credential(
-                keypair.public_key().to_base58_string(),
-                keypair.private_key().to_base58_string(),
-            )
-            .await?;
-
-        Ok(())
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    async fn restore_keypair(&self) -> Result<identity::KeyPair, GatewayClientError> {
-        let data = self.storage.get_next_erc20_credential().await?;
-        let public_key = identity::PublicKey::from_base58_string(data.public_key).unwrap();
-        let private_key = identity::PrivateKey::from_base58_string(data.private_key).unwrap();
-
-        Ok(identity::KeyPair::from_keys(private_key, public_key))
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    async fn mark_keypair_as_spent(
-        &self,
-        keypair: &identity::KeyPair,
-    ) -> Result<(), GatewayClientError> {
-        self.storage
-            .consume_erc20_credential(keypair.public_key().to_base58_string())
-            .await?;
-
-        Ok(())
+    pub fn new(storage: St) -> Result<Self, GatewayClientError> {
+        Ok(BandwidthController { storage })
     }
 
     #[cfg(feature = "coconut")]
@@ -179,206 +75,4 @@ where
             &verification_key,
         )?)
     }
-
-    #[cfg(not(feature = "coconut"))]
-    pub async fn prepare_token_credential(
-        &self,
-        gateway_identity: identity::PublicKey,
-        gateway_owner: String,
-    ) -> Result<TokenCredential, GatewayClientError> {
-        let kp = match self.restore_keypair().await {
-            Ok(kp) => kp,
-            Err(_) => {
-                let mut rng = OsRng;
-                let kp = identity::KeyPair::new(&mut rng);
-                self.backup_keypair(&kp).await?;
-                kp
-            }
-        };
-
-        let verification_key = *kp.public_key();
-        let signed_verification_key = kp.private_key().sign(&verification_key.to_bytes());
-        self.buy_token_credential(verification_key, signed_verification_key, gateway_owner)
-            .await?;
-
-        self.mark_keypair_as_spent(&kp).await?;
-
-        let message: Vec<u8> = verification_key
-            .to_bytes()
-            .iter()
-            .chain(gateway_identity.to_bytes().iter())
-            .copied()
-            .collect();
-        let signature = kp.private_key().sign(&message);
-
-        Ok(TokenCredential::new(
-            verification_key,
-            gateway_identity,
-            BANDWIDTH_VALUE,
-            signature,
-        ))
-    }
-
-    #[cfg(not(feature = "coconut"))]
-    pub async fn buy_token_credential(
-        &self,
-        verification_key: identity::PublicKey,
-        signed_verification_key: identity::Signature,
-        gateway_owner: String,
-    ) -> Result<(), GatewayClientError> {
-        let confirmations = if cfg!(debug_assertions) {
-            1
-        } else {
-            ETH_MIN_BLOCK_DEPTH
-        };
-        // 15 seconds per confirmation block + 10 seconds of network overhead + 20 seconds of wait for kill
-        log::info!(
-            "Waiting for Ethereum transaction. This should take about {} seconds",
-            (confirmations + 1) * 15 + 30
-        );
-        let mut options = Options::default();
-        let estimation = self
-            .erc20_contract
-            .estimate_gas(
-                ETH_ERC20_APPROVE_FUNCTION_NAME,
-                (
-                    Token::Address(Address::from(ETH_CONTRACT_ADDRESS)),
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                ),
-                SecretKeyRef::from(&self.eth_private_key).address(),
-                options.clone(),
-            )
-            .await?;
-        options.gas = Some(estimation);
-        log::info!("Calling ERC20 approve in 10 seconds with an estimated gas of {}. Kill the process if you want to abort", estimation);
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
-        #[cfg(target_arch = "wasm32")]
-        if let Err(err) = fluvio_wasm_timer::Delay::new(std::time::Duration::from_secs(10)).await {
-            log::error!(
-                "the timer has gone away while waiting for possible kill! - {}",
-                err
-            );
-        }
-        let recipt = self
-            .erc20_contract
-            .signed_call_with_confirmations(
-                ETH_ERC20_APPROVE_FUNCTION_NAME,
-                (
-                    Token::Address(Address::from(ETH_CONTRACT_ADDRESS)),
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                ),
-                options,
-                1, // One confirmation is enough, as we'll be consuming the approved token next anyway
-                &self.eth_private_key,
-            )
-            .await?;
-        if Some(U64::from(0u64)) == recipt.status {
-            return Err(GatewayClientError::BurnTokenError(
-                web3::Error::InvalidResponse(format!(
-                    "Approve transaction status is 0 (failure): {:?}",
-                    recipt.logs,
-                )),
-            ));
-        } else {
-            log::info!(
-                "Approved {} tokens for bandwidth use on Ethereum",
-                TOKENS_TO_BURN
-            );
-        }
-
-        let mut options = Options::default();
-        let estimation = self
-            .contract
-            .estimate_gas(
-                ETH_BURN_FUNCTION_NAME,
-                (
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                    Token::Uint(U256::from(&verification_key.to_bytes())),
-                    Token::Bytes(signed_verification_key.to_bytes().to_vec()),
-                    Token::String(gateway_owner.clone()),
-                ),
-                SecretKeyRef::from(&self.eth_private_key).address(),
-                options.clone(),
-            )
-            .await?;
-        options.gas = Some(estimation);
-        log::info!("Generating bandwidth on ETH contract in 10 seconds with an estimated gas of {}. \
-         Kill the process if you want to abort. Keep in mind that if you abort now, you'll still have \
-         some tokens approved for bandwidth spending from the previous action. \
-         If you don't want that, you'll need to manually decreaseAllowance to revert the approval.", estimation);
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::time::sleep(tokio::time::Duration::from_secs(10)).await;
-        #[cfg(target_arch = "wasm32")]
-        if let Err(err) = fluvio_wasm_timer::Delay::new(std::time::Duration::from_secs(10)).await {
-            log::error!(
-                "the timer has gone away while waiting for possible kill! - {}",
-                err
-            );
-        }
-        let recipt = self
-            .contract
-            .signed_call_with_confirmations(
-                ETH_BURN_FUNCTION_NAME,
-                (
-                    Token::Uint(U256::from(UTOKENS_TO_BURN)),
-                    Token::Uint(U256::from(&verification_key.to_bytes())),
-                    Token::Bytes(signed_verification_key.to_bytes().to_vec()),
-                    Token::String(gateway_owner),
-                ),
-                options,
-                confirmations,
-                &self.eth_private_key,
-            )
-            .await?;
-        if Some(U64::from(0u64)) == recipt.status {
-            Err(GatewayClientError::BurnTokenError(
-                web3::Error::InvalidResponse(format!(
-                    "Transaction status is 0 (failure): {:?}",
-                    recipt.logs,
-                )),
-            ))
-        } else {
-            log::info!(
-                "Bought bandwidth on Ethereum: {} MB",
-                BANDWIDTH_VALUE / 1024 / 1024
-            );
-            Ok(())
-        }
-    }
-}
-
-#[cfg(not(feature = "coconut"))]
-#[cfg(test)]
-mod tests {
-    use network_defaults::ETH_EVENT_NAME;
-
-    use super::*;
-
-    #[test]
-    fn parse_contract() {
-        let transport =
-            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
-        let web3 = web3::Web3::new(transport);
-        // test no panic occurs
-        eth_contract(web3);
-    }
-
-    #[test]
-    fn parse_erc20_contract() {
-        let transport =
-            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
-        let web3 = web3::Web3::new(transport);
-        // test no panic occurs
-        eth_erc20_contract(web3);
-    }
-
-    #[test]
-    fn check_event_name_constant_against_abi() {
-        let transport =
-            Http::new("https://rinkeby.infura.io/v3/00000000000000000000000000000000").unwrap();
-        let web3 = web3::Web3::new(transport);
-        let contract = eth_contract(web3);
-        assert!(contract.abi().event(ETH_EVENT_NAME).is_ok());
-    }
 }

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

@@ -15,8 +15,6 @@ use crate::wasm_storage::PersistentStorage;
 use coconut_interface::Credential;
 #[cfg(not(target_arch = "wasm32"))]
 use credential_storage::PersistentStorage;
-#[cfg(not(feature = "coconut"))]
-use credentials::token::bandwidth::TokenCredential;
 use crypto::asymmetric::identity;
 use futures::{FutureExt, SinkExt, StreamExt};
 use gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
@@ -30,13 +28,15 @@ 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"))]
 use tokio_tungstenite::connect_async;
 
 #[cfg(target_arch = "wasm32")]
-use fluvio_wasm_timer as wasm_timer;
+use wasm_timer;
 #[cfg(target_arch = "wasm32")]
 use wasm_utils::websocket::JSWebsocket;
 
@@ -65,6 +65,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 +84,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 +96,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 +135,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 +143,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 +166,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 +299,33 @@ 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
+                } else {
+                    std::future::pending::<()>().await
+                }
+            }
+            .fuse()
+        };
+        #[cfg(not(target_arch = "wasm32"))]
+        tokio::pin!(shutdown);
+
+        #[cfg(target_arch = "wasm32")]
+        let mut shutdown = std::future::pending::<()>().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);
                         }
                         _ => (),
                     }
-               }
+                }
             }
         }
     }
@@ -505,30 +552,6 @@ impl GatewayClient {
         Ok(())
     }
 
-    #[cfg(not(feature = "coconut"))]
-    async fn claim_token_bandwidth(
-        &mut self,
-        credential: TokenCredential,
-    ) -> Result<(), GatewayClientError> {
-        let mut rng = OsRng;
-
-        let iv = IV::new_random(&mut rng);
-
-        let msg = ClientControlRequest::new_enc_token_bandwidth_credential(
-            &credential,
-            self.shared_key.as_ref().unwrap(),
-            iv,
-        )
-        .into();
-        self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
-            ServerResponse::Bandwidth { available_total } => Ok(available_total),
-            ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
-            _ => Err(GatewayClientError::UnexpectedResponse),
-        }?;
-
-        Ok(())
-    }
-
     async fn try_claim_testnet_bandwidth(&mut self) -> Result<(), GatewayClientError> {
         let msg = ClientControlRequest::ClaimFreeTestnetBandwidth.into();
         self.bandwidth_remaining = match self.send_websocket_message(msg).await? {
@@ -567,17 +590,10 @@ impl GatewayClient {
             .prepare_coconut_credential()
             .await?;
         #[cfg(not(feature = "coconut"))]
-        let credential = self
-            .bandwidth_controller
-            .as_ref()
-            .unwrap()
-            .prepare_token_credential(self.gateway_identity, _gateway_owner)
-            .await?;
+        return self.try_claim_testnet_bandwidth().await;
 
         #[cfg(feature = "coconut")]
         return self.claim_coconut_bandwidth(credential).await;
-        #[cfg(not(feature = "coconut"))]
-        return self.claim_token_bandwidth(credential).await;
     }
 
     fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
@@ -723,6 +739,8 @@ impl GatewayClient {
                                 .as_ref()
                                 .expect("no shared key present even though we're authenticated!"),
                         ),
+                        #[cfg(not(target_arch = "wasm32"))]
+                        self.shutdown.clone(),
                     )
                 }
                 _ => unreachable!(),

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

@@ -11,8 +11,6 @@ use thiserror::Error;
 use tungstenite::Error as WsError;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::JsValue;
-#[cfg(not(feature = "coconut"))]
-use web3::{contract::Error as Web3ContractError, Error as Web3Error};
 
 #[derive(Debug, Error)]
 pub enum GatewayClientError {
@@ -37,18 +35,6 @@ pub enum GatewayClientError {
     #[error("There was a network error")]
     NetworkErrorWasm(JsValue),
 
-    #[cfg(not(feature = "coconut"))]
-    #[error("Could not burn ERC20 token in Ethereum smart contract - {0}")]
-    BurnTokenError(#[from] Web3Error),
-
-    #[cfg(not(feature = "coconut"))]
-    #[error("Could not run web3 contract - {0}")]
-    Web3ContractError(#[from] Web3ContractError),
-
-    #[cfg(not(feature = "coconut"))]
-    #[error("Invalid Ethereum private key")]
-    InvalidEthereumPrivateKey,
-
     #[error("Invalid URL - {0}")]
     InvalidURL(String),
 
@@ -64,6 +50,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 +82,9 @@ pub enum GatewayClientError {
 
     #[error("Timed out")]
     Timeout,
+
+    #[error("Failed to send mixnet message")]
+    MixnetMsgSenderFailedToSend,
 }
 
 impl GatewayClientError {

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

@@ -25,3 +25,15 @@ pub(crate) fn cleanup_socket_message(
         None => Err(GatewayClientError::ConnectionAbruptlyClosed),
     }
 }
+
+pub(crate) fn cleanup_socket_messages(
+    msgs: Option<Vec<Result<Message, WsError>>>,
+) -> Result<Vec<Message>, GatewayClientError> {
+    match msgs {
+        Some(msgs) => msgs
+            .into_iter()
+            .map(|msg| msg.map_err(GatewayClientError::NetworkError))
+            .collect(),
+        None => Err(GatewayClientError::ConnectionAbruptlyClosed),
+    }
+}

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

@@ -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();
 
@@ -47,11 +59,22 @@ impl PacketRouter {
             } else if received_packet.len()
                 == PacketSize::RegularPacket.plaintext_size() - ack_overhead
             {
+                trace!("routing regular packet");
                 received_messages.push(received_packet);
             } else if received_packet.len()
-                == PacketSize::ExtendedPacket.plaintext_size() - ack_overhead
+                == PacketSize::ExtendedPacket8.plaintext_size() - ack_overhead
             {
-                warn!("received extended packet? Did not expect this...");
+                trace!("routing extended8 packet");
+                received_messages.push(received_packet);
+            } else if received_packet.len()
+                == PacketSize::ExtendedPacket16.plaintext_size() - ack_overhead
+            {
+                trace!("routing extended16 packet");
+                received_messages.push(received_packet);
+            } else if received_packet.len()
+                == PacketSize::ExtendedPacket32.plaintext_size() - ack_overhead
+            {
+                trace!("routing extended32 packet");
                 received_messages.push(received_packet);
             } else {
                 // this can happen if other clients are not padding their messages
@@ -60,24 +83,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(())
     }
 }

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

@@ -1,16 +1,18 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::cleanup_socket_message;
+use crate::cleanup_socket_messages;
 use crate::error::GatewayClientError;
 use crate::packet_router::PacketRouter;
 use futures::channel::oneshot;
 use futures::stream::{SplitSink, SplitStream};
-use futures::{FutureExt, SinkExt, StreamExt};
+use futures::{SinkExt, StreamExt};
 use gateway_requests::registration::handshake::SharedKeys;
 use gateway_requests::BinaryResponse;
 use log::*;
 use std::sync::Arc;
+#[cfg(not(target_arch = "wasm32"))]
+use task::ShutdownListener;
 use tungstenite::Message;
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -42,16 +44,15 @@ pub(crate) struct PartiallyDelegated {
 }
 
 impl PartiallyDelegated {
-    fn route_socket_message(
-        ws_msg: Message,
-        packet_router: &PacketRouter,
-        shared_key: &SharedKeys,
-    ) {
-        match ws_msg {
-            Message::Binary(bin_msg) => {
-                // this function decrypts the request and checks the MAC
-                let plaintext =
-                    match BinaryResponse::try_from_encrypted_tagged_bytes(bin_msg, shared_key) {
+    fn recover_received_plaintexts(ws_msgs: Vec<Message>, shared_key: &SharedKeys) -> Vec<Vec<u8>> {
+        let mut plaintexts = Vec::with_capacity(ws_msgs.len());
+        for ws_msg in ws_msgs {
+            match ws_msg {
+                Message::Binary(bin_msg) => {
+                    // this function decrypts the request and checks the MAC
+                    let plaintext = match BinaryResponse::try_from_encrypted_tagged_bytes(
+                        bin_msg, shared_key,
+                    ) {
                         Ok(bin_response) => match bin_response {
                             BinaryResponse::PushedMixMessage(plaintext) => plaintext,
                         },
@@ -60,32 +61,44 @@ impl PartiallyDelegated {
                                 "message received from the gateway was malformed! - {:?}",
                                 err
                             );
-                            return;
+                            continue;
                         }
                     };
+                    plaintexts.push(plaintext)
+                }
+                // I think that in the future we should perhaps have some sequence number system, i.e.
+                // so each request/response pair can be easily identified, so that if messages are
+                // not ordered (for some peculiar reason) we wouldn't lose anything.
+                // This would also require NOT discarding any text responses here.
 
-                // TODO: some batching mechanism to allow reading and sending more than
-                // one packet at the time, because the receiver can easily handle it
-                packet_router.route_received(vec![plaintext])
+                // 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
+                );
+                    continue;
+                }
+                _ => continue,
             }
-            // I think that in the future we should perhaps have some sequence number system, i.e.
-            // so each request/response pair can be easily identified, so that if messages are
-            // not ordered (for some peculiar reason) we wouldn't lose anything.
-            // This would also require NOT discarding any text responses here.
+        }
+        plaintexts
+    }
 
-            // 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
-            ),
-            _ => (),
-        };
+    fn route_socket_messages(
+        ws_msgs: Vec<Message>,
+        packet_router: &mut PacketRouter,
+        shared_key: &SharedKeys,
+    ) -> Result<(), GatewayClientError> {
+        let plaintexts = Self::recover_received_plaintexts(ws_msgs, shared_key);
+        packet_router.route_received(plaintexts)
     }
 
     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.
@@ -95,20 +108,47 @@ impl PartiallyDelegated {
         let (sink, mut stream) = conn.split();
 
         let mixnet_receiver_future = async move {
-            let mut fused_receiver = notify_receiver.fuse();
-            let mut fused_stream = (&mut stream).fuse();
+            let mut notify_receiver = notify_receiver;
+            let mut chunk_stream = (&mut stream).ready_chunks(8);
+            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 = {
+                async {
+                    if let Some(mut s) = shutdown {
+                        s.recv().await
+                    } else {
+                        std::future::pending::<()>().await
+                    }
+                }
+            };
+            #[cfg(not(target_arch = "wasm32"))]
+            tokio::pin!(shutdown);
+
+            #[cfg(target_arch = "wasm32")]
+            let mut shutdown = std::future::pending::<()>();
 
             let ret_err = loop {
-                futures::select! {
-                    _ = fused_receiver => {
+                tokio::select! {
+                    _ = &mut shutdown => {
+                        log::trace!("GatewayClient listener: Received shutdown");
+                        log::debug!("GatewayClient listener: Exiting");
+                        return;
+                    }
+                    _ = &mut notify_receiver => {
                         break Ok(());
                     }
-                    msg = fused_stream.next() => {
-                        let ws_msg = match cleanup_socket_message(msg) {
+                    msgs = chunk_stream.next() => {
+                        let ws_msgs = match cleanup_socket_messages(msgs) {
                             Err(err) => break Err(err),
-                            Ok(msg) => msg
+                            Ok(msgs) => msgs
                         };
-                        Self::route_socket_message(ws_msg, &packet_router, shared_key.as_ref());
+
+                        if let Err(err) = Self::route_socket_messages(ws_msgs, &mut packet_router, shared_key.as_ref()) {
+                            log::warn!("Route socket messages failed: {:?}", err);
+                        }
                     }
                 };
             };
@@ -162,12 +202,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.

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

@@ -26,13 +26,6 @@ pub struct CoconutCredential {
     pub signature: String,
 }
 
-pub struct ERC20Credential {
-    pub id: i64,
-    pub public_key: String,
-    pub private_key: String,
-    pub consumed: bool,
-}
-
 #[async_trait]
 pub trait Storage: Send + Sync {
     async fn insert_coconut_credential(
@@ -47,16 +40,6 @@ pub trait Storage: Send + Sync {
     async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError>;
 
     async fn remove_coconut_credential(&self, id: i64) -> Result<(), StorageError>;
-
-    async fn insert_erc20_credential(
-        &self,
-        public_key: String,
-        private_key: String,
-    ) -> Result<(), StorageError>;
-
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError>;
-
-    async fn consume_erc20_credential(&self, public_key: String) -> Result<(), StorageError>;
 }
 
 #[async_trait]
@@ -79,20 +62,4 @@ impl Storage for PersistentStorage {
     async fn remove_coconut_credential(&self, _id: i64) -> Result<(), StorageError> {
         Err(StorageError::WasmNotSupported)
     }
-
-    async fn insert_erc20_credential(
-        &self,
-        _public_key: String,
-        _private_key: String,
-    ) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn get_next_erc20_credential(&self) -> Result<ERC20Credential, StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
-
-    async fn consume_erc20_credential(&self, _public_key: String) -> Result<(), StorageError> {
-        Err(StorageError::WasmNotSupported)
-    }
 }

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

@@ -9,7 +9,7 @@ edition = "2021"
 [dependencies]
 futures = "0.3"
 log = "0.4.8"
-tokio = { version = "1.19.1", features = ["time", "net", "rt"] }
+tokio = { version = "1.21.2", features = ["time", "net", "rt"] }
 tokio-util = { version = "0.7.3", features = ["codec"] }
 
 # internal

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

@@ -23,6 +23,7 @@ pub struct Config {
     maximum_reconnection_backoff: Duration,
     initial_connection_timeout: Duration,
     maximum_connection_buffer_size: usize,
+    use_legacy_version: bool,
 }
 
 impl Config {
@@ -31,12 +32,14 @@ impl Config {
         maximum_reconnection_backoff: Duration,
         initial_connection_timeout: Duration,
         maximum_connection_buffer_size: usize,
+        use_legacy_version: bool,
     ) -> Self {
         Config {
             initial_reconnection_backoff,
             maximum_reconnection_backoff,
             initial_connection_timeout,
             maximum_connection_buffer_size,
+            use_legacy_version,
         }
     }
 }
@@ -186,7 +189,7 @@ impl Client {
                 address.into(),
                 receiver,
                 initial_connection_timeout,
-                &*current_reconnection_attempt,
+                &current_reconnection_attempt,
             )
             .await
         });
@@ -201,7 +204,8 @@ impl SendWithoutResponse for Client {
         packet_mode: PacketMode,
     ) -> io::Result<()> {
         trace!("Sending packet to {:?}", address);
-        let framed_packet = FramedSphinxPacket::new(packet, packet_mode);
+        let framed_packet =
+            FramedSphinxPacket::new(packet, packet_mode, self.config.use_legacy_version);
 
         if let Some(sender) = self.conn_new.get_mut(&address) {
             if let Err(err) = sender.channel.try_send(framed_packet) {
@@ -259,6 +263,7 @@ mod tests {
             maximum_reconnection_backoff: Duration::from_millis(300_000),
             initial_connection_timeout: Duration::from_millis(1_500),
             maximum_connection_buffer_size: 128,
+            use_legacy_version: false,
         })
     }
 

common/client-libs/mixnet-client/src/forwarder.rs

@@ -24,12 +24,14 @@ impl PacketForwarder {
         maximum_reconnection_backoff: Duration,
         initial_connection_timeout: Duration,
         maximum_connection_buffer_size: usize,
+        use_legacy_version: bool,
     ) -> (PacketForwarder, MixForwardingSender) {
         let client_config = Config::new(
             initial_reconnection_backoff,
             maximum_reconnection_backoff,
             initial_connection_timeout,
             maximum_connection_buffer_size,
+            use_legacy_version,
         );
 
         let (packet_sender, packet_receiver) = mpsc::unbounded();

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

@@ -13,6 +13,7 @@ colored = "2.0"
 cw3 = "0.13.1"
 mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract" }
 vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
+contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
 coconut-bandwidth-contract-common = { path= "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
 vesting-contract = { path = "../../../contracts/vesting" }
@@ -22,7 +23,7 @@ reqwest = { version = "0.11", features = ["json"] }
 thiserror = "1"
 log = "0.4"
 url = { version = "2.2", features = ["serde"] }
-tokio = { version = "1.19.1", features = ["sync", "time"] }
+tokio = { version = "1.21.2", features = ["sync", "time"] }
 futures = "0.3"
 
 coconut-interface = { path = "../../coconut-interface" }

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

@@ -2,35 +2,33 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{validator_api, ValidatorClientError};
-use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
+use mixnet_contract_common::mixnode::MixNodeDetails;
+use mixnet_contract_common::MixId;
+use mixnet_contract_common::{GatewayBond, IdentityKeyRef};
 use url::Url;
 use validator_api_requests::coconut::{
     BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
     VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
-    CoreNodeStatusResponse, MixnodeStatusResponse, RewardEstimationResponse,
-    StakeSaturationResponse,
+    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
+    RewardEstimationResponse, StakeSaturationResponse,
 };
 
 #[cfg(feature = "nymd-client")]
-use validator_api_requests::models::{MixNodeBondAnnotated, UptimeResponse};
-
+use crate::nymd::traits::MixnetQueryClient;
 #[cfg(feature = "nymd-client")]
-use crate::nymd::{
-    self, error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
-};
-
+use crate::nymd::{self, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient};
 #[cfg(feature = "nymd-client")]
 use mixnet_contract_common::{
-    mixnode::DelegationEvent, ContractStateParams, Delegation, IdentityKey, Interval,
-    MixnetContractVersion, MixnodeRewardingStatusResponse, RewardedSetNodeStatus,
-    RewardedSetUpdateDetails,
+    mixnode::MixNodeBond,
+    pending_events::{PendingEpochEvent, PendingIntervalEvent},
+    Delegation, RewardedSetNodeStatus, UnbondedMixnode,
 };
 #[cfg(feature = "nymd-client")]
 use network_defaults::NymNetworkDetails;
 #[cfg(feature = "nymd-client")]
-use std::collections::{HashMap, HashSet};
+use validator_api_requests::models::MixNodeBondAnnotated;
 
 #[cfg(feature = "nymd-client")]
 #[must_use]
@@ -191,12 +189,9 @@ impl Client<QueryNymdClient> {
     }
 }
 
+// nymd wrappers
 #[cfg(feature = "nymd-client")]
 impl<C> Client<C> {
-    pub fn change_validator_api(&mut self, new_endpoint: Url) {
-        self.validator_api.change_url(new_endpoint)
-    }
-
     // use case: somebody initialised client without a contract in order to upload and initialise one
     // and now they want to actually use it without making new client
     pub fn set_mixnet_contract_address(&mut self, mixnet_contract_address: cosmrs::AccountId) {
@@ -208,203 +203,22 @@ impl<C> Client<C> {
         self.nymd.mixnet_contract_address().clone()
     }
 
-    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnodes().await?)
-    }
-
-    pub async fn get_cached_mixnodes_detailed(
-        &self,
-    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnodes_detailed().await?)
-    }
-
-    pub async fn get_cached_rewarded_mixnodes(
-        &self,
-    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
-        Ok(self.validator_api.get_rewarded_mixnodes().await?)
-    }
-
-    pub async fn get_cached_rewarded_mixnodes_detailed(
-        &self,
-    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
-        Ok(self.validator_api.get_rewarded_mixnodes_detailed().await?)
-    }
-
-    pub async fn get_cached_active_mixnodes(
-        &self,
-    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
-        Ok(self.validator_api.get_active_mixnodes().await?)
-    }
-
-    pub async fn get_cached_active_mixnodes_detailed(
-        &self,
-    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
-        Ok(self.validator_api.get_active_mixnodes_detailed().await?)
-    }
-
-    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
-        Ok(self.validator_api.get_gateways().await?)
-    }
-
-    pub async fn get_contract_settings(&self) -> Result<ContractStateParams, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_contract_settings().await?)
-    }
-
-    pub async fn get_operator_rewards(&self, address: String) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_operator_rewards(address).await?.u128())
-    }
-
-    pub async fn get_delegator_rewards(
-        &self,
-        address: String,
-        mix_identity: IdentityKey,
-        proxy: Option<String>,
-    ) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .get_delegator_rewards(address, mix_identity, proxy)
-            .await?
-            .u128())
-    }
-
-    pub async fn get_pending_delegation_events(
-        &self,
-        owner_address: String,
-        proxy_address: Option<String>,
-    ) -> Result<Vec<DelegationEvent>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .get_pending_delegation_events(owner_address, proxy_address)
-            .await?)
-    }
-
-    pub async fn get_current_epoch(&self) -> Result<Interval, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_current_epoch().await?)
-    }
-
-    pub async fn get_current_operator_cost(&self) -> Result<u64, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_current_operator_cost().await?)
-    }
-
-    pub async fn get_mixnet_contract_version(&self) -> Result<MixnetContractVersion, NymdError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        self.nymd.get_mixnet_contract_version().await
-    }
-
-    pub async fn get_rewarding_status(
-        &self,
-        mix_identity: mixnet_contract_common::IdentityKey,
-        rewarding_interval_nonce: u32,
-    ) -> Result<MixnodeRewardingStatusResponse, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .get_rewarding_status(mix_identity, rewarding_interval_nonce)
-            .await?)
-    }
-
-    pub async fn get_reward_pool(&self) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_reward_pool().await?.u128())
-    }
-
-    pub async fn get_circulating_supply(&self) -> Result<u128, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_circulating_supply().await?.u128())
-    }
-
-    pub async fn get_sybil_resistance_percent(&self) -> Result<u8, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_sybil_resistance_percent().await?)
-    }
-
-    pub async fn get_active_set_work_factor(&self) -> Result<u8, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_active_set_work_factor().await?)
-    }
-
-    pub async fn get_epochs_in_interval(&self) -> Result<u64, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_epochs_in_interval().await?)
-    }
-
-    pub async fn get_interval_reward_percent(&self) -> Result<u8, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_interval_reward_percent().await?)
-    }
-
-    pub async fn get_current_rewarded_set_update_details(
-        &self,
-    ) -> Result<RewardedSetUpdateDetails, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .query_current_rewarded_set_update_details()
-            .await?)
-    }
-
     // basically handles paging for us
-    pub async fn get_all_nymd_rewarded_set_mixnode_identities(
+    pub async fn get_all_nymd_rewarded_set_mixnodes(
         &self,
-    ) -> Result<Vec<(IdentityKey, RewardedSetNodeStatus)>, ValidatorClientError>
+    ) -> Result<Vec<(MixId, RewardedSetNodeStatus)>, ValidatorClientError>
     where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
     {
         let mut identities = Vec::new();
         let mut start_after = None;
-        let mut height = None;
 
         loop {
             let mut paged_response = self
                 .nymd
-                .get_rewarded_set_identities_paged(
-                    start_after.take(),
-                    self.rewarded_set_page_limit,
-                    height,
-                )
+                .get_rewarded_set_paged(start_after.take(), self.rewarded_set_page_limit)
                 .await?;
-            identities.append(&mut paged_response.identities);
-
-            if height.is_none() {
-                // keep using the same height (the first query happened at the most recent height)
-                height = Some(paged_response.at_height)
-            }
+            identities.append(&mut paged_response.nodes);
 
             if let Some(start_after_res) = paged_response.start_next_after {
                 start_after = Some(start_after_res)
@@ -416,83 +230,122 @@ impl<C> Client<C> {
         Ok(identities)
     }
 
-    pub async fn get_nymd_rewarded_and_active_sets(
-        &self,
-    ) -> Result<Vec<(MixNodeBond, RewardedSetNodeStatus)>, ValidatorClientError>
+    pub async fn get_all_nymd_mixnode_bonds(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
     where
-        C: CosmWasmClient + Sync,
-    {
-        let all_mixnodes = self.get_all_nymd_mixnodes().await?;
-        let rewarded_set_identities = self
-            .get_all_nymd_rewarded_set_mixnode_identities()
-            .await?
-            .into_iter()
-            .collect::<HashMap<_, _>>();
-
-        Ok(all_mixnodes
-            .into_iter()
-            .filter_map(|node| {
-                rewarded_set_identities
-                    .get(node.identity())
-                    .map(|status| (node, *status))
-            })
-            .collect())
-    }
-
-    /// If you need both rewarded and the active set, consider using [Self::get_nymd_rewarded_and_active_sets] instead
-    pub async fn get_nymd_rewarded_set(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let all_mixnodes = self.get_all_nymd_mixnodes().await?;
-        let rewarded_set_identities = self
-            .get_all_nymd_rewarded_set_mixnode_identities()
-            .await?
-            .into_iter()
-            .map(|(identity, _status)| identity)
-            .collect::<HashSet<_>>();
-
-        Ok(all_mixnodes
-            .into_iter()
-            .filter(|node| rewarded_set_identities.contains(node.identity()))
-            .collect())
-    }
-
-    /// If you need both rewarded and the active set, consider using [Self::get_nymd_rewarded_and_active_sets] instead
-    pub async fn get_nymd_active_set(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        let all_mixnodes = self.get_all_nymd_mixnodes().await?;
-        let active_set_identities = self
-            .get_all_nymd_rewarded_set_mixnode_identities()
-            .await?
-            .into_iter()
-            .filter_map(|(identity, status)| {
-                if status.is_active() {
-                    Some(identity)
-                } else {
-                    None
-                }
-            })
-            .collect::<HashSet<_>>();
-
-        Ok(all_mixnodes
-            .into_iter()
-            .filter(|node| active_set_identities.contains(node.identity()))
-            .collect())
-    }
-
-    pub async fn get_all_nymd_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
     {
         let mut mixnodes = Vec::new();
         let mut start_after = None;
         loop {
             let mut paged_response = self
                 .nymd
-                .get_mixnodes_paged(start_after.take(), self.mixnode_page_limit)
+                .get_mixnode_bonds_paged(self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_mixnodes_detailed_paged(self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_unbonded_mixnodes(
+        &self,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_unbonded_paged(self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_unbonded_mixnodes_by_owner(
+        &self,
+        owner: &cosmrs::AccountId,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_unbonded_by_owner_paged(owner, self.mixnode_page_limit, start_after.take())
+                .await?;
+            mixnodes.append(&mut paged_response.nodes);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(mixnodes)
+    }
+
+    pub async fn get_all_nymd_unbonded_mixnodes_by_identity(
+        &self,
+        identity_key: String,
+    ) -> Result<Vec<(MixId, UnbondedMixnode)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut mixnodes = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_unbonded_by_identity_paged(
+                    identity_key.clone(),
+                    self.mixnode_page_limit,
+                    start_after.take(),
+                )
                 .await?;
             mixnodes.append(&mut paged_response.nodes);
 
@@ -508,7 +361,7 @@ impl<C> Client<C> {
 
     pub async fn get_all_nymd_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError>
     where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
     {
         let mut gateways = Vec::new();
         let mut start_after = None;
@@ -531,18 +384,18 @@ impl<C> Client<C> {
 
     pub async fn get_all_nymd_single_mixnode_delegations(
         &self,
-        identity: IdentityKey,
+        mix_id: MixId,
     ) -> Result<Vec<Delegation>, ValidatorClientError>
     where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
     {
         let mut delegations = Vec::new();
         let mut start_after = None;
         loop {
             let mut paged_response = self
                 .nymd
-                .get_mix_delegations_paged(
-                    identity.clone(),
+                .get_mixnode_delegations_paged(
+                    mix_id,
                     start_after.take(),
                     self.mixnode_delegations_page_limit,
                 )
@@ -564,7 +417,7 @@ impl<C> Client<C> {
         delegation_owner: &cosmrs::AccountId,
     ) -> Result<Vec<Delegation>, ValidatorClientError>
     where
-        C: CosmWasmClient + Sync,
+        C: CosmWasmClient + Sync + Send,
     {
         let mut delegations = Vec::new();
         let mut start_after = None;
@@ -589,10 +442,128 @@ impl<C> Client<C> {
         Ok(delegations)
     }
 
-    pub async fn get_mixnode_avg_uptimes(
+    pub async fn get_all_network_delegations(&self) -> Result<Vec<Delegation>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut delegations = Vec::new();
+        let mut start_after = None;
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_all_network_delegations_paged(
+                    start_after.take(),
+                    self.mixnode_delegations_page_limit,
+                )
+                .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)
+    }
+
+    pub async fn get_all_nymd_pending_epoch_events(
         &self,
-    ) -> Result<Vec<UptimeResponse>, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnode_avg_uptimes().await?)
+    ) -> Result<Vec<PendingEpochEvent>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut events = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_pending_epoch_events_paged(start_after.take(), self.rewarded_set_page_limit)
+                .await?;
+            events.append(&mut paged_response.events);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(events)
+    }
+
+    pub async fn get_all_nymd_pending_interval_events(
+        &self,
+    ) -> Result<Vec<PendingIntervalEvent>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut events = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let mut paged_response = self
+                .nymd
+                .get_pending_interval_events_paged(start_after.take(), self.rewarded_set_page_limit)
+                .await?;
+            events.append(&mut paged_response.events);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(events)
+    }
+}
+
+// validator-api wrappers
+#[cfg(feature = "nymd-client")]
+impl<C> Client<C> {
+    pub fn change_validator_api(&mut self, new_endpoint: Url) {
+        self.validator_api.change_url(new_endpoint)
+    }
+
+    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
+        Ok(self.validator_api.get_mixnodes().await?)
+    }
+
+    pub async fn get_cached_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_mixnodes_detailed().await?)
+    }
+
+    pub async fn get_cached_rewarded_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes().await?)
+    }
+
+    pub async fn get_cached_rewarded_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_rewarded_mixnodes_detailed().await?)
+    }
+
+    pub async fn get_cached_active_mixnodes(
+        &self,
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
+        Ok(self.validator_api.get_active_mixnodes().await?)
+    }
+
+    pub async fn get_cached_active_mixnodes_detailed(
+        &self,
+    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
+        Ok(self.validator_api.get_active_mixnodes_detailed().await?)
+    }
+
+    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
+        Ok(self.validator_api.get_gateways().await?)
     }
 
     pub async fn blind_sign(
@@ -630,17 +601,17 @@ impl ApiClient {
 
     pub async fn get_cached_active_mixnodes(
         &self,
-    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.validator_api.get_active_mixnodes().await?)
     }
 
     pub async fn get_cached_rewarded_mixnodes(
         &self,
-    ) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.validator_api.get_rewarded_mixnodes().await?)
     }
 
-    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorClientError> {
+    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.validator_api.get_mixnodes().await?)
     }
 
@@ -652,7 +623,7 @@ impl ApiClient {
         &self,
         identity: IdentityKeyRef<'_>,
         since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorClientError> {
+    ) -> Result<GatewayCoreStatusResponse, ValidatorClientError> {
         Ok(self
             .validator_api
             .get_gateway_core_status_count(identity, since)
@@ -661,39 +632,39 @@ impl ApiClient {
 
     pub async fn get_mixnode_core_status_count(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
         since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorClientError> {
+    ) -> Result<MixnodeCoreStatusResponse, ValidatorClientError> {
         Ok(self
             .validator_api
-            .get_mixnode_core_status_count(identity, since)
+            .get_mixnode_core_status_count(mix_id, since)
             .await?)
     }
 
     pub async fn get_mixnode_status(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<MixnodeStatusResponse, ValidatorClientError> {
-        Ok(self.validator_api.get_mixnode_status(identity).await?)
+        Ok(self.validator_api.get_mixnode_status(mix_id).await?)
     }
 
     pub async fn get_mixnode_reward_estimation(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<RewardEstimationResponse, ValidatorClientError> {
         Ok(self
             .validator_api
-            .get_mixnode_reward_estimation(identity)
+            .get_mixnode_reward_estimation(mix_id)
             .await?)
     }
 
     pub async fn get_mixnode_stake_saturation(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<StakeSaturationResponse, ValidatorClientError> {
         Ok(self
             .validator_api
-            .get_mixnode_stake_saturation(identity)
+            .get_mixnode_stake_saturation(mix_id)
             .await?)
     }
 

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

@@ -1,11 +1,12 @@
 use crate::nymd::error::NymdError;
 use crate::nymd::{Config as ClientConfig, NymdClient, QueryNymdClient};
 use crate::ApiClient;
-use network_defaults::all::Network;
 
+use crate::nymd::traits::MixnetQueryClient;
 use colored::Colorize;
 use core::fmt;
 use itertools::Itertools;
+use network_defaults::NymNetworkDetails;
 use std::collections::HashMap;
 use std::hash::BuildHasher;
 use std::time::Duration;
@@ -17,12 +18,12 @@ const CONNECTION_TEST_TIMEOUT_SEC: u64 = 2;
 
 // Run connection tests for all specified nymd and api urls. These are all run concurrently.
 pub async fn run_validator_connection_test<H: BuildHasher + 'static>(
-    nymd_urls: impl Iterator<Item = (Network, Url)>,
-    api_urls: impl Iterator<Item = (Network, Url)>,
-    mixnet_contract_address: HashMap<Network, cosmrs::AccountId, H>,
+    nymd_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    api_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    mixnet_contract_address: HashMap<NymNetworkDetails, cosmrs::AccountId, H>,
 ) -> (
-    HashMap<Network, Vec<(Url, bool)>>,
-    HashMap<Network, Vec<(Url, bool)>>,
+    HashMap<NymNetworkDetails, Vec<(Url, bool)>>,
+    HashMap<NymNetworkDetails, Vec<(Url, bool)>>,
 ) {
     // Setup all the clients for the connection tests
     let connection_test_clients =
@@ -45,16 +46,16 @@ pub async fn run_validator_connection_test<H: BuildHasher + 'static>(
 }
 
 fn setup_connection_tests<H: BuildHasher + 'static>(
-    nymd_urls: impl Iterator<Item = (Network, Url)>,
-    api_urls: impl Iterator<Item = (Network, Url)>,
-    mixnet_contract_address: HashMap<Network, cosmrs::AccountId, H>,
+    nymd_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    api_urls: impl Iterator<Item = (NymNetworkDetails, Url)>,
+    mixnet_contract_address: HashMap<NymNetworkDetails, cosmrs::AccountId, H>,
 ) -> impl Iterator<Item = ClientForConnectionTest> {
     let nymd_connection_test_clients = nymd_urls.filter_map(move |(network, url)| {
         let address = mixnet_contract_address
             .get(&network)
             .expect("No configured contract address")
             .clone();
-        let config = ClientConfig::try_from_nym_network_details(&network.details())
+        let config = ClientConfig::try_from_nym_network_details(&network)
             .expect("failed to create valid nymd client config");
 
         if let Ok(mut client) = NymdClient::<QueryNymdClient>::connect(config, url.as_str()) {
@@ -80,7 +81,7 @@ fn setup_connection_tests<H: BuildHasher + 'static>(
 fn extract_and_collect_results_into_map(
     connection_results: &[ConnectionResult],
     url_type: &UrlType,
-) -> HashMap<Network, Vec<(Url, bool)>> {
+) -> HashMap<NymNetworkDetails, Vec<(Url, bool)>> {
     connection_results
         .iter()
         .filter(|c| &c.url_type() == url_type)
@@ -92,7 +93,7 @@ fn extract_and_collect_results_into_map(
 }
 
 async fn test_nymd_connection(
-    network: Network,
+    network: NymNetworkDetails,
     url: &Url,
     client: &NymdClient<QueryNymdClient>,
 ) -> ConnectionResult {
@@ -104,56 +105,47 @@ async fn test_nymd_connection(
     {
         Ok(Err(NymdError::TendermintError(e))) => {
             // If we get a tendermint-rpc error, we classify the node as not contactable
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}: {}",
-                "failed".red(),
-                e
-            );
+            log::debug!("Checking: nymd_url: {url}: {}: {}", "failed".red(), e);
             false
         }
         Ok(Err(NymdError::AbciError(code, log))) => {
             // We accept the mixnet contract not found as ok from a connection standpoint. This happens
             // for example on a pre-launch network.
             log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}, but with abci error: {code}: {log}",
+                "Checking: nymd_url: {url}: {}, but with abci error: {code}: {log}",
                 "success".green()
             );
             code == 18
         }
         Ok(Err(error @ NymdError::NoContractAddressAvailable)) => {
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}: {error}",
-                "failed".red()
-            );
+            log::debug!("Checking: nymd_url: {url}: {}: {error}", "failed".red());
             false
         }
         Ok(Err(e)) => {
             // For any other error, we're optimistic and just try anyway.
             log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}, but with error: {e}",
+                "Checking: nymd_url: {url}: {}, but with error: {e}",
                 "success".green()
             );
             true
         }
         Ok(Ok(_)) => {
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}",
-                "success".green()
-            );
+            log::debug!("Checking: nymd_url: {url}: {}", "success".green());
             true
         }
         Err(e) => {
-            log::debug!(
-                "Checking: nymd_url: {network}: {url}: {}: {e}",
-                "failed".red()
-            );
+            log::debug!("Checking: nymd_url: {url}: {}: {e}", "failed".red());
             false
         }
     };
     ConnectionResult::Nymd(network, url.clone(), result)
 }
 
-async fn test_api_connection(network: Network, url: &Url, client: &ApiClient) -> ConnectionResult {
+async fn test_api_connection(
+    network: NymNetworkDetails,
+    url: &Url,
+    client: &ApiClient,
+) -> ConnectionResult {
     let result = match timeout(
         Duration::from_secs(CONNECTION_TEST_TIMEOUT_SEC),
         client.get_cached_mixnodes(),
@@ -161,21 +153,15 @@ async fn test_api_connection(network: Network, url: &Url, client: &ApiClient) ->
     .await
     {
         Ok(Ok(_)) => {
-            log::debug!("Checking: api_url: {network}: {url}: {}", "success".green());
+            log::debug!("Checking: api_url: {url}: {}", "success".green());
             true
         }
         Ok(Err(e)) => {
-            log::debug!(
-                "Checking: api_url: {network}: {url}: {}: {e}",
-                "failed".red()
-            );
+            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
             false
         }
         Err(e) => {
-            log::debug!(
-                "Checking: api_url: {network}: {url}: {}: {e}",
-                "failed".red()
-            );
+            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
             false
         }
     };
@@ -183,8 +169,8 @@ async fn test_api_connection(network: Network, url: &Url, client: &ApiClient) ->
 }
 
 enum ClientForConnectionTest {
-    Nymd(Network, Url, Box<NymdClient<QueryNymdClient>>),
-    Api(Network, Url, ApiClient),
+    Nymd(NymNetworkDetails, Url, Box<NymdClient<QueryNymdClient>>),
+    Api(NymNetworkDetails, Url, ApiClient),
 }
 
 impl ClientForConnectionTest {
@@ -217,12 +203,12 @@ impl fmt::Display for UrlType {
 
 #[derive(Debug)]
 enum ConnectionResult {
-    Nymd(Network, Url, bool),
-    Api(Network, Url, bool),
+    Nymd(NymNetworkDetails, Url, bool),
+    Api(NymNetworkDetails, Url, bool),
 }
 
 impl ConnectionResult {
-    fn result(&self) -> (&Network, &Url, &bool) {
+    fn result(&self) -> (&NymNetworkDetails, &Url, &bool) {
         match self {
             ConnectionResult::Nymd(network, url, result)
             | ConnectionResult::Api(network, url, result) => (network, url, result),
@@ -239,11 +225,8 @@ impl ConnectionResult {
 
 impl fmt::Display for ConnectionResult {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let (network, url, result) = self.result();
+        let (_network, url, result) = self.result();
         let url_type = self.url_type();
-        write!(
-            f,
-            "{network}: {url}: {url_type}: connection is successful: {result}"
-        )
+        write!(f, "{url}: {url_type}: connection is successful: {result}")
     }
 }

common/client-libs/validator-client/src/nymd/cosmwasm_client/types.rs

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

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

@@ -0,0 +1,388 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
+use crate::nymd::error::NymdError;
+use crate::nymd::NymdClient;
+use async_trait::async_trait;
+use cosmrs::AccountId;
+use mixnet_contract_common::delegation::{MixNodeDelegationResponse, OwnerProxySubKey};
+use mixnet_contract_common::mixnode::{
+    MixNodeDetails, MixnodeRewardingDetailsResponse, PagedMixnodesDetailsResponse,
+    PagedUnbondedMixnodesResponse, StakeSaturationResponse, UnbondedMixnodeResponse,
+};
+use mixnet_contract_common::reward_params::{Performance, RewardingParams};
+use mixnet_contract_common::rewarding::{
+    EstimatedCurrentEpochRewardResponse, PendingRewardResponse,
+};
+use mixnet_contract_common::{
+    delegation, ContractBuildInformation, ContractState, ContractStateParams,
+    CurrentIntervalResponse, EpochEventId, GatewayBondResponse, GatewayOwnershipResponse,
+    IdentityKey, IntervalEventId, LayerDistribution, MixId, MixOwnershipResponse,
+    MixnodeDetailsResponse, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
+    PagedGatewayResponse, PagedMixNodeDelegationsResponse, PagedMixnodeBondsResponse,
+    PagedRewardedSetResponse, PendingEpochEventsResponse, PendingIntervalEventsResponse,
+    QueryMsg as MixnetQueryMsg,
+};
+use serde::Deserialize;
+
+#[async_trait]
+pub trait MixnetQueryClient {
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    // state/sys-params-related
+
+    async fn get_mixnet_contract_version(&self) -> Result<ContractBuildInformation, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetContractVersion {})
+            .await
+    }
+
+    async fn get_rewarding_validator_address(&self) -> Result<AccountId, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardingValidatorAddress {})
+            .await
+    }
+
+    async fn get_mixnet_contract_settings(&self) -> Result<ContractStateParams, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetStateParams {})
+            .await
+    }
+
+    async fn get_mixnet_contract_state(&self) -> Result<ContractState, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetState {})
+            .await
+    }
+
+    async fn get_rewarding_parameters(&self) -> Result<RewardingParams, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardingParams {})
+            .await
+    }
+
+    async fn get_current_interval_details(&self) -> Result<CurrentIntervalResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetCurrentIntervalDetails {})
+            .await
+    }
+
+    async fn get_rewarded_set_paged(
+        &self,
+        start_after: Option<MixId>,
+        limit: Option<u32>,
+    ) -> Result<PagedRewardedSetResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetRewardedSet { limit, start_after })
+            .await
+    }
+
+    // mixnode-related:
+
+    async fn get_mixnode_bonds_paged(
+        &self,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedMixnodeBondsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixNodeBonds { limit, start_after })
+            .await
+    }
+
+    async fn get_mixnodes_detailed_paged(
+        &self,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedMixnodesDetailsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixNodesDetailed { limit, start_after })
+            .await
+    }
+
+    async fn get_unbonded_paged(
+        &self,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodes { limit, start_after })
+            .await
+    }
+
+    async fn get_unbonded_by_owner_paged(
+        &self,
+        owner: &AccountId,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodesByOwner {
+            owner: owner.to_string(),
+            limit,
+            start_after,
+        })
+        .await
+    }
+
+    async fn get_unbonded_by_identity_paged(
+        &self,
+        identity_key: String,
+        limit: Option<u32>,
+        start_after: Option<MixId>,
+    ) -> Result<PagedUnbondedMixnodesResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodesByIdentityKey {
+            identity_key,
+            limit,
+            start_after,
+        })
+        .await
+    }
+
+    async fn get_owned_mixnode(
+        &self,
+        address: &AccountId,
+    ) -> Result<MixOwnershipResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetOwnedMixnode {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    async fn get_mixnode_details(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeDetailsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeDetails { mix_id })
+            .await
+    }
+
+    async fn get_mixnode_rewarding_details(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeRewardingDetailsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeRewardingDetails { mix_id })
+            .await
+    }
+
+    async fn get_mixnode_stake_saturation(
+        &self,
+        mix_id: MixId,
+    ) -> Result<StakeSaturationResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetStakeSaturation { mix_id })
+            .await
+    }
+
+    async fn get_unbonded_mixnode_information(
+        &self,
+        mix_id: MixId,
+    ) -> Result<UnbondedMixnodeResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetUnbondedMixNodeInformation { mix_id })
+            .await
+    }
+
+    async fn get_layer_distribution(&self) -> Result<LayerDistribution, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetLayerDistribution {})
+            .await
+    }
+
+    // gateway-related:
+
+    async fn get_gateways_paged(
+        &self,
+        start_after: Option<IdentityKey>,
+        limit: Option<u32>,
+    ) -> Result<PagedGatewayResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetGateways { start_after, limit })
+            .await
+    }
+
+    /// Checks whether there is a bonded gateway associated with the provided identity key
+    async fn get_gateway_bond(
+        &self,
+        identity: IdentityKey,
+    ) -> Result<GatewayBondResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetGatewayBond { identity })
+            .await
+    }
+
+    /// Checks whether there is a bonded gateway associated with the provided client's address
+    async fn get_owned_gateway(
+        &self,
+        address: &AccountId,
+    ) -> Result<GatewayOwnershipResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetOwnedGateway {
+            address: address.to_string(),
+        })
+        .await
+    }
+
+    // delegation-related:
+
+    /// Gets list of all delegations towards particular mixnode on particular page.
+    async fn get_mixnode_delegations_paged(
+        &self,
+        mix_id: MixId,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedMixNodeDelegationsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetMixnodeDelegations {
+            mix_id,
+            start_after,
+            limit,
+        })
+        .await
+    }
+
+    /// Gets list of all the mixnodes to which a particular address delegated.
+    async fn get_delegator_delegations_paged(
+        &self,
+        delegator: String,
+        start_after: Option<(MixId, OwnerProxySubKey)>,
+        limit: Option<u32>,
+    ) -> Result<PagedDelegatorDelegationsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetDelegatorDelegations {
+            delegator,
+            start_after,
+            limit,
+        })
+        .await
+    }
+
+    /// Checks value of delegation of given client towards particular mixnode.
+    async fn get_delegation_details(
+        &self,
+        mix_id: MixId,
+        delegator: &AccountId,
+        proxy: Option<String>,
+    ) -> Result<MixNodeDelegationResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetDelegationDetails {
+            mix_id,
+            delegator: delegator.to_string(),
+            proxy,
+        })
+        .await
+    }
+
+    /// Gets all the delegations on the entire network
+    async fn get_all_network_delegations_paged(
+        &self,
+        start_after: Option<delegation::StorageKey>,
+        limit: Option<u32>,
+    ) -> Result<PagedAllDelegationsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetAllDelegations { start_after, limit })
+            .await
+    }
+
+    // rewards related
+    async fn get_pending_operator_reward(
+        &self,
+        operator: &AccountId,
+    ) -> Result<PendingRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingOperatorReward {
+            address: operator.to_string(),
+        })
+        .await
+    }
+
+    async fn get_pending_mixnode_operator_reward(
+        &self,
+        mix_id: MixId,
+    ) -> Result<PendingRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingMixNodeOperatorReward { mix_id })
+            .await
+    }
+
+    async fn get_pending_delegator_reward(
+        &self,
+        delegator: &AccountId,
+        mix_id: MixId,
+        proxy: Option<String>,
+    ) -> Result<PendingRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingDelegatorReward {
+            address: delegator.to_string(),
+            mix_id,
+            proxy,
+        })
+        .await
+    }
+
+    // given the provided performance, estimate the reward at the end of the current epoch
+    async fn get_estimated_current_epoch_operator_reward(
+        &self,
+        mix_id: MixId,
+        estimated_performance: Performance,
+    ) -> Result<EstimatedCurrentEpochRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetEstimatedCurrentEpochOperatorReward {
+            mix_id,
+            estimated_performance,
+        })
+        .await
+    }
+
+    // given the provided performance, estimate the reward at the end of the current epoch
+    async fn get_estimated_current_epoch_delegator_reward(
+        &self,
+        delegator: &AccountId,
+        mix_id: MixId,
+        proxy: Option<String>,
+        estimated_performance: Performance,
+    ) -> Result<EstimatedCurrentEpochRewardResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetEstimatedCurrentEpochDelegatorReward {
+            address: delegator.to_string(),
+            mix_id,
+            proxy,
+            estimated_performance,
+        })
+        .await
+    }
+
+    // interval-related
+
+    async fn get_pending_epoch_events_paged(
+        &self,
+        start_after: Option<EpochEventId>,
+        limit: Option<u32>,
+    ) -> Result<PendingEpochEventsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingEpochEvents { start_after, limit })
+            .await
+    }
+
+    async fn get_pending_interval_events_paged(
+        &self,
+        start_after: Option<IntervalEventId>,
+        limit: Option<u32>,
+    ) -> Result<PendingIntervalEventsResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetPendingIntervalEvents { start_after, limit })
+            .await
+    }
+
+    async fn get_mixnode_details_by_identity(
+        &self,
+        mix_identity: IdentityKey,
+    ) -> Result<Option<MixNodeDetails>, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetBondedMixnodeDetailsByIdentity {
+            mix_identity,
+        })
+        .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetQueryClient for NymdClient<C>
+where
+    C: CosmWasmClient + Sync + Send,
+{
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        self.client
+            .query_contract_smart(self.mixnet_contract_address(), &query)
+            .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetQueryClient for crate::Client<C>
+where
+    C: CosmWasmClient + Sync + Send,
+{
+    async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        self.nymd.query_mixnet_contract(query).await
+    }
+}

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

@@ -0,0 +1,496 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nymd::coin::Coin;
+pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
+use crate::nymd::cosmwasm_client::types::ExecuteResult;
+use crate::nymd::error::NymdError;
+use crate::nymd::{Fee, NymdClient, SigningCosmWasmClient};
+use async_trait::async_trait;
+use cosmrs::AccountId;
+use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
+use mixnet_contract_common::reward_params::{IntervalRewardingParamsUpdate, Performance};
+use mixnet_contract_common::{
+    ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, MixId, MixNode,
+};
+
+#[async_trait]
+pub trait MixnetSigningClient {
+    async fn execute_mixnet_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: MixnetExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    // state/sys-params-related
+
+    async fn update_rewarding_validator_address(
+        &self,
+        address: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateRewardingValidatorAddress {
+                address: address.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_contract_state_params(
+        &self,
+        updated_parameters: ContractStateParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateContractStateParams { updated_parameters },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_active_set_size(
+        &self,
+        active_set_size: u32,
+        force_immediately: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateActiveSetSize {
+                active_set_size,
+                force_immediately,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_rewarding_parameters(
+        &self,
+        updated_params: IntervalRewardingParamsUpdate,
+        force_immediately: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateRewardingParams {
+                updated_params,
+                force_immediately,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_interval_config(
+        &self,
+        epochs_in_interval: u32,
+        epoch_duration_secs: u64,
+        force_immediately: bool,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateIntervalConfig {
+                epochs_in_interval,
+                epoch_duration_secs,
+                force_immediately,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn advance_current_epoch(
+        &self,
+        new_rewarded_set: Vec<MixId>,
+        expected_active_set_size: u32,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::AdvanceCurrentEpoch {
+                new_rewarded_set,
+                expected_active_set_size,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn reconcile_epoch_events(
+        &self,
+        limit: Option<u32>,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::ReconcileEpochEvents { limit },
+            vec![],
+        )
+        .await
+    }
+
+    // mixnode-related:
+
+    async fn bond_mixnode(
+        &self,
+        mix_node: MixNode,
+        cost_params: MixNodeCostParams,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondMixnode {
+                mix_node,
+                cost_params,
+                owner_signature,
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn bond_mixnode_on_behalf(
+        &self,
+        owner: AccountId,
+        mix_node: MixNode,
+        cost_params: MixNodeCostParams,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondMixnodeOnBehalf {
+                mix_node,
+                cost_params,
+                owner_signature,
+                owner: owner.to_string(),
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(fee, MixnetExecuteMsg::UnbondMixnode {}, vec![])
+            .await
+    }
+
+    async fn unbond_mixnode_on_behalf(
+        &self,
+        owner: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UnbondMixnodeOnBehalf {
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_cost_params(
+        &self,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeCostParams { new_costs },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_cost_params_on_behalf(
+        &self,
+        owner: AccountId,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeCostParamsOnBehalf {
+                new_costs,
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_config(
+        &self,
+        new_config: MixNodeConfigUpdate,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeConfig { new_config },
+            vec![],
+        )
+        .await
+    }
+
+    async fn update_mixnode_config_on_behalf(
+        &self,
+        owner: AccountId,
+        new_config: MixNodeConfigUpdate,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UpdateMixnodeConfigOnBehalf {
+                new_config,
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    // gateway-related:
+
+    async fn bond_gateway(
+        &self,
+        gateway: Gateway,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondGateway {
+                gateway,
+                owner_signature,
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn bond_gateway_on_behalf(
+        &self,
+        owner: AccountId,
+        gateway: Gateway,
+        owner_signature: String,
+        pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::BondGatewayOnBehalf {
+                gateway,
+                owner_signature,
+                owner: owner.to_string(),
+            },
+            vec![pledge],
+        )
+        .await
+    }
+
+    async fn unbond_gateway(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(fee, MixnetExecuteMsg::UnbondGateway {}, vec![])
+            .await
+    }
+
+    async fn unbond_gateway_on_behalf(
+        &self,
+        owner: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UnbondGatewayOnBehalf {
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    // delegation-related:
+
+    async fn delegate_to_mixnode(
+        &self,
+        mix_id: MixId,
+        amount: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::DelegateToMixnode { mix_id },
+            vec![amount],
+        )
+        .await
+    }
+
+    async fn delegate_to_mixnode_on_behalf(
+        &self,
+        delegate: AccountId,
+        mix_id: MixId,
+        amount: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::DelegateToMixnodeOnBehalf {
+                mix_id,
+                delegate: delegate.to_string(),
+            },
+            vec![amount],
+        )
+        .await
+    }
+
+    async fn undelegate_from_mixnode(
+        &self,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UndelegateFromMixnode { mix_id },
+            vec![],
+        )
+        .await
+    }
+
+    async fn undelegate_to_mixnode_on_behalf(
+        &self,
+        delegate: AccountId,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::UndelegateFromMixnodeOnBehalf {
+                mix_id,
+                delegate: delegate.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    // reward-related
+
+    async fn reward_mixnode(
+        &self,
+        mix_id: MixId,
+        performance: Performance,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::RewardMixnode {
+                mix_id,
+                performance,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn withdraw_operator_reward(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(fee, MixnetExecuteMsg::WithdrawOperatorReward {}, vec![])
+            .await
+    }
+
+    async fn withdraw_operator_reward_on_behalf(
+        &self,
+        owner: AccountId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::WithdrawOperatorRewardOnBehalf {
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn withdraw_delegator_reward(
+        &self,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::WithdrawDelegatorReward { mix_id },
+            vec![],
+        )
+        .await
+    }
+
+    async fn withdraw_delegator_reward_on_behalf(
+        &self,
+        owner: AccountId,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::WithdrawDelegatorRewardOnBehalf {
+                mix_id,
+                owner: owner.to_string(),
+            },
+            vec![],
+        )
+        .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetSigningClient for NymdClient<C>
+where
+    C: SigningCosmWasmClient + Sync + Send,
+{
+    async fn execute_mixnet_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: MixnetExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let memo = msg.default_memo();
+        self.client
+            .execute(
+                self.address(),
+                self.mixnet_contract_address(),
+                &msg,
+                fee,
+                memo,
+                funds,
+            )
+            .await
+    }
+}
+
+#[async_trait]
+impl<C> MixnetSigningClient for crate::Client<C>
+where
+    C: SigningCosmWasmClient + Sync + Send,
+{
+    async fn execute_mixnet_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: MixnetExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.nymd.execute_mixnet_contract(fee, msg, funds).await
+    }
+}

common/client-libs/validator-client/src/nymd/traits/mod.rs

@@ -1,8 +1,10 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 mod coconut_bandwidth_query_client;
 mod coconut_bandwidth_signing_client;
+mod mixnet_query_client;
+mod mixnet_signing_client;
 mod multisig_query_client;
 mod multisig_signing_client;
 mod vesting_query_client;
@@ -10,6 +12,8 @@ mod vesting_signing_client;
 
 pub use coconut_bandwidth_query_client::CoconutBandwidthQueryClient;
 pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
+pub use mixnet_query_client::MixnetQueryClient;
+pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_query_client::MultisigQueryClient;
 pub use multisig_signing_client::MultisigSigningClient;
 pub use vesting_query_client::VestingQueryClient;

common/client-libs/validator-client/src/nymd/traits/vesting_query_client.rs

@@ -6,14 +6,27 @@ pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 use crate::nymd::error::NymdError;
 use crate::nymd::NymdClient;
 use async_trait::async_trait;
+use contracts_common::ContractBuildInformation;
 use cosmwasm_std::{Coin as CosmWasmCoin, Timestamp};
+use mixnet_contract_common::MixId;
+use serde::Deserialize;
 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]
 pub trait VestingQueryClient {
+    async fn query_vesting_contract<T>(&self, query: VestingQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>;
+
+    async fn get_vesting_contract_version(&self) -> Result<ContractBuildInformation, NymdError> {
+        self.query_vesting_contract(VestingQueryMsg::GetContractVersion {})
+            .await
+    }
+
     async fn locked_coins(
         &self,
         address: &str,
@@ -70,10 +83,50 @@ pub trait VestingQueryClient {
         &self,
         vesting_account_address: &str,
     ) -> Result<Period, NymdError>;
+
+    async fn get_delegation_timestamps(
+        &self,
+        address: &str,
+        mix_id: MixId,
+    ) -> Result<DelegationTimesResponse, NymdError>;
+
+    async fn get_all_vesting_delegations_paged(
+        &self,
+        start_after: Option<(u32, MixId, 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]
 impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
+    async fn query_vesting_contract<T>(&self, query: VestingQueryMsg) -> Result<T, NymdError>
+    where
+        for<'a> T: Deserialize<'a>,
+    {
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &query)
+            .await
+    }
+
     async fn locked_coins(
         &self,
         vesting_account_address: &str,
@@ -232,4 +285,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_id: MixId,
+    ) -> Result<DelegationTimesResponse, NymdError> {
+        let request = VestingQueryMsg::GetDelegationTimes {
+            address: address.to_string(),
+            mix_id,
+        };
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &request)
+            .await
+    }
+
+    async fn get_all_vesting_delegations_paged(
+        &self,
+        start_after: Option<(u32, MixId, 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
+    }
 }

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

@@ -6,14 +6,29 @@ use crate::nymd::cosmwasm_client::types::ExecuteResult;
 use crate::nymd::error::NymdError;
 use crate::nymd::{Coin, Fee, NymdClient};
 use async_trait::async_trait;
-use mixnet_contract_common::{Gateway, IdentityKey, IdentityKeyRef, MixNode};
+use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
+use mixnet_contract_common::{Gateway, MixId, MixNode};
 use vesting_contract_common::messages::{ExecuteMsg as VestingExecuteMsg, VestingSpecification};
+use vesting_contract_common::PledgeCap;
 
 #[async_trait]
 pub trait VestingSigningClient {
+    async fn execute_vesting_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: VestingExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError>;
+
+    async fn vesting_update_mixnode_cost_params(
+        &self,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError>;
+
     async fn vesting_update_mixnode_config(
         &self,
-        profix_margin_percent: u8,
+        new_config: MixNodeConfigUpdate,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError>;
 
@@ -43,10 +58,12 @@ pub trait VestingSigningClient {
     async fn vesting_bond_mixnode(
         &self,
         mix_node: MixNode,
+        cost_params: MixNodeCostParams,
         owner_signature: &str,
         pledge: Coin,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError>;
+
     async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError>;
 
     async fn vesting_track_unbond_mixnode(
@@ -65,21 +82,21 @@ pub trait VestingSigningClient {
     async fn vesting_track_undelegation(
         &self,
         address: &str,
-        mix_identity: IdentityKey,
+        mix_id: MixId,
         amount: Coin,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError>;
 
-    async fn vesting_delegate_to_mixnode<'a>(
+    async fn vesting_delegate_to_mixnode(
         &self,
-        mix_identity: IdentityKeyRef<'a>,
+        mix_id: MixId,
         amount: Coin,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError>;
 
-    async fn vesting_undelegate_from_mixnode<'a>(
+    async fn vesting_undelegate_from_mixnode(
         &self,
-        mix_identity: IdentityKeyRef<'a>,
+        mix_id: MixId,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError>;
 
@@ -89,21 +106,53 @@ pub trait VestingSigningClient {
         staking_address: Option<String>,
         vesting_spec: Option<VestingSpecification>,
         amount: Coin,
+        cap: Option<PledgeCap>,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError>;
 }
 
 #[async_trait]
 impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient<C> {
+    async fn execute_vesting_contract(
+        &self,
+        fee: Option<Fee>,
+        msg: VestingExecuteMsg,
+        funds: Vec<Coin>,
+    ) -> Result<ExecuteResult, NymdError> {
+        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
+        let memo = msg.name().to_string();
+        self.client
+            .execute(
+                self.address(),
+                self.vesting_contract_address(),
+                &msg,
+                fee,
+                memo,
+                funds,
+            )
+            .await
+    }
+
+    async fn vesting_update_mixnode_cost_params(
+        &self,
+        new_costs: MixNodeCostParams,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::UpdateMixnodeCostParams { new_costs },
+            vec![],
+        )
+        .await
+    }
+
     async fn vesting_update_mixnode_config(
         &self,
-        profit_margin_percent: u8,
+        new_config: MixNodeConfigUpdate,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError> {
         let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::UpdateMixnodeConfig {
-            profit_margin_percent,
-        };
+        let req = VestingExecuteMsg::UpdateMixnodeConfig { new_config };
         self.client
             .execute(
                 self.address(),
@@ -203,26 +252,22 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
     async fn vesting_bond_mixnode(
         &self,
         mix_node: MixNode,
+        cost_params: MixNodeCostParams,
         owner_signature: &str,
         pledge: Coin,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::BondMixnode {
-            mix_node,
-            owner_signature: owner_signature.to_string(),
-            amount: pledge.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::BondMixnode",
-                vec![],
-            )
-            .await
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::BondMixnode {
+                mix_node,
+                cost_params,
+                owner_signature: owner_signature.to_string(),
+                amount: pledge.into(),
+            },
+            vec![],
+        )
+        .await
     }
 
     async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
@@ -262,6 +307,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
             )
             .await
     }
+
     async fn withdraw_vested_coins(
         &self,
         amount: Coin,
@@ -282,72 +328,54 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
             )
             .await
     }
+
     async fn vesting_track_undelegation(
         &self,
         address: &str,
-        mix_identity: IdentityKey,
+        mix_id: MixId,
         amount: Coin,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::TrackUndelegation {
-            owner: address.to_string(),
-            mix_identity,
-            amount: amount.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::TrackUndelegation",
-                vec![],
-            )
-            .await
-    }
-    async fn vesting_delegate_to_mixnode<'a>(
-        &self,
-        mix_identity: IdentityKeyRef<'a>,
-        amount: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::DelegateToMixnode {
-            mix_identity: mix_identity.into(),
-            amount: amount.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::DelegateToMixnode",
-                vec![],
-            )
-            .await
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::TrackUndelegation {
+                owner: address.to_string(),
+                mix_id,
+                amount: amount.into(),
+            },
+            vec![],
+        )
+        .await
     }
 
-    async fn vesting_undelegate_from_mixnode<'a>(
+    async fn vesting_delegate_to_mixnode(
         &self,
-        mix_identity: IdentityKeyRef<'a>,
+        mix_id: MixId,
+        amount: Coin,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError> {
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
-        let req = VestingExecuteMsg::UndelegateFromMixnode {
-            mix_identity: mix_identity.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address(),
-                &req,
-                fee,
-                "VestingContract::UndelegateFromMixnode",
-                vec![],
-            )
-            .await
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::DelegateToMixnode {
+                mix_id,
+                amount: amount.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn vesting_undelegate_from_mixnode(
+        &self,
+        mix_id: MixId,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::UndelegateFromMixnode { mix_id },
+            vec![],
+        )
+        .await
     }
 
     async fn create_periodic_vesting_account(
@@ -356,6 +384,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
         staking_address: Option<String>,
         vesting_spec: Option<VestingSpecification>,
         amount: Coin,
+        cap: Option<PledgeCap>,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NymdError> {
         let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier)));
@@ -363,6 +392,7 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
             owner_address: owner_address.to_string(),
             staking_address,
             vesting_spec,
+            cap,
         };
         self.client
             .execute(

common/client-libs/validator-client/src/nymd/wallet/mod.rs

@@ -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};
@@ -72,7 +72,7 @@ impl DirectSecp256k1HdWallet {
     }
 
     fn derive_keypair(&self, hd_path: &DerivationPath) -> Result<Secp256k1Keypair, NymdError> {
-        let extended_private_key = XPrv::derive_from_path(&self.seed, hd_path)?;
+        let extended_private_key = XPrv::derive_from_path(self.seed, hd_path)?;
 
         let private_key: SigningKey = extended_private_key.into();
         let public_key = private_key.public_key();
@@ -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,
@@ -196,8 +207,9 @@ impl DirectSecp256k1HdWalletBuilder {
 
 #[cfg(test)]
 mod tests {
+    use network_defaults::NymNetworkDetails;
+
     use super::*;
-    use network_defaults::all::Network::*;
 
     #[test]
     fn generating_account_addresses() {
@@ -207,7 +219,9 @@ 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 prefix = MAINNET.bech32_prefix();
+        let prefix = NymNetworkDetails::new_mainnet()
+            .chain_details
+            .bech32_account_prefix;
 
         let addrs = vec![
             "n1jw6mp7d5xqc7w6xm79lha27glmd0vdt3l9artf",

common/client-libs/validator-client/src/validator_api/error.rs

@@ -1,4 +1,5 @@
 use thiserror::Error;
+use validator_api_requests::models::RequestError;
 
 #[derive(Error, Debug)]
 pub enum ValidatorAPIError {
@@ -10,4 +11,7 @@ pub enum ValidatorAPIError {
 
     #[error("Request failed with error message - {0}")]
     GenericRequestFailure(String),
+
+    #[error("The validator API has failed to resolve our request. It returned status code {status} and additional error message: {}", error.message())]
+    ApiRequestFailure { status: u16, error: RequestError },
 }

common/client-libs/validator-client/src/validator_api/mod.rs

@@ -3,17 +3,20 @@
 
 use crate::validator_api::error::ValidatorAPIError;
 use crate::validator_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
-use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixNodeBond};
+use mixnet_contract_common::mixnode::MixNodeDetails;
+use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
+use reqwest::Response;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 use url::Url;
 use validator_api_requests::coconut::{
     BlindSignRequestBody, BlindedSignatureResponse, CosmosAddressResponse, VerificationKeyResponse,
     VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
-    CoreNodeStatusResponse, InclusionProbabilityResponse, MixNodeBondAnnotated,
-    MixnodeStatusResponse, RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
+    GatewayCoreStatusResponse, GatewayStatusReportResponse, GatewayUptimeHistoryResponse,
+    InclusionProbabilityResponse, MixNodeBondAnnotated, MixnodeCoreStatusResponse,
+    MixnodeStatusReportResponse, MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RequestError,
+    RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
 };
 
 pub mod error;
@@ -46,6 +49,19 @@ impl Client {
         &self.url
     }
 
+    async fn send_get_request<K, V>(
+        &self,
+        path: PathSegments<'_>,
+        params: Params<'_, K, V>,
+    ) -> Result<Response, ValidatorAPIError>
+    where
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        let url = create_api_url(&self.url, path, params);
+        Ok(self.reqwest_client.get(url).send().await?)
+    }
+
     async fn query_validator_api<T, K, V>(
         &self,
         path: PathSegments<'_>,
@@ -56,8 +72,36 @@ impl Client {
         K: AsRef<str>,
         V: AsRef<str>,
     {
-        let url = create_api_url(&self.url, path, params);
-        Ok(self.reqwest_client.get(url).send().await?.json().await?)
+        let res = self.send_get_request(path, params).await?;
+        if res.status().is_success() {
+            Ok(res.json().await?)
+        } else {
+            Err(ValidatorAPIError::GenericRequestFailure(res.text().await?))
+        }
+    }
+
+    // This works for endpoints returning Result<Json<T>, ErrorResponse>
+    async fn query_validator_api_fallible<T, K, V>(
+        &self,
+        path: PathSegments<'_>,
+        params: Params<'_, K, V>,
+    ) -> Result<T, ValidatorAPIError>
+    where
+        for<'a> T: Deserialize<'a>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        let res = self.send_get_request(path, params).await?;
+        let status = res.status();
+        if res.status().is_success() {
+            Ok(res.json().await?)
+        } else {
+            let request_error: RequestError = res.json().await?;
+            Err(ValidatorAPIError::ApiRequestFailure {
+                status: status.as_u16(),
+                error: request_error,
+            })
+        }
     }
 
     async fn post_validator_api<B, T, K, V>(
@@ -83,7 +127,7 @@ impl Client {
         }
     }
 
-    pub async fn get_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+    pub async fn get_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorAPIError> {
         self.query_validator_api(&[routes::API_VERSION, routes::MIXNODES], NO_PARAMS)
             .await
     }
@@ -103,7 +147,7 @@ impl Client {
             .await
     }
 
-    pub async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+    pub async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorAPIError> {
         self.query_validator_api(
             &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
             NO_PARAMS,
@@ -126,7 +170,7 @@ impl Client {
         .await
     }
 
-    pub async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeBond>, ValidatorAPIError> {
+    pub async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorAPIError> {
         self.query_validator_api(
             &[routes::API_VERSION, routes::MIXNODES, routes::REWARDED],
             NO_PARAMS,
@@ -134,6 +178,74 @@ impl Client {
         .await
     }
 
+    pub async fn get_mixnode_report(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeStatusReportResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::MIXNODE,
+                &mix_id.to_string(),
+                routes::REPORT,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_gateway_report(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<GatewayStatusReportResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::GATEWAY,
+                identity,
+                routes::REPORT,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_mixnode_history(
+        &self,
+        mix_id: MixId,
+    ) -> Result<MixnodeUptimeHistoryResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::MIXNODE,
+                &mix_id.to_string(),
+                routes::HISTORY,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    pub async fn get_gateway_history(
+        &self,
+        identity: IdentityKeyRef<'_>,
+    ) -> Result<GatewayUptimeHistoryResponse, ValidatorAPIError> {
+        self.query_validator_api(
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::GATEWAY,
+                identity,
+                routes::HISTORY,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
     pub async fn get_rewarded_mixnodes_detailed(
         &self,
     ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorAPIError> {
@@ -149,28 +261,11 @@ impl Client {
         .await
     }
 
-    pub async fn get_probs_mixnode_rewarded(
-        &self,
-        mixnode_id: &str,
-    ) -> Result<HashMap<String, f32>, ValidatorAPIError> {
-        self.query_validator_api(
-            &[
-                routes::API_VERSION,
-                routes::MIXNODES,
-                routes::REWARDED,
-                routes::INCLUSION_CHANCE,
-                mixnode_id,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
     pub async fn get_gateway_core_status_count(
         &self,
         identity: IdentityKeyRef<'_>,
         since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorAPIError> {
+    ) -> Result<GatewayCoreStatusResponse, ValidatorAPIError> {
         if let Some(since) = since {
             self.query_validator_api(
                 &[
@@ -199,16 +294,16 @@ impl Client {
 
     pub async fn get_mixnode_core_status_count(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
         since: Option<i64>,
-    ) -> Result<CoreNodeStatusResponse, ValidatorAPIError> {
+    ) -> Result<MixnodeCoreStatusResponse, ValidatorAPIError> {
         if let Some(since) = since {
             self.query_validator_api(
                 &[
                     routes::API_VERSION,
                     routes::STATUS_ROUTES,
                     routes::MIXNODE,
-                    identity,
+                    &mix_id.to_string(),
                     CORE_STATUS_COUNT,
                 ],
                 &[(SINCE_ARG, since.to_string())],
@@ -220,7 +315,8 @@ impl Client {
                     routes::API_VERSION,
                     routes::STATUS_ROUTES,
                     routes::MIXNODE,
-                    identity,
+                    &mix_id.to_string(),
+                    CORE_STATUS_COUNT,
                 ],
                 NO_PARAMS,
             )
@@ -230,14 +326,14 @@ impl Client {
 
     pub async fn get_mixnode_status(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<MixnodeStatusResponse, ValidatorAPIError> {
         self.query_validator_api(
             &[
                 routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                 routes::STATUS,
             ],
             NO_PARAMS,
@@ -247,14 +343,14 @@ impl Client {
 
     pub async fn get_mixnode_reward_estimation(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<RewardEstimationResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
             &[
                 routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                 routes::REWARD_ESTIMATION,
             ],
             NO_PARAMS,
@@ -264,14 +360,14 @@ impl Client {
 
     pub async fn get_mixnode_stake_saturation(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<StakeSaturationResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
             &[
                 routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                 routes::STAKE_SATURATION,
             ],
             NO_PARAMS,
@@ -281,14 +377,14 @@ impl Client {
 
     pub async fn get_mixnode_inclusion_probability(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<InclusionProbabilityResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
             &[
                 routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
-                identity,
+                &mix_id.to_string(),
                 routes::INCLUSION_CHANCE,
             ],
             NO_PARAMS,
@@ -298,27 +394,14 @@ impl Client {
 
     pub async fn get_mixnode_avg_uptime(
         &self,
-        identity: IdentityKeyRef<'_>,
+        mix_id: MixId,
     ) -> Result<UptimeResponse, ValidatorAPIError> {
-        self.query_validator_api(
+        self.query_validator_api_fallible(
             &[
                 routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
-                identity,
-                routes::AVG_UPTIME,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    pub async fn get_mixnode_avg_uptimes(&self) -> Result<Vec<UptimeResponse>, ValidatorAPIError> {
-        self.query_validator_api(
-            &[
-                routes::API_VERSION,
-                routes::STATUS_ROUTES,
-                routes::MIXNODES,
+                &mix_id.to_string(),
                 routes::AVG_UPTIME,
             ],
             NO_PARAMS,