Revert "Ability to update mixnode config in maintenance mode"

This reverts commit dbd0e6b4fa.
Ability to update mixnode config in maintenance mode
2022-11-15 16:17:50 +00:00 · 2022-11-14 14:24:03 +00:00 · 2022-10-27 11:05:55 +01:00 · 2022-10-24 09:51:14 +01:00 · 2022-10-24 09:51:13 +01:00
340 changed files with 4806 additions and 8011 deletions
@@ -3,21 +3,3 @@

 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
@@ -1,52 +1,36 @@
 name: Daily security audit

-on:
-  schedule:
-    - cron: '5 9 * * *'
+on: workflow_dispatch
 jobs:
-  cargo-deny:
+  security_audit:
    runs-on: ubuntu-latest
    steps:
-      - name: Checkout repository code
-        uses: actions/checkout@v2
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v1
+      - uses: actions-rs/audit-check@v1
        with:
-          toolchain: stable
-      - name: Install cargo deny
-        run: cargo install --locked cargo-deny
-      - name: Run cargo deny
-        run: |
-          find . -name Cargo.toml -exec cargo deny --manifest-path {} check \
-            advisories -A advisory-not-detected  --hide-inclusion-graph \; &> \
-            >(uniq  &> .github/workflows/support-files/notifications/deny.message )
-      - uses: actions/upload-artifact@v3
-        with:
-          name: report
-          path: .github/workflows/support-files/notifications/deny.message
+          token: ${{ secrets.GITHUB_TOKEN }}
+
  notification:
-    needs: cargo-deny
+    if: ${{ failure() }}
+    needs: security_audit
    runs-on: ubuntu-latest
    steps:
      - name: Check out repository code
        uses: actions/checkout@v2
-      - name: Download report from previous job
-        uses: actions/download-artifact@v3
-        with:
-          name: report
-          path: .github/workflows/support-files/notifications
      - name: Keybase - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
      - name: Keybase - Send Notification
        env:
-          NYM_NOTIFICATION_KIND: security
-          NYM_PROJECT_NAME: "Daily security report"
+          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_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "security"
+          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
@@ -0,0 +1,72 @@
+name: Continuous integration on dispatch
+
+on: workflow_dispatch
+
+jobs:
+  build:
+    runs-on: [ self-hosted, custom-linux ]
+    # Enable sccache via environment variable
+    env:
+      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+
+      - name: Check out repository code
+        uses: actions/checkout@v2
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Build all binaries
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace
+
+      - name: Run all tests
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --all-features
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+      - uses: actions-rs/clippy-check@v1
+        name: Clippy checks
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --all-features
+
+      - name: Run clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --workspace -- -D warnings
+
+      - name: Build all binaries with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --workspace --features=coconut
+
+      - name: Run all tests with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --workspace --features=coconut
+
+      - name: Run clippy with coconut enabled
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --features=coconut -- -D warnings
@@ -1,53 +0,0 @@
-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: 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
@@ -1,4 +1,4 @@
-name: Nightly builds on latest release
+name: Nightly builds on dispatch

 on: workflow_dispatch
 jobs:
@@ -7,40 +7,26 @@ jobs:
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
-      # creates the matrix strategy from nightly_build_release_matrix.json
-      - uses: actions/checkout@v3
+      # creates the matrix strategy from nightly_build_matrix_includes.json
+      - uses: actions/checkout@v2
      - id: set-matrix
        uses: JoshuaTheMiller/conditional-build-matrix@main
        with:
-          inputFile: '.github/workflows/nightly_build_release_matrix.json'
+          inputFile: '.github/workflows/nightly_build_matrix_on_dispatch.json'
          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
-  get_release:
-    runs-on: ubuntu-latest
-    needs: matrix_prep
-    outputs:
-      output1: ${{ steps.step2.outputs.lastest_release }}
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-
-      - name: Set environment variable to latest release branch
-        id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+' | tail -n 1)" >> $GITHUB_OUTPUT
  build:
-    needs: [get_release,matrix_prep]
+    needs: matrix_prep
    strategy:
      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
    runs-on: ${{ matrix.os }}
    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-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 squashfs-tools
        if: matrix.os == 'ubuntu-latest'

-      - name: Check out latest release branch
-        uses: actions/checkout@v3
-        with:
-          ref: ${{ needs.get_release.outputs.output1 }}
+      - name: Check out repository code
+        uses: actions/checkout@v2

      - name: Install rust toolchain
        uses: actions-rs/toolchain@v1
@@ -56,12 +42,6 @@ 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:
@@ -119,12 +99,6 @@ 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:
@@ -177,7 +151,7 @@ jobs:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
      - name: Check out repository code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
      - name: Keybase - Node Install
        if: env.WORKFLOW_CONCLUSION == 'failure'
        run: npm install
@@ -186,14 +160,14 @@ jobs:
        if: env.WORKFLOW_CONCLUSION == 'failure'
        env:
          NYM_NOTIFICATION_KIND: nightly
-          NYM_PROJECT_NAME: "Nym nightly build on latest release"
+          NYM_PROJECT_NAME: "Nym nightly build"
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
          GIT_BRANCH: "${GITHUB_REF##*/}"
          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-          KEYBASE_NYM_CHANNEL: "ci-nightly-release"
+          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:
@@ -25,9 +25,6 @@ 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 && github.event_name != 'workflow_dispatch'
        uses: actions/github-script@v3
@@ -3,7 +3,7 @@ require('dotenv').config();
 const Bot = require('keybase-bot');

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

 /**
@@ -1,24 +0,0 @@
-const Handlebars = require('handlebars');
-const fs = require('fs');
-const path = require('path');
-const { Octokit, App } = require('octokit');
-
-async function addToContextAndValidate(context) {
-  return
-}
-
-async function getMessageBody(context) {
-  try {
-    const source = fs
-    .readFileSync("deny.message").toString();
-    return source;
-} catch (error) {
-    console.error(error);
-}
-
-}
-
-module.exports = {
-  addToContextAndValidate,
-  getMessageBody,
-};
@@ -6,49 +6,27 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ### Added

- binaries: add `-c` shortform for `--config-env-file`
-
-### Changed
-
- clients: add concept of transmission lanes to better handle multiple data streams ([#1720])
-
-[#1720]: https://github.com/nymtech/nym/pull/1720
-
-
-## [v1.1.0](https://github.com/nymtech/nym/tree/v1.1.0) (2022-11-09)
-
-### 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
+- nym-cli: added CLI tool for interacting with the Nyx blockchain and Nym mixnet smart contracts ([#1577])
 - validator-client: added `query_contract_smart` and `query_contract_raw` on `NymdClient` ([#1558])
+- network-requester: added additional Blockstream Green wallet endpoint to `example.allowed.list` ([#1611](https://github.com/nymtech/nym/pull/1611))
+- common/ledger: new library for communicating with a Ledger device ([#1640])
+- native-client/socks5-client: `disable_loop_cover_traffic_stream` Debug config option to disable the separate loop cover traffic stream ([#1666])
+- native-client/socks5-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: `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])
 - 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])
+- validator-api: add `interval_operating_cost` and `profit_margin_percent` to cmpute reward estimation endpoint

 ### 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])
+- validator-api, mixnode, gateway should now prefer values in config.toml over mainnet defaults ([#1645])

 ### 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])
+- socks5 client: graceful shutdown should fix error on disconnect in nym-connect ([#1591])
 - 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])
+- gateway-client: will attempt to read now as many as 8 websocket messages at once, assuming they're already available on the socket ([#1669])

-[#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
@@ -56,18 +34,11 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#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)
@@ -576,18 +576,10 @@ dependencies = [
 "os_str_bytes",
 ]

-[[package]]
-name = "client-connections"
-version = "0.1.0"
-dependencies = [
- "futures",
-]
-
 [[package]]
 name = "client-core"
-version = "1.1.0"
+version = "1.0.1"
 dependencies = [
- "client-connections",
 "config",
 "crypto",
 "dirs",
@@ -747,7 +739,6 @@ dependencies = [
 "cosmwasm-std",
 "schemars",
 "serde",
- "serde_json",
 "thiserror",
 ]

@@ -858,9 +849,9 @@ dependencies = [

 [[package]]
 name = "cpufeatures"
-version = "0.2.5"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+checksum = "59a6001667ab124aebae2a495118e11d30984c3a653e99d86d58971708cf5e4b"
 dependencies = [
 "libc",
 ]
@@ -1590,17 +1581,14 @@ dependencies = [

 [[package]]
 name = "explorer-api"
-version = "1.1.0"
+version = "1.0.1"
 dependencies = [
 "chrono",
 "clap 3.2.8",
- "contracts-common",
- "dotenv",
 "humantime-serde",
 "isocountry",
 "itertools",
 "log",
- "logging",
 "maxminddb",
 "mixnet-contract-common",
 "network-defaults",
@@ -2739,14 +2727,6 @@ dependencies = [
 "cfg-if 1.0.0",
 ]

-[[package]]
-name = "logging"
-version = "0.1.0"
-dependencies = [
- "log",
- "pretty_env_logger",
-]
-
 [[package]]
 name = "loom"
 version = "0.5.4"
@@ -3078,7 +3058,7 @@ dependencies = [

 [[package]]
 name = "nym-cli"
-version = "1.1.0"
+version = "1.0.0"
 dependencies = [
 "anyhow",
 "base64",
@@ -3089,7 +3069,6 @@ dependencies = [
 "clap_complete_fig",
 "dotenv",
 "log",
- "logging",
 "network-defaults",
 "nym-cli-commands",
 "pretty_env_logger",
@@ -3130,10 +3109,9 @@ dependencies = [

 [[package]]
 name = "nym-client"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "clap 3.2.8",
- "client-connections",
 "client-core",
 "coconut-interface",
 "completions",
@@ -3146,7 +3124,6 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
- "logging",
 "network-defaults",
 "nymsphinx",
 "pemstore",
@@ -3156,7 +3133,6 @@ dependencies = [
 "serde_json",
 "sled",
 "task",
- "thiserror",
 "tokio",
 "tokio-tungstenite 0.14.0",
 "topology",
@@ -3169,7 +3145,7 @@ dependencies = [

 [[package]]
 name = "nym-gateway"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3189,7 +3165,6 @@ dependencies = [
 "gateway-requests",
 "humantime-serde",
 "log",
- "logging",
 "mixnet-client",
 "mixnode-common",
 "network-defaults",
@@ -3216,7 +3191,7 @@ dependencies = [

 [[package]]
 name = "nym-mixnode"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "anyhow",
 "bs58",
@@ -3232,7 +3207,6 @@ dependencies = [
 "humantime-serde",
 "lazy_static",
 "log",
- "logging",
 "mixnet-client",
 "mixnode-common",
 "nonexhaustive-delayqueue",
@@ -3258,17 +3232,15 @@ dependencies = [

 [[package]]
 name = "nym-network-requester"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "async-trait",
 "clap 3.2.8",
- "client-connections",
 "completions",
 "dirs",
 "futures",
 "ipnetwork 0.20.0",
 "log",
- "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -3294,7 +3266,6 @@ version = "1.0.2"
 dependencies = [
 "dirs",
 "log",
- "logging",
 "pretty_env_logger",
 "rocket",
 "serde",
@@ -3306,10 +3277,9 @@ dependencies = [

 [[package]]
 name = "nym-socks5-client"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "clap 3.2.8",
- "client-connections",
 "client-core",
 "coconut-interface",
 "completions",
@@ -3322,7 +3292,6 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
- "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -3335,7 +3304,6 @@ dependencies = [
 "snafu 0.6.10",
 "socks5-requests",
 "task",
- "thiserror",
 "tokio",
 "topology",
 "url",
@@ -3372,7 +3340,7 @@ dependencies = [

 [[package]]
 name = "nym-validator-api"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3382,7 +3350,6 @@ dependencies = [
 "coconut-interface",
 "config",
 "console-subscriber",
- "contracts-common",
 "cosmwasm-std",
 "credential-storage",
 "credentials",
@@ -3397,7 +3364,6 @@ dependencies = [
 "humantime-serde",
 "inclusion-probability",
 "log",
- "logging",
 "mixnet-contract-common",
 "multisig-contract-common",
 "nymcoconut",
@@ -4134,7 +4100,6 @@ name = "proxy-helpers"
 version = "0.1.0"
 dependencies = [
 "bytes",
- "client-connections",
 "futures",
 "log",
 "ordered-buffer",
@@ -6422,7 +6387,6 @@ dependencies = [
 "coconut-interface",
 "colored",
 "config",
- "contracts-common",
 "cosmrs",
 "cosmwasm-std",
 "cw3",
@@ -6511,14 +6475,12 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 name = "vesting-contract"
 version = "1.1.0"
 dependencies = [
- "contracts-common",
 "cosmwasm-std",
 "cw-storage-plus",
 "mixnet-contract-common",
 "schemars",
 "serde",
 "thiserror",
- "vergen 5.1.17",
 "vesting-contract-common",
 ]

@@ -6526,7 +6488,6 @@ dependencies = [
 name = "vesting-contract-common"
 version = "0.1.0"
 dependencies = [
- "contracts-common",
 "cosmwasm-std",
 "mixnet-contract-common",
 "schemars",
@@ -26,7 +26,6 @@ members = [
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
-    "common/client-connections",
    "common/coconut-interface",
    "common/commands",
    "common/config",
@@ -42,7 +41,6 @@ members = [
    "common/execute",
    "common/inclusion-probability",
    "common/ledger",
-    "common/logging",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -92,9 +92,6 @@ build-wallet:
 build-connect:
 	cargo build --manifest-path nym-connect/Cargo.toml --workspace

-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

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.0"
+version = "1.0.1"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"

@@ -14,13 +14,11 @@ log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 sled = { version = "0.34", optional = true }
-tap = "1.0.1"
 thiserror = "1.0.34"
 url = { version ="2.2", features = ["serde"] }

 # internal
 config = { path = "../../common/config" }
-client-connections = { path = "../../common/client-connections" }
 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"] }
@@ -30,6 +28,7 @@ nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
 topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
+tap = "1.0.1"

 tokio = { version = "1.21.2", features = ["time", "macros"]}

@@ -57,5 +56,4 @@ tempfile = "3.1.0"
 default = ["reply-surb"]
 wasm = ["gateway-client/wasm"]
 coconut = ["gateway-client/coconut", "gateway-requests/coconut"]
-reply-surb = ["sled"]
-
+reply-surb = ["sled"]
@@ -16,7 +16,6 @@ use rand::{rngs::OsRng, CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
-use tokio::sync::mpsc::error::TrySendError;

 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
@@ -172,22 +171,11 @@ impl LoopCoverTrafficStream<OsRng> {
        )
        .expect("Somehow failed to generate a loop cover message with a valid topology");

-        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");
-                    // However it's still useful to alert the user that the gateway or the link to
-                    // the gateway can't keep up. Either due to insufficient bandwidth on the
-                    // client side, or that the gateway is overloaded.
-                    log::warn!("Failed to send: gateway appears to not keep up");
-                }
-                TrySendError::Closed(_) => {
-                    log::warn!("Failed to send cover message - channel closed");
-                }
-            }
-        }
+        // 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();

        // 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
@@ -1,4 +1,3 @@
-use client_connections::TransmissionLane;
 use futures::channel::mpsc;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::anonymous_replies::ReplySurb;
@@ -12,7 +11,6 @@ pub enum InputMessage {
        recipient: Recipient,
        data: Vec<u8>,
        with_reply_surb: bool,
-        lane: TransmissionLane,
    },
    Reply {
        reply_surb: ReplySurb,
@@ -21,17 +19,11 @@ pub enum InputMessage {
 }

 impl InputMessage {
-    pub fn new_fresh(
-        recipient: Recipient,
-        data: Vec<u8>,
-        with_reply_surb: bool,
-        lane: TransmissionLane,
-    ) -> Self {
+    pub fn new_fresh(recipient: Recipient, data: Vec<u8>, with_reply_surb: bool) -> Self {
        InputMessage::Fresh {
            recipient,
            data,
            with_reply_surb,
-            lane,
        }
    }

@@ -2,15 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::spawn_future;
+use futures::channel::mpsc;
+use futures::StreamExt;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;

-pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
-pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
+pub type BatchMixMessageSender = mpsc::UnboundedSender<Vec<MixPacket>>;
+pub type BatchMixMessageReceiver = mpsc::UnboundedReceiver<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,17 +25,15 @@ pub struct MixTrafficController {
 }

 impl MixTrafficController {
-    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,
-        )
+    pub fn new(
+        mix_rx: BatchMixMessageReceiver,
+        gateway_client: GatewayClient,
+    ) -> MixTrafficController {
+        MixTrafficController {
+            gateway_client,
+            mix_rx,
+            consecutive_gateway_failure_count: 0,
+        }
    }

    async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
@@ -74,7 +72,7 @@ impl MixTrafficController {

            while !shutdown.is_shutdown() {
                tokio::select! {
-                    mix_packets = self.mix_rx.recv() => match mix_packets {
+                    mix_packets = self.mix_rx.next() => match mix_packets {
                        Some(mix_packets) => {
                            self.on_messages(mix_packets).await;
                        },
@@ -98,7 +96,7 @@ impl MixTrafficController {
        spawn_future(async move {
            debug!("Started MixTrafficController without graceful shutdown support");

-            while let Some(mix_packets) = self.mix_rx.recv().await {
+            while let Some(mix_packets) = self.mix_rx.next().await {
                self.on_messages(mix_packets).await;
            }
        })
@@ -33,7 +33,7 @@ impl AcknowledgementListener {
    }

    async fn on_ack(&mut self, ack_content: Vec<u8>) {
-        trace!("Received an ack");
+        debug!("Received an ack");
        let frag_id = match recover_identifier(&self.ack_key, &ack_content)
            .map(FragmentIdentifier::try_from_bytes)
        {
@@ -8,7 +8,6 @@ use crate::client::{
    real_messages_control::real_traffic_stream::{BatchRealMessageSender, RealMessage},
    topology_control::TopologyAccessor,
 };
-use client_connections::TransmissionLane;
 use futures::StreamExt;
 use log::*;
 use nymsphinx::anonymous_replies::ReplySurb;
@@ -105,7 +104,6 @@ where
        content: Vec<u8>,
        with_reply_surb: bool,
    ) -> Option<Vec<RealMessage>> {
-        log::trace!("handling msg size: {}", content.len());
        let topology_permit = self.topology_access.get_read_permit().await;
        let topology = match topology_permit
            .try_get_valid_topology_ref(&self.ack_recipient, Some(&recipient))
@@ -166,30 +164,26 @@ where
    }

    async fn on_input_message(&mut self, msg: InputMessage) {
-        let (real_messages, lane) = match msg {
+        let real_messages = match msg {
            InputMessage::Fresh {
                recipient,
                data,
                with_reply_surb,
-                lane,
-            } => (
+            } => {
                self.handle_fresh_message(recipient, data, with_reply_surb)
-                    .await,
-                lane,
-            ),
-            InputMessage::Reply { reply_surb, data } => (
-                self.handle_reply(reply_surb, data)
                    .await
-                    .map(|message| vec![message]),
-                TransmissionLane::Reply,
-            ),
+            }
+            InputMessage::Reply { reply_surb, data } => self
+                .handle_reply(reply_surb, data)
+                .await
+                .map(|message| vec![message]),
        };

        // there's no point in trying to send nothing
        if let Some(real_messages) = real_messages {
            // tells real message sender (with the poisson timer) to send this to the mix network
            self.real_message_sender
-                .unbounded_send((real_messages, lane))
+                .unbounded_send(real_messages)
                .unwrap();
        }
    }
@@ -1,21 +1,17 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::{
-    action_controller::{Action, ActionSender},
-    PendingAcknowledgement, RetransmissionRequestReceiver,
-};
+use super::action_controller::{Action, ActionSender};
+use super::PendingAcknowledgement;
+use super::RetransmissionRequestReceiver;
 use crate::client::{
    real_messages_control::real_traffic_stream::{BatchRealMessageSender, RealMessage},
    topology_control::TopologyAccessor,
 };
-
-use client_connections::TransmissionLane;
 use futures::StreamExt;
 use log::*;
-use nymsphinx::{
-    acknowledgements::AckKey, addressing::clients::Recipient, preparer::MessagePreparer,
-};
+use nymsphinx::preparer::MessagePreparer;
+use nymsphinx::{acknowledgements::AckKey, addressing::clients::Recipient};
 use rand::{CryptoRng, Rng};
 use std::sync::{Arc, Weak};

@@ -117,10 +113,10 @@ where

        // send to `OutQueueControl` to eventually send to the mix network
        self.real_message_sender
-            .unbounded_send((
-                vec![RealMessage::new(prepared_fragment.mix_packet, frag_id)],
-                TransmissionLane::Retransmission,
-            ))
+            .unbounded_send(vec![RealMessage::new(
+                prepared_fragment.mix_packet,
+                frag_id,
+            )])
            .unwrap();
    }

@@ -14,7 +14,6 @@ use crate::client::{
    topology_control::TopologyAccessor,
 };
 use crate::spawn_future;
-use client_connections::ClosedConnectionReceiver;
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
@@ -111,7 +110,6 @@ impl RealMessagesController<OsRng> {
        mix_sender: BatchMixMessageSender,
        topology_access: TopologyAccessor,
        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
-        closed_connection_rx: ClosedConnectionReceiver,
    ) -> Self {
        let rng = OsRng;

@@ -161,7 +159,6 @@ impl RealMessagesController<OsRng> {
            rng,
            config.self_recipient,
            topology_access,
-            closed_connection_rx,
        );

        RealMessagesController {
@@ -4,7 +4,6 @@
 use crate::client::mix_traffic::BatchMixMessageSender;
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
-use client_connections::{ClosedConnectionReceiver, ConnectionId, TransmissionLane};
 use futures::channel::mpsc;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
@@ -17,6 +16,7 @@ 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;
@@ -27,23 +27,6 @@ use tokio::time;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;

-use self::{
-    sending_delay_controller::SendingDelayController, transmission_buffer::TransmissionBuffer,
-};
-
-mod sending_delay_controller;
-mod transmission_buffer;
-
-#[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()
-}
-
 /// Configurable parameters of the `OutQueueControl`
 pub(crate) struct Config {
    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
@@ -106,10 +89,6 @@ where
    #[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_delay_controller: SendingDelayController,
-
    /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them
    /// out to the network without any further delays.
    mix_tx: BatchMixMessageSender,
@@ -127,13 +106,8 @@ where
    /// Accessor to the common instance of network topology.
    topology_access: TopologyAccessor,

-    /// Buffer containing all incoming real messages keyed by transmission lane, that we will send
-    /// out to the mixnet.
-    transmission_buffer: TransmissionBuffer,
-
-    /// Incoming channel for being notified of closed connections, so that we can close lanes
-    /// corresponding to connections. To avoid sending traffic unnecessary
-    closed_connection_rx: ClosedConnectionReceiver,
+    /// Buffer containing all real messages received. It is first exhausted before more are pulled.
+    received_buffer: VecDeque<RealMessage>,
 }

 pub(crate) struct RealMessage {
@@ -152,9 +126,8 @@ impl RealMessage {

 // messages are already prepared, etc. the real point of it is to forward it to mix_traffic
 // after sufficient delay
-pub(crate) type BatchRealMessageSender =
-    mpsc::UnboundedSender<(Vec<RealMessage>, TransmissionLane)>;
-type BatchRealMessageReceiver = mpsc::UnboundedReceiver<(Vec<RealMessage>, TransmissionLane)>;
+pub(crate) type BatchRealMessageSender = mpsc::UnboundedSender<Vec<RealMessage>>;
+type BatchRealMessageReceiver = mpsc::UnboundedReceiver<Vec<RealMessage>>;

 pub(crate) enum StreamMessage {
    Cover,
@@ -177,21 +150,18 @@ where
        rng: R,
        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
-        closed_connection_rx: ClosedConnectionReceiver,
    ) -> Self {
        OutQueueControl {
            config,
            ack_key,
            sent_notifier,
            next_delay: None,
-            sending_delay_controller: Default::default(),
            mix_tx,
            real_receiver,
            our_full_destination,
            rng,
            topology_access,
-            transmission_buffer: Default::default(),
-            closed_connection_rx,
+            received_buffer: VecDeque::with_capacity(0), // we won't be putting any data into this guy directly
        }
    }

@@ -206,7 +176,7 @@ where
    async fn on_message(&mut self, next_message: StreamMessage) {
        trace!("created new message");

-        let (next_message, fragment_id) = match next_message {
+        let next_message = match next_message {
            StreamMessage::Cover => {
                // TODO for way down the line: in very rare cases (during topology update) we might have
                // to wait a really tiny bit before actually obtaining the permit hence messing with our
@@ -225,41 +195,34 @@ where
                }
                let topology_ref = topology_ref_option.unwrap();

-                (
-                    generate_loop_cover_packet(
-                        &mut self.rng,
-                        topology_ref,
-                        &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",
-                    ),
-                    None,
+                generate_loop_cover_packet(
+                    &mut self.rng,
+                    topology_ref,
+                    &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")
            }
            StreamMessage::Real(real_message) => {
-                (real_message.mix_packet, Some(real_message.fragment_id))
+                self.sent_notify(real_message.fragment_id);
+                real_message.mix_packet
            }
        };

-        if let Err(err) = self.mix_tx.send(vec![next_message]).await {
-            log::error!("Failed to send - channel closed: {}", err);
+        // 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
+        if let Err(err) = self.mix_tx.unbounded_send(vec![next_message]) {
+            log::warn!(
+                "Failed to send {} packets (possible process shutdown?)",
+                err.into_inner().len()
+            );
        }

-        // notify ack controller about sending our message only after we actually managed to push it
-        // through the channel
-        if let Some(fragment_id) = fragment_id {
-            self.sent_notify(fragment_id);
-        }
-
-        // In addition to closing connections on receiving messages throught closed_connection_rx,
-        // also close connections when sufficiently stale.
-        self.transmission_buffer.prune_stale_connections();
-
        // 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
@@ -271,57 +234,7 @@ where
        tokio::task::yield_now().await;
    }

-    fn on_close_connection(&mut self, connection_id: ConnectionId) {
-        log::debug!("Removing lane for connection: {connection_id}");
-        self.transmission_buffer
-            .remove(&TransmissionLane::ConnectionId(connection_id));
-    }
-
-    fn current_average_message_sending_delay(&self) -> Duration {
-        self.config.average_message_sending_delay
-            * self.sending_delay_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_delay_controller.current_multiplier()
-        );
-
-        // Even just a single used slot is enough to signal backpressure
-        if used_slots > 0 {
-            log::trace!("Backpressure detected");
-            self.sending_delay_controller.record_backpressure_detected();
-        }
-
-        // If the buffer is running out, slow down the sending rate
-        if self.mix_tx.capacity() == 0
-            && self.sending_delay_controller.not_increased_delay_recently()
-        {
-            self.sending_delay_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_delay_controller.is_sending_reliable() {
-            self.sending_delay_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();
-
-        // Start by checking if we have any incoming messages about closed connections
-        // NOTE: this feels a bit iffy, the `OutQueueControl` is getting ripe for a rewrite to
-        // something simpler.
-        if let Poll::Ready(Some(id)) = Pin::new(&mut self.closed_connection_rx).poll_next(cx) {
-            self.on_close_connection(id);
-        }
-
        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() {
@@ -330,6 +243,7 @@ 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.config.average_message_sending_delay;
            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
@@ -346,35 +260,28 @@ where
                next_delay.as_mut().reset(next_poisson_delay);
            }

-            // On every iteration we get new messages from upstream. Given that these come bunched
-            // in `Vec`, this ensures that on average we will fetch messages faster than we can
-            // send, which is a condition for being able to multiplex sphinx packets from multiple
-            // data streams.
+            // 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),

-                Poll::Ready(Some((real_messages, conn_id))) => {
-                    log::trace!("handling real_messages: size: {}", real_messages.len());
-
-                    self.transmission_buffer.store(&conn_id, real_messages);
-                    let real_next = self
-                        .transmission_buffer
-                        .pop_next_message_at_random()
-                        .expect("we just added one");
-
-                    Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
+                // 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(),
+                    ))))
                }

-                Poll::Pending => {
-                    if let Some(real_next) = self.transmission_buffer.pop_next_message_at_random() {
-                        Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
-                    } else {
-                        // otherwise construct a dummy one
-                        Poll::Ready(Some(StreamMessage::Cover))
-                    }
-                }
+                // otherwise construct a dummy one
+                Poll::Pending => Poll::Ready(Some(StreamMessage::Cover)),
            }
        } else {
            // we never set an initial delay - let's do it now
@@ -396,9 +303,14 @@ where
    }

    fn poll_immediate(&mut self, cx: &mut Context<'_>) -> Poll<Option<StreamMessage>> {
-        // Start by checking if we have any incoming messages about closed connections
-        if let Poll::Ready(Some(id)) = Pin::new(&mut self.closed_connection_rx).poll_next(cx) {
-            self.on_close_connection(id);
+        // 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) {
@@ -406,26 +318,17 @@ where
            // (and whoever is using the stream should panic)
            Poll::Ready(None) => Poll::Ready(None),

-            Poll::Ready(Some((real_messages, conn_id))) => {
-                log::trace!("handling real_messages: size: {}", real_messages.len());
-
-                // First store what we got for the given connection id
-                self.transmission_buffer.store(&conn_id, real_messages);
-                let real_next = self
-                    .transmission_buffer
-                    .pop_next_message_at_random()
-                    .expect("we just added one");
-
-                Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
+            // 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(),
+                ))))
            }

-            Poll::Pending => {
-                if let Some(real_next) = self.transmission_buffer.pop_next_message_at_random() {
-                    Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
-                } else {
-                    Poll::Pending
-                }
-            }
+            // if there's nothing, then there's nothing
+            Poll::Pending => Poll::Pending,
        }
    }

@@ -440,47 +343,24 @@ where
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
-    fn log_status(&self) {
-        let packets = self.transmission_buffer.total_size();
-        let backlog = self.transmission_buffer.total_size_in_bytes() as f64 / 1024.0;
-        let lanes = self.transmission_buffer.num_lanes();
-        let mult = self.sending_delay_controller.current_multiplier();
-        let delay = self.current_average_message_sending_delay().as_millis();
-        if self.config.disable_poisson_packet_distribution {
-            log::info!(
-                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), no delay",
-                backlog
-            );
-        } else {
-            log::info!(
-                "Status: {lanes} lanes, backlog: {:.2} kiB ({packets}), avg delay: {}ms ({mult})",
-                backlog,
-                delay
-            );
-        }
-    }
-
    #[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");

-        let mut status_timer = tokio::time::interval(Duration::from_secs(1));
-
        while !shutdown.is_shutdown() {
            tokio::select! {
                biased;
                _ = shutdown.recv() => {
                    log::trace!("OutQueueControl: Received shutdown");
                }
-                _ = status_timer.tick() => {
-                    self.log_status();
-                }
-                next_message = self.next() => if let Some(next_message) = next_message {
-                    self.on_message(next_message).await;
-                } else {
-                    log::trace!("OutQueueControl: Stopping since channel closed");
-                    break;
+                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;
+                    }
                }
            }
        }
@@ -1,124 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::get_time_now;
-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;
-
-pub(crate) 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,
-}
-
-impl Default for SendingDelayController {
-    fn default() -> Self {
-        SendingDelayController::new(MIN_DELAY_MULTIPLIER, MAX_DELAY_MULTIPLIER)
-    }
-}
-
-impl SendingDelayController {
-    pub(crate) 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,
-        }
-    }
-
-    pub(crate) fn current_multiplier(&self) -> u32 {
-        self.current_multiplier
-    }
-
-    pub(crate) fn increase_delay_multiplier(&mut self) {
-        if self.current_multiplier < self.upper_bound {
-            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
-            );
-        } else {
-            log::warn!("Trying to increase delay multipler higher than allowed");
-        }
-    }
-
-    pub(crate) fn decrease_delay_multiplier(&mut self) {
-        if self.current_multiplier > self.lower_bound {
-            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
-            );
-        }
-    }
-
-    pub(crate) fn record_backpressure_detected(&mut self) {
-        self.time_when_backpressure_detected = get_time_now();
-    }
-
-    pub(crate) fn not_increased_delay_recently(&self) -> bool {
-        get_time_now()
-            > self.time_when_changed + Duration::from_secs(INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
-    }
-
-    pub(crate) 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
-    }
-}
@@ -1,207 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use client_connections::TransmissionLane;
-use rand::seq::SliceRandom;
-use std::{
-    collections::{HashMap, HashSet, VecDeque},
-    time::Duration,
-};
-
-#[cfg(not(target_arch = "wasm32"))]
-use tokio::time;
-
-#[cfg(target_arch = "wasm32")]
-use wasm_timer;
-
-use super::{get_time_now, RealMessage};
-
-// The number of lanes included in the oldest set. Used when we need to prioritize traffic.
-const OLDEST_LANE_SET_SIZE: usize = 5;
-// As a way of prune connections we also check for timeouts.
-const MSG_CONSIDERED_STALE_AFTER_SECS: u64 = 10 * 60;
-
-#[derive(Default)]
-pub(crate) struct TransmissionBuffer {
-    buffer: HashMap<TransmissionLane, LaneBufferEntry>,
-}
-
-impl TransmissionBuffer {
-    #[allow(unused)]
-    pub(crate) fn is_empty(&self) -> bool {
-        self.buffer.is_empty()
-    }
-
-    pub(crate) fn remove(&mut self, lane: &TransmissionLane) -> Option<LaneBufferEntry> {
-        self.buffer.remove(lane)
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn num_lanes(&self) -> usize {
-        self.buffer.keys().count()
-    }
-
-    #[allow(unused)]
-    pub(crate) fn connections(&self) -> HashSet<u64> {
-        self.buffer
-            .keys()
-            .filter_map(|lane| match lane {
-                TransmissionLane::ConnectionId(id) => Some(id),
-                _ => None,
-            })
-            .copied()
-            .collect()
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn total_size(&self) -> usize {
-        self.buffer.values().map(LaneBufferEntry::len).sum()
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn total_size_in_bytes(&self) -> usize {
-        self.buffer
-            .values()
-            .map(|lane_buffer_entry| {
-                lane_buffer_entry
-                    .real_messages
-                    .iter()
-                    .map(|real_message| real_message.mix_packet.sphinx_packet().len())
-                    .sum::<usize>()
-            })
-            .sum()
-    }
-
-    fn get_oldest_set(&self) -> Vec<TransmissionLane> {
-        let mut buffer: Vec<_> = self
-            .buffer
-            .iter()
-            .map(|(k, v)| (k, v.messages_transmitted))
-            .collect();
-        buffer.sort_by_key(|v| v.1);
-        buffer
-            .iter()
-            .rev()
-            .map(|(k, _)| *k)
-            .take(OLDEST_LANE_SET_SIZE)
-            .copied()
-            .collect()
-    }
-
-    pub(crate) fn store(&mut self, lane: &TransmissionLane, real_messages: Vec<RealMessage>) {
-        if let Some(lane_buffer_entry) = self.buffer.get_mut(lane) {
-            lane_buffer_entry.append(real_messages);
-        } else {
-            self.buffer
-                .insert(*lane, LaneBufferEntry::new(real_messages));
-        }
-    }
-
-    fn pick_random_lane(&self) -> Option<&TransmissionLane> {
-        let lanes: Vec<&TransmissionLane> = self.buffer.keys().collect();
-        lanes.choose(&mut rand::thread_rng()).copied()
-    }
-
-    fn pick_random_small_lane(&self) -> Option<&TransmissionLane> {
-        let lanes: Vec<&TransmissionLane> = self
-            .buffer
-            .iter()
-            .filter(|(_, v)| v.is_small())
-            .map(|(k, _)| k)
-            .collect();
-        lanes.choose(&mut rand::thread_rng()).copied()
-    }
-
-    fn pick_random_old_lane(&self) -> Option<TransmissionLane> {
-        let lanes = self.get_oldest_set();
-        lanes.choose(&mut rand::thread_rng()).copied()
-    }
-
-    fn pop_front_from_lane(&mut self, lane: &TransmissionLane) -> Option<RealMessage> {
-        let real_msgs_queued = self.buffer.get_mut(lane)?;
-        let real_next = real_msgs_queued.pop_front()?;
-        real_msgs_queued.messages_transmitted += 1;
-        if real_msgs_queued.is_empty() {
-            self.buffer.remove(lane);
-        }
-        Some(real_next)
-    }
-
-    pub(crate) fn pop_next_message_at_random(&mut self) -> Option<RealMessage> {
-        if self.buffer.is_empty() {
-            return None;
-        }
-
-        // Very basic heuristic where we prioritize according to small lanes first, the older lanes
-        // to try to finish lanes when possible, then the rest.
-        let lane = if let Some(small_lane) = self.pick_random_small_lane() {
-            *small_lane
-        } else if let Some(old_lane) = self.pick_random_old_lane() {
-            old_lane
-        } else {
-            *self.pick_random_lane()?
-        };
-
-        log::trace!("picking to send from lane: {:?}", lane);
-        self.pop_front_from_lane(&lane)
-    }
-
-    pub(crate) fn prune_stale_connections(&mut self) {
-        let stale_entries: Vec<_> = self
-            .buffer
-            .iter()
-            .filter_map(|(lane, entry)| if entry.is_stale() { Some(lane) } else { None })
-            .copied()
-            .collect();
-
-        for lane in stale_entries {
-            self.remove(&lane);
-        }
-    }
-}
-
-pub(crate) struct LaneBufferEntry {
-    pub real_messages: VecDeque<RealMessage>,
-    pub messages_transmitted: usize,
-    #[cfg(not(target_arch = "wasm32"))]
-    pub time_for_last_activity: time::Instant,
-    #[cfg(target_arch = "wasm32")]
-    pub time_for_last_activity: wasm_timer::Instant,
-}
-
-impl LaneBufferEntry {
-    fn new(real_messages: Vec<RealMessage>) -> Self {
-        LaneBufferEntry {
-            real_messages: real_messages.into(),
-            messages_transmitted: 0,
-            time_for_last_activity: get_time_now(),
-        }
-    }
-
-    fn append(&mut self, real_messages: Vec<RealMessage>) {
-        self.real_messages.append(&mut real_messages.into());
-        self.time_for_last_activity = get_time_now();
-    }
-
-    fn pop_front(&mut self) -> Option<RealMessage> {
-        self.real_messages.pop_front()
-    }
-
-    fn is_small(&self) -> bool {
-        self.real_messages.len() < 100
-    }
-
-    fn is_stale(&self) -> bool {
-        get_time_now() - self.time_for_last_activity
-            > Duration::from_secs(MSG_CONSIDERED_STALE_AFTER_SECS)
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    fn len(&self) -> usize {
-        self.real_messages.len()
-    }
-
-    fn is_empty(&self) -> bool {
-        self.real_messages.is_empty()
-    }
-}
@@ -208,7 +208,7 @@ impl ReceivedMessagesBuffer {
    }

    async fn handle_new_received(&mut self, msgs: Vec<Vec<u8>>) {
-        trace!(
+        debug!(
            "Processing {:?} new message that might get added to the buffer!",
            msgs.len()
        );
@@ -57,15 +57,24 @@ impl<'a> TopologyReadPermit<'a> {
    ) -> Option<&'a NymTopology> {
        // Note: implicit deref with Deref for TopologyReadPermit is happening here
        let topology_ref_option = self.permit.as_ref();
-        topology_ref_option.as_ref().filter(|topology_ref| {
-            !(!topology_ref.can_construct_path_through(DEFAULT_NUM_MIX_HOPS)
-                || !topology_ref.gateway_exists(ack_recipient.gateway())
-                || if let Some(packet_recipient) = packet_recipient {
-                    !topology_ref.gateway_exists(packet_recipient.gateway())
+        match topology_ref_option {
+            None => None,
+            Some(topology_ref) => {
+                // see if it's possible to route the packet to both gateways
+                if !topology_ref.can_construct_path_through(DEFAULT_NUM_MIX_HOPS)
+                    || !topology_ref.gateway_exists(ack_recipient.gateway())
+                    || if let Some(packet_recipient) = packet_recipient {
+                        !topology_ref.gateway_exists(packet_recipient.gateway())
+                    } else {
+                        false
+                    }
+                {
+                    None
                } else {
-                    false
-                })
-        })
+                    Some(topology_ref)
+                }
+            }
+        }
    }
 }

@@ -2,7 +2,6 @@
 // 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;
@@ -248,8 +247,8 @@ impl<T: NymConfig> Config<T> {
        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_use_extended_packet_size(&self) -> bool {
+        self.debug.use_extended_packet_size
    }

    pub fn get_version(&self) -> &str {
@@ -471,16 +470,8 @@ pub struct Debug {
    /// 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,
+    /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size.
+    pub use_extended_packet_size: bool,
 }

 impl Default for Debug {
@@ -497,17 +488,7 @@ impl Default for Debug {
            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,
+            use_extended_packet_size: false,
        }
    }
 }
@@ -24,6 +24,4 @@ pub enum ClientCoreError {
    ListOfValidatorApisIsEmpty,
    #[error("Could not load existing gateway configuration: {0}")]
    CouldNotLoadExistingGatewayConfiguration(std::io::Error),
-    #[error("The current network topology seem to be insufficient to route any packets through")]
-    InsufficientNetworkTopology,
 }
@@ -22,7 +22,7 @@ cfg_if::cfg_if! {
        #[clap(author = "Nymtech", version, about)]
        struct Cli {
            /// Path pointing to an env file that configures the client.
-            #[clap(short, long)]
+            #[clap(long)]
            pub(crate) config_env_file: Option<std::path::PathBuf>,

            /// Path where the sqlite credental database will be located.
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.0"
+version = "1.0.2"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -27,20 +27,17 @@ 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
-thiserror = "1.0.34"
 tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket

 ## internal
 client-core = { path = "../client-core" }
-client-connections = { path = "../../common/client-connections" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 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" }
@@ -43,7 +43,6 @@ async fn send_file_with_reply() {
        recipient,
        message: read_data,
        with_reply_surb: true,
-        connection_id: 0,
    };

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

    println!("sending content of 'dummy_file' over the mix network...");
@@ -1,13 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_connections::{ClosedConnectionReceiver, ClosedConnectionSender, TransmissionLane};
 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::{BatchMixMessageSender, MixTrafficController};
+use client_core::client::mix_traffic::{
+    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
+};
 use client_core::client::real_messages_control;
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
@@ -19,7 +20,6 @@ use client_core::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-use client_core::error::ClientCoreError;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
 use gateway_client::bandwidth::BandwidthController;
@@ -31,11 +31,11 @@ use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use nymsphinx::anonymous_replies::ReplySurb;
+use nymsphinx::params::PacketSize;
 use nymsphinx::receiver::ReconstructedMessage;
 use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

 use crate::client::config::{Config, SocketType};
-use crate::error::ClientError;
 use crate::websocket;

 pub(crate) mod config;
@@ -103,15 +103,13 @@ impl NymClient {
            topology_accessor,
        );

-        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());
+        if self.config.get_base().get_use_extended_packet_size() {
+            stream.set_custom_packet_size(PacketSize::ExtendedPacket)
        }

        stream.start_with_shutdown(shutdown);
    }

-    #[allow(clippy::too_many_arguments)]
    fn start_real_traffic_controller(
        &self,
        topology_accessor: TopologyAccessor,
@@ -119,7 +117,6 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        closed_connection_rx: ClosedConnectionReceiver,
        shutdown: ShutdownListener,
    ) {
        let mut controller_config = real_messages_control::Config::new(
@@ -135,9 +132,8 @@ impl NymClient {
            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());
+        if self.config.get_base().get_use_extended_packet_size() {
+            controller_config.set_custom_packet_size(PacketSize::ExtendedPacket)
        }

        info!("Starting real traffic stream...");
@@ -149,7 +145,6 @@ impl NymClient {
            mix_sender,
            topology_accessor,
            reply_key_storage,
-            closed_connection_rx,
        )
        .start_with_shutdown(shutdown);
    }
@@ -238,7 +233,7 @@ impl NymClient {
        &mut self,
        topology_accessor: TopologyAccessor,
        shutdown: ShutdownListener,
-    ) -> Result<(), ClientError> {
+    ) {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -253,16 +248,14 @@ impl NymClient {

        // TODO: a slightly more graceful termination here
        if !topology_refresher.is_topology_routable().await {
-            log::error!(
-                "The current network topology seem to be insufficient to route any packets through \
+            panic!(
+                "The current network topology seem to be insufficient to route any packets through\
                - check if enough nodes and a gateway are online"
            );
-            return Err(ClientCoreError::InsufficientNetworkTopology.into());
        }

        info!("Starting topology refresher...");
        topology_refresher.start_with_shutdown(shutdown);
-        Ok(())
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -270,29 +263,24 @@ 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...");
-        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
-        mix_traffic_controller.start_with_shutdown(shutdown);
-        mix_tx
+        MixTrafficController::new(mix_rx, gateway_client).start_with_shutdown(shutdown);
    }

    fn start_websocket_listener(
        &self,
        buffer_requester: ReceivedBufferRequestSender,
        msg_input: InputMessageSender,
-        closed_connection_tx: ClosedConnectionSender,
    ) {
        info!("Starting websocket listener...");

-        let websocket_handler = websocket::Handler::new(
-            msg_input,
-            closed_connection_tx,
-            buffer_requester,
-            self.as_mix_recipient(),
-        );
+        let websocket_handler =
+            websocket::Handler::new(msg_input, buffer_requester, self.as_mix_recipient());

        websocket::Listener::new(self.config.get_listening_port()).start(websocket_handler);
    }
@@ -301,8 +289,7 @@ impl NymClient {
    /// It's untested and there are absolutely no guarantees about it (but seems to have worked
    /// well enough in local tests)
    pub fn send_message(&mut self, recipient: Recipient, message: Vec<u8>, with_reply_surb: bool) {
-        let lane = TransmissionLane::General;
-        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb, lane);
+        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb);

        self.input_tx
            .as_ref()
@@ -342,8 +329,8 @@ impl NymClient {
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub async fn run_forever(&mut self) -> Result<(), ClientError> {
-        let shutdown = self.start().await?;
+    pub async fn run_forever(&mut self) {
+        let shutdown = self.start().await;
        wait_for_signal().await;

        println!(
@@ -360,16 +347,20 @@ impl NymClient {
        //shutdown.wait_for_shutdown().await;

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

-    pub async fn start(&mut self) -> Result<ShutdownNotifier, ClientError> {
+    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();
@@ -394,7 +385,7 @@ impl NymClient {
        // 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(), shutdown.subscribe())
-            .await?;
+            .await;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
@@ -406,24 +397,17 @@ impl NymClient {
            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
            .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, shutdown.subscribe());
-
-        // Channels that the websocket listener can use to signal downstream to the real traffic
-        // controller that connections are closed.
-        let (closed_connection_tx, closed_connection_rx) = mpsc::unbounded();
-
+        self.start_mix_traffic_controller(
+            sphinx_message_receiver,
+            gateway_client,
+            shutdown.subscribe(),
+        );
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
            ack_receiver,
            input_receiver,
            sphinx_message_sender.clone(),
-            closed_connection_rx,
            shutdown.subscribe(),
        );

@@ -440,11 +424,9 @@ impl NymClient {
        }

        match self.config.get_socket_type() {
-            SocketType::WebSocket => self.start_websocket_listener(
-                received_buffer_request_sender,
-                input_sender,
-                closed_connection_tx,
-            ),
+            SocketType::WebSocket => {
+                self.start_websocket_listener(received_buffer_request_sender, input_sender)
+            }
            SocketType::None => {
                // if we did not start the socket, it means we're running (supposedly) in the native mode
                // and hence we should announce 'ourselves' to the buffer
@@ -465,6 +447,6 @@ impl NymClient {
        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());

-        Ok(shutdown)
+        shutdown
    }
 }
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::{Config, SocketType};
-use crate::error::ClientError;
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use completions::{fig_generate, ArgShell};
@@ -50,7 +49,7 @@ fn long_version_static() -> &'static str {
 #[clap(author = "Nymtech", version, long_version = long_version_static(), about)]
 pub(crate) struct Cli {
    /// Path pointing to an env file that configures the client.
-    #[clap(short, long)]
+    #[clap(long)]
    pub(crate) config_env_file: Option<std::path::PathBuf>,

    #[clap(subcommand)]
@@ -84,17 +83,16 @@ pub(crate) struct OverrideConfig {
    enabled_credentials_mode: bool,
 }

-pub(crate) async fn execute(args: &Cli) -> Result<(), ClientError> {
+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::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),
    }
-    Ok(())
 }

 pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
@@ -4,7 +4,6 @@
 use crate::{
    client::{config::Config, NymClient},
    commands::{override_config, OverrideConfig},
-    error::ClientError,
 };

 use clap::Args;
@@ -74,14 +73,14 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub(crate) async fn execute(args: &Run) -> Result<(), ClientError> {
+pub(crate) async fn execute(args: &Run) {
    let id = &args.id;

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

@@ -90,8 +89,8 @@ pub(crate) async fn execute(args: &Run) -> Result<(), ClientError> {

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

-    NymClient::new(config).run_forever().await
+    NymClient::new(config).run_forever().await;
 }
@@ -1,23 +0,0 @@
-use client_core::error::ClientCoreError;
-use crypto::asymmetric::identity::Ed25519RecoveryError;
-use gateway_client::error::GatewayClientError;
-use validator_client::ValidatorClientError;
-
-#[derive(thiserror::Error, Debug)]
-pub enum ClientError {
-    #[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("client-core error: {0}")]
-    ClientCoreError(#[from] ClientCoreError),
-
-    #[error("Failed to load config for: {0}")]
-    FailedToLoadConfig(String),
-    #[error("Failed local version check, client and config mismatch")]
-    FailedLocalVersionCheck,
-}
@@ -2,5 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod client;
-pub mod error;
 pub mod websocket;
@@ -2,23 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0

 use clap::{crate_version, Parser};
-use error::ClientError;
-use logging::setup_logging;
 use network_defaults::setup_env;

 pub mod client;
 pub mod commands;
-pub mod error;
 pub mod websocket;

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

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

 fn banner() -> String {
@@ -37,3 +34,25 @@ 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();
+}
@@ -1,7 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_connections::{ClosedConnectionSender, TransmissionLane};
 use client_core::client::{
    inbound_messages::{InputMessage, InputMessageSender},
    received_buffer::{
@@ -35,7 +34,6 @@ impl Default for ReceivedResponseType {

 pub(crate) struct Handler {
    msg_input: InputMessageSender,
-    closed_connection_tx: ClosedConnectionSender,
    buffer_requester: ReceivedBufferRequestSender,
    self_full_address: Recipient,
    socket: Option<WebSocketStream<TcpStream>>,
@@ -47,7 +45,6 @@ impl Clone for Handler {
    fn clone(&self) -> Self {
        Handler {
            msg_input: self.msg_input.clone(),
-            closed_connection_tx: self.closed_connection_tx.clone(),
            buffer_requester: self.buffer_requester.clone(),
            self_full_address: self.self_full_address,
            socket: None,
@@ -67,13 +64,11 @@ impl Drop for Handler {
 impl Handler {
    pub(crate) fn new(
        msg_input: InputMessageSender,
-        closed_connection_tx: ClosedConnectionSender,
        buffer_requester: ReceivedBufferRequestSender,
        self_full_address: Recipient,
    ) -> Self {
        Handler {
            msg_input,
-            closed_connection_tx,
            buffer_requester,
            self_full_address,
            socket: None,
@@ -86,11 +81,9 @@ impl Handler {
        recipient: Recipient,
        message: Vec<u8>,
        with_reply_surb: bool,
-        connection_id: u64,
    ) -> Option<ServerResponse> {
        // the ack control is now responsible for chunking, etc.
-        let lane = TransmissionLane::ConnectionId(connection_id);
-        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb, lane);
+        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb);
        self.msg_input.unbounded_send(input_msg).unwrap();

        None
@@ -111,27 +104,18 @@ impl Handler {
        ServerResponse::SelfAddress(self.self_full_address)
    }

-    fn handle_closed_connection(&self, connection_id: u64) -> Option<ServerResponse> {
-        self.closed_connection_tx
-            .unbounded_send(connection_id)
-            .unwrap();
-        None
-    }
-
    fn handle_request(&mut self, request: ClientRequest) -> Option<ServerResponse> {
        match request {
            ClientRequest::Send {
                recipient,
                message,
                with_reply_surb,
-                connection_id,
-            } => self.handle_send(recipient, message, with_reply_surb, connection_id),
+            } => self.handle_send(recipient, message, with_reply_surb),
            ClientRequest::Reply {
                message,
                reply_surb,
            } => self.handle_reply(reply_surb, message),
            ClientRequest::SelfAddress => Some(self.handle_self_address()),
-            ClientRequest::ClosedConnection(id) => self.handle_closed_connection(id),
        }
    }

@@ -20,9 +20,6 @@ pub const REPLY_REQUEST_TAG: u8 = 0x01;
 /// Value tag representing [`SelfAddress`] variant of the [`ClientRequest`]
 pub const SELF_ADDRESS_REQUEST_TAG: u8 = 0x02;

-/// Value tag representing [`ClosedConnection`] variant of the [`ClientRequest`]
-pub const CLOSED_CONNECTION_REQUEST_TAG: u8 = 0x03;
-
 #[allow(non_snake_case)]
 #[derive(Debug)]
 pub enum ClientRequest {
@@ -31,32 +28,23 @@ pub enum ClientRequest {
        message: Vec<u8>,
        // Perhaps we could change it to a number to indicate how many reply_SURBs we want to include?
        with_reply_surb: bool,
-        connection_id: u64,
    },
    Reply {
        message: Vec<u8>,
        reply_surb: ReplySurb,
    },
    SelfAddress,
-    ClosedConnection(u64),
 }

 // we could have been parsing it directly TryFrom<WsMessage>, but we want to retain
 // information about whether it came from binary or text to send appropriate response back
 impl ClientRequest {
-    // SEND_REQUEST_TAG || with_surb || recipient || conn_id || data_len || data
-    fn serialize_send(
-        recipient: Recipient,
-        data: Vec<u8>,
-        with_reply_surb: bool,
-        connection_id: u64,
-    ) -> Vec<u8> {
+    // SEND_REQUEST_TAG || with_surb || recipient || data_len || data
+    fn serialize_send(recipient: Recipient, data: Vec<u8>, with_reply_surb: bool) -> Vec<u8> {
        let data_len_bytes = (data.len() as u64).to_be_bytes();
-        let conn_id_bytes = connection_id.to_be_bytes();
        std::iter::once(SEND_REQUEST_TAG)
            .chain(std::iter::once(with_reply_surb as u8))
            .chain(recipient.to_bytes().iter().cloned()) // will not be length prefixed because the length is constant
-            .chain(conn_id_bytes.iter().cloned())
            .chain(data_len_bytes.iter().cloned())
            .chain(data.into_iter())
            .collect()
@@ -98,15 +86,9 @@ impl ClientRequest {
            }
        };

-        let mut connection_id_bytes = [0u8; size_of::<u64>()];
-        connection_id_bytes
-            .copy_from_slice(&b[2 + Recipient::LEN..2 + Recipient::LEN + size_of::<u64>()]);
-        let connection_id = u64::from_be_bytes(connection_id_bytes);
-
-        let data_len_bytes =
-            &b[2 + Recipient::LEN + size_of::<u64>()..2 + Recipient::LEN + 2 * size_of::<u64>()];
+        let data_len_bytes = &b[2 + Recipient::LEN..2 + Recipient::LEN + size_of::<u64>()];
        let data_len = u64::from_be_bytes(data_len_bytes.try_into().unwrap());
-        let data = &b[2 + Recipient::LEN + 2 * size_of::<u64>()..];
+        let data = &b[2 + Recipient::LEN + size_of::<u64>()..];
        if data.len() as u64 != data_len {
            return Err(error::Error::new(
                ErrorKind::MalformedRequest,
@@ -122,7 +104,6 @@ impl ClientRequest {
            with_reply_surb,
            recipient,
            message: data.to_vec(),
-            connection_id,
        })
    }

@@ -221,34 +202,13 @@ impl ClientRequest {
        ClientRequest::SelfAddress
    }

-    // CLOSED_CONNECTION_REQUEST_TAG
-    fn serialize_closed_connection(connection_id: u64) -> Vec<u8> {
-        let conn_id_bytes = connection_id.to_be_bytes();
-        std::iter::once(CLOSED_CONNECTION_REQUEST_TAG)
-            .chain(conn_id_bytes.iter().cloned())
-            .collect()
-    }
-
-    // CLOSED_CONNECTION_REQUEST_TAG
-    fn deserialize_closed_connection(b: &[u8]) -> Self {
-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], CLOSED_CONNECTION_REQUEST_TAG);
-
-        let mut connection_id_bytes = [0u8; size_of::<u64>()];
-        connection_id_bytes.copy_from_slice(&b[1..=size_of::<u64>()]);
-        let connection_id = u64::from_be_bytes(connection_id_bytes);
-
-        ClientRequest::ClosedConnection(connection_id)
-    }
-
    pub fn serialize(self) -> Vec<u8> {
        match self {
            ClientRequest::Send {
                recipient,
                message,
                with_reply_surb,
-                connection_id,
-            } => Self::serialize_send(recipient, message, with_reply_surb, connection_id),
+            } => Self::serialize_send(recipient, message, with_reply_surb),

            ClientRequest::Reply {
                message,
@@ -256,8 +216,6 @@ impl ClientRequest {
            } => Self::serialize_reply(message, reply_surb),

            ClientRequest::SelfAddress => Self::serialize_self_address(),
-
-            ClientRequest::ClosedConnection(id) => Self::serialize_closed_connection(id),
        }
    }

@@ -287,7 +245,6 @@ impl ClientRequest {
            SEND_REQUEST_TAG => Self::deserialize_send(b),
            REPLY_REQUEST_TAG => Self::deserialize_reply(b),
            SELF_ADDRESS_REQUEST_TAG => Ok(Self::deserialize_self_address(b)),
-            CLOSED_CONNECTION_REQUEST_TAG => Ok(Self::deserialize_closed_connection(b)),
            n => Err(error::Error::new(
                ErrorKind::UnknownRequest,
                format!("type {}", n),
@@ -323,7 +280,6 @@ mod tests {
            recipient,
            message: b"foomp".to_vec(),
            with_reply_surb: false,
-            connection_id: 42,
        };

        let bytes = send_request_no_surb.serialize();
@@ -333,12 +289,10 @@ mod tests {
                recipient,
                message,
                with_reply_surb,
-                connection_id,
            } => {
                assert_eq!(recipient.to_string(), recipient_string);
                assert_eq!(message, b"foomp".to_vec());
-                assert!(!with_reply_surb);
-                assert_eq!(connection_id, 42)
+                assert!(!with_reply_surb)
            }
            _ => unreachable!(),
        }
@@ -347,7 +301,6 @@ mod tests {
            recipient,
            message: b"foomp".to_vec(),
            with_reply_surb: true,
-            connection_id: 213,
        };

        let bytes = send_request_surb.serialize();
@@ -357,12 +310,10 @@ mod tests {
                recipient,
                message,
                with_reply_surb,
-                connection_id,
            } => {
                assert_eq!(recipient.to_string(), recipient_string);
                assert_eq!(message, b"foomp".to_vec());
-                assert!(with_reply_surb);
-                assert_eq!(connection_id, 213)
+                assert!(with_reply_surb)
            }
            _ => unreachable!(),
        }
@@ -401,15 +352,4 @@ mod tests {
            _ => unreachable!(),
        }
    }
-
-    #[test]
-    fn close_connection_request_serialization_works() {
-        let close_connection_request = ClientRequest::ClosedConnection(42);
-        let bytes = close_connection_request.serialize();
-        let recovered = ClientRequest::deserialize(&bytes).unwrap();
-        match recovered {
-            ClientRequest::ClosedConnection(id) => assert_eq!(id, 42),
-            _ => unreachable!(),
-        }
-    }
 }
@@ -20,7 +20,6 @@ pub(super) enum ClientRequestText {
        message: String,
        recipient: String,
        with_reply_surb: bool,
-        connection_id: u64,
    },
    SelfAddress,
    #[serde(rename_all = "camelCase")]
@@ -47,7 +46,6 @@ impl TryInto<ClientRequest> for ClientRequestText {
                message,
                recipient,
                with_reply_surb,
-                connection_id,
            } => {
                let message_bytes = message.into_bytes();
                let recipient = Recipient::try_from_base58_string(recipient).map_err(|err| {
@@ -58,7 +56,6 @@ impl TryInto<ClientRequest> for ClientRequestText {
                    message: message_bytes,
                    recipient,
                    with_reply_surb,
-                    connection_id,
                })
            }
            ClientRequestText::SelfAddress => Ok(ClientRequest::SelfAddress),
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.0"
+version = "1.0.2"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -20,20 +20,17 @@ 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"
-thiserror = "1.0.34"
 tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] }
 url = "2.2"

 # internal
 client-core = { path = "../client-core" }
-client-connections = { path = "../../common/client-connections" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 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" }
@@ -4,18 +4,18 @@
 use std::sync::atomic::Ordering;

 use crate::client::config::Config;
-use crate::error::Socks5ClientError;
 use crate::socks::{
    authentication::{AuthenticationMethods, Authenticator, User},
    server::SphinxSocksServer,
 };
-use client_connections::{ClosedConnectionReceiver, ClosedConnectionSender};
 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::{BatchMixMessageSender, MixTrafficController};
+use client_core::client::mix_traffic::{
+    BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController,
+};
 use client_core::client::real_messages_control::RealMessagesController;
 use client_core::client::received_buffer::{
    ReceivedBufferRequestReceiver, ReceivedBufferRequestSender, ReceivedMessagesBufferController,
@@ -25,7 +25,6 @@ use client_core::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-use client_core::error::ClientCoreError;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
 use futures::StreamExt;
@@ -37,6 +36,7 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
+use nymsphinx::params::PacketSize;
 use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

 pub mod config;
@@ -103,15 +103,13 @@ impl NymClient {
            topology_accessor,
        );

-        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());
+        if self.config.get_base().get_use_extended_packet_size() {
+            stream.set_custom_packet_size(PacketSize::ExtendedPacket)
        }

        stream.start_with_shutdown(shutdown);
    }

-    #[allow(clippy::too_many_arguments)]
    fn start_real_traffic_controller(
        &self,
        topology_accessor: TopologyAccessor,
@@ -119,7 +117,6 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        closed_connection_rx: ClosedConnectionReceiver,
        shutdown: ShutdownListener,
    ) {
        let mut controller_config = client_core::client::real_messages_control::Config::new(
@@ -135,9 +132,8 @@ impl NymClient {
            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());
+        if self.config.get_base().get_use_extended_packet_size() {
+            controller_config.set_custom_packet_size(PacketSize::ExtendedPacket)
        }

        info!("Starting real traffic stream...");
@@ -149,7 +145,6 @@ impl NymClient {
            mix_sender,
            topology_accessor,
            reply_key_storage,
-            closed_connection_rx,
        )
        .start_with_shutdown(shutdown);
    }
@@ -238,7 +233,7 @@ impl NymClient {
        &mut self,
        topology_accessor: TopologyAccessor,
        shutdown: ShutdownListener,
-    ) -> Result<(), Socks5ClientError> {
+    ) {
        let topology_refresher_config = TopologyRefresherConfig::new(
            self.config.get_base().get_validator_api_endpoints(),
            self.config.get_base().get_topology_refresh_rate(),
@@ -253,16 +248,14 @@ impl NymClient {

        // TODO: a slightly more graceful termination here
        if !topology_refresher.is_topology_routable().await {
-            log::error!(
-                "The current network topology seem to be insufficient to route any packets through \
+            panic!(
+                "The current network topology seem to be insufficient to route any packets through\
                - check if enough nodes and a gateway are online"
            );
-            return Err(ClientCoreError::InsufficientNetworkTopology.into());
        }

        info!("Starting topology refresher...");
        topology_refresher.start_with_shutdown(shutdown);
-        Ok(())
    }

    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
@@ -270,20 +263,19 @@ 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...");
-        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
-        mix_traffic_controller.start_with_shutdown(shutdown);
-        mix_tx
+        MixTrafficController::new(mix_rx, gateway_client).start_with_shutdown(shutdown);
    }

    fn start_socks5_listener(
        &self,
        buffer_requester: ReceivedBufferRequestSender,
        msg_input: InputMessageSender,
-        closed_connection_tx: ClosedConnectionSender,
        shutdown: ShutdownListener,
    ) {
        info!("Starting socks5 listener...");
@@ -298,16 +290,12 @@ impl NymClient {
            self.as_mix_recipient(),
            shutdown,
        );
-        tokio::spawn(async move {
-            sphinx_socks
-                .serve(msg_input, buffer_requester, closed_connection_tx)
-                .await
-        });
+        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) -> Result<(), Socks5ClientError> {
-        let mut shutdown = self.start().await?;
+    pub async fn run_forever(&mut self) {
+        let mut shutdown = self.start().await;
        wait_for_signal().await;

        log::info!("Sending shutdown");
@@ -318,15 +306,11 @@ impl NymClient {
        shutdown.wait_for_shutdown().await;

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

    // Variant of `run_forever` that listends for remote control messages
-    pub async fn run_and_listen(
-        &mut self,
-        mut receiver: Socks5ControlMessageReceiver,
-    ) -> Result<(), Socks5ClientError> {
-        let mut shutdown = self.start().await?;
+    pub async fn run_and_listen(&mut self, mut receiver: Socks5ControlMessageReceiver) {
+        let mut shutdown = self.start().await;
        tokio::select! {
            message = receiver.next() => {
                log::debug!("Received message: {:?}", message);
@@ -352,16 +336,20 @@ impl NymClient {
        shutdown.wait_for_shutdown().await;

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

-    pub async fn start(&mut self) -> Result<ShutdownNotifier, Socks5ClientError> {
+    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();
@@ -386,7 +374,7 @@ impl NymClient {
        // 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(), shutdown.subscribe())
-            .await?;
+            .await;
        self.start_received_messages_buffer_controller(
            received_buffer_request_receiver,
            mixnet_messages_receiver,
@@ -398,24 +386,17 @@ impl NymClient {
            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
            .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, shutdown.subscribe());
-
-        // Channel for announcing closed (socks5) connections by the controller.
-        // This will be forwarded to `OutQueueControl`
-        let (closed_connection_tx, closed_connection_rx) = mpsc::unbounded();
-
+        self.start_mix_traffic_controller(
+            sphinx_message_receiver,
+            gateway_client,
+            shutdown.subscribe(),
+        );
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            reply_key_storage,
            ack_receiver,
            input_receiver,
            sphinx_message_sender.clone(),
-            closed_connection_rx,
            shutdown.subscribe(),
        );

@@ -434,13 +415,12 @@ impl NymClient {
        self.start_socks5_listener(
            received_buffer_request_sender,
            input_sender,
-            closed_connection_tx,
            shutdown.subscribe(),
        );

        info!("Client startup finished!");
        info!("The address of this client is: {}", self.as_mix_recipient());

-        Ok(shutdown)
+        shutdown
    }
 }
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::Config;
-use crate::error::Socks5ClientError;
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use completions::{fig_generate, ArgShell};
@@ -51,7 +50,7 @@ fn long_version_static() -> &'static str {
 #[clap(author = "Nymtech", version, long_version = long_version_static(), about)]
 pub(crate) struct Cli {
    /// Path pointing to an env file that configures the client.
-    #[clap(short, long)]
+    #[clap(long)]
    pub(crate) config_env_file: Option<std::path::PathBuf>,

    #[clap(subcommand)]
@@ -62,10 +61,8 @@ pub(crate) struct Cli {
 pub(crate) enum Commands {
    /// Initialise a Nym client. Do this first!
    Init(init::Init),
-
    /// Run the Nym client with provided configuration client optionally overriding set parameters
    Run(run::Run),
-
    /// Try to upgrade the client
    Upgrade(upgrade::Upgrade),

@@ -86,17 +83,16 @@ pub(crate) struct OverrideConfig {
    enabled_credentials_mode: bool,
 }

-pub(crate) async fn execute(args: &Cli) -> Result<(), Socks5ClientError> {
+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::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),
    }
-    Ok(())
 }

 pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Config {
@@ -4,7 +4,6 @@
 use crate::{
    client::{config::Config, NymClient},
    commands::{override_config, OverrideConfig},
-    error::Socks5ClientError,
 };

 use clap::Args;
@@ -81,14 +80,14 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

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

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

@@ -97,8 +96,8 @@ pub(crate) async fn execute(args: &Run) -> Result<(), Socks5ClientError> {

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

-    NymClient::new(config).run_forever().await
+    NymClient::new(config).run_forever().await;
 }
@@ -1,23 +0,0 @@
-use client_core::error::ClientCoreError;
-use crypto::asymmetric::identity::Ed25519RecoveryError;
-use gateway_client::error::GatewayClientError;
-use validator_client::ValidatorClientError;
-
-#[derive(thiserror::Error, Debug)]
-pub enum Socks5ClientError {
-    #[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("client-core error: {0}")]
-    ClientCoreError(#[from] ClientCoreError),
-
-    #[error("Failed to load config for: {0}")]
-    FailedToLoadConfig(String),
-    #[error("Failed local version check, client and config mismatch")]
-    FailedLocalVersionCheck,
-}
@@ -2,5 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod client;
-pub mod error;
 pub mod socks;
@@ -2,23 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0

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

 pub mod client;
 mod commands;
-pub mod error;
 pub mod socks;

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

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

 fn banner() -> String {
@@ -37,3 +34,23 @@ 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();
+}
@@ -4,8 +4,8 @@ use super::authentication::{AuthenticationMethods, Authenticator, User};
 use super::request::{SocksCommand, SocksRequest};
 use super::types::{ResponseCode, SocksProxyError};
 use super::{RESERVED, SOCKS_VERSION};
-use client_connections::TransmissionLane;
-use client_core::client::inbound_messages::{InputMessage, InputMessageSender};
+use client_core::client::inbound_messages::InputMessage;
+use client_core::client::inbound_messages::InputMessageSender;
 use futures::channel::mpsc;
 use futures::task::{Context, Poll};
 use log::*;
@@ -226,21 +226,17 @@ impl SocksClient {
        }
    }

-    fn send_connect_to_mixnet(&mut self, remote_address: RemoteAddress) {
+    async fn send_connect_to_mixnet(&mut self, remote_address: RemoteAddress) {
        let req = Request::new_connect(self.connection_id, remote_address, self.self_address);
        let msg = Message::Request(req);

-        let input_message = InputMessage::new_fresh(
-            self.service_provider,
-            msg.into_bytes(),
-            false,
-            TransmissionLane::ConnectionId(self.connection_id),
-        );
+        let input_message = InputMessage::new_fresh(self.service_provider, msg.into_bytes(), false);
        self.input_sender.unbounded_send(input_message).unwrap();
    }

    async fn run_proxy(&mut self, conn_receiver: ConnectionReceiver, remote_proxy_target: String) {
-        self.send_connect_to_mixnet(remote_proxy_target.clone());
+        self.send_connect_to_mixnet(remote_proxy_target.clone())
+            .await;

        let stream = self.stream.run_proxy();
        let local_stream_remote = stream
@@ -263,8 +259,7 @@ impl SocksClient {
        .run(move |conn_id, read_data, socket_closed| {
            let provider_request = Request::new_send(conn_id, read_data, socket_closed);
            let provider_message = Message::Request(provider_request);
-            let lane = TransmissionLane::ConnectionId(conn_id);
-            InputMessage::new_fresh(recipient, provider_message.into_bytes(), false, lane)
+            InputMessage::new_fresh(recipient, provider_message.into_bytes(), false)
        })
        .await
        .into_inner();
@@ -4,7 +4,6 @@ use super::{
    mixnet_responses::MixnetResponseListener,
    types::{ResponseCode, SocksProxyError},
 };
-use client_connections::ClosedConnectionSender;
 use client_core::client::{
    inbound_messages::InputMessageSender, received_buffer::ReceivedBufferRequestSender,
 };
@@ -52,14 +51,13 @@ impl SphinxSocksServer {
        &mut self,
        input_sender: InputMessageSender,
        buffer_requester: ReceivedBufferRequestSender,
-        closed_connection_tx: ClosedConnectionSender,
    ) -> Result<(), SocksProxyError> {
        let listener = TcpListener::bind(self.listening_address).await.unwrap();
        info!("Serving Connections...");

        // controller for managing all active connections
        let (mut active_streams_controller, controller_sender) =
-            Controller::new(closed_connection_tx, self.shutdown.clone());
+            Controller::new(self.shutdown.clone());
        tokio::spawn(async move {
            active_streams_controller.run().await;
        });
@@ -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"
@@ -29,7 +29,6 @@ url = "2.2"

 # internal
 client-core = { path = "../client-core", default-features = false, features = ["wasm"] }
-client-connections = { path = "../../common/client-connections" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
@@ -56,8 +55,6 @@ wee_alloc = { version = "0.4", optional = true }
 wasm-bindgen-test = "0.3"

 [package.metadata.wasm-pack.profile.release]
-wasm-opt = true
+wasm-opt = false
+

-[profile.release]
-lto = true
-opt-level = 'z'
@@ -1,5 +0,0 @@
-clippy:
-	cargo clippy --all-features --target wasm32-unknown-unknown -- -D warnings
-
-test:
-	wasm-pack test --node
@@ -2,11 +2,6 @@ const CopyWebpackPlugin = require('copy-webpack-plugin');
 const path = require('path');

 module.exports = {
-  performance: {
-    hints: false,
-    maxEntrypointSize: 512000,
-    maxAssetSize: 512000
-  },
  entry: {
    bootstrap: './bootstrap.js',
    worker: './worker.js',
@@ -27,7 +22,6 @@ module.exports = {
        },
      ],
    }),
-
  ],
  experiments: { syncWebAssembly: true },
 };
@@ -73,7 +73,6 @@ async function main() {
  // const preferredGateway = 'CgQrYP8etksSBf4nALNqp93SHPpgFwEUyTsjBNNLj5WM';

  const gatewayEndpoint = await get_gateway(validator, preferredGateway);
-  gatewayEndpoint.gateway_listener = "wss://gateway1.nymtech.net:443"; // this is needed if we want it to work on the web. However this gateway is a v1 gateway, we will need to change for v2 once we get there

  // only really useful if you want to adjust some settings like traffic rate
  // (if not needed you can just pass a null)
@@ -1,217 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use serde::{Deserialize, Serialize};
-use wasm_bindgen::prelude::*;
-use wasm_bindgen::JsCast;
-
-#[wasm_bindgen(typescript_custom_section)]
-const TS_DEFS: &'static str = r#"
-export interface BinaryMessage {
-    kind: number,
-    payload: Uint8Array;
-    headers: string,
-}
-
-export interface StringMessage {
-    kind: number,
-    payload: string;
-}
-"#;
-
-#[wasm_bindgen]
-extern "C" {
-    #[wasm_bindgen(typescript_type = "BinaryMessage")]
-    pub type IBinaryMessage;
-    #[wasm_bindgen(typescript_type = "StringMessage")]
-    pub type IStringMessage;
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct BinaryMessage {
-    pub kind: u8,
-    pub payload: Vec<u8>,
-    pub headers: String,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct StringMessage {
-    pub kind: u8,
-    pub payload: String,
-}
-
-/// Create a new binary message with a user-specified `kind`.
-#[wasm_bindgen]
-pub fn create_binary_message(kind: u8, payload: Vec<u8>) -> Vec<u8> {
-    create_binary_message_with_headers(kind, payload, "".to_string())
-}
-
-/// Create a new message with a UTF-8 encoded string `payload` and a user-specified `kind`.
-#[wasm_bindgen]
-pub fn create_binary_message_from_string(kind: u8, payload: String) -> Vec<u8> {
-    create_binary_message_with_headers(kind, payload.as_bytes().to_vec(), "".to_string())
-}
-
-/// Create a new binary message with a user-specified `kind`, and `headers` as a string.
-#[wasm_bindgen]
-pub fn create_binary_message_with_headers(kind: u8, payload: Vec<u8>, headers: String) -> Vec<u8> {
-    let headers = headers.as_bytes().to_vec();
-    let size = (headers.len() as u64).to_be_bytes().to_vec();
-    vec![vec![kind], size, headers, payload].concat()
-}
-
-/// Parse the `kind` and byte array `payload` from a byte array
-#[wasm_bindgen]
-pub async fn parse_binary_message(message: Vec<u8>) -> Result<IBinaryMessage, JsError> {
-    if message.len() < 2 {
-        return Err(JsError::new(
-            "Could not parse message, as less than 2 bytes long",
-        ));
-    }
-
-    let (kind, _headers, payload) = parse_binary_payload(&message);
-
-    Ok(serde_wasm_bindgen::to_value(&BinaryMessage {
-        kind,
-        payload: payload.to_vec(),
-        headers: "".to_string(),
-    })
-    .unwrap()
-    .unchecked_into::<IBinaryMessage>())
-}
-
-/// Parse the `kind` and byte array `payload` from a byte array with headers
-#[wasm_bindgen]
-pub async fn parse_binary_message_with_headers(
-    message: Vec<u8>,
-) -> Result<IBinaryMessage, JsError> {
-    if message.len() < 2 {
-        return Err(JsError::new(
-            "Could not parse message, as less than 2 bytes long",
-        ));
-    }
-
-    let (kind, headers, payload) = parse_binary_payload(&message);
-
-    Ok(serde_wasm_bindgen::to_value(&BinaryMessage {
-        kind,
-        payload: payload.to_vec(),
-        headers,
-    })
-    .unwrap()
-    .unchecked_into::<IBinaryMessage>())
-}
-
-/// Parse the `kind` and UTF-8 string `payload` from a byte array with headers
-#[wasm_bindgen]
-pub async fn parse_string_message_with_headers(
-    message: Vec<u8>,
-) -> Result<IStringMessage, JsError> {
-    if message.len() < 2 {
-        return Err(JsError::new(
-            "Could not parse message, as less than 2 bytes long",
-        ));
-    }
-
-    let (kind, _headers, payload) = parse_binary_payload(&message);
-    let payload = String::from_utf8_lossy(payload).into_owned();
-
-    Ok(
-        serde_wasm_bindgen::to_value(&StringMessage { kind, payload })
-            .unwrap()
-            .unchecked_into::<IStringMessage>(),
-    )
-}
-pub(crate) fn parse_binary_payload(message: &[u8]) -> (u8, String, &[u8]) {
-    // 1st byte is the kind
-    let kind = message[0];
-
-    // then the size as u64 big endian
-    let mut size = [0u8; 8];
-    size.clone_from_slice(&message[1..9]);
-    let size = u64::from_be_bytes(size) as usize;
-
-    // then the headers
-    let headers = String::from_utf8_lossy(&message[9..9 + size]).into_owned();
-
-    // finally the payload
-    let payload = &message[9 + size..];
-
-    (kind, headers, payload)
-}
-
-/// Parse the `kind` and UTF-8 string `payload` from a byte array
-#[wasm_bindgen]
-pub async fn parse_string_message(message: Vec<u8>) -> Result<IStringMessage, JsError> {
-    if message.len() < 2 {
-        return Err(JsError::new(
-            "Could not parse message, as less than 2 bytes long",
-        ));
-    }
-
-    let kind = message[0];
-    let payload = String::from_utf8_lossy(&message[1..]).into_owned();
-
-    Ok(
-        serde_wasm_bindgen::to_value(&StringMessage { kind, payload })
-            .unwrap()
-            .unchecked_into::<IStringMessage>(),
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{create_binary_message_with_headers, parse_binary_payload};
-    use wasm_bindgen_test::*;
-
-    #[wasm_bindgen_test]
-    fn test_binary_with_headers() {
-        let message_as_bytes = create_binary_message_with_headers(
-            42u8,
-            vec![0u8, 1u8, 2u8],
-            "test headers".to_string(),
-        );
-
-        // calculate header size
-        let headers = "test headers".as_bytes().to_vec();
-        let size = headers.len();
-
-        // the expected size
-        let expected_size = 12;
-        assert_eq!(size, expected_size);
-
-        assert_eq!(message_as_bytes[0], 42u8);
-        assert_eq!(message_as_bytes[1..9], 12u64.to_be_bytes());
-        assert_eq!(
-            message_as_bytes[9 + expected_size..9 + expected_size + 3],
-            vec![0u8, 1u8, 2u8]
-        );
-
-        let res = parse_binary_payload(&message_as_bytes);
-
-        assert_eq!(res.0, 42u8);
-        assert_eq!(res.1, "test headers".to_string());
-        assert_eq!(res.2, vec![0u8, 1u8, 2u8]);
-    }
-
-    #[wasm_bindgen_test]
-    fn test_binary_with_empty_headers() {
-        let message_as_bytes =
-            create_binary_message_with_headers(42u8, vec![0u8, 1u8, 2u8], "".to_string());
-
-        let expected_size = 0;
-
-        assert_eq!(message_as_bytes[0], 42u8);
-        assert_eq!(message_as_bytes[1..9], 0u64.to_be_bytes());
-        assert_eq!(
-            message_as_bytes[9 + expected_size..9 + expected_size + 3],
-            vec![0u8, 1u8, 2u8]
-        );
-
-        let res = parse_binary_payload(&message_as_bytes);
-
-        assert_eq!(res.0, 42u8);
-        assert_eq!(res.1, "".to_string());
-        assert_eq!(res.2, vec![0u8, 1u8, 2u8]);
-    }
-}
@@ -4,7 +4,7 @@
 // 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 client_core::config::{Debug as ConfigDebug, GatewayEndpoint};
 use std::time::Duration;
 use url::Url;
 use wasm_bindgen::prelude::*;
@@ -107,11 +107,6 @@ pub struct Debug {

 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),
@@ -131,7 +126,7 @@ impl From<Debug> for ConfigDebug {
            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,
+            use_extended_packet_size: debug.use_extended_packet_size,
        }
    }
 }
@@ -153,7 +148,7 @@ impl From<ConfigDebug> for Debug {
            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(),
+            use_extended_packet_size: debug.use_extended_packet_size,
        }
    }
 }
@@ -2,12 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0

 use self::config::Config;
-use client_connections::{ClosedConnectionReceiver, TransmissionLane};
 use client_core::client::{
    cover_traffic_stream::LoopCoverTrafficStream,
    inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender},
    key_manager::KeyManager,
-    mix_traffic::{BatchMixMessageSender, MixTrafficController},
+    mix_traffic::{BatchMixMessageReceiver, BatchMixMessageSender, MixTrafficController},
    real_messages_control::{self, RealMessagesController},
    received_buffer::{
        ReceivedBufferMessage, ReceivedBufferRequestReceiver, ReceivedBufferRequestSender,
@@ -23,10 +22,11 @@ use gateway_client::{
    MixnetMessageSender,
 };
 use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::params::PacketSize;
 use rand::rngs::OsRng;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
-use wasm_utils::console_log;
+use wasm_utils::{console_log, console_warn};

 pub mod config;

@@ -45,7 +45,6 @@ pub struct NymClient {

    // callbacks
    on_message: Option<js_sys::Function>,
-    on_binary_message: Option<js_sys::Function>,
    on_gateway_connect: Option<js_sys::Function>,
 }

@@ -57,7 +56,6 @@ impl NymClient {
            config,
            key_manager: Self::setup_key_manager(),
            on_message: None,
-            on_binary_message: None,
            on_gateway_connect: None,
            input_tx: None,
        }
@@ -75,11 +73,8 @@ impl NymClient {
        self.on_message = Some(on_message);
    }

-    pub fn set_on_binary_message(&mut self, on_binary_message: js_sys::Function) {
-        self.on_binary_message = Some(on_binary_message);
-    }
-
    pub fn set_on_gateway_connect(&mut self, on_connect: js_sys::Function) {
+        console_log!("setting on connect...");
        self.on_gateway_connect = Some(on_connect)
    }

@@ -115,8 +110,8 @@ impl NymClient {
            topology_accessor,
        );

-        if let Some(size) = &self.config.debug.use_extended_packet_size {
-            stream.set_custom_packet_size(size.clone().into());
+        if self.config.debug.use_extended_packet_size {
+            stream.set_custom_packet_size(PacketSize::ExtendedPacket)
        }

        stream.start();
@@ -128,7 +123,6 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        closed_connection_rx: ClosedConnectionReceiver,
    ) {
        let mut controller_config = real_messages_control::Config::new(
            self.key_manager.ack_key(),
@@ -141,8 +135,8 @@ impl NymClient {
            self.as_mix_recipient(),
        );

-        if let Some(size) = &self.config.debug.use_extended_packet_size {
-            controller_config.set_custom_packet_size(size.clone().into());
+        if self.config.debug.use_extended_packet_size {
+            controller_config.set_custom_packet_size(PacketSize::ExtendedPacket)
        }

        console_log!("Starting real traffic stream...");
@@ -153,7 +147,6 @@ impl NymClient {
            input_receiver,
            mix_sender,
            topology_accessor,
-            closed_connection_rx,
        )
        .start();
    }
@@ -260,11 +253,13 @@ impl NymClient {
    // 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 {
+    fn start_mix_traffic_controller(
+        &mut self,
+        mix_rx: BatchMixMessageReceiver,
+        gateway_client: GatewayClient,
+    ) {
        console_log!("Starting mix traffic controller...");
-        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
-        mix_traffic_controller.start();
-        mix_tx
+        MixTrafficController::new(mix_rx, gateway_client).start();
    }

    // TODO: this procedure is extremely overcomplicated, because it's based off native client's behaviour
@@ -274,7 +269,6 @@ impl NymClient {
        received_buffer_request_sender: ReceivedBufferRequestSender,
    ) {
        let on_message = self.on_message.take();
-        let on_binary_message = self.on_binary_message.take();

        spawn_local(async move {
            let (reconstructed_sender, mut reconstructed_receiver) = mpsc::unbounded();
@@ -289,14 +283,8 @@ impl NymClient {
            let this = JsValue::null();

            while let Some(reconstructed) = reconstructed_receiver.next().await {
-                for msg in reconstructed {
-                    if let Some(ref callback_binary) = on_binary_message {
-                        let arg1 = serde_wasm_bindgen::to_value(&msg.message).unwrap();
-                        callback_binary
-                            .call1(&this, &arg1)
-                            .expect("on binary message failed!");
-                    }
-                    if let Some(ref callback) = on_message {
+                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)")
                        }
@@ -304,6 +292,9 @@ impl NymClient {
                        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)
                }
            }
        });
@@ -316,6 +307,11 @@ impl NymClient {
        // 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,10 +326,6 @@ impl NymClient {
        let (ack_sender, ack_receiver) = mpsc::unbounded();
        let shared_topology_accessor = TopologyAccessor::new();

-        // Channel that the real traffix controller can listed to for closing connections.
-        // Currently unused in the wasm client.
-        let (_closed_connection_tx, closed_connection_rx) = mpsc::unbounded();
-
        // the components are started in very specific order. Unless you know what you are doing,
        // do not change that.
        self.start_topology_refresher(shared_topology_accessor.clone())
@@ -347,18 +339,12 @@ impl NymClient {
            .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_mix_traffic_controller(sphinx_message_receiver, gateway_client);
        self.start_real_traffic_controller(
            shared_topology_accessor.clone(),
            ack_receiver,
            input_receiver,
            sphinx_message_sender.clone(),
-            closed_connection_rx,
        );

        if !self.config.debug.disable_loop_cover_traffic_stream {
@@ -384,9 +370,8 @@ impl NymClient {
        console_log!("Sending {} bytes to {}", message.len(), recipient);

        let recipient = Recipient::try_from_base58_string(recipient).unwrap();
-        let lane = TransmissionLane::General;

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

        self.input_tx
            .as_ref()
@@ -3,8 +3,6 @@

 use wasm_bindgen::prelude::*;

-#[cfg(target_arch = "wasm32")]
-pub mod binary_message_helper;
 #[cfg(target_arch = "wasm32")]
 mod client;
 #[cfg(target_arch = "wasm32")]
@@ -1,2 +0,0 @@
-allow-unwrap-in-tests = true
-allow-expect-in-tests = true
@@ -1,9 +0,0 @@
-[package]
-name = "client-connections"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-futures = "0.3"
@@ -1,21 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use futures::channel::mpsc;
-
-pub type ConnectionId = u64;
-
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
-pub enum TransmissionLane {
-    General,
-    Reply,
-    Retransmission,
-    Control,
-    ConnectionId(ConnectionId),
-}
-
-/// Announce connections that are closed, for whoever is interested.
-/// One usecase is that the network-requester and socks5-client wants to know about this, so that
-/// they can forward this to the `OutQueueControl` (via `ClientRequest` for the network-requester)
-pub type ClosedConnectionSender = mpsc::UnboundedSender<ConnectionId>;
-pub type ClosedConnectionReceiver = mpsc::UnboundedReceiver<ConnectionId>;
@@ -62,19 +62,9 @@ impl PacketRouter {
                trace!("routing regular packet");
                received_messages.push(received_packet);
            } else if received_packet.len()
-                == PacketSize::ExtendedPacket8.plaintext_size() - ack_overhead
+                == PacketSize::ExtendedPacket.plaintext_size() - ack_overhead
            {
-                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");
+                trace!("routing extended packet");
                received_messages.push(received_packet);
            } else {
                // this can happen if other clients are not padding their messages
@@ -23,7 +23,6 @@ pub struct Config {
    maximum_reconnection_backoff: Duration,
    initial_connection_timeout: Duration,
    maximum_connection_buffer_size: usize,
-    use_legacy_version: bool,
 }

 impl Config {
@@ -32,14 +31,12 @@ 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,
        }
    }
 }
@@ -204,8 +201,7 @@ impl SendWithoutResponse for Client {
        packet_mode: PacketMode,
    ) -> io::Result<()> {
        trace!("Sending packet to {:?}", address);
-        let framed_packet =
-            FramedSphinxPacket::new(packet, packet_mode, self.config.use_legacy_version);
+        let framed_packet = FramedSphinxPacket::new(packet, packet_mode);

        if let Some(sender) = self.conn_new.get_mut(&address) {
            if let Err(err) = sender.channel.try_send(framed_packet) {
@@ -263,7 +259,6 @@ 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,
        })
    }

@@ -24,14 +24,12 @@ 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();
@@ -13,7 +13,6 @@ 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" }
@@ -15,12 +15,14 @@ use cosmrs::rpc::query::Query;
 use cosmrs::rpc::Error as TendermintRpcError;
 use cosmrs::rpc::HttpClientUrl;
 use cosmrs::tx::Msg;
+use cosmwasm_std::Uint128;
 use execute::execute;
 use network_defaults::{ChainDetails, NymNetworkDetails};
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use std::time::SystemTime;
 use vesting_contract_common::ExecuteMsg as VestingExecuteMsg;
+use vesting_contract_common::QueryMsg as VestingQueryMsg;

 pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
@@ -45,7 +47,6 @@ pub use fee::{gas_price::GasPrice, GasAdjustable, GasAdjustment};
 use mixnet_contract_common::MixId;
 pub use signing_client::Client as SigningNymdClient;
 pub use traits::{VestingQueryClient, VestingSigningClient};
-use vesting_contract_common::PledgeCap;

 pub mod coin;
 pub mod cosmwasm_client;
@@ -481,6 +482,16 @@ impl<C> NymdClient<C> {
        self.client.get_total_supply().await
    }

+    pub async fn vesting_get_locked_pledge_cap(&self) -> Result<Uint128, NymdError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let request = VestingQueryMsg::GetLockedPledgeCap {};
+        self.client
+            .query_contract_smart(self.vesting_contract_address(), &request)
+            .await
+    }
+
    pub async fn simulate<I, M>(&self, messages: I) -> Result<SimulateResponse, NymdError>
    where
        C: SigningCosmWasmClient + Sync,
@@ -726,16 +737,12 @@ impl<C> NymdClient<C> {
    #[execute("vesting")]
    fn _vesting_update_locked_pledge_cap(
        &self,
-        address: String,
-        cap: PledgeCap,
+        amount: Uint128,
        fee: Option<Fee>,
    ) -> (VestingExecuteMsg, Option<Fee>)
    where
        C: SigningCosmWasmClient + Sync,
    {
-        (
-            VestingExecuteMsg::UpdateLockedPledgeCap { address, cap },
-            fee,
-        )
+        (VestingExecuteMsg::UpdateLockedPledgeCap { amount }, fee)
    }
 }
@@ -6,10 +6,8 @@ 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, AllDelegationsResponse, DelegationTimesResponse,
@@ -18,15 +16,6 @@ use vesting_contract_common::{

 #[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,
@@ -118,15 +107,6 @@ pub trait VestingQueryClient {

 #[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,
@@ -9,7 +9,6 @@ use async_trait::async_trait;
 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 {
@@ -106,7 +105,6 @@ pub trait VestingSigningClient {
        staking_address: Option<String>,
        vesting_spec: Option<VestingSpecification>,
        amount: Coin,
-        cap: Option<PledgeCap>,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;
 }
@@ -384,7 +382,6 @@ 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)));
@@ -392,7 +389,6 @@ impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient
            owner_address: owner_address.to_string(),
            staking_address,
            vesting_spec,
-            cap,
        };
        self.client
            .execute(
@@ -1,5 +1,4 @@
 use thiserror::Error;
-use validator_api_requests::models::RequestError;

 #[derive(Error, Debug)]
 pub enum ValidatorAPIError {
@@ -11,7 +10,4 @@ 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 },
 }
@@ -5,7 +5,6 @@ use crate::validator_api::error::ValidatorAPIError;
 use crate::validator_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use mixnet_contract_common::mixnode::MixNodeDetails;
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
-use reqwest::Response;
 use serde::{Deserialize, Serialize};
 use url::Url;
 use validator_api_requests::coconut::{
@@ -13,10 +12,9 @@ use validator_api_requests::coconut::{
    VerifyCredentialBody, VerifyCredentialResponse,
 };
 use validator_api_requests::models::{
-    GatewayCoreStatusResponse, GatewayStatusReportResponse, GatewayUptimeHistoryResponse,
-    InclusionProbabilityResponse, MixNodeBondAnnotated, MixnodeCoreStatusResponse,
-    MixnodeStatusReportResponse, MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RequestError,
-    RewardEstimationResponse, StakeSaturationResponse, UptimeResponse,
+    GatewayCoreStatusResponse, InclusionProbabilityResponse, MixNodeBondAnnotated,
+    MixnodeCoreStatusResponse, MixnodeStatusResponse, RewardEstimationResponse,
+    StakeSaturationResponse, UptimeResponse,
 };

 pub mod error;
@@ -49,19 +47,6 @@ 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<'_>,
@@ -72,36 +57,8 @@ impl Client {
        K: AsRef<str>,
        V: AsRef<str>,
    {
-        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,
-            })
-        }
+        let url = create_api_url(&self.url, path, params);
+        Ok(self.reqwest_client.get(url).send().await?.json().await?)
    }

    async fn post_validator_api<B, T, K, V>(
@@ -178,74 +135,6 @@ 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> {
@@ -345,7 +234,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<RewardEstimationResponse, ValidatorAPIError> {
-        self.query_validator_api_fallible(
+        self.query_validator_api(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -362,7 +251,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<StakeSaturationResponse, ValidatorAPIError> {
-        self.query_validator_api_fallible(
+        self.query_validator_api(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -379,7 +268,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<InclusionProbabilityResponse, ValidatorAPIError> {
-        self.query_validator_api_fallible(
+        self.query_validator_api(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -396,7 +285,7 @@ impl Client {
        &self,
        mix_id: MixId,
    ) -> Result<UptimeResponse, ValidatorAPIError> {
-        self.query_validator_api_fallible(
+        self.query_validator_api(
            &[
                routes::API_VERSION,
                routes::STATUS_ROUTES,
@@ -10,6 +10,7 @@ pub const GATEWAYS: &str = "gateways";
 pub const DETAILED: &str = "detailed";
 pub const ACTIVE: &str = "active";
 pub const REWARDED: &str = "rewarded";
+
 pub const COCONUT_ROUTES: &str = "coconut";
 pub const BANDWIDTH: &str = "bandwidth";

@@ -27,8 +28,6 @@ pub const CORE_STATUS_COUNT: &str = "core-status-count";
 pub const SINCE_ARG: &str = "since";

 pub const STATUS: &str = "status";
-pub const REPORT: &str = "report";
-pub const HISTORY: &str = "history";
 pub const REWARD_ESTIMATION: &str = "reward-estimation";
 pub const AVG_UPTIME: &str = "avg_uptime";
 pub const STAKE_SATURATION: &str = "stake-saturation";
@@ -12,7 +12,6 @@ use validator_client::nymd::AccountId;
 use validator_client::nymd::VestingSigningClient;
 use validator_client::nymd::{CosmosCoin, Denom};
 use vesting_contract_common::messages::VestingSpecification;
-use vesting_contract_common::PledgeCap;

 use crate::context::SigningClient;

@@ -35,12 +34,6 @@ pub struct Args {

    #[clap(long)]
    pub staking_address: Option<String>,
-
-    #[clap(
-        long,
-        help = "Pledge cap as either absolute uNYM value or percentage, floats need to be in the 0.0 to 1.0 range and will be parsed as percentages, integers will be parsed as uNYM"
-    )]
-    pub pledge_cap: Option<PledgeCap>,
 }

 pub async fn create(args: Args, client: SigningClient, network_details: &NymNetworkDetails) {
@@ -62,7 +55,6 @@ pub async fn create(args: Args, client: SigningClient, network_details: &NymNetw
            args.staking_address,
            Some(vesting),
            coin.into(),
-            args.pledge_cap,
            None,
        )
        .await
@@ -10,7 +10,4 @@ edition = "2021"
 cosmwasm-std = "1.0.0"
 serde = { version = "1.0", features = ["derive"] }
 schemars = "0.8"
-thiserror = "1"
-
-[dev-dependencies]
-serde_json = "1.0.0"
+thiserror = "1"
@@ -11,8 +11,6 @@ use cosmwasm_std::Event;
 /// * `event`: event to search through.
 /// * `key`: key associated with the particular attribute
 pub fn must_find_attribute(event: &Event, key: &str) -> String {
-    // due to how the function is supposed to work, the unwrap is fine in this instance
-    #[allow(clippy::unwrap_used)]
    may_find_attribute(event, key).unwrap()
 }

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

-#![warn(clippy::expect_used)]
-#![warn(clippy::unwrap_used)]
-
 pub mod events;
 pub mod types;

@@ -72,7 +72,7 @@ impl Percent {

 impl Display for Percent {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let adjusted = Decimal::from_ratio(100u32, 1u32) * self.0;
+        let adjusted = Decimal::from_atomics(100u32, 0).unwrap() * self.0;
        write!(f, "{}%", adjusted)
    }
 }
@@ -152,47 +152,3 @@ pub struct ContractBuildInformation {
    /// Provides the rustc version that was used for the build, for example `1.52.0-nightly`.
    pub rustc_version: String,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn percent_serde() {
-        let valid_value = Percent::from_percentage_value(80).unwrap();
-        let serialized = serde_json::to_string(&valid_value).unwrap();
-
-        let deserialized: Percent = serde_json::from_str(&serialized).unwrap();
-        assert_eq!(valid_value, deserialized);
-
-        let invalid_values = vec!["\"42\"", "\"1.1\"", "\"1.00000001\"", "\"foomp\"", "\"1a\""];
-        for invalid_value in invalid_values {
-            assert!(serde_json::from_str::<'_, Percent>(invalid_value).is_err())
-        }
-        assert_eq!(
-            serde_json::from_str::<'_, Percent>("\"0.95\"").unwrap(),
-            Percent::from_percentage_value(95).unwrap()
-        )
-    }
-
-    #[test]
-    fn percent_to_absolute_integer() {
-        let p = serde_json::from_str::<'_, Percent>("\"0.0001\"").unwrap();
-        assert_eq!(p.round_to_integer(), 0);
-
-        let p = serde_json::from_str::<'_, Percent>("\"0.0099\"").unwrap();
-        assert_eq!(p.round_to_integer(), 0);
-
-        let p = serde_json::from_str::<'_, Percent>("\"0.0199\"").unwrap();
-        assert_eq!(p.round_to_integer(), 1);
-
-        let p = serde_json::from_str::<'_, Percent>("\"0.45123\"").unwrap();
-        assert_eq!(p.round_to_integer(), 45);
-
-        let p = serde_json::from_str::<'_, Percent>("\"0.999999999\"").unwrap();
-        assert_eq!(p.round_to_integer(), 99);
-
-        let p = serde_json::from_str::<'_, Percent>("\"1.00\"").unwrap();
-        assert_eq!(p.round_to_integer(), 100);
-    }
-}
@@ -1,9 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use cosmwasm_std::{Decimal, Uint128};
-
-pub const TOKEN_SUPPLY: Uint128 = Uint128::new(1_000_000_000_000_000);
+use cosmwasm_std::Decimal;

 // I'm still not 100% sure how to feel about existence of this file
 // This is equivalent of representing our display coin with 6 decimal places.
@@ -4,10 +4,8 @@
 // due to code generated by JsonSchema
 #![allow(clippy::field_reassign_with_default)]

-use crate::constants::TOKEN_SUPPLY;
-use crate::helpers::IntoBaseDecimal;
 use crate::{Addr, MixId};
-use cosmwasm_std::{Coin, Decimal, StdResult};
+use cosmwasm_std::{Coin, Decimal};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

@@ -62,11 +60,6 @@ impl Delegation {
        height: u64,
        proxy: Option<Addr>,
    ) -> Self {
-        assert!(
-            amount.amount <= TOKEN_SUPPLY,
-            "delegation cannot be larger than the token supply"
-        );
-
        Delegation {
            owner,
            mix_id,
@@ -94,8 +87,10 @@ impl Delegation {
        (mix_id, owner_proxy_subkey)
    }

-    pub fn dec_amount(&self) -> StdResult<Decimal> {
-        self.amount.amount.into_base_decimal()
+    pub fn dec_amount(&self) -> Decimal {
+        // the unwrap here is fine as we're guaranteed our base coin amount is going to fit in a Decimal
+        // with 0 decimal places
+        Decimal::from_atomics(self.amount.amount, 0).unwrap()
    }

    pub fn proxy_storage_key(&self) -> OwnerProxySubKey {
@@ -13,6 +13,9 @@ pub enum MixnetContractError {
        source: cosmwasm_std::StdError,
    },

+    #[error("Provided percent value is greater than 100%")]
+    InvalidPercent,
+
    #[error("Attempted to subtract decimals with overflow ({minuend}.sub({subtrahend}))")]
    OverflowDecimalSubtraction {
        minuend: Decimal,
@@ -133,4 +136,7 @@ pub enum MixnetContractError {

    #[error("Mixnode {mix_id} appears multiple times in the provided rewarded set update!")]
    DuplicateRewardedSetNode { mix_id: MixId },
+
+    #[error("Migration from the old contract is currently in progress. The transaction is temporarily disabled until that is finished")]
+    MigrationInProgress,
 }
@@ -1,7 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use cosmwasm_std::{Decimal, StdError, StdResult, Uint128};
+use cosmwasm_std::Decimal;

 pub fn compare_decimals(a: Decimal, b: Decimal, epsilon: Option<Decimal>) {
    let epsilon = epsilon.unwrap_or_else(|| Decimal::from_ratio(1u128, 100_000_000u128));
@@ -11,23 +11,3 @@ pub fn compare_decimals(a: Decimal, b: Decimal, epsilon: Option<Decimal>) {
        assert!(b - a < epsilon, "{} != {}", a, b)
    }
 }
-
-pub fn into_base_decimal(val: impl Into<Uint128>) -> StdResult<Decimal> {
-    val.into_base_decimal()
-}
-
-pub trait IntoBaseDecimal {
-    fn into_base_decimal(self) -> StdResult<Decimal>;
-}
-
-impl<T> IntoBaseDecimal for T
-where
-    T: Into<Uint128>,
-{
-    fn into_base_decimal(self) -> StdResult<Decimal> {
-        let atomics = self.into();
-        Decimal::from_atomics(atomics, 0).map_err(|_| StdError::GenericErr {
-            msg: format!("Decimal range exceeded for {atomics} with 0 decimal places."),
-        })
-    }
-}
@@ -73,9 +73,6 @@ pub struct Interval {
    // TODO add a better TS type generation
    #[cfg_attr(feature = "generate-ts", ts(type = "string"))]
    #[serde(with = "string_rfc3339_offset_date_time")]
-    // note: the `ts-rs failed to parse this attribute. It will be ignored.` warning emitted during
-    // compilation is fine (I guess). `ts-rs` can't handle `with` serde attribute, but that's okay
-    // since we explicitly specified this field should correspond to typescript's string
    current_epoch_start: OffsetDateTime,
    current_epoch_id: EpochId,
    #[cfg_attr(feature = "generate-ts", ts(type = "{ secs: number; nanos: number; }"))]
@@ -145,17 +142,14 @@ impl JsonSchema for Interval {
 impl Interval {
    /// Initialize epoch in the contract with default values.
    pub fn init_interval(epochs_in_interval: u32, epoch_length: Duration, env: &Env) -> Self {
-        // if this fails it means the value provided from the chain itself (via cosmwasm) is invalid,
-        // so we really have to panic here as anything beyond that point would be invalid anyway
-        #[allow(clippy::expect_used)]
-        let current_epoch_start =
-            OffsetDateTime::from_unix_timestamp(env.block.time.seconds() as i64)
-                .expect("The timestamp provided via env.block.time is invalid");
-
        Interval {
            id: 0,
            epochs_in_interval,
-            current_epoch_start,
+            // I really don't see a way for this to fail, unless the blockchain is lying to us
+            current_epoch_start: OffsetDateTime::from_unix_timestamp(
+                env.block.time.seconds() as i64
+            )
+            .expect("Invalid timestamp from env.block.time"),
            current_epoch_id: 0,
            epoch_length,
            total_elapsed_epochs: 0,
@@ -1,9 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-#![warn(clippy::expect_used)]
-#![warn(clippy::unwrap_used)]
-
 mod constants;
 pub mod delegation;
 pub mod error;
@@ -4,14 +4,13 @@
 // due to code generated by JsonSchema
 #![allow(clippy::field_reassign_with_default)]

-use crate::constants::{TOKEN_SUPPLY, UNIT_DELEGATION_BASE};
+use crate::constants::UNIT_DELEGATION_BASE;
 use crate::error::MixnetContractError;
-use crate::helpers::IntoBaseDecimal;
 use crate::reward_params::{NodeRewardParams, RewardingParams};
 use crate::rewarding::helpers::truncate_reward;
 use crate::rewarding::RewardDistribution;
 use crate::{Delegation, EpochId, IdentityKey, MixId, Percent, SphinxKey};
-use cosmwasm_std::{Addr, Coin, Decimal, StdResult, Uint128};
+use cosmwasm_std::{Addr, Coin, Decimal, Uint128};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
@@ -65,7 +64,7 @@ impl MixNodeDetails {
        self.rewarding_details.pending_operator_reward(pledge)
    }

-    pub fn pending_detailed_operator_reward(&self) -> StdResult<Decimal> {
+    pub fn pending_detailed_operator_reward(&self) -> Decimal {
        let pledge = self.original_pledge();
        self.rewarding_details
            .pending_detailed_operator_reward(pledge)
@@ -108,21 +107,16 @@ impl MixNodeRewarding {
        cost_params: MixNodeCostParams,
        initial_pledge: &Coin,
        current_epoch: EpochId,
-    ) -> Result<Self, MixnetContractError> {
-        assert!(
-            initial_pledge.amount <= TOKEN_SUPPLY,
-            "pledge cannot be larger than the token supply"
-        );
-
-        Ok(MixNodeRewarding {
+    ) -> Self {
+        MixNodeRewarding {
            cost_params,
-            operator: initial_pledge.amount.into_base_decimal()?,
+            operator: Decimal::from_atomics(initial_pledge.amount, 0).unwrap(),
            delegates: Decimal::zero(),
            total_unit_reward: Decimal::zero(),
            unit_delegation: UNIT_DELEGATION_BASE,
            last_rewarded_epoch: current_epoch,
            unique_delegations: 0,
-        })
+        }
    }

    /// Determines whether this node is still bonded. This is performed via a simple check,
@@ -141,30 +135,27 @@ impl MixNodeRewarding {
        }
    }

-    pub fn pending_detailed_operator_reward(&self, original_pledge: &Coin) -> StdResult<Decimal> {
-        let initial_dec = original_pledge.amount.into_base_decimal()?;
+    pub fn pending_detailed_operator_reward(&self, original_pledge: &Coin) -> Decimal {
+        let initial_dec = Decimal::from_atomics(original_pledge.amount, 0).unwrap();
        if initial_dec > self.operator {
            panic!(
                "seems slashing has occurred while it has not been implemented nor accounted for!"
            )
        }
-        Ok(self.operator - initial_dec)
+        self.operator - initial_dec
    }

    pub fn operator_pledge_with_reward(&self, denom: impl Into<String>) -> Coin {
        truncate_reward(self.operator, denom)
    }

-    pub fn pending_delegator_reward(&self, delegation: &Delegation) -> StdResult<Coin> {
-        let delegator_reward = self.determine_delegation_reward(delegation)?;
-        Ok(truncate_reward(delegator_reward, &delegation.amount.denom))
+    pub fn pending_delegator_reward(&self, delegation: &Delegation) -> Coin {
+        let delegator_reward = self.determine_delegation_reward(delegation);
+        truncate_reward(delegator_reward, &delegation.amount.denom)
    }

-    pub fn withdraw_operator_reward(
-        &mut self,
-        original_pledge: &Coin,
-    ) -> Result<Coin, MixnetContractError> {
-        let initial_dec = original_pledge.amount.into_base_decimal()?;
+    pub fn withdraw_operator_reward(&mut self, original_pledge: &Coin) -> Coin {
+        let initial_dec = Decimal::from_atomics(original_pledge.amount, 0).unwrap();
        if initial_dec > self.operator {
            panic!(
                "seems slashing has occurred while it has not been implemented nor accounted for!"
@@ -173,14 +164,14 @@ impl MixNodeRewarding {
        let diff = self.operator - initial_dec;
        self.operator = initial_dec;

-        Ok(truncate_reward(diff, &original_pledge.denom))
+        truncate_reward(diff, &original_pledge.denom)
    }

    pub fn withdraw_delegator_reward(
        &mut self,
        delegation: &mut Delegation,
    ) -> Result<Coin, MixnetContractError> {
-        let reward = self.determine_delegation_reward(delegation)?;
+        let reward = self.determine_delegation_reward(delegation);
        self.decrease_delegates_decimal(reward)?;

        delegation.cumulative_reward_ratio = self.full_reward_ratio();
@@ -310,27 +301,23 @@ impl MixNodeRewarding {
        self.distribute_rewards(reward_distribution, absolute_epoch_id)
    }

-    pub fn determine_delegation_reward(&self, delegation: &Delegation) -> StdResult<Decimal> {
+    pub fn determine_delegation_reward(&self, delegation: &Delegation) -> Decimal {
        let starting_ratio = delegation.cumulative_reward_ratio;
        let ending_ratio = self.full_reward_ratio();
        let adjust = starting_ratio + self.unit_delegation;

-        Ok((ending_ratio - starting_ratio) * delegation.dec_amount()? / adjust)
+        (ending_ratio - starting_ratio) * delegation.dec_amount() / adjust
    }

    // this updates `unique_delegations` field
-    pub fn add_base_delegation(&mut self, amount: Uint128) -> Result<(), MixnetContractError> {
-        self.increase_delegates_uint128(amount)?;
+    pub fn add_base_delegation(&mut self, amount: Uint128) {
+        self.increase_delegates_uint128(amount);
        self.unique_delegations += 1;
-        Ok(())
    }

-    pub fn increase_delegates_uint128(
-        &mut self,
-        amount: Uint128,
-    ) -> Result<(), MixnetContractError> {
-        self.delegates += amount.into_base_decimal()?;
-        Ok(())
+    pub fn increase_delegates_uint128(&mut self, amount: Uint128) {
+        // the unwrap here is fine as the value is guaranteed to fit under provided constraints
+        self.delegates += Decimal::from_atomics(amount, 0).unwrap()
    }

    // this updates `unique_delegations` field
@@ -348,7 +335,7 @@ impl MixNodeRewarding {
        &mut self,
        amount: Uint128,
    ) -> Result<(), MixnetContractError> {
-        let amount_dec = amount.into_base_decimal()?;
+        let amount_dec = Decimal::from_atomics(amount, 0).unwrap();
        self.decrease_delegates_decimal(amount_dec)
    }

@@ -381,8 +368,8 @@ impl MixNodeRewarding {
    }

    pub fn undelegate(&mut self, delegation: &Delegation) -> Result<Coin, MixnetContractError> {
-        let reward = self.determine_delegation_reward(delegation)?;
-        let full_amount = reward + delegation.dec_amount()?;
+        let reward = self.determine_delegation_reward(delegation);
+        let full_amount = reward + delegation.dec_amount();
        self.remove_delegation_decimal(full_amount)?;
        Ok(truncate_reward(full_amount, &delegation.amount.denom))
    }
@@ -2,15 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::delegation::OwnerProxySubKey;
-use crate::error::MixnetContractError;
-use crate::helpers::IntoBaseDecimal;
 use crate::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
 use crate::reward_params::{
    IntervalRewardParams, IntervalRewardingParamsUpdate, Performance, RewardingParams,
 };
 use crate::{delegation, ContractStateParams, MixId, Percent};
 use crate::{Gateway, IdentityKey, MixNode};
-use cosmwasm_std::Decimal;
+use cosmwasm_std::{Addr, Coin, Decimal};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
@@ -20,6 +18,7 @@ use std::time::Duration;
 pub struct InstantiateMsg {
    pub rewarding_validator_address: String,
    pub vesting_contract_address: String,
+    pub v1_mixnet_contract_address: String,

    pub rewarding_denom: String,
    pub epochs_in_interval: u32,
@@ -43,17 +42,14 @@ pub struct InitialRewardingParams {
 }

 impl InitialRewardingParams {
-    pub fn into_rewarding_params(
-        self,
-        epochs_in_interval: u32,
-    ) -> Result<RewardingParams, MixnetContractError> {
+    pub fn into_rewarding_params(self, epochs_in_interval: u32) -> RewardingParams {
        let epoch_reward_budget = self.initial_reward_pool
-            / epochs_in_interval.into_base_decimal()?
+            / Decimal::from_atomics(epochs_in_interval, 0).unwrap()
            * self.interval_pool_emission;
        let stake_saturation_point =
-            self.initial_staking_supply / self.rewarded_set_size.into_base_decimal()?;
+            self.initial_staking_supply / Decimal::from_atomics(self.rewarded_set_size, 0).unwrap();

-        Ok(RewardingParams {
+        RewardingParams {
            interval: IntervalRewardParams {
                reward_pool: self.initial_reward_pool,
                staking_supply: self.initial_staking_supply,
@@ -66,13 +62,87 @@ impl InitialRewardingParams {
            },
            rewarded_set_size: self.rewarded_set_size,
            active_set_size: self.active_set_size,
-        })
+        }
    }
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
+    // special, first-time migration:
+    #[serde(rename = "m1")]
+    SaveOperator {
+        #[serde(rename = "a1")]
+        host: String,
+
+        #[serde(rename = "a2")]
+        mix_port: u16,
+
+        #[serde(rename = "a3")]
+        verloc_port: u16,
+
+        #[serde(rename = "a4")]
+        http_api_port: u16,
+
+        #[serde(rename = "a5")]
+        sphinx_key: String,
+
+        #[serde(rename = "a6")]
+        identity_key: IdentityKey,
+
+        #[serde(rename = "a7")]
+        version: String,
+
+        #[serde(rename = "a8")]
+        pledge_amount: Coin,
+
+        #[serde(rename = "a9")]
+        owner: Addr,
+
+        #[serde(rename = "a10")]
+        block_height: u64,
+
+        #[serde(rename = "a11")]
+        profit_margin_percent: u8,
+
+        #[serde(rename = "a12")]
+        proxy: Option<Addr>,
+    },
+    #[serde(rename = "m2")]
+    SaveDelegation {
+        #[serde(rename = "a1")]
+        owner: Addr,
+
+        #[serde(rename = "a2")]
+        mix_id: u32,
+
+        #[serde(rename = "a3")]
+        amount: Coin,
+
+        #[serde(rename = "a4")]
+        block_height: u64,
+
+        #[serde(rename = "a5")]
+        proxy: Option<Addr>,
+    },
+    #[serde(rename = "m3")]
+    SaveGateway {
+        #[serde(rename = "a1")]
+        pledge_amount: Coin,
+
+        #[serde(rename = "a2")]
+        owner: Addr,
+
+        #[serde(rename = "a3")]
+        block_height: u64,
+
+        #[serde(rename = "a4")]
+        gateway: Gateway,
+
+        #[serde(rename = "a5")]
+        proxy: Option<Addr>,
+    },
+
    // state/sys-params-related
    UpdateRewardingValidatorAddress {
        address: String,
@@ -273,6 +343,7 @@ impl ExecuteMsg {
            ExecuteMsg::TestingResolveAllPendingEvents { .. } => {
                "resolving all pending events".into()
            }
+            _ => unimplemented!("migration-specific messages are not supported by this"),
        }
    }
 }
@@ -1,7 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::helpers::IntoBaseDecimal;
 use crate::{error::MixnetContractError, Percent};
 use cosmwasm_std::Decimal;
 use schemars::JsonSchema;
@@ -111,33 +110,24 @@ impl RewardingParams {
    pub fn dec_rewarded_set_size(&self) -> Decimal {
        // the unwrap here is fine as we're guaranteed an `u32` is going to fit in a Decimal
        // with 0 decimal places
-        #[allow(clippy::unwrap_used)]
-        self.rewarded_set_size.into_base_decimal().unwrap()
+        Decimal::from_atomics(self.rewarded_set_size, 0).unwrap()
    }

    pub fn dec_active_set_size(&self) -> Decimal {
        // the unwrap here is fine as we're guaranteed an `u32` is going to fit in a Decimal
        // with 0 decimal places
-        #[allow(clippy::unwrap_used)]
-        self.active_set_size.into_base_decimal().unwrap()
+        Decimal::from_atomics(self.active_set_size, 0).unwrap()
    }

    fn dec_standby_set_size(&self) -> Decimal {
        // the unwrap here is fine as we're guaranteed an `u32` is going to fit in a Decimal
        // with 0 decimal places
-        #[allow(clippy::unwrap_used)]
-        (self.rewarded_set_size - self.active_set_size)
-            .into_base_decimal()
-            .unwrap()
+        Decimal::from_atomics(self.rewarded_set_size - self.active_set_size, 0).unwrap()
    }

    pub fn apply_epochs_in_interval_change(&mut self, new_epochs_in_interval: u32) {
-        // the unwrap here is fine as we're guaranteed an `u32` is going to fit in a Decimal
-        // with 0 decimal places
-        #[allow(clippy::unwrap_used)]
-        let new_epochs_in_interval = new_epochs_in_interval.into_base_decimal().unwrap();
-
-        self.interval.epoch_reward_budget = self.interval.reward_pool / new_epochs_in_interval
+        self.interval.epoch_reward_budget = self.interval.reward_pool
+            / Decimal::from_atomics(new_epochs_in_interval, 0).unwrap()
            * self.interval.interval_pool_emission;
    }

@@ -179,10 +169,6 @@ impl RewardingParams {
            self.interval.staking_supply = staking_supply;
        }

-        if let Some(staking_supply_scale_factor) = updates.staking_supply_scale_factor {
-            self.interval.staking_supply_scale_factor = staking_supply_scale_factor
-        }
-
        if let Some(sybil_resistance_percent) = updates.sybil_resistance_percent {
            self.interval.sybil_resistance = sybil_resistance_percent;
        }
@@ -210,13 +196,13 @@ impl RewardingParams {

        if recompute_epoch_budget {
            self.interval.epoch_reward_budget = self.interval.reward_pool
-                / epochs_in_interval.into_base_decimal()?
+                / Decimal::from_atomics(epochs_in_interval, 0).unwrap()
                * self.interval.interval_pool_emission;
        }

        if recompute_saturation_point {
-            self.interval.stake_saturation_point =
-                self.interval.staking_supply / self.rewarded_set_size.into_base_decimal()?
+            self.interval.stake_saturation_point = self.interval.staking_supply
+                / Decimal::from_atomics(self.rewarded_set_size, 0).unwrap();
        }

        Ok(())
@@ -254,9 +240,6 @@ pub struct IntervalRewardingParamsUpdate {
    #[cfg_attr(feature = "generate-ts", ts(type = "string | null"))]
    pub staking_supply: Option<Decimal>,

-    #[cfg_attr(feature = "generate-ts", ts(type = "string | null"))]
-    pub staking_supply_scale_factor: Option<Percent>,
-
    #[cfg_attr(feature = "generate-ts", ts(type = "string | null"))]
    pub sybil_resistance_percent: Option<Percent>,

@@ -274,7 +257,6 @@ impl IntervalRewardingParamsUpdate {
        // essentially at least a single field has to be a `Some`
        self.reward_pool.is_some()
            || self.staking_supply.is_some()
-            || self.staking_supply_scale_factor.is_some()
            || self.sybil_resistance_percent.is_some()
            || self.active_set_work_factor.is_some()
            || self.interval_pool_emission.is_some()
@@ -1,7 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use contracts_common::truncate_decimal;
 use cosmwasm_std::{Coin, Decimal, Uint128};

 /// Truncates all decimal points so that the reward would fit in a `Coin` and so that we would
@@ -18,3 +17,7 @@ pub fn truncate_reward(reward: Decimal, denom: impl Into<String>) -> Coin {
 pub fn truncate_reward_amount(reward: Decimal) -> Uint128 {
    truncate_decimal(reward)
 }
+
+pub fn truncate_decimal(amount: Decimal) -> Uint128 {
+    amount * Uint128::new(1)
+}
@@ -29,7 +29,7 @@ pub struct RewardEstimate {
    pub operating_cost: Decimal,
 }

-#[derive(Clone, Copy, Debug, Default, Deserialize, Serialize, JsonSchema, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Deserialize, Serialize, JsonSchema, PartialEq, Eq)]
 pub struct RewardDistribution {
    pub operator: Decimal,
    pub delegates: Decimal,
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::MixnetContractError;
-use crate::helpers::IntoBaseDecimal;
 use crate::reward_params::NodeRewardParams;
 use crate::rewarding::simulator::simulated_node::SimulatedNode;
 use crate::rewarding::RewardDistribution;
@@ -34,7 +33,7 @@ impl Simulator {
        }
    }

-    fn advance_epoch(&mut self) -> Result<(), MixnetContractError> {
+    fn advance_epoch(&mut self) {
        let updated = self.interval.advance_epoch();

        // we rolled over an interval
@@ -48,13 +47,10 @@ impl Simulator {
                    .staking_supply_scale_factor
                    * self.pending_reward_pool_emission;
            let epoch_reward_budget = reward_pool
-                / self.interval.epochs_in_interval().into_base_decimal()?
+                / Decimal::from_atomics(self.interval.epochs_in_interval(), 0).unwrap()
                * old.interval_pool_emission.value();
            let stake_saturation_point = staking_supply
-                / self
-                    .system_rewarding_params
-                    .rewarded_set_size
-                    .into_base_decimal()?;
+                / Decimal::from_atomics(self.system_rewarding_params.rewarded_set_size, 0).unwrap();

            let updated_params = RewardingParams {
                interval: IntervalRewardParams {
@@ -75,15 +71,9 @@ impl Simulator {
            self.pending_reward_pool_emission = Decimal::zero();
        }
        self.interval = updated;
-
-        Ok(())
    }

-    pub fn bond(
-        &mut self,
-        pledge: Coin,
-        cost_params: MixNodeCostParams,
-    ) -> Result<MixId, MixnetContractError> {
+    pub fn bond(&mut self, pledge: Coin, cost_params: MixNodeCostParams) -> MixId {
        let mix_id = self.next_mix_id;

        self.nodes.insert(
@@ -93,24 +83,16 @@ impl Simulator {
                cost_params,
                &pledge,
                self.interval.current_epoch_absolute_id(),
-            )?,
+            ),
        );

        self.next_mix_id += 1;

-        Ok(mix_id)
+        mix_id
    }

-    pub fn delegate<S: Into<String>>(
-        &mut self,
-        delegator: S,
-        delegation: Coin,
-        mix_id: MixId,
-    ) -> Result<(), MixnetContractError> {
-        let node = self
-            .nodes
-            .get_mut(&mix_id)
-            .ok_or(MixnetContractError::MixNodeBondNotFound { mix_id })?;
+    pub fn delegate<S: Into<String>>(&mut self, delegator: S, delegation: Coin, mix_id: MixId) {
+        let node = self.nodes.get_mut(&mix_id).expect("node doesn't exist");
        node.delegate(delegator, delegation)
    }

@@ -121,35 +103,23 @@ impl Simulator {
        delegator: S,
        mix_id: MixId,
    ) -> Result<(Coin, Coin), MixnetContractError> {
-        let node = self
-            .nodes
-            .get_mut(&mix_id)
-            .ok_or(MixnetContractError::MixNodeBondNotFound { mix_id })?;
+        let node = self.nodes.get_mut(&mix_id).expect("node not found");
        node.undelegate(delegator)
    }

-    pub fn simulate_epoch_single_node(
-        &mut self,
-        params: NodeRewardParams,
-    ) -> Result<RewardDistribution, MixnetContractError> {
+    pub fn simulate_epoch_single_node(&mut self, params: NodeRewardParams) -> RewardDistribution {
        assert_eq!(self.nodes.len(), 1);

-        if let Some(&id) = self.nodes.keys().next() {
-            let mut params_map = BTreeMap::new();
-            params_map.insert(id, params);
-            Ok(self
-                .simulate_epoch(&params_map)?
-                .remove(&id)
-                .unwrap_or_default())
-        } else {
-            Ok(RewardDistribution::default())
-        }
+        let id = *self.nodes.keys().next().unwrap();
+        let mut params_map = BTreeMap::new();
+        params_map.insert(id, params);
+        self.simulate_epoch(&params_map).remove(&id).unwrap()
    }

    pub fn simulate_epoch(
        &mut self,
        node_params: &BTreeMap<MixId, NodeRewardParams>,
-    ) -> Result<BTreeMap<MixId, RewardDistribution>, MixnetContractError> {
+    ) -> BTreeMap<MixId, RewardDistribution> {
        let mut params_keys = node_params.keys().copied().collect::<Vec<_>>();
        params_keys.sort_unstable();
        let mut node_keys = self.nodes.keys().copied().collect::<Vec<_>>();
@@ -177,41 +147,34 @@ impl Simulator {
            dist.insert(*mix_id, reward_distribution);
        }

-        self.advance_epoch()?;
-        Ok(dist)
+        self.advance_epoch();
+        dist
    }

-    pub fn determine_delegation_reward(
-        &self,
-        delegation: &Delegation,
-    ) -> Result<Decimal, MixnetContractError> {
-        Ok(self.nodes[&delegation.mix_id]
+    pub fn determine_delegation_reward(&self, delegation: &Delegation) -> Decimal {
+        self.nodes[&delegation.mix_id]
            .rewarding_details
-            .determine_delegation_reward(delegation)?)
+            .determine_delegation_reward(delegation)
    }

-    pub fn determine_total_delegation_reward(&self) -> Result<Decimal, MixnetContractError> {
+    pub fn determine_total_delegation_reward(&self) -> Decimal {
        let mut total = Decimal::zero();

        for node in self.nodes.values() {
            for delegation in node.delegations.values() {
                total += node
                    .rewarding_details
-                    .determine_delegation_reward(delegation)?
+                    .determine_delegation_reward(delegation)
            }
        }
-        Ok(total)
+        total
    }

    // assume node state doesn't change in the interval (kinda unrealistic)
-    pub fn simulate_full_interval(
-        &mut self,
-        node_params: &BTreeMap<MixId, NodeRewardParams>,
-    ) -> Result<(), MixnetContractError> {
+    pub fn simulate_full_interval(&mut self, node_params: &BTreeMap<MixId, NodeRewardParams>) {
        for _ in 0..self.interval.epochs_in_interval() {
-            self.simulate_epoch(node_params)?;
+            self.simulate_epoch(node_params);
        }
-        Ok(())
    }
 }

@@ -234,10 +197,6 @@ mod tests {
        use cosmwasm_std::testing::mock_env;
        use std::time::Duration;

-        // explicitly marking this as part of #[allow(clippy::unwrap_used)] until
-        // https://github.com/rust-lang/rust-clippy/pull/9686
-        // is merged into a release
-        #[allow(clippy::unwrap_used)]
        fn base_simulator(initial_pledge: u128) -> Simulator {
            let profit_margin = Percent::from_percentage_value(10).unwrap();
            let interval_operating_cost = Coin::new(40_000_000, "unym");
@@ -279,32 +238,20 @@ mod tests {
                profit_margin_percent: profit_margin,
                interval_operating_cost,
            };
-            simulator.bond(initial_pledge, cost_params).unwrap();
+            simulator.bond(initial_pledge, cost_params);
            simulator
        }

        // essentially our delegations + estimated rewards HAVE TO equal to what we actually determined
-        //
-        // explicitly marking this as part of #[allow(clippy::unwrap_used)] until
-        // https://github.com/rust-lang/rust-clippy/pull/9686
-        // is merged into a release
-        #[allow(clippy::unwrap_used)]
        fn check_rewarding_invariant(simulator: &Simulator) {
            for node in simulator.nodes.values() {
-                let delegation_sum: Decimal = node
-                    .delegations
-                    .values()
-                    .map(|d| d.dec_amount().unwrap())
-                    .sum();
+                let delegation_sum: Decimal =
+                    node.delegations.values().map(|d| d.dec_amount()).sum();

                let reward_sum: Decimal = node
                    .delegations
                    .values()
-                    .map(|d| {
-                        node.rewarding_details
-                            .determine_delegation_reward(d)
-                            .unwrap()
-                    })
+                    .map(|d| node.rewarding_details.determine_delegation_reward(d))
                    .sum();

                // let reward_sum = simulator.determine_total_delegation_reward();
@@ -322,7 +269,7 @@ mod tests {

            let epoch_params =
                NodeRewardParams::new(Percent::from_percentage_value(100).unwrap(), true);
-            let rewards = simulator.simulate_epoch_single_node(epoch_params).unwrap();
+            let rewards = simulator.simulate_epoch_single_node(epoch_params);

            assert_eq!(rewards.delegates, Decimal::zero());
            compare_decimals(
@@ -335,13 +282,11 @@ mod tests {
        #[test]
        fn single_delegation_at_genesis() {
            let mut simulator = base_simulator(10000_000000);
-            simulator
-                .delegate("alice", Coin::new(18000_000000, "unym"), 0)
-                .unwrap();
+            simulator.delegate("alice", Coin::new(18000_000000, "unym"), 0);

            let node_params =
                NodeRewardParams::new(Percent::from_percentage_value(100).unwrap(), true);
-            let rewards = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards = simulator.simulate_epoch_single_node(node_params);

            compare_decimals(
                rewards.delegates,
@@ -352,7 +297,7 @@ mod tests {

            compare_decimals(
                rewards.delegates,
-                simulator.determine_total_delegation_reward().unwrap(),
+                simulator.determine_total_delegation_reward(),
                None,
            );
            let node = &simulator.nodes[&0];
@@ -372,22 +317,20 @@ mod tests {
            let node_params =
                NodeRewardParams::new(Percent::from_percentage_value(100).unwrap(), true);

-            let rewards1 = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards1 = simulator.simulate_epoch_single_node(node_params);
            let expected_operator1 = "1128452.5416104363".parse().unwrap();
            assert_eq!(rewards1.delegates, Decimal::zero());
            compare_decimals(rewards1.operator, expected_operator1, None);

-            simulator
-                .delegate("alice", Coin::new(18000_000000, "unym"), 0)
-                .unwrap();
+            simulator.delegate("alice", Coin::new(18000_000000, "unym"), 0);

-            let rewards2 = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards2 = simulator.simulate_epoch_single_node(node_params);
            let expected_operator2 = "1363843.413584609".parse().unwrap();
            let expected_delegator_reward1 = "1795952.25874404".parse().unwrap();
            compare_decimals(rewards2.delegates, expected_delegator_reward1, None);
            compare_decimals(rewards2.operator, expected_operator2, None);

-            let rewards3 = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards3 = simulator.simulate_epoch_single_node(node_params);
            let expected_operator3 = "1364017.7824440491".parse().unwrap();
            let expected_delegator_reward2 = "1796135.9269468693".parse().unwrap();
            compare_decimals(rewards3.delegates, expected_delegator_reward2, None);
@@ -421,15 +364,11 @@ mod tests {

            // add 2 delegations at genesis (because it makes things easier and as shown with previous tests
            // delegating at different times still work)
-            simulator
-                .delegate("alice", Coin::new(18000_000000, "unym"), 0)
-                .unwrap();
-            simulator
-                .delegate("bob", Coin::new(4000_000000, "unym"), 0)
-                .unwrap();
+            simulator.delegate("alice", Coin::new(18000_000000, "unym"), 0);
+            simulator.delegate("bob", Coin::new(4000_000000, "unym"), 0);

            // "normal", sanity check rewarding
-            let rewards1 = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards1 = simulator.simulate_epoch_single_node(node_params);
            let expected_operator1 = "1411087.1007647323".parse().unwrap();
            let expected_delegator_reward1 = "2199961.032388664".parse().unwrap();
            compare_decimals(rewards1.delegates, expected_delegator_reward1, None);
@@ -439,15 +378,14 @@ mod tests {
            let node = simulator.nodes.get_mut(&0).unwrap();
            let reward = node
                .rewarding_details
-                .withdraw_operator_reward(&original_pledge)
-                .unwrap();
+                .withdraw_operator_reward(&original_pledge);
            assert_eq!(reward.amount, truncate_reward_amount(expected_operator1));
            assert_eq!(
                node.rewarding_details.operator,
                Decimal::from_atomics(original_pledge.amount, 0).unwrap()
            );

-            let rewards2 = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards2 = simulator.simulate_epoch_single_node(node_params);
            let expected_operator2 = "1411113.0004067947".parse().unwrap();
            let expected_delegator_reward2 = "2200183.3879084454".parse().unwrap();
            compare_decimals(rewards2.delegates, expected_delegator_reward2, None);
@@ -464,15 +402,11 @@ mod tests {

            // add 2 delegations at genesis (because it makes things easier and as shown with previous tests
            // delegating at different times still work)
-            simulator
-                .delegate("alice", Coin::new(18000_000000, "unym"), 0)
-                .unwrap();
-            simulator
-                .delegate("bob", Coin::new(4000_000000, "unym"), 0)
-                .unwrap();
+            simulator.delegate("alice", Coin::new(18000_000000, "unym"), 0);
+            simulator.delegate("bob", Coin::new(4000_000000, "unym"), 0);

            // "normal", sanity check rewarding
-            let rewards1 = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards1 = simulator.simulate_epoch_single_node(node_params);
            let expected_operator1 = "1411087.1007647323".parse().unwrap();
            let expected_delegator_reward1 = "2199961.032388664".parse().unwrap();
            compare_decimals(rewards1.delegates, expected_delegator_reward1, None);
@@ -490,7 +424,7 @@ mod tests {
            assert_eq!(reward.amount, truncate_reward_amount(expected_del1_reward));

            // new reward after withdrawal
-            let rewards2 = simulator.simulate_epoch_single_node(node_params).unwrap();
+            let rewards2 = simulator.simulate_epoch_single_node(node_params);
            let expected_operator2 = "1411250.1907492676".parse().unwrap();
            let expected_delegator_reward2 = "2200004.051009689".parse().unwrap();
            compare_decimals(rewards2.delegates, expected_delegator_reward2, None);
@@ -533,30 +467,22 @@ mod tests {
            let mut performance = Percent::from_percentage_value(100).unwrap();
            for epoch in 0..720 {
                if epoch == 0 {
-                    simulator
-                        .delegate("a", Coin::new(18000_000000, "unym"), 0)
-                        .unwrap()
+                    simulator.delegate("a", Coin::new(18000_000000, "unym"), 0)
                }
                if epoch == 42 {
-                    simulator
-                        .delegate("b", Coin::new(2000_000000, "unym"), 0)
-                        .unwrap()
+                    simulator.delegate("b", Coin::new(2000_000000, "unym"), 0)
                }
                if epoch == 89 {
                    is_active = false;
                }
                if epoch == 123 {
-                    simulator
-                        .delegate("c", Coin::new(6666_000000, "unym"), 0)
-                        .unwrap()
+                    simulator.delegate("c", Coin::new(6666_000000, "unym"), 0)
                }
                if epoch == 167 {
                    performance = Percent::from_percentage_value(90).unwrap();
                }
                if epoch == 245 {
-                    simulator
-                        .delegate("d", Coin::new(2050_000000, "unym"), 0)
-                        .unwrap()
+                    simulator.delegate("d", Coin::new(2050_000000, "unym"), 0)
                }
                if epoch == 264 {
                    let (delegation, _reward) = simulator.undelegate("b", 0).unwrap();
@@ -577,15 +503,13 @@ mod tests {
                    // TODO: figure out if there's a good way to verify whether `reward` is what we expect it to be
                }
                if epoch == 545 {
-                    simulator
-                        .delegate("e", Coin::new(5000_000000, "unym"), 0)
-                        .unwrap()
+                    simulator.delegate("e", Coin::new(5000_000000, "unym"), 0)
                }

                // this has to always hold
                check_rewarding_invariant(&simulator);
                let node_params = NodeRewardParams::new(performance, is_active);
-                simulator.simulate_epoch_single_node(node_params).unwrap();
+                simulator.simulate_epoch_single_node(node_params);
            }

            // after everyone undelegates, there should be nothing left in the delegates pool
@@ -639,135 +563,95 @@ mod tests {

        let mut simulator = Simulator::new(rewarding_params, interval);

-        let n0 = simulator
-            .bond(
-                Coin::new(11_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(1_000_000_000000, "unym"), n0)
-            .unwrap();
+        let n0 = simulator.bond(
+            Coin::new(11_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(1_000_000_000000, "unym"), n0);

-        let n1 = simulator
-            .bond(
-                Coin::new(1_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(11_000_000_000000, "unym"), n1)
-            .unwrap();
+        let n1 = simulator.bond(
+            Coin::new(1_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(11_000_000_000000, "unym"), n1);

-        let n2 = simulator
-            .bond(
-                Coin::new(1_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(9_000_000_000000, "unym"), n2)
-            .unwrap();
+        let n2 = simulator.bond(
+            Coin::new(1_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(9_000_000_000000, "unym"), n2);

-        let n3 = simulator
-            .bond(
-                Coin::new(1_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(0).unwrap(),
-                    interval_operating_cost: Coin::new(500_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(7_000_000_000000, "unym"), n3)
-            .unwrap();
+        let n3 = simulator.bond(
+            Coin::new(1_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(0).unwrap(),
+                interval_operating_cost: Coin::new(500_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(7_000_000_000000, "unym"), n3);

-        let n4 = simulator
-            .bond(
-                Coin::new(1000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(7_999_000_000000, "unym"), n4)
-            .unwrap();
+        let n4 = simulator.bond(
+            Coin::new(1000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(7_999_000_000000, "unym"), n4);

-        let n5 = simulator
-            .bond(
-                Coin::new(1_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(7_000_000_000000, "unym"), n5)
-            .unwrap();
+        let n5 = simulator.bond(
+            Coin::new(1_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(7_000_000_000000, "unym"), n5);

-        let n6 = simulator
-            .bond(
-                Coin::new(11_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(1_000_000_000000, "unym"), n6)
-            .unwrap();
+        let n6 = simulator.bond(
+            Coin::new(11_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(1_000_000_000000, "unym"), n6);

-        let n7 = simulator
-            .bond(
-                Coin::new(1_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(9_000_000_000000, "unym"), n7)
-            .unwrap();
+        let n7 = simulator.bond(
+            Coin::new(1_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(9_000_000_000000, "unym"), n7);

-        let n8 = simulator
-            .bond(
-                Coin::new(1_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(0).unwrap(),
-                    interval_operating_cost: Coin::new(500_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(7_000_000_000000, "unym"), n8)
-            .unwrap();
+        let n8 = simulator.bond(
+            Coin::new(1_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(0).unwrap(),
+                interval_operating_cost: Coin::new(500_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(7_000_000_000000, "unym"), n8);

-        let n9 = simulator
-            .bond(
-                Coin::new(1_000_000_000000, "unym"),
-                MixNodeCostParams {
-                    profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
-                    interval_operating_cost: Coin::new(40_000_000, "unym"),
-                },
-            )
-            .unwrap();
-        simulator
-            .delegate("delegator", Coin::new(7_000_000_000000, "unym"), n9)
-            .unwrap();
+        let n9 = simulator.bond(
+            Coin::new(1_000_000_000000, "unym"),
+            MixNodeCostParams {
+                profit_margin_percent: Percent::from_percentage_value(10).unwrap(),
+                interval_operating_cost: Coin::new(40_000_000, "unym"),
+            },
+        );
+        simulator.delegate("delegator", Coin::new(7_000_000_000000, "unym"), n9);

        let uptime_1 = Percent::from_percentage_value(100).unwrap();
        let uptime_09 = Percent::from_percentage_value(90).unwrap();
@@ -789,7 +673,7 @@ mod tests {
        .collect::<BTreeMap<_, _>>();

        for _ in 0..23 {
-            simulator.simulate_full_interval(&node_params).unwrap();
+            simulator.simulate_full_interval(&node_params);
        }

        // we allow the delta to be within 0.1unym,
@@ -20,25 +20,21 @@ impl SimulatedNode {
        cost_params: MixNodeCostParams,
        initial_pledge: &Coin,
        current_epoch: EpochId,
-    ) -> Result<Self, MixnetContractError> {
-        Ok(SimulatedNode {
+    ) -> Self {
+        SimulatedNode {
            mix_id,
            rewarding_details: MixNodeRewarding::initialise_new(
                cost_params,
                initial_pledge,
                current_epoch,
-            )?,
+            ),
            delegations: HashMap::new(),
-        })
+        }
    }

-    pub fn delegate<S: Into<String>>(
-        &mut self,
-        delegator: S,
-        delegation: Coin,
-    ) -> Result<(), MixnetContractError> {
+    pub fn delegate<S: Into<String>>(&mut self, delegator: S, delegation: Coin) {
        self.rewarding_details
-            .add_base_delegation(delegation.amount)?;
+            .add_base_delegation(delegation.amount);

        let delegator = delegator.into();
        let delegation = Delegation::new(
@@ -51,7 +47,6 @@ impl SimulatedNode {
        );

        self.delegations.insert(delegator, delegation);
-        Ok(())
    }

    pub fn undelegate<S: Into<String>>(
@@ -59,19 +54,16 @@ impl SimulatedNode {
        delegator: S,
    ) -> Result<(Coin, Coin), MixnetContractError> {
        let delegator = delegator.into();
-        let delegation = self.delegations.remove(&delegator).ok_or(
-            MixnetContractError::NoMixnodeDelegationFound {
-                mix_id: MixId::MAX,
-                address: delegator,
-                proxy: None,
-            },
-        )?;
+        let delegation = self
+            .delegations
+            .remove(&delegator)
+            .expect("delegation not found");

        let reward = self
            .rewarding_details
-            .determine_delegation_reward(&delegation)?;
+            .determine_delegation_reward(&delegation);
        self.rewarding_details
-            .remove_delegation_decimal(delegation.dec_amount()? + reward)?;
+            .remove_delegation_decimal(delegation.dec_amount() + reward)?;

        let reward_denom = &delegation.amount.denom;
        let truncated_reward = truncate_reward(reward, reward_denom);
@@ -2,12 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::MixnetContractError;
+use crate::rewarding::helpers::truncate_decimal;
 use crate::{Layer, RewardedSetNodeStatus};
-use cosmwasm_std::Addr;
-use cosmwasm_std::Coin;
+use cosmwasm_std::{Addr, Uint128};
+use cosmwasm_std::{Coin, Decimal};
 use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use std::ops::Index;
+use serde::de::Error;
+use serde::{Deserialize, Deserializer, Serialize};
+use std::fmt::{self, Display, Formatter};
+use std::ops::{Index, Mul};

 // type aliases for better reasoning about available data
 pub type IdentityKey = String;
@@ -35,10 +38,6 @@ impl LayerDistribution {
            (Layer::Two, self.layer2),
            (Layer::Three, self.layer3),
        ];
-
-        // we explicitly put 3 elements into the iterator, so the iterator is DEFINITELY
-        // not empty and thus the unwrap cannot fail
-        #[allow(clippy::unwrap_used)]
        layers.iter().min_by_key(|x| x.1).unwrap().0
    }

@@ -126,3 +125,48 @@ pub struct PagedRewardedSetResponse {
    pub nodes: Vec<(MixId, RewardedSetNodeStatus)>,
    pub start_next_after: Option<MixId>,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn percent_serde() {
+        let valid_value = Percent::from_percentage_value(80).unwrap();
+        let serialized = serde_json::to_string(&valid_value).unwrap();
+
+        println!("{}", serialized);
+        let deserialized: Percent = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(valid_value, deserialized);
+
+        let invalid_values = vec!["\"42\"", "\"1.1\"", "\"1.00000001\"", "\"foomp\"", "\"1a\""];
+        for invalid_value in invalid_values {
+            assert!(serde_json::from_str::<'_, Percent>(invalid_value).is_err())
+        }
+        assert_eq!(
+            serde_json::from_str::<'_, Percent>("\"0.95\"").unwrap(),
+            Percent::from_percentage_value(95).unwrap()
+        )
+    }
+
+    #[test]
+    fn percent_to_absolute_integer() {
+        let p = serde_json::from_str::<'_, Percent>("\"0.0001\"").unwrap();
+        assert_eq!(p.round_to_integer(), 0);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.0099\"").unwrap();
+        assert_eq!(p.round_to_integer(), 0);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.0199\"").unwrap();
+        assert_eq!(p.round_to_integer(), 1);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.45123\"").unwrap();
+        assert_eq!(p.round_to_integer(), 45);
+
+        let p = serde_json::from_str::<'_, Percent>("\"0.999999999\"").unwrap();
+        assert_eq!(p.round_to_integer(), 99);
+
+        let p = serde_json::from_str::<'_, Percent>("\"1.00\"").unwrap();
+        assert_eq!(p.round_to_integer(), 100);
+    }
+}
@@ -6,7 +6,6 @@ edition = "2021"
 [dependencies]
 cosmwasm-std = "1.0.0"
 mixnet-contract-common = { path = "../mixnet-contract" }
-contracts-common = { path = "../contracts-common" }
 serde = { version = "1.0", features = ["derive"] }
 schemars = "0.8"
 ts-rs = {version = "6.1.2", optional = true}
@@ -1,15 +1,9 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-
-#![warn(clippy::expect_used)]
-#![warn(clippy::unwrap_used)]
-
-use contracts_common::Percent;
 use cosmwasm_std::{Addr, Coin, Timestamp, Uint128};
 use mixnet_contract_common::MixId;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;

 pub use messages::{ExecuteMsg, InitMsg, MigrateMsg, QueryMsg};

@@ -48,35 +42,6 @@ impl PledgeData {
    }
 }

-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub enum PledgeCap {
-    Percent(Percent),
-    Absolute(Uint128), // This has to be in unym
-}
-
-impl FromStr for PledgeCap {
-    type Err = String;
-
-    fn from_str(cap: &str) -> Result<Self, Self::Err> {
-        let cap = cap.replace('_', "").replace(',', ".");
-        match Percent::from_str(&cap) {
-            Ok(p) => Ok(PledgeCap::Percent(p)),
-            Err(_) => match cap.parse::<u128>() {
-                Ok(i) => Ok(PledgeCap::Absolute(Uint128::from(i))),
-                Err(_e) => Err(format!("Could not parse {} as Percent or Uint128", cap)),
-            },
-        }
-    }
-}
-
-impl Default for PledgeCap {
-    fn default() -> Self {
-        #[allow(clippy::expect_used)]
-        PledgeCap::Percent(Percent::from_percentage_value(10).expect("This can never fail!"))
-    }
-}
-
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 pub struct OriginalVestingResponse {
    pub amount: Coin,
@@ -133,32 +98,3 @@ pub struct AllDelegationsResponse {
    pub delegations: Vec<VestingDelegation>,
    pub start_next_after: Option<(u32, MixId, u64)>,
 }
-
-#[cfg(test)]
-mod test {
-    use contracts_common::Percent;
-    use cosmwasm_std::Uint128;
-    use std::str::FromStr;
-
-    use crate::PledgeCap;
-
-    #[test]
-    fn test_pledge_cap_from_str() {
-        assert_eq!(
-            PledgeCap::from_str("0.1").unwrap(),
-            PledgeCap::Percent(Percent::from_percentage_value(10).unwrap())
-        );
-        assert_eq!(
-            PledgeCap::from_str("0,1").unwrap(),
-            PledgeCap::Percent(Percent::from_percentage_value(10).unwrap())
-        );
-        assert_eq!(
-            PledgeCap::from_str("100_000_000_000").unwrap(),
-            PledgeCap::Absolute(Uint128::new(100_000_000_000))
-        );
-        assert_eq!(
-            PledgeCap::from_str("100000000000").unwrap(),
-            PledgeCap::Absolute(Uint128::new(100_000_000_000))
-        );
-    }
-}
@@ -1,4 +1,4 @@
-use cosmwasm_std::{Coin, Timestamp};
+use cosmwasm_std::{Coin, Timestamp, Uint128};
 use mixnet_contract_common::{
    mixnode::{MixNodeConfigUpdate, MixNodeCostParams},
    Gateway, MixId, MixNode,
@@ -6,8 +6,6 @@ use mixnet_contract_common::{
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

-use crate::PledgeCap;
-
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct InitMsg {
@@ -85,7 +83,6 @@ pub enum ExecuteMsg {
        owner_address: String,
        staking_address: Option<String>,
        vesting_spec: Option<VestingSpecification>,
-        cap: Option<PledgeCap>,
    },
    WithdrawVestedCoins {
        amount: Coin,
@@ -123,8 +120,7 @@ pub enum ExecuteMsg {
        to_address: Option<String>,
    },
    UpdateLockedPledgeCap {
-        address: String,
-        cap: PledgeCap,
+        amount: Uint128,
    },
 }

@@ -160,7 +156,6 @@ impl ExecuteMsg {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryMsg {
-    GetContractVersion {},
    LockedCoins {
        vesting_account_address: String,
        block_time: Option<Timestamp>,
@@ -206,6 +201,7 @@ pub enum QueryMsg {
    GetCurrentVestingPeriod {
        address: String,
    },
+    GetLockedPledgeCap {},
    GetDelegationTimes {
        address: String,
        mix_id: MixId,
@@ -1,10 +0,0 @@
-[package]
-name = "logging"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-log = "0.4.0"
-pretty_env_logger = "0.4.0"
@@ -1,25 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// I'd argue we should start transitioning from `log` to `tracing`
-pub 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();
-}
@@ -116,10 +116,7 @@ impl SphinxPacketProcessor {
                trace!("received an ack packet!");
                Ok((None, data))
            }
-            PacketSize::RegularPacket
-            | PacketSize::ExtendedPacket8
-            | PacketSize::ExtendedPacket16
-            | PacketSize::ExtendedPacket32 => {
+            PacketSize::RegularPacket | PacketSize::ExtendedPacket => {
                trace!("received a normal packet!");
                let (ack_data, message) = self.split_hop_data_into_ack_and_message(data)?;
                let (ack_first_hop, ack_packet) = SurbAck::try_recover_first_hop_packet(&ack_data)?;
@@ -1 +0,0 @@
-This project was partially funded through the NGI0 PET Fund, a fund established by NL.net with financial support from the European Commission's NGI programme, under the aegis of DG Communications Networks, Content and Technology under grant agreement No 825310.
@@ -85,7 +85,7 @@ impl SecretKey {
    // x || ys.len() || ys
    pub fn to_bytes(&self) -> Vec<u8> {
        let ys_len = self.ys.len();
-        let mut bytes = Vec::with_capacity(8 + (ys_len + 1) * 32);
+        let mut bytes = Vec::with_capacity(8 + (ys_len + 1) as usize * 32);

        bytes.extend_from_slice(&self.x.to_bytes());
        bytes.extend_from_slice(&ys_len.to_le_bytes());
@@ -162,7 +162,7 @@ impl TryFrom<&[u8]> for VerificationKey {
        let mut beta_g1_end: u64 = 0;
        for i in 0..betas_len {
            let start = (104 + i * 48) as usize;
-            let end = start + 48;
+            let end = (start + 48) as usize;
            let beta_i_bytes = bytes[start..end].try_into().unwrap();
            let beta_i = try_deserialize_g1_projective(
                &beta_i_bytes,
@@ -178,7 +178,7 @@ impl TryFrom<&[u8]> for VerificationKey {
        let mut beta_g2 = Vec::with_capacity(betas_len as usize);
        for i in 0..betas_len {
            let start = (beta_g1_end + i * 96) as usize;
-            let end = start + 96;
+            let end = (start + 96) as usize;
            let beta_i_bytes = bytes[start..end].try_into().unwrap();
            let beta_i = try_deserialize_g2_projective(
                &beta_i_bytes,
@@ -94,10 +94,10 @@ fn prepare_unlinked_fragmented_set(

    for i in 1..(pre_casted_frags + 1) {
        // we can't use u8 directly here as upper (NON-INCLUSIVE, so it would always fit) bound could be u8::max_value() + 1
-        let lb = (i - 1) * unlinked_fragment_payload_max_len(max_plaintext_size);
+        let lb = (i as usize - 1) * unlinked_fragment_payload_max_len(max_plaintext_size);
        let ub = usize::min(
            message.len(),
-            i * unlinked_fragment_payload_max_len(max_plaintext_size),
+            i as usize * unlinked_fragment_payload_max_len(max_plaintext_size),
        );
        fragments.push(
            Fragment::try_new(
@@ -25,10 +25,8 @@ impl Display for MixPacketFormattingError {
            InvalidPacketSize(actual) =>
                write!(
                    f,
-                    "received request had invalid size. (actual: {}, but expected one of: {} (ACK), {} (REGULAR), {}, {}, {} (EXTENDED))",
-                    actual, PacketSize::AckPacket.size(), PacketSize::RegularPacket.size(),
-                    PacketSize::ExtendedPacket8.size(), PacketSize::ExtendedPacket16.size(),
-                    PacketSize::ExtendedPacket32.size()
+                    "received request had invalid size. (actual: {}, but expected one of: {} (ACK), {} (REGULAR), {} (EXTENDED))",
+                    actual, PacketSize::AckPacket.size(), PacketSize::RegularPacket.size(), PacketSize::ExtendedPacket.size()
                ),
            MalformedSphinxPacket => write!(f, "received sphinx packet was malformed"),
            InvalidPacketMode => write!(f, "provided packet mode is invalid")
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jędrzej Stuczyński	d916854ba3	Revert "Ability to update mixnode config in maintenance mode" This reverts commit `dbd0e6b4fa`.	2022-11-15 16:17:50 +00:00
Jędrzej Stuczyński	dbd0e6b4fa	Ability to update mixnode config in maintenance mode	2022-11-14 14:24:03 +00:00
Jędrzej Stuczyński	abf7b57ccb	Bugfix/correct staking supply accounting (#1706 ) * Added staking_supply_scale_factor field on RewardingParams * Scaling the amount of tokens released to the circulating/staking supplies	2022-10-27 11:05:55 +01:00
Jędrzej Stuczyński	ec1988b745	Added code for gateway migration	2022-10-24 09:51:14 +01:00
Jędrzej Stuczyński	08bb9c0fbc	Saving received messages from v1 contract into new storage	2022-10-24 09:51:13 +01:00
				`@@ -1 +0,0 @@`
				`This project was partially funded through the NGI0 PET Fund, a fund established by NL.net with financial support from the European Commission's NGI programme, under the aegis of DG Communications Networks, Content and Technology under grant agreement No 825310.`