fix build a rever console utility addition

requested changes
fix build
2022-10-27 12:37:18 +02:00 · 2022-10-27 11:05:19 +02:00 · 2022-10-24 12:01:37 +02:00 · 2022-10-24 11:51:46 +02:00 · 2022-10-21 10:55:45 +02:00 · 2022-10-20 17:53:17 +02:00
436 changed files with 9299 additions and 12804 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
@@ -29,12 +29,6 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
@@ -54,6 +48,12 @@ jobs:
          command: test
          args: --workspace --all-features -- --ignored

+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
      - uses: actions-rs/clippy-check@v1
        name: Clippy checks
        with:
@@ -66,8 +66,6 @@ jobs:
          command: clippy
          args: --workspace -- -D warnings

-      # COCONUT stuff
-
      - name: Build all binaries with coconut enabled
        uses: actions-rs/cargo@v1
        with:
@@ -84,4 +82,4 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: clippy
-          args: --all-targets --features=coconut -- -D warnings
+          args: --features=coconut -- -D warnings
@@ -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,56 +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: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-
-      - name: Check the release tag starts with `nym-explorer-api-`
-        if: startsWith(github.ref, 'refs/tags/nym-explorer-api-') == false && github.event_name != 'workflow_dispatch'
-        uses: actions/github-script@v3
-        with:
-          script: |
-            core.setFailed('Release tag did not start with nym-explorer-api-...')
-
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Build all explorer-api
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path explorer-api/Cargo.toml --workspace --release
-
-      - name: Upload Artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: my-artifact
-          path: |
-            target/release/explorer-api
-          retention-days: 30
-
-      - name: Upload to release based on tag name
-        uses: softprops/action-gh-release@v1
-        if: github.event_name == 'release'
-        with:
-          files: |
-            target/release/explorer-api
@@ -1,49 +1,32 @@
-name: Nightly builds on latest release
+name: Nightly builds on dispatch

-on:
-  schedule:
-    - cron: '14 2 * * *'
+on: workflow_dispatch
 jobs:
  matrix_prep:
    runs-on: ubuntu-latest
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
-      # creates the matrix strategy from nightly_build_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.latest_release }}
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: Fetch all branches
-        run: git fetch --all
-      - name: Set output 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 | sed 's/  origin\///')" >> $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
@@ -59,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:
@@ -122,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:
@@ -180,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
@@ -189,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,52 +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`
- websocket-requests: add server response signalling current packet queue length in the client
-
-### Changed
-
- clients: add concept of transmission lanes to better handle multiple data streams ([#1720])
- socks5-client: wait closing inbound connection until data is sent, and throttle incoming data in general ([#1783])
-
-[#1720]: https://github.com/nymtech/nym/pull/1720
-[#1783]: https://github.com/nymtech/nym/pull/1783
-
-
-## [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
@@ -59,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,19 +576,10 @@ dependencies = [
 "os_str_bytes",
 ]

-[[package]]
-name = "client-connections"
-version = "0.1.0"
-dependencies = [
- "futures",
- "log",
-]
-
 [[package]]
 name = "client-core"
-version = "1.1.0"
+version = "1.0.1"
 dependencies = [
- "client-connections",
 "config",
 "crypto",
 "dirs",
@@ -636,16 +627,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "coconut-dkg-common"
-version = "0.1.0"
-dependencies = [
- "contracts-common",
- "cosmwasm-std",
- "schemars",
- "serde",
-]
-
 [[package]]
 name = "coconut-interface"
 version = "0.1.0"
@@ -755,13 +736,8 @@ checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
 name = "contracts-common"
 version = "0.1.0"
 dependencies = [
- "bs58",
 "cosmwasm-std",
- "dkg",
- "schemars",
 "serde",
- "serde_json",
- "thiserror",
 ]

 [[package]]
@@ -871,9 +847,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",
 ]
@@ -1423,7 +1399,6 @@ dependencies = [
 "ff 0.11.0",
 "group 0.11.0",
 "lazy_static",
- "pemstore",
 "rand 0.8.5",
 "rand_chacha 0.3.1",
 "rand_core 0.6.3",
@@ -1475,9 +1450,9 @@ dependencies = [

 [[package]]
 name = "ed25519"
-version = "1.5.2"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e9c280362032ea4203659fc489832d0204ef09f247a0506f170dafcac08c369"
+checksum = "3d5c4b5e5959dc2c2b89918d8e2cc40fcdd623cef026ed09d2f0ee05199dc8e4"
 dependencies = [
 "serde",
 "signature",
@@ -1604,17 +1579,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",
@@ -2753,14 +2725,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"
@@ -3092,7 +3056,7 @@ dependencies = [

 [[package]]
 name = "nym-cli"
-version = "1.1.0"
+version = "1.0.0"
 dependencies = [
 "anyhow",
 "base64",
@@ -3103,7 +3067,6 @@ dependencies = [
 "clap_complete_fig",
 "dotenv",
 "log",
- "logging",
 "network-defaults",
 "nym-cli-commands",
 "pretty_env_logger",
@@ -3144,10 +3107,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",
@@ -3160,7 +3122,6 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
- "logging",
 "network-defaults",
 "nymsphinx",
 "pemstore",
@@ -3169,9 +3130,7 @@ dependencies = [
 "serde",
 "serde_json",
 "sled",
- "tap",
 "task",
- "thiserror",
 "tokio",
 "tokio-tungstenite 0.14.0",
 "topology",
@@ -3184,7 +3143,7 @@ dependencies = [

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

 [[package]]
 name = "nym-mixnode"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "anyhow",
 "bs58",
@@ -3247,7 +3205,6 @@ dependencies = [
 "humantime-serde",
 "lazy_static",
 "log",
- "logging",
 "mixnet-client",
 "mixnode-common",
 "nonexhaustive-delayqueue",
@@ -3273,17 +3230,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",
@@ -3309,7 +3264,6 @@ version = "1.0.2"
 dependencies = [
 "dirs",
 "log",
- "logging",
 "pretty_env_logger",
 "rocket",
 "serde",
@@ -3321,10 +3275,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",
@@ -3337,7 +3290,6 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
- "logging",
 "network-defaults",
 "nymsphinx",
 "ordered-buffer",
@@ -3349,9 +3301,7 @@ dependencies = [
 "serde",
 "snafu 0.6.10",
 "socks5-requests",
- "tap",
 "task",
- "thiserror",
 "tokio",
 "topology",
 "url",
@@ -3388,19 +3338,16 @@ dependencies = [

 [[package]]
 name = "nym-validator-api"
-version = "1.1.0"
+version = "1.0.2"
 dependencies = [
 "anyhow",
 "async-trait",
- "bs58",
 "cfg-if 1.0.0",
 "clap 3.2.8",
 "coconut-bandwidth-contract-common",
- "coconut-dkg-common",
 "coconut-interface",
 "config",
 "console-subscriber",
- "contracts-common",
 "cosmwasm-std",
 "credential-storage",
 "credentials",
@@ -3408,7 +3355,6 @@ dependencies = [
 "cw-utils",
 "cw3",
 "dirs",
- "dkg",
 "dotenv",
 "futures",
 "gateway-client",
@@ -3416,13 +3362,11 @@ dependencies = [
 "humantime-serde",
 "inclusion-probability",
 "log",
- "logging",
 "mixnet-contract-common",
 "multisig-contract-common",
 "nymcoconut",
 "nymsphinx",
 "okapi",
- "pemstore",
 "pin-project",
 "pretty_env_logger",
 "rand 0.7.3",
@@ -3475,18 +3419,16 @@ name = "nymcoconut"
 version = "0.5.0"
 dependencies = [
 "bincode",
- "bls12_381 0.6.0",
+ "bls12_381 0.5.0",
 "bs58",
 "criterion",
 "digest 0.9.0",
- "dkg",
 "doc-comment",
- "ff 0.11.0",
+ "ff 0.10.1",
 "getrandom 0.2.6",
- "group 0.11.0",
+ "group 0.10.0",
 "itertools",
 "rand 0.8.5",
- "rand_chacha 0.3.1",
 "serde",
 "serde_derive",
 "sha2 0.9.9",
@@ -4156,7 +4098,6 @@ name = "proxy-helpers"
 version = "0.1.0"
 dependencies = [
 "bytes",
- "client-connections",
 "futures",
 "log",
 "ordered-buffer",
@@ -6441,11 +6382,9 @@ dependencies = [
 "base64",
 "bip39",
 "coconut-bandwidth-contract-common",
- "coconut-dkg-common",
 "coconut-interface",
 "colored",
 "config",
- "contracts-common",
 "cosmrs",
 "cosmwasm-std",
 "cw3",
@@ -6534,14 +6473,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",
 ]

@@ -6549,7 +6486,6 @@ dependencies = [
 name = "vesting-contract-common"
 version = "0.1.0"
 dependencies = [
- "contracts-common",
 "cosmwasm-std",
 "mixnet-contract-common",
 "schemars",
@@ -26,12 +26,10 @@ 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",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
-    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
@@ -43,7 +41,6 @@ members = [
    "common/execute",
    "common/inclusion-probability",
    "common/ledger",
-    "common/logging",
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
@@ -2,12 +2,12 @@ test: clippy-all cargo-test wasm fmt
 test-all: test cargo-test-expensive
 no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
-clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
+clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect
 clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
-cargo-test: test-main test-contracts test-wallet test-connect test-coconut test-wasm-client
+cargo-test: test-main test-contracts test-wallet test-connect test-coconut
 cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive test-coconut-expensive
-build: build-contracts build-wallet build-main build-connect build-wasm-client
-fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client
+build: build-contracts build-wallet build-main build-connect
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect

 clippy-happy-main:
 	cargo clippy
@@ -40,9 +40,6 @@ clippy-all-wallet:
 clippy-all-connect:
 	cargo clippy --workspace --manifest-path nym-connect/Cargo.toml --all-features -- -D warnings

-clippy-all-wasm-client:
-	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings
-
 test-main:
 	cargo test --workspace

@@ -71,9 +68,6 @@ test-wallet:
 test-wallet-expensive:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored

-test-wasm-client:
-	cargo test --workspace --manifest-path clients/webassembly/Cargo.toml --all-features
-
 test-connect:
 	cargo test --manifest-path nym-connect/Cargo.toml --all-features

@@ -92,12 +86,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
-
 build-nym-cli:
 	cargo build --release --manifest-path tools/nym-cli/Cargo.toml

@@ -113,9 +101,6 @@ fmt-wallet:
 fmt-connect:
 	cargo fmt --manifest-path nym-connect/Cargo.toml --all

-fmt-wasm-client:
-	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all
-
 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown

@@ -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,9 +1,9 @@
-use client_connections::TransmissionLane;
+use futures::channel::mpsc;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::anonymous_replies::ReplySurb;

-pub type InputMessageSender = tokio::sync::mpsc::Sender<InputMessage>;
-pub type InputMessageReceiver = tokio::sync::mpsc::Receiver<InputMessage>;
+pub type InputMessageSender = mpsc::UnboundedSender<InputMessage>;
+pub type InputMessageReceiver = mpsc::UnboundedReceiver<InputMessage>;

 #[derive(Debug)]
 pub enum InputMessage {
@@ -11,7 +11,6 @@ pub enum InputMessage {
        recipient: Recipient,
        data: Vec<u8>,
        with_reply_surb: bool,
-        lane: TransmissionLane,
    },
    Reply {
        reply_surb: ReplySurb,
@@ -20,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,7 @@ 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;
 use nymsphinx::preparer::MessagePreparer;
@@ -104,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))
@@ -165,36 +164,27 @@ 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
-            if self
-                .real_message_sender
-                .send((real_messages, lane))
-                .await
-                .is_err()
-            {
-                panic!();
-            }
+            self.real_message_sender
+                .unbounded_send(real_messages)
+                .unwrap();
        }
    }

@@ -204,7 +194,7 @@ where

        while !shutdown.is_shutdown() {
            tokio::select! {
-                input_msg = self.input_receiver.recv() => match input_msg {
+                input_msg = self.input_receiver.next() => match input_msg {
                    Some(input_msg) => {
                        self.on_input_message(input_msg).await;
                    },
@@ -225,7 +215,7 @@ where
    #[cfg(target_arch = "wasm32")]
    pub(super) async fn run(&mut self) {
        debug!("Started InputMessageListener without graceful shutdown support");
-        while let Some(input_msg) = self.input_receiver.recv().await {
+        while let Some(input_msg) = self.input_receiver.next().await {
            self.on_input_message(input_msg).await;
        }
    }
@@ -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};

@@ -116,17 +112,12 @@ where
            .unwrap();

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

    #[cfg(not(target_arch = "wasm32"))]
@@ -8,15 +8,12 @@
 use self::{
    acknowledgement_control::AcknowledgementController, real_traffic_stream::OutQueueControl,
 };
-use crate::{
-    client::{
-        inbound_messages::InputMessageReceiver, mix_traffic::BatchMixMessageSender,
-        real_messages_control::acknowledgement_control::AcknowledgementControllerConnectors,
-        topology_control::TopologyAccessor,
-    },
-    spawn_future,
+use crate::client::real_messages_control::acknowledgement_control::AcknowledgementControllerConnectors;
+use crate::client::{
+    inbound_messages::InputMessageReceiver, mix_traffic::BatchMixMessageSender,
+    topology_control::TopologyAccessor,
 };
-use client_connections::{ClosedConnectionReceiver, LaneQueueLengths};
+use crate::spawn_future;
 use futures::channel::mpsc;
 use gateway_client::AcknowledgementReceiver;
 use log::*;
@@ -106,7 +103,6 @@ where
 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 impl RealMessagesController<OsRng> {
-    #[allow(clippy::too_many_arguments)]
    pub fn new(
        config: Config,
        ack_receiver: AcknowledgementReceiver,
@@ -114,12 +110,10 @@ impl RealMessagesController<OsRng> {
        mix_sender: BatchMixMessageSender,
        topology_access: TopologyAccessor,
        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
-        lane_queue_lengths: LaneQueueLengths,
-        closed_connection_rx: ClosedConnectionReceiver,
    ) -> Self {
        let rng = OsRng;

-        let (real_message_sender, real_message_receiver) = tokio::sync::mpsc::channel(1);
+        let (real_message_sender, real_message_receiver) = mpsc::unbounded();
        let (sent_notifier_tx, sent_notifier_rx) = mpsc::unbounded();

        let ack_controller_connectors = AcknowledgementControllerConnectors::new(
@@ -165,8 +159,6 @@ impl RealMessagesController<OsRng> {
            rng,
            config.self_recipient,
            topology_access,
-            lane_queue_lengths,
-            closed_connection_rx,
        );

        RealMessagesController {
@@ -4,9 +4,7 @@
 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, ConnectionCommand, ConnectionId, LaneQueueLengths, TransmissionLane,
-};
+use futures::channel::mpsc;
 use futures::task::{Context, Poll};
 use futures::{Future, Stream, StreamExt};
 use log::*;
@@ -18,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;
@@ -28,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.
@@ -107,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,
@@ -128,16 +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,
-
-    /// Report queue lengths so that upstream can backoff sending data, and keep connections open.
-    lane_queue_lengths: LaneQueueLengths,
+    /// Buffer containing all real messages received. It is first exhausted before more are pulled.
+    received_buffer: VecDeque<RealMessage>,
 }

 pub(crate) struct RealMessage {
@@ -156,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 =
-    tokio::sync::mpsc::Sender<(Vec<RealMessage>, TransmissionLane)>;
-type BatchRealMessageReceiver = tokio::sync::mpsc::Receiver<(Vec<RealMessage>, TransmissionLane)>;
+pub(crate) type BatchRealMessageSender = mpsc::UnboundedSender<Vec<RealMessage>>;
+type BatchRealMessageReceiver = mpsc::UnboundedReceiver<Vec<RealMessage>>;

 pub(crate) enum StreamMessage {
    Cover,
@@ -181,23 +150,18 @@ where
        rng: R,
        our_full_destination: Recipient,
        topology_access: TopologyAccessor,
-        lane_queue_lengths: LaneQueueLengths,
-        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,
-            lane_queue_lengths,
+            received_buffer: VecDeque::with_capacity(0), // we won't be putting any data into this guy directly
        }
    }

@@ -212,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
@@ -231,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
@@ -277,71 +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 pop_next_message(&mut self) -> Option<RealMessage> {
-        // Pop the next message from the transmission buffer
-        let (lane, real_next) = self.transmission_buffer.pop_next_message_at_random()?;
-
-        // Update the published queue length
-        let lane_length = self.transmission_buffer.lane_length(&lane);
-        self.lane_queue_lengths.set(&lane, lane_length);
-
-        Some(real_next)
-    }
-
    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) {
-            match id {
-                ConnectionCommand::Close(id) => self.on_close_connection(id),
-                ConnectionCommand::ActiveConnections(_) => panic!(),
-            }
-        }
-
        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() {
@@ -350,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
@@ -366,32 +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.
-            match Pin::new(&mut self.real_receiver).poll_recv(cx) {
+            // 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.pop_next_message().expect("Just stored 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.pop_next_message() {
-                        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
@@ -413,36 +303,32 @@ 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) {
-            match id {
-                ConnectionCommand::Close(id) => self.on_close_connection(id),
-                ConnectionCommand::ActiveConnections(_) => panic!(),
+        // 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_recv(cx) {
+        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());
-
-                // First store what we got for the given connection id
-                self.transmission_buffer.store(&conn_id, real_messages);
-                let real_next = self.pop_next_message().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.pop_next_message() {
-                    Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
-                } else {
-                    Poll::Pending
-                }
-            }
+            // if there's nothing, then there's nothing
+            Poll::Pending => Poll::Pending,
        }
    }

@@ -457,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,211 +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()
-    }
-
-    pub(crate) fn lane_length(&self, lane: &TransmissionLane) -> Option<usize> {
-        self.buffer.get(lane).map(LaneBufferEntry::len)
-    }
-
-    #[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<(TransmissionLane, 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()?
-        };
-
-        let msg = self.pop_front_from_lane(&lane)?;
-        log::trace!("picking to send from lane: {:?}", lane);
-        Some((lane, msg))
-    }
-
-    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)
-    }
-
-    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()
        );
@@ -8,13 +8,10 @@ use nymsphinx::anonymous_replies::{
 };
 use std::path::Path;

-#[derive(Debug, thiserror::Error)]
+#[derive(Debug)]
 pub enum ReplyKeyStorageError {
-    #[error("DB Read Error: {0}")]
    DbReadError(sled::Error),
-    #[error("DB Write Error: {0}")]
    DbWriteError(sled::Error),
-    #[error("DB Open Error: {0}")]
    DbOpenError(sled::Error),
 }

@@ -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" }
@@ -51,7 +48,6 @@ topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
 websocket-requests = { path = "websocket-requests" }
-tap = "1.0.1"

 [features]
 coconut = ["coconut-interface", "credentials", "credentials/coconut", "gateway-requests/coconut", "gateway-client/coconut", "client-core/coconut"]
@@ -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,15 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_connections::{
-    ClosedConnectionReceiver, ClosedConnectionSender, LaneQueueLengths, 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::{
@@ -21,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;
@@ -33,12 +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 tap::TapFallible;
 use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

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

 pub(crate) mod config;
@@ -106,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,
@@ -122,8 +117,6 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        lane_queue_lengths: LaneQueueLengths,
-        closed_connection_rx: ClosedConnectionReceiver,
        shutdown: ShutdownListener,
    ) {
        let mut controller_config = real_messages_control::Config::new(
@@ -139,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...");
@@ -153,8 +145,6 @@ impl NymClient {
            mix_sender,
            topology_accessor,
            reply_key_storage,
-            lane_queue_lengths,
-            closed_connection_rx,
        )
        .start_with_shutdown(shutdown);
    }
@@ -243,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(),
@@ -258,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)
@@ -275,31 +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,
-        shared_lane_queue_lengths: LaneQueueLengths,
-        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(),
-            shared_lane_queue_lengths,
-        );
+        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);
    }
@@ -307,43 +288,27 @@ impl NymClient {
    /// EXPERIMENTAL DIRECT RUST API
    /// It's untested and there are absolutely no guarantees about it (but seems to have worked
    /// well enough in local tests)
-    pub async 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);
+    pub fn send_message(&mut self, recipient: Recipient, message: Vec<u8>, with_reply_surb: bool) {
+        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb);

-        if self
-            .input_tx
+        self.input_tx
            .as_ref()
            .expect("start method was not called before!")
-            .send(input_msg)
-            .await
-            .is_err()
-        {
-            panic!();
-        }
+            .unbounded_send(input_msg)
+            .unwrap();
    }

    /// EXPERIMENTAL DIRECT RUST API
    /// It's untested and there are absolutely no guarantees about it (but seems to have worked
    /// well enough in local tests)
-    pub async fn send_reply(&mut self, reply_surb: ReplySurb, message: Vec<u8>) {
+    pub fn send_reply(&mut self, reply_surb: ReplySurb, message: Vec<u8>) {
        let input_msg = InputMessage::new_reply(reply_surb, message);

-        if self
-            .input_tx
+        self.input_tx
            .as_ref()
            .expect("start method was not called before!")
-            .send(input_msg)
-            .await
-            .is_err()
-        {
-            panic!();
-        }
+            .unbounded_send(input_msg)
+            .unwrap();
    }

    /// EXPERIMENTAL DIRECT RUST API
@@ -364,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!(
@@ -382,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();
@@ -400,7 +369,7 @@ impl NymClient {
        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();

        // channels responsible for controlling real messages
-        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
+        let (input_sender, input_receiver) = mpsc::unbounded::<InputMessage>();

        // channels responsible for controlling ack messages
        let (ack_sender, ack_receiver) = mpsc::unbounded();
@@ -408,10 +377,7 @@ impl NymClient {

        let reply_key_storage =
            ReplyKeyStorage::load(self.config.get_base().get_reply_encryption_key_store_path())
-                .tap_err(|err| {
-                    log::error!("Failed to load reply key storage - is it perhaps already in use?");
-                    log::error!("{}", err);
-                })?;
+                .expect("Failed to load reply key storage!");

        // Shutdown notifier for signalling tasks to stop
        let shutdown = ShutdownNotifier::default();
@@ -419,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,
@@ -431,29 +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();
-
-        // Shared queue length data. Published by the `OutQueueController` in the client, and used
-        // primarily to throttle incoming connections (e.g socks5 for attached network-requesters)
-        let shared_lane_queue_lengths = LaneQueueLengths::new();
-
+        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(),
-            shared_lane_queue_lengths.clone(),
-            closed_connection_rx,
            shutdown.subscribe(),
        );

@@ -470,12 +424,9 @@ impl NymClient {
        }

        match self.config.get_socket_type() {
-            SocketType::WebSocket => self.start_websocket_listener(
-                received_buffer_request_sender,
-                input_sender,
-                shared_lane_queue_lengths,
-                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
@@ -496,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,25 +0,0 @@
-use client_core::{client::reply_key_storage::ReplyKeyStorageError, 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("Reply key storage error: {0}")]
-    ReplyKeyStorageError(#[from] ReplyKeyStorageError),
-
-    #[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,9 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_connections::{
-    ClosedConnectionSender, ConnectionCommand, LaneQueueLengths, TransmissionLane,
-};
 use client_core::client::{
    inbound_messages::{InputMessage, InputMessageSender},
    received_buffer::{
@@ -37,12 +34,10 @@ 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>>,
    received_response_type: ReceivedResponseType,
-    lane_queue_lengths: LaneQueueLengths,
 }

 // clone is used to use handler on a new connection, which initially is `None`
@@ -50,12 +45,10 @@ 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,
            received_response_type: Default::default(),
-            lane_queue_lengths: self.lane_queue_lengths.clone(),
        }
    }
 }
@@ -71,61 +64,38 @@ impl Drop for Handler {
 impl Handler {
    pub(crate) fn new(
        msg_input: InputMessageSender,
-        closed_connection_tx: ClosedConnectionSender,
        buffer_requester: ReceivedBufferRequestSender,
-        self_full_address: &Recipient,
-        lane_queue_lengths: LaneQueueLengths,
+        self_full_address: Recipient,
    ) -> Self {
        Handler {
            msg_input,
-            closed_connection_tx,
            buffer_requester,
-            self_full_address: *self_full_address,
+            self_full_address,
            socket: None,
            received_response_type: Default::default(),
-            lane_queue_lengths,
        }
    }

-    async fn handle_send(
+    fn handle_send(
        &mut self,
-        recipient: &Recipient,
+        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);
-        if self.msg_input.send(input_msg).await.is_err() {
-            panic!();
-        }
+        let input_msg = InputMessage::new_fresh(recipient, message, with_reply_surb);
+        self.msg_input.unbounded_send(input_msg).unwrap();

-        // on receiving a send, we reply back the current lane queue length for that connection id.
-        // Note that this does _NOT_ take into account the packets that have been received but not
-        // yet reach `OutQueueControl`, so it might be a tad low.
-        if let Ok(lane_queue_lengths) = self.lane_queue_lengths.lock() {
-            let queue_length = lane_queue_lengths.get(&lane).unwrap_or(0);
-            return Some(ServerResponse::LaneQueueLength(connection_id, queue_length));
-        }
-
-        log::warn!("Failed to get the lane queue length lock, not responding back with the current queue length");
        None
    }

-    async fn handle_reply(
-        &mut self,
-        reply_surb: ReplySurb,
-        message: Vec<u8>,
-    ) -> Option<ServerResponse> {
+    fn handle_reply(&mut self, reply_surb: ReplySurb, message: Vec<u8>) -> Option<ServerResponse> {
        if message.len() > ReplySurb::max_msg_len(Default::default()) {
            return Some(ServerResponse::new_error(format!("too long message to put inside a reply SURB. Received: {} bytes and maximum is {} bytes", message.len(), ReplySurb::max_msg_len(Default::default()))));
        }

        let input_msg = InputMessage::new_reply(reply_surb, message);
-        if self.msg_input.send(input_msg).await.is_err() {
-            panic!();
-        }
+        self.msg_input.unbounded_send(input_msg).unwrap();

        None
    }
@@ -134,48 +104,22 @@ impl Handler {
        ServerResponse::SelfAddress(self.self_full_address)
    }

-    fn handle_closed_connection(&self, connection_id: u64) -> Option<ServerResponse> {
-        self.closed_connection_tx
-            .unbounded_send(ConnectionCommand::Close(connection_id))
-            .unwrap();
-        None
-    }
-
-    fn handle_get_lane_queue_length(&self, connection_id: u64) -> Option<ServerResponse> {
-        let Ok(lane_queue_lengths) = self.lane_queue_lengths.lock() else {
-            log::warn!(
-                "Failed to get the lane queue length lock, not responding back with the current queue length"
-            );
-            return None;
-        };
-
-        let lane = TransmissionLane::ConnectionId(connection_id);
-        let queue_length = lane_queue_lengths.get(&lane).unwrap_or(0);
-        Some(ServerResponse::LaneQueueLength(connection_id, queue_length))
-    }
-
-    async fn handle_request(&mut self, request: ClientRequest) -> Option<ServerResponse> {
+    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)
-                    .await
-            }
+            } => self.handle_send(recipient, message, with_reply_surb),
            ClientRequest::Reply {
                message,
                reply_surb,
-            } => self.handle_reply(reply_surb, message).await,
+            } => self.handle_reply(reply_surb, message),
            ClientRequest::SelfAddress => Some(self.handle_self_address()),
-            ClientRequest::ClosedConnection(id) => self.handle_closed_connection(id),
-            ClientRequest::GetLaneQueueLength(id) => self.handle_get_lane_queue_length(id),
        }
    }

-    async fn handle_text_message(&mut self, msg: String) -> Option<WsMessage> {
+    fn handle_text_message(&mut self, msg: String) -> Option<WsMessage> {
        debug!("Handling text message request");
        trace!("Content: {:?}", msg);

@@ -184,13 +128,13 @@ impl Handler {

        let response = match client_request {
            Err(err) => Some(ServerResponse::Error(err)),
-            Ok(req) => self.handle_request(req).await,
+            Ok(req) => self.handle_request(req),
        };

        response.map(|resp| WsMessage::text(resp.into_text()))
    }

-    async fn handle_binary_message(&mut self, msg: &[u8]) -> Option<WsMessage> {
+    fn handle_binary_message(&mut self, msg: Vec<u8>) -> Option<WsMessage> {
        debug!("Handling binary message request");

        self.received_response_type = ReceivedResponseType::Binary;
@@ -198,23 +142,49 @@ impl Handler {

        let response = match client_request {
            Err(err) => Some(ServerResponse::Error(err)),
-            Ok(req) => self.handle_request(req).await,
+            Ok(req) => self.handle_request(req),
        };

        response.map(|resp| WsMessage::Binary(resp.into_binary()))
    }

-    async fn handle_ws_request(&mut self, raw_request: WsMessage) -> Option<WsMessage> {
+    fn handle_ws_request(&mut self, raw_request: WsMessage) -> Option<WsMessage> {
        // apparently tungstenite auto-handles ping/pong/close messages so for now let's ignore
        // them and let's test that claim. If that's not the case, just copy code from
        // old version of this file.
        match raw_request {
-            WsMessage::Text(text_message) => self.handle_text_message(text_message).await,
-            WsMessage::Binary(binary_message) => self.handle_binary_message(&binary_message).await,
+            WsMessage::Text(text_message) => self.handle_text_message(text_message),
+            WsMessage::Binary(binary_message) => self.handle_binary_message(binary_message),
            _ => None,
        }
    }

+    // I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
+    // let's just play along for now
+    fn prepare_reconstructed_binary(
+        &self,
+        reconstructed_messages: Vec<ReconstructedMessage>,
+    ) -> Vec<Result<WsMessage, WsError>> {
+        reconstructed_messages
+            .into_iter()
+            .map(ServerResponse::Received)
+            .map(|resp| Ok(WsMessage::Binary(resp.into_binary())))
+            .collect()
+    }
+
+    // I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
+    // let's just play along for now
+    fn prepare_reconstructed_text(
+        &self,
+        reconstructed_messages: Vec<ReconstructedMessage>,
+    ) -> Vec<Result<WsMessage, WsError>> {
+        reconstructed_messages
+            .into_iter()
+            .map(ServerResponse::Received)
+            .map(|resp| Ok(WsMessage::Text(resp.into_text())))
+            .collect()
+    }
+
    async fn push_websocket_received_plaintexts(
        &mut self,
        reconstructed_messages: Vec<ReconstructedMessage>,
@@ -223,8 +193,10 @@ impl Handler {
        // if it's text or binary, but for time being we use the naive assumption that if
        // client is sending Message::Text it expects text back. Same for Message::Binary
        let response_messages = match self.received_response_type {
-            ReceivedResponseType::Binary => prepare_reconstructed_binary(reconstructed_messages),
-            ReceivedResponseType::Text => prepare_reconstructed_text(reconstructed_messages),
+            ReceivedResponseType::Binary => {
+                self.prepare_reconstructed_binary(reconstructed_messages)
+            }
+            ReceivedResponseType::Text => self.prepare_reconstructed_text(reconstructed_messages),
        };

        let mut send_stream = futures::stream::iter(response_messages);
@@ -272,7 +244,7 @@ impl Handler {
                        break;
                    }

-                    if let Some(response) = self.handle_ws_request(socket_msg).await {
+                    if let Some(response) = self.handle_ws_request(socket_msg) {
                        if let Err(err) = self.send_websocket_response(response).await {
                            warn!(
                                "Failed to send message over websocket: {}. Assuming the connection is dead.",
@@ -319,27 +291,3 @@ impl Handler {
        self.listen_for_requests(reconstructed_receiver).await;
    }
 }
-
-// I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
-// let's just play along for now
-fn prepare_reconstructed_binary(
-    reconstructed_messages: Vec<ReconstructedMessage>,
-) -> Vec<Result<WsMessage, WsError>> {
-    reconstructed_messages
-        .into_iter()
-        .map(ServerResponse::Received)
-        .map(|resp| Ok(WsMessage::Binary(resp.into_binary())))
-        .collect()
-}
-
-// I'm still not entirely sure why `send_all` requires `TryStream` rather than `Stream`, but
-// let's just play along for now
-fn prepare_reconstructed_text(
-    reconstructed_messages: Vec<ReconstructedMessage>,
-) -> Vec<Result<WsMessage, WsError>> {
-    reconstructed_messages
-        .into_iter()
-        .map(ServerResponse::Received)
-        .map(|resp| Ok(WsMessage::Text(resp.into_text())))
-        .collect()
-}
@@ -20,12 +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;
-
-/// Value tag representing [`GetLaneQueueLength`] variant of the [`ClientRequest`]
-pub const GET_LANE_QUEUE_LENGHT_TAG: u8 = 0x04;
-
 #[allow(non_snake_case)]
 #[derive(Debug)]
 pub enum ClientRequest {
@@ -34,42 +28,32 @@ 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),
-    GetLaneQueueLength(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()
    }

-    // SEND_REQUEST_TAG || with_reply || recipient || conn_id || data_len || data
+    // SEND_REQUEST_TAG || with_reply || recipient || data_len || data
    fn deserialize_send(b: &[u8]) -> Result<Self, error::Error> {
-        // we need to have at least 1 (tag) + 1 (reply flag) + Recipient::LEN + 2*sizeof<u64> bytes
-        if b.len() < 2 + Recipient::LEN + 2 * size_of::<u64>() {
+        // we need to have at least 1 (tag) + 1 (reply flag) + Recipient::LEN + sizeof<u64> bytes
+        if b.len() < 2 + Recipient::LEN + size_of::<u64>() {
            return Err(error::Error::new(
                ErrorKind::TooShortRequest,
                "not enough data provided to recover 'send'".to_string(),
@@ -102,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,
@@ -126,12 +104,11 @@ impl ClientRequest {
            with_reply_surb,
            recipient,
            message: data.to_vec(),
-            connection_id,
        })
    }

    // REPLY_REQUEST_TAG || surb_len || surb || message_len || message
-    fn serialize_reply(message: Vec<u8>, reply_surb: &ReplySurb) -> Vec<u8> {
+    fn serialize_reply(message: Vec<u8>, reply_surb: ReplySurb) -> Vec<u8> {
        let reply_surb_bytes = reply_surb.to_bytes();
        let surb_len_bytes = (reply_surb_bytes.len() as u64).to_be_bytes();
        let message_len_bytes = (message.len() as u64).to_be_bytes();
@@ -225,65 +202,20 @@ 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().copied())
-            .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)
-    }
-
-    // GET_LANE_QUEUE_LENGHT_TAG
-    fn serialize_get_lane_queue_lengths(connection_id: u64) -> Vec<u8> {
-        let conn_id_bytes = connection_id.to_be_bytes();
-        std::iter::once(GET_LANE_QUEUE_LENGHT_TAG)
-            .chain(conn_id_bytes.iter().copied())
-            .collect()
-    }
-
-    // GET_LANE_QUEUE_LENGHT_TAG
-    fn deserialize_get_lane_queue_length(b: &[u8]) -> Self {
-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], GET_LANE_QUEUE_LENGHT_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::GetLaneQueueLength(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,
                reply_surb,
-            } => Self::serialize_reply(message, &reply_surb),
+            } => Self::serialize_reply(message, reply_surb),

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

@@ -313,17 +245,15 @@ 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)),
-            GET_LANE_QUEUE_LENGHT_TAG => Ok(Self::deserialize_get_lane_queue_length(b)),
            n => Err(error::Error::new(
                ErrorKind::UnknownRequest,
-                format!("type {n}"),
+                format!("type {}", n),
            )),
        }
    }

-    pub fn try_from_binary(raw_req: &[u8]) -> Result<Self, error::Error> {
-        Self::deserialize(raw_req)
+    pub fn try_from_binary(raw_req: Vec<u8>) -> Result<Self, error::Error> {
+        Self::deserialize(&raw_req)
    }

    pub fn try_from_text(raw_req: String) -> Result<Self, error::Error> {
@@ -350,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();
@@ -360,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!(),
        }
@@ -374,7 +301,6 @@ mod tests {
            recipient,
            message: b"foomp".to_vec(),
            with_reply_surb: true,
-            connection_id: 213,
        };

        let bytes = send_request_surb.serialize();
@@ -384,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!(),
        }
@@ -428,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!(),
-        }
-    }
 }
@@ -23,14 +23,10 @@ pub const RECEIVED_RESPONSE_TAG: u8 = 0x01;
 /// Value tag representing [`SelfAddress`] variant of the [`ServerResponse`]
 pub const SELF_ADDRESS_RESPONSE_TAG: u8 = 0x02;

-/// Value tag representing [`LaneQueueLength`] variant of the [`ServerResponse`]
-pub const LANE_QUEUE_LENGTH_RESPONSE_TAG: u8 = 0x03;
-
 #[derive(Debug)]
 pub enum ServerResponse {
    Received(ReconstructedMessage),
    SelfAddress(Recipient),
-    LaneQueueLength(u64, usize),
    Error(error::Error),
 }

@@ -197,31 +193,6 @@ impl ServerResponse {
        Ok(ServerResponse::SelfAddress(recipient))
    }

-    // LANE_QUEUE_LENGTH_RESPONSE_TAG || lane || queue_length
-    fn serialize_lane_queue_length(lane: u64, queue_length: usize) -> Vec<u8> {
-        std::iter::once(LANE_QUEUE_LENGTH_RESPONSE_TAG)
-            .chain(lane.to_be_bytes().iter().cloned())
-            .chain(queue_length.to_be_bytes().iter().cloned())
-            .collect()
-    }
-
-    // LANE_QUEUE_LENGTH_RESPONSE_TAG || lane || queue_length
-    fn deserialize_lane_queue_length(b: &[u8]) -> Result<Self, error::Error> {
-        // this MUST match because it was called by 'deserialize'
-        debug_assert_eq!(b[0], LANE_QUEUE_LENGTH_RESPONSE_TAG);
-
-        let mut lane_bytes = [0u8; size_of::<u64>()];
-        lane_bytes.copy_from_slice(&b[1..=size_of::<u64>()]);
-        let lane = u64::from_be_bytes(lane_bytes);
-
-        let mut queue_length_bytes = [0u8; size_of::<usize>()];
-        queue_length_bytes
-            .copy_from_slice(&b[1 + size_of::<u64>()..1 + size_of::<u64>() + size_of::<usize>()]);
-        let queue_length = usize::from_be_bytes(queue_length_bytes);
-
-        Ok(ServerResponse::LaneQueueLength(lane, queue_length))
-    }
-
    // ERROR_RESPONSE_TAG || err_code || msg_len || msg
    fn serialize_error(error: error::Error) -> Vec<u8> {
        let message_len_bytes = (error.message.len() as u64).to_be_bytes();
@@ -301,9 +272,6 @@ impl ServerResponse {
                Self::serialize_received(reconstructed_message)
            }
            ServerResponse::SelfAddress(address) => Self::serialize_self_address(address),
-            ServerResponse::LaneQueueLength(lane, queue_length) => {
-                Self::serialize_lane_queue_length(lane, queue_length)
-            }
            ServerResponse::Error(err) => Self::serialize_error(err),
        }
    }
@@ -334,7 +302,6 @@ impl ServerResponse {
        match response_tag {
            RECEIVED_RESPONSE_TAG => Self::deserialize_received(b),
            SELF_ADDRESS_RESPONSE_TAG => Self::deserialize_self_address(b),
-            LANE_QUEUE_LENGTH_RESPONSE_TAG => Self::deserialize_lane_queue_length(b),
            ERROR_RESPONSE_TAG => Self::deserialize_error(b),
            n => Err(error::Error::new(
                ErrorKind::UnknownResponse,
@@ -411,20 +378,6 @@ mod tests {
        }
    }

-    #[test]
-    fn lane_queue_length_response_serialization_works() {
-        let lane_queue_length_response = ServerResponse::LaneQueueLength(13, 42);
-        let bytes = lane_queue_length_response.serialize();
-        let recovered = ServerResponse::deserialize(&bytes).unwrap();
-        match recovered {
-            ServerResponse::LaneQueueLength(lane, queue_length) => {
-                assert_eq!(lane, 13);
-                assert_eq!(queue_length, 42)
-            }
-            _ => unreachable!(),
-        }
-    }
-
    #[test]
    fn error_response_serialization_works() {
        let dummy_error = error::Error::new(ErrorKind::UnknownRequest, "foomp message".to_string());
@@ -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),
@@ -94,10 +91,6 @@ pub(super) enum ServerResponseText {
    SelfAddress {
        address: String,
    },
-    LaneQueueLength {
-        lane: u64,
-        queue_length: usize,
-    },
    Error {
        message: String,
    },
@@ -139,9 +132,6 @@ impl From<ServerResponse> for ServerResponseText {
            ServerResponse::SelfAddress(recipient) => ServerResponseText::SelfAddress {
                address: recipient.to_string(),
            },
-            ServerResponse::LaneQueueLength(lane, queue_length) => {
-                ServerResponseText::LaneQueueLength { lane, queue_length }
-            }
            ServerResponse::Error(err) => ServerResponseText::Error {
                message: err.to_string(),
            },
@@ -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" }
@@ -46,7 +43,6 @@ task = { path = "../../common/task" }
 topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nymd-client"] }
 version-checker = { path = "../../common/version-checker" }
-tap = "1.0.1"

 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut", "credentials/coconut", "client-core/coconut"]
@@ -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, LaneQueueLengths};
 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,7 +36,7 @@ use gateway_client::{
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
-use tap::TapFallible;
+use nymsphinx::params::PacketSize;
 use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};

 pub mod config;
@@ -104,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,
@@ -120,8 +117,6 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        closed_connection_rx: ClosedConnectionReceiver,
-        lane_queue_lengths: LaneQueueLengths,
        shutdown: ShutdownListener,
    ) {
        let mut controller_config = client_core::client::real_messages_control::Config::new(
@@ -137,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...");
@@ -151,8 +145,6 @@ impl NymClient {
            mix_sender,
            topology_accessor,
            reply_key_storage,
-            lane_queue_lengths,
-            closed_connection_rx,
        )
        .start_with_shutdown(shutdown);
    }
@@ -241,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(),
@@ -256,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)
@@ -273,21 +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,
-        lane_queue_lengths: LaneQueueLengths,
        shutdown: ShutdownListener,
    ) {
        info!("Starting socks5 listener...");
@@ -300,19 +288,14 @@ impl NymClient {
            authenticator,
            self.config.get_provider_mix_address(),
            self.as_mix_recipient(),
-            lane_queue_lengths,
            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");
@@ -323,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);
@@ -357,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();
@@ -375,7 +358,7 @@ impl NymClient {
        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();

        // channels responsible for controlling real messages
-        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
+        let (input_sender, input_receiver) = mpsc::unbounded::<InputMessage>();

        // channels responsible for controlling ack messages
        let (ack_sender, ack_receiver) = mpsc::unbounded();
@@ -383,10 +366,7 @@ impl NymClient {

        let reply_key_storage =
            ReplyKeyStorage::load(self.config.get_base().get_reply_encryption_key_store_path())
-                .tap_err(|err| {
-                    log::error!("Failed to load reply key storage - is it perhaps already in use?");
-                    log::error!("{}", err);
-                })?;
+                .expect("Failed to load reply key storage!");

        // Shutdown notifier for signalling tasks to stop
        let shutdown = ShutdownNotifier::default();
@@ -394,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,
@@ -406,29 +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();
-
-        // Shared queue length data. Published by the `OutQueueController` in the client, and used
-        // primarily to throttle incoming connections
-        let shared_lane_queue_lengths = LaneQueueLengths::new();
-
+        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,
-            shared_lane_queue_lengths.clone(),
            shutdown.subscribe(),
        );

@@ -447,14 +415,12 @@ impl NymClient {
        self.start_socks5_listener(
            received_buffer_request_sender,
            input_sender,
-            closed_connection_tx,
-            shared_lane_queue_lengths,
            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,25 +0,0 @@
-use client_core::{client::reply_key_storage::ReplyKeyStorageError, 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("Reply key storage error: {0}")]
-    ReplyKeyStorageError(#[from] ReplyKeyStorageError),
-
-    #[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::{LaneQueueLengths, 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::*;
@@ -141,7 +141,6 @@ pub(crate) struct SocksClient {
    service_provider: Recipient,
    self_address: Recipient,
    started_proxy: bool,
-    lane_queue_lengths: LaneQueueLengths,
    shutdown_listener: ShutdownListener,
 }

@@ -159,7 +158,6 @@ impl Drop for SocksClient {

 impl SocksClient {
    /// Create a new SOCKClient
-    #[allow(clippy::too_many_arguments)]
    pub fn new(
        stream: TcpStream,
        authenticator: Authenticator,
@@ -167,7 +165,6 @@ impl SocksClient {
        service_provider: Recipient,
        controller_sender: ControllerSender,
        self_address: Recipient,
-        lane_queue_lengths: LaneQueueLengths,
        shutdown_listener: ShutdownListener,
    ) -> Self {
        let connection_id = Self::generate_random();
@@ -182,7 +179,6 @@ impl SocksClient {
            service_provider,
            self_address,
            started_proxy: false,
-            lane_queue_lengths,
            shutdown_listener,
        }
    }
@@ -234,15 +230,8 @@ impl SocksClient {
        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),
-        );
-        if self.input_sender.send(input_message).await.is_err() {
-            panic!();
-        }
+        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) {
@@ -265,14 +254,12 @@ impl SocksClient {
            conn_receiver,
            input_sender,
            connection_id,
-            Some(self.lane_queue_lengths.clone()),
            self.shutdown_listener.clone(),
        )
        .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, LaneQueueLengths};
 use client_core::client::{
    inbound_messages::InputMessageSender, received_buffer::ReceivedBufferRequestSender,
 };
@@ -21,7 +20,6 @@ pub struct SphinxSocksServer {
    listening_address: SocketAddr,
    service_provider: Recipient,
    self_address: Recipient,
-    lane_queue_lengths: LaneQueueLengths,
    shutdown: ShutdownListener,
 }

@@ -32,7 +30,6 @@ impl SphinxSocksServer {
        authenticator: Authenticator,
        service_provider: Recipient,
        self_address: Recipient,
-        lane_queue_lengths: LaneQueueLengths,
        shutdown: ShutdownListener,
    ) -> Self {
        // hardcode ip as we (presumably) ONLY want to listen locally. If we change it, we can
@@ -44,7 +41,6 @@ impl SphinxSocksServer {
            listening_address: format!("{}:{}", ip, port).parse().unwrap(),
            service_provider,
            self_address,
-            lane_queue_lengths,
            shutdown,
        }
    }
@@ -55,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, false, self.shutdown.clone());
+            Controller::new(self.shutdown.clone());
        tokio::spawn(async move {
            active_streams_controller.run().await;
        });
@@ -88,7 +83,6 @@ impl SphinxSocksServer {
                        self.service_provider,
                        controller_sender.clone(),
                        self.self_address,
-                        self.lane_queue_lengths.clone(),
                        self.shutdown.clone(),
                    );

@@ -1,7 +1,7 @@
 [package]
 name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
-version = "1.1.0"
+version = "1.0.0"
 edition = "2021"
 keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"
@@ -19,18 +19,16 @@ coconut = ["coconut-interface", "credentials", "gateway-client/coconut"]

 [dependencies]
 futures = "0.3"
-js-sys = "0.3"
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 serde-wasm-bindgen = "0.4"
-tokio = { version = "1.21.2", features = ["sync"] }
-url = "2.2"
 wasm-bindgen = { version = "=0.2.83", features = ["serde-serialize"]  }
 wasm-bindgen-futures = "0.4"
+js-sys = "0.3"
+rand = { version = "0.7.3", features = ["wasm-bindgen"] }
+url = "2.2"

 # internal
 client-core = { path = "../client-core", default-features = false, features = ["wasm"] }
-client-connections = { path = "../../common/client-connections" }
 coconut-interface = { path = "../../common/coconut-interface", optional = true }
 credentials = { path = "../../common/credentials", optional = true }
 crypto = { path = "../../common/crypto" }
@@ -57,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, LaneQueueLengths, 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,8 +123,6 @@ impl NymClient {
        ack_receiver: AcknowledgementReceiver,
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
-        closed_connection_rx: ClosedConnectionReceiver,
-        lane_queue_lengths: LaneQueueLengths,
    ) {
        let mut controller_config = real_messages_control::Config::new(
            self.key_manager.ack_key(),
@@ -142,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...");
@@ -154,8 +147,6 @@ impl NymClient {
            input_receiver,
            mix_sender,
            topology_accessor,
-            lane_queue_lengths,
-            closed_connection_rx,
        )
        .start();
    }
@@ -262,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
@@ -276,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();
@@ -291,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)")
                        }
@@ -306,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)
                }
            }
        });
@@ -318,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();
@@ -326,16 +320,12 @@ impl NymClient {
        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();

        // channels responsible for controlling real messages
-        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
+        let (input_sender, input_receiver) = mpsc::unbounded::<InputMessage>();

        // channels responsible for controlling ack messages
        let (ack_sender, ack_receiver) = mpsc::unbounded();
        let shared_topology_accessor = TopologyAccessor::new();

-        // 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())
@@ -349,23 +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);
-
-        // Shared queue length data. Published by the `OutQueueController` in the client, and used
-        // primarily to throttle incoming connections
-        let shared_lane_queue_lengths = LaneQueueLengths::new();
-
+        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,
-            shared_lane_queue_lengths,
        );

        if !self.config.debug.disable_loop_cover_traffic_stream {
@@ -391,20 +370,14 @@ 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);

-        if self
-            .input_tx
+        self.input_tx
            .as_ref()
            .expect("start method was not called before!")
-            .send(input_msg)
-            .await
-            .is_err()
-        {
-            panic!();
-        }
+            .unbounded_send(input_msg)
+            .unwrap();

        self
    }
@@ -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,10 +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"
-log = "0.4.17"
@@ -1,113 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::collections::HashMap;
-
-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<ConnectionCommand>;
-pub type ClosedConnectionReceiver = mpsc::UnboundedReceiver<ConnectionCommand>;
-
-pub enum ConnectionCommand {
-    // Announce that at a connection was closed. E.g the `OutQueueControl` uses this to discard
-    // transmission lanes.
-    Close(ConnectionId),
-
-    // In the network requester for example, we usually want to broadcast active connections
-    // regularly, so we know what connections we need to request lane queue lengths for from the
-    // client.
-    // In the socks5-client, this is not needed since have direct access to the lane queue lengths.
-    ActiveConnections(Vec<ConnectionId>),
-}
-
-// The `OutQueueControl` publishes the backlog per lane, primarily so that upstream can slow down
-// if needed.
-#[derive(Clone, Debug)]
-pub struct LaneQueueLengths(std::sync::Arc<std::sync::Mutex<LaneQueueLengthsInner>>);
-
-impl LaneQueueLengths {
-    pub fn new() -> Self {
-        LaneQueueLengths(std::sync::Arc::new(std::sync::Mutex::new(
-            LaneQueueLengthsInner {
-                map: HashMap::new(),
-            },
-        )))
-    }
-
-    pub fn set(&mut self, lane: &TransmissionLane, lane_length: Option<usize>) {
-        match self.0.lock() {
-            Ok(mut inner) => {
-                if let Some(length) = lane_length {
-                    inner
-                        .map
-                        .entry(*lane)
-                        .and_modify(|e| *e = length)
-                        .or_insert(length);
-                } else {
-                    inner.map.remove(lane);
-                }
-            }
-            Err(err) => log::warn!("Failed to set lane queue length: {err}"),
-        }
-    }
-
-    pub fn get(&self, lane: &TransmissionLane) -> Option<usize> {
-        match self.0.lock() {
-            Ok(inner) => inner.get(lane),
-            Err(err) => {
-                log::warn!("Failed to get lane queue length: {err}");
-                None
-            }
-        }
-    }
-}
-
-impl Default for LaneQueueLengths {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl std::ops::Deref for LaneQueueLengths {
-    type Target = std::sync::Arc<std::sync::Mutex<LaneQueueLengthsInner>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-#[derive(Debug)]
-pub struct LaneQueueLengthsInner {
-    pub map: HashMap<TransmissionLane, usize>,
-}
-
-impl LaneQueueLengthsInner {
-    pub fn get(&self, lane: &TransmissionLane) -> Option<usize> {
-        self.map.get(lane).copied()
-    }
-
-    pub fn values(&self) -> impl Iterator<Item = &usize> {
-        self.map.values()
-    }
-
-    pub fn modify<F>(&mut self, lane: &TransmissionLane, f: F)
-    where
-        F: FnOnce(&mut usize),
-    {
-        self.map.entry(*lane).and_modify(f);
-    }
-}
@@ -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();
@@ -11,9 +11,6 @@ rust-version = "1.56"
 base64 = "0.13"
 colored = "2.0"
 cw3 = "0.13.1"
-
-coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
 mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract" }
 vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
 coconut-bandwidth-contract-common = { path= "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
@@ -2,8 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::{validator_api, ValidatorClientError};
-use coconut_dkg_common::dealer::ContractDealing;
-use coconut_dkg_common::types::DealerDetails;
 use mixnet_contract_common::mixnode::MixNodeDetails;
 use mixnet_contract_common::MixId;
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef};
@@ -18,7 +16,7 @@ use validator_api_requests::models::{
 };

 #[cfg(feature = "nymd-client")]
-use crate::nymd::traits::{DkgQueryClient, MixnetQueryClient};
+use crate::nymd::traits::MixnetQueryClient;
 #[cfg(feature = "nymd-client")]
 use crate::nymd::{self, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient};
 #[cfg(feature = "nymd-client")]
@@ -45,7 +43,6 @@ pub struct Config {
    gateway_page_limit: Option<u32>,
    mixnode_delegations_page_limit: Option<u32>,
    rewarded_set_page_limit: Option<u32>,
-    dealers_page_limit: Option<u32>,
 }

 #[cfg(feature = "nymd-client")]
@@ -75,7 +72,6 @@ impl Config {
            gateway_page_limit: None,
            mixnode_delegations_page_limit: None,
            rewarded_set_page_limit: None,
-            dealers_page_limit: None,
        })
    }

@@ -123,7 +119,6 @@ pub struct Client<C> {
    gateway_page_limit: Option<u32>,
    mixnode_delegations_page_limit: Option<u32>,
    rewarded_set_page_limit: Option<u32>,
-    dealers_page_limit: Option<u32>,

    // ideally they would have been read-only, but unfortunately rust doesn't have such features
    pub validator_api: validator_api::Client,
@@ -150,7 +145,6 @@ impl Client<SigningNymdClient> {
            gateway_page_limit: config.gateway_page_limit,
            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
            rewarded_set_page_limit: config.rewarded_set_page_limit,
-            dealers_page_limit: config.dealers_page_limit,
            validator_api: validator_api_client,
            nymd: nymd_client,
        })
@@ -184,7 +178,6 @@ impl Client<QueryNymdClient> {
            gateway_page_limit: config.gateway_page_limit,
            mixnode_delegations_page_limit: config.mixnode_delegations_page_limit,
            rewarded_set_page_limit: config.rewarded_set_page_limit,
-            dealers_page_limit: config.dealers_page_limit,
            validator_api: validator_api_client,
            nymd: nymd_client,
        })
@@ -526,82 +519,6 @@ impl<C> Client<C> {

        Ok(events)
    }
-
-    pub async fn get_all_nymd_current_dealers(
-        &self,
-    ) -> Result<Vec<DealerDetails>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut dealers = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nymd
-                .get_current_dealers_paged(start_after.take(), self.dealers_page_limit)
-                .await?;
-            dealers.append(&mut paged_response.dealers);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res.into_string())
-            } else {
-                break;
-            }
-        }
-
-        Ok(dealers)
-    }
-
-    pub async fn get_all_nymd_past_dealers(
-        &self,
-    ) -> Result<Vec<DealerDetails>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut dealers = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nymd
-                .get_past_dealers_paged(start_after.take(), self.dealers_page_limit)
-                .await?;
-            dealers.append(&mut paged_response.dealers);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res.into_string())
-            } else {
-                break;
-            }
-        }
-
-        Ok(dealers)
-    }
-
-    pub async fn get_all_nymd_epoch_dealings(
-        &self,
-        idx: usize,
-    ) -> Result<Vec<ContractDealing>, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync + Send,
-    {
-        let mut dealings = Vec::new();
-        let mut start_after = None;
-        loop {
-            let mut paged_response = self
-                .nymd
-                .get_dealings_paged(idx, start_after.take(), self.dealers_page_limit)
-                .await?;
-            dealings.append(&mut paged_response.dealings);
-
-            if let Some(start_after_res) = paged_response.start_next_after {
-                start_after = Some(start_after_res.into_string())
-            } else {
-                break;
-            }
-        }
-
-        Ok(dealings)
-    }
 }

 // validator-api wrappers
@@ -6,9 +6,6 @@ use cosmrs::tendermint::abci;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};

-pub use coconut_bandwidth_contract_common::event_attributes::*;
-pub use coconut_dkg_common::event_attributes::*;
-
 // it seems that currently validators just emit stringified events (which are also returned as part of deliverTx response)
 // as theirs logs
 #[derive(Debug, Serialize, Deserialize)]
@@ -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;
@@ -65,7 +66,6 @@ pub struct Config {
    pub(crate) bandwidth_claim_contract_address: Option<AccountId>,
    pub(crate) coconut_bandwidth_contract_address: Option<AccountId>,
    pub(crate) multisig_contract_address: Option<AccountId>,
-    pub(crate) coconut_dkg_contract_address: Option<AccountId>,
    // TODO: add this in later commits
    // pub(crate) gas_price: GasPrice,
 }
@@ -119,10 +119,6 @@ impl Config {
                details.contracts.multisig_contract_address.as_ref(),
                prefix,
            )?,
-            coconut_dkg_contract_address: Self::parse_optional_account(
-                details.contracts.coconut_dkg_contract_address.as_ref(),
-                prefix,
-            )?,
        })
    }
 }
@@ -280,14 +276,6 @@ impl<C> NymdClient<C> {
        self.config.multisig_contract_address.as_ref().unwrap()
    }

-    // TODO: this should get changed into Result<&AccountId, NymdError> (or Option<&AccountId> in future commits
-    // note: what unwrap is doing here is just moving a failure that would have normally
-    // occurred in `connect` when attempting to parse an empty address,
-    // so it's not introducing new source of failure (just moves it)
-    pub fn coconut_dkg_contract_address(&self) -> &AccountId {
-        self.config.coconut_dkg_contract_address.as_ref().unwrap()
-    }
-
    pub fn set_simulated_gas_multiplier(&mut self, multiplier: f32) {
        self.simulated_gas_multiplier = multiplier;
    }
@@ -494,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,
@@ -739,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)
    }
 }
@@ -1,114 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nymd::error::NymdError;
-use crate::nymd::{CosmWasmClient, NymdClient};
-use async_trait::async_trait;
-use coconut_dkg_common::dealer::{
-    DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
-};
-use coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
-use coconut_dkg_common::types::{EpochState, MinimumDepositResponse};
-use cosmrs::AccountId;
-
-#[async_trait]
-pub trait DkgQueryClient {
-    async fn get_current_epoch_state(&self) -> Result<EpochState, NymdError>;
-    async fn get_dealer_details(
-        &self,
-        address: &AccountId,
-    ) -> Result<DealerDetailsResponse, NymdError>;
-    async fn get_current_dealers_paged(
-        &self,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedDealerResponse, NymdError>;
-    async fn get_past_dealers_paged(
-        &self,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedDealerResponse, NymdError>;
-
-    async fn get_deposit_amount(&self) -> Result<MinimumDepositResponse, NymdError>;
-    async fn get_dealings_paged(
-        &self,
-        idx: usize,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedDealingsResponse, NymdError>;
-}
-
-#[async_trait]
-impl<C> DkgQueryClient for NymdClient<C>
-where
-    C: CosmWasmClient + Send + Sync,
-{
-    async fn get_current_epoch_state(&self) -> Result<EpochState, NymdError> {
-        let request = DkgQueryMsg::GetCurrentEpochState {};
-        self.client
-            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
-            .await
-    }
-    async fn get_dealer_details(
-        &self,
-        address: &AccountId,
-    ) -> Result<DealerDetailsResponse, NymdError> {
-        let request = DkgQueryMsg::GetDealerDetails {
-            dealer_address: address.to_string(),
-        };
-        self.client
-            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
-            .await
-    }
-
-    async fn get_current_dealers_paged(
-        &self,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedDealerResponse, NymdError> {
-        let request = DkgQueryMsg::GetCurrentDealers {
-            start_after,
-            limit: page_limit,
-        };
-        self.client
-            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
-            .await
-    }
-
-    async fn get_past_dealers_paged(
-        &self,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedDealerResponse, NymdError> {
-        let request = DkgQueryMsg::GetPastDealers {
-            start_after,
-            limit: page_limit,
-        };
-        self.client
-            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
-            .await
-    }
-
-    async fn get_deposit_amount(&self) -> Result<MinimumDepositResponse, NymdError> {
-        let request = DkgQueryMsg::GetDepositAmount {};
-        self.client
-            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
-            .await
-    }
-
-    async fn get_dealings_paged(
-        &self,
-        idx: usize,
-        start_after: Option<String>,
-        page_limit: Option<u32>,
-    ) -> Result<PagedDealingsResponse, NymdError> {
-        let request = DkgQueryMsg::GetDealing {
-            idx: idx as u64,
-            limit: page_limit,
-            start_after,
-        };
-        self.client
-            .query_contract_smart(self.coconut_dkg_contract_address(), &request)
-            .await
-    }
-}
@@ -1,73 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nymd::cosmwasm_client::types::ExecuteResult;
-use crate::nymd::error::NymdError;
-use crate::nymd::traits::dkg_query_client::DkgQueryClient;
-use crate::nymd::{Fee, NymdClient, SigningCosmWasmClient};
-use async_trait::async_trait;
-use coconut_dkg_common::msg::ExecuteMsg as DkgExecuteMsg;
-use coconut_dkg_common::types::EncodedBTEPublicKeyWithProof;
-use contracts_common::dealings::ContractSafeBytes;
-
-#[async_trait]
-pub trait DkgSigningClient {
-    async fn register_dealer(
-        &self,
-        bte_key: EncodedBTEPublicKeyWithProof,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn submit_dealing_bytes(
-        &self,
-        commitment: ContractSafeBytes,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError>;
-}
-
-#[async_trait]
-impl<C> DkgSigningClient for NymdClient<C>
-where
-    C: SigningCosmWasmClient + Send + Sync,
-{
-    async fn register_dealer(
-        &self,
-        bte_key: EncodedBTEPublicKeyWithProof,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        let req = DkgExecuteMsg::RegisterDealer {
-            bte_key_with_proof: bte_key,
-        };
-        let deposit = self.get_deposit_amount().await?;
-
-        self.client
-            .execute(
-                self.address(),
-                self.coconut_dkg_contract_address(),
-                &req,
-                fee.unwrap_or_default(),
-                format!("registering {} as a dealer", self.address()),
-                vec![deposit.amount.into()],
-            )
-            .await
-    }
-
-    async fn submit_dealing_bytes(
-        &self,
-        dealing_bytes: ContractSafeBytes,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NymdError> {
-        let req = DkgExecuteMsg::CommitDealing { dealing_bytes };
-
-        self.client
-            .execute(
-                self.address(),
-                self.coconut_dkg_contract_address(),
-                &req,
-                fee.unwrap_or_default(),
-                "dealing commitment",
-                vec![],
-            )
-            .await
-    }
-}
@@ -3,8 +3,6 @@

 mod coconut_bandwidth_query_client;
 mod coconut_bandwidth_signing_client;
-mod dkg_query_client;
-mod dkg_signing_client;
 mod mixnet_query_client;
 mod mixnet_signing_client;
 mod multisig_query_client;
@@ -14,8 +12,6 @@ mod vesting_signing_client;

 pub use coconut_bandwidth_query_client::CoconutBandwidthQueryClient;
 pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
-pub use dkg_query_client::DkgQueryClient;
-pub use dkg_signing_client::DkgSigningClient;
 pub use mixnet_query_client::MixnetQueryClient;
 pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_query_client::MultisigQueryClient;
@@ -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";
@@ -9,7 +9,7 @@ use crate::utils::{pretty_cosmwasm_coin, show_error_passthrough};

 use comfy_table::Table;
 use cosmwasm_std::Addr;
-use mixnet_contract_common::{Delegation, PendingEpochEvent, PendingEpochEventKind};
+use mixnet_contract_common::{Delegation, PendingEpochEvent, PendingEpochEventData};

 #[derive(Debug, Parser)]
 pub struct Args {}
@@ -90,8 +90,8 @@ async fn print_delegation_events(
    ]);

    for event in events {
-        match event.event.kind {
-            PendingEpochEventKind::Delegate {
+        match event.event {
+            PendingEpochEventData::Delegate {
                owner,
                mix_id,
                amount,
@@ -107,7 +107,7 @@ async fn print_delegation_events(
                    ]);
                }
            }
-            PendingEpochEventKind::Undelegate {
+            PendingEpochEventData::Undelegate {
                owner,
                mix_id,
                proxy,
@@ -13,7 +13,7 @@ use validator_client::nymd::wallet::DirectSecp256k1HdWallet;
 pub struct SignatureOutputJson {
    pub account_id: String,
    pub public_key: PublicKey,
-    pub signature_as_hex: String,
+    pub signature: String,
 }

 #[derive(Debug, Parser)]
@@ -46,7 +46,7 @@ pub fn sign(args: Args, prefix: &str, mnemonic: Option<bip39::Mnemonic>) {
                            let output = SignatureOutputJson {
                                account_id: account.address().to_string(),
                                public_key: account.public_key(),
-                                signature_as_hex: signature.to_string(),
+                                signature: signature.to_string(),
                            };
                            println!("{}", json!(output));
                        }
@@ -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
@@ -1,4 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub const PROPOSAL_ID: &str = "proposal_id";
@@ -1,5 +1,4 @@
 pub mod deposit;
-pub mod event_attributes;
 pub mod events;
 pub mod msg;
 pub mod spend_credential;
@@ -1,13 +0,0 @@
-[package]
-name = "coconut-dkg-common"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cosmwasm-std = "1.0.0"
-schemars = "0.8"
-serde = { version = "1.0.103", default-features = false, features = ["derive"] }
-
-contracts-common = { path = "../contracts-common" }
@@ -1,102 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, NodeIndex};
-use cosmwasm_std::{Addr, Coin};
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
-#[serde(rename_all = "snake_case")]
-pub struct DealerDetails {
-    pub address: Addr,
-    pub bte_public_key_with_proof: EncodedBTEPublicKeyWithProof,
-    pub assigned_index: NodeIndex,
-    pub deposit: Coin,
-}
-
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum DealerType {
-    Current,
-    Past,
-    Unknown,
-}
-
-impl DealerType {
-    pub fn is_current(&self) -> bool {
-        matches!(&self, DealerType::Current)
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub struct DealerDetailsResponse {
-    pub details: Option<DealerDetails>,
-    pub dealer_type: DealerType,
-}
-
-impl DealerDetailsResponse {
-    pub fn new(details: Option<DealerDetails>, dealer_type: DealerType) -> Self {
-        DealerDetailsResponse {
-            details,
-            dealer_type,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub struct PagedDealerResponse {
-    pub dealers: Vec<DealerDetails>,
-    pub per_page: usize,
-    pub start_next_after: Option<Addr>,
-}
-
-impl PagedDealerResponse {
-    pub fn new(
-        dealers: Vec<DealerDetails>,
-        per_page: usize,
-        start_next_after: Option<Addr>,
-    ) -> Self {
-        PagedDealerResponse {
-            dealers,
-            per_page,
-            start_next_after,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub struct ContractDealing {
-    pub dealing: ContractSafeBytes,
-    pub dealer: Addr,
-}
-
-impl ContractDealing {
-    pub fn new(dealing: ContractSafeBytes, dealer: Addr) -> Self {
-        ContractDealing { dealing, dealer }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub struct PagedDealingsResponse {
-    pub dealings: Vec<ContractDealing>,
-    pub per_page: usize,
-    pub start_next_after: Option<Addr>,
-}
-
-impl PagedDealingsResponse {
-    pub fn new(
-        dealings: Vec<ContractDealing>,
-        per_page: usize,
-        start_next_after: Option<Addr>,
-    ) -> Self {
-        PagedDealingsResponse {
-            dealings,
-            per_page,
-            start_next_after,
-        }
-    }
-}
@@ -1,4 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub const NODE_INDEX: &str = "node_index";
@@ -1,4 +0,0 @@
-pub mod dealer;
-pub mod event_attributes;
-pub mod msg;
-pub mod types;
@@ -1,60 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
-pub struct InstantiateMsg {
-    pub group_addr: String,
-    pub mix_denom: String,
-    pub admin: String,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, Eq, PartialEq, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum ExecuteMsg {
-    RegisterDealer {
-        bte_key_with_proof: EncodedBTEPublicKeyWithProof,
-    },
-
-    CommitDealing {
-        dealing_bytes: ContractSafeBytes,
-    },
-
-    AdvanceEpochState {},
-
-    // DEBUG ONLY TXs. THEY SHALL BE REMOVED BEFORE FINALISING THE CODE
-    // only exists for debugging purposes on local network to reset the entire state of the contract
-    DebugUnsafeResetAll {
-        init_msg: InstantiateMsg,
-    },
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub enum QueryMsg {
-    GetCurrentEpochState {},
-    GetDealerDetails {
-        dealer_address: String,
-    },
-    GetCurrentDealers {
-        limit: Option<u32>,
-        start_after: Option<String>,
-    },
-    GetPastDealers {
-        limit: Option<u32>,
-        start_after: Option<String>,
-    },
-    GetDepositAmount {},
-    GetDealing {
-        idx: u64,
-        limit: Option<u32>,
-        start_after: Option<String>,
-    },
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
-#[serde(rename_all = "snake_case")]
-pub struct MigrateMsg {}
@@ -1,87 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use serde::{Deserialize, Serialize};
-use std::fmt::{Display, Formatter};
-
-pub use crate::dealer::{DealerDetails, PagedDealerResponse};
-pub use contracts_common::dealings::ContractSafeBytes;
-pub use cosmwasm_std::{Addr, Coin};
-
-pub type EncodedBTEPublicKeyWithProof = String;
-pub type EncodedBTEPublicKeyWithProofRef<'a> = &'a str;
-pub type NodeIndex = u64;
-
-// 2 public attributes, 2 private attributes, 1 fixed for coconut credential
-pub const TOTAL_DEALINGS: usize = 2 + 2 + 1;
-
-// currently (it is still extremely likely to change, we might be able to get rid of verification key-related complaints),
-// the epoch can be in the following states (in order):
-// 1. PublicKeySubmission -> potential dealers are submitting their BTE and ed25519 public keys to participate in dealing exchange
-// 2. DealingExchange -> the actual (off-chain) dealing exchange is happening
-// 3. ComplaintSubmission -> receivers submitting evidence of other dealers sending malformed data
-// 4. ComplaintVoting -> (if any complaints were submitted) receivers voting on the validity of the evidence provided
-// 5. VerificationKeySubmission -> receivers submitting their partial (and master) verification keys
-// 6. VerificationKeyMismatchSubmission -> receivers / watchers raising issue that the submitted VK are mismatched with their local derivations
-// 7. VerificationKeyMismatchVoting -> (if any complaints were submitted) receivers voting on received mismatches
-// 8. InProgress -> all receivers have all their secrets derived and all is good
-//
-// Note: It's important that the variant ordering is not changed otherwise it would mess up the derived `PartialOrd`
-#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd)]
-#[serde(rename_all = "snake_case")]
-pub enum EpochState {
-    PublicKeySubmission,
-    DealingExchange,
-    VerificationKeySubmission,
-    InProgress,
-}
-
-impl Default for EpochState {
-    fn default() -> Self {
-        Self::PublicKeySubmission
-    }
-}
-
-impl Display for EpochState {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            EpochState::PublicKeySubmission => write!(f, "PublicKeySubmission"),
-            EpochState::DealingExchange => write!(f, "DealingExchange"),
-            EpochState::VerificationKeySubmission => write!(f, "VerificationKeySubmission"),
-            EpochState::InProgress => write!(f, "InProgress"),
-        }
-    }
-}
-
-impl EpochState {
-    pub fn next(self) -> Option<Self> {
-        match self {
-            EpochState::PublicKeySubmission => Some(EpochState::DealingExchange),
-            EpochState::DealingExchange => Some(EpochState::VerificationKeySubmission),
-            EpochState::VerificationKeySubmission => Some(EpochState::InProgress),
-            EpochState::InProgress => None,
-        }
-    }
-
-    pub fn all_until(&self, end: Self) -> Vec<Self> {
-        let mut states = vec![*self];
-        while states.last().unwrap() != &end {
-            let next_state = states.last().unwrap().next().expect("somehow reached the end of state diff -> this should be impossible under any circumstances!");
-            states.push(next_state);
-        }
-
-        states
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub struct MinimumDepositResponse {
-    pub amount: Coin,
-}
-
-impl MinimumDepositResponse {
-    pub fn new(amount: Coin) -> Self {
-        MinimumDepositResponse { amount }
-    }
-}
@@ -7,15 +7,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-bs58 = "0.4.0"
 cosmwasm-std = "1.0.0"
-dkg = { path = "../../../common/crypto/dkg", optional = true }
-schemars = "0.8"
 serde = { version = "1.0", features = ["derive"] }
-thiserror = "1"
-
-[dev-dependencies]
-serde_json = "1.0.0"
-
-[features]
-coconut = ["dkg"]
@@ -1,87 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#[cfg(feature = "coconut")]
-use dkg::{error::DkgError, Dealing};
-use schemars::JsonSchema;
-use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::fmt::{Display, Formatter};
-use std::ops::Deref;
-
-// some sane upper-bound size on byte sizes
-// currently set to 128 bytes
-pub const MAX_DISPLAY_SIZE: usize = 128;
-
-// TODO: if we are to use this for different types, it might make sense to introduce something like
-// CommitmentTypeId field on the below for distinguishing different ones. it would somehow become part of the trait
-#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, JsonSchema)]
-pub struct ContractSafeBytes(Vec<u8>);
-
-impl Deref for ContractSafeBytes {
-    type Target = Vec<u8>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl Display for ContractSafeBytes {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        if !self.0.is_empty() {
-            write!(f, "0x")?;
-        }
-        for byte in self.0.iter().take(MAX_DISPLAY_SIZE) {
-            write!(f, "{:02X}", byte)?;
-        }
-        // just some sanity safeguards
-        if self.0.len() > MAX_DISPLAY_SIZE {
-            write!(f, "...")?;
-        }
-        Ok(())
-    }
-}
-
-// since cosmwasm stores everything with byte representation of stringified json, it's actually more efficient
-// to serialize this as a string as opposed to keeping it as vector of bytes.
-// for example vec![255,255] would have string representation of "[255,255]" and will be serialized to
-// [91, 50, 53, 53, 44, 50, 53, 53, 93]. the equivalent base58 encoded string `"LUv"` will be serialized to
-// [34, 76, 85, 118, 34]
-//
-// the difference between base58 and base64 is rather minimal and I've gone with base58 for consistency sake
-impl Serialize for ContractSafeBytes {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        serializer.serialize_str(&bs58::encode(&self.0).into_string())
-    }
-}
-
-impl<'de> Deserialize<'de> for ContractSafeBytes {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let s = <String>::deserialize(deserializer)?;
-        let bytes = bs58::decode(&s)
-            .into_vec()
-            .map_err(serde::de::Error::custom)?;
-        Ok(ContractSafeBytes(bytes))
-    }
-}
-
-#[cfg(feature = "coconut")]
-impl<'a> From<&'a Dealing> for ContractSafeBytes {
-    fn from(dealing: &'a Dealing) -> Self {
-        ContractSafeBytes(dealing.to_bytes())
-    }
-}
-
-#[cfg(feature = "coconut")]
-impl<'a> TryFrom<&'a ContractSafeBytes> for Dealing {
-    type Error = DkgError;
-
-    fn try_from(value: &'a ContractSafeBytes) -> Result<Self, Self::Error> {
-        Dealing::try_from_bytes(&value.0)
-    }
-}
@@ -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,10 +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 dealings;
 pub mod events;
 pub mod types;

@@ -1,128 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use cosmwasm_std::Decimal;
-use cosmwasm_std::Uint128;
-use schemars::JsonSchema;
-use serde::de::Error;
-use serde::{Deserialize, Deserializer, Serialize};
-use std::fmt::{self, Display, Formatter};
-use std::ops::Mul;
-use std::str::FromStr;
-use thiserror::Error;
-
-pub fn truncate_decimal(amount: Decimal) -> Uint128 {
-    amount * Uint128::new(1)
-}
-
-#[derive(Error, Debug)]
-pub enum ContractsCommonError {
-    #[error("Provided percent value ({0}) is greater than 100%")]
-    InvalidPercent(Decimal),
-
-    #[error("{source}")]
-    StdErr {
-        #[from]
-        source: cosmwasm_std::StdError,
-    },
-}
-
-/// Percent represents a value between 0 and 100%
-/// (i.e. between 0.0 and 1.0)
-#[derive(
-    Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Serialize, Deserialize, JsonSchema,
-)]
-pub struct Percent(#[serde(deserialize_with = "de_decimal_percent")] Decimal);
-
-impl Percent {
-    pub fn new(value: Decimal) -> Result<Self, ContractsCommonError> {
-        if value > Decimal::one() {
-            Err(ContractsCommonError::InvalidPercent(value))
-        } else {
-            Ok(Percent(value))
-        }
-    }
-
-    pub fn is_zero(&self) -> bool {
-        self.0 == Decimal::zero()
-    }
-
-    pub fn zero() -> Self {
-        Self(Decimal::zero())
-    }
-
-    pub fn hundred() -> Self {
-        Self(Decimal::one())
-    }
-
-    pub fn from_percentage_value(value: u64) -> Result<Self, ContractsCommonError> {
-        Percent::new(Decimal::percent(value))
-    }
-
-    pub fn value(&self) -> Decimal {
-        self.0
-    }
-
-    pub fn round_to_integer(&self) -> u8 {
-        let hundred = Decimal::from_ratio(100u32, 1u32);
-        // we know the cast from u128 to u8 is a safe one since the internal value must be within 0 - 1 range
-        truncate_decimal(hundred * self.0).u128() as u8
-    }
-}
-
-impl Display for Percent {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        let adjusted = Decimal::from_ratio(100u32, 1u32) * self.0;
-        write!(f, "{}%", adjusted)
-    }
-}
-
-impl FromStr for Percent {
-    type Err = ContractsCommonError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Percent::new(Decimal::from_str(s)?)
-    }
-}
-
-impl Mul<Decimal> for Percent {
-    type Output = Decimal;
-
-    fn mul(self, rhs: Decimal) -> Self::Output {
-        self.0 * rhs
-    }
-}
-
-impl Mul<Percent> for Decimal {
-    type Output = Decimal;
-
-    fn mul(self, rhs: Percent) -> Self::Output {
-        rhs * self
-    }
-}
-
-impl Mul<Uint128> for Percent {
-    type Output = Uint128;
-
-    fn mul(self, rhs: Uint128) -> Self::Output {
-        self.0 * rhs
-    }
-}
-
-// implement custom Deserialize because we want to validate Percent has the correct range
-fn de_decimal_percent<'de, D>(deserializer: D) -> Result<Decimal, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let v = Decimal::deserialize(deserializer)?;
-    if v > Decimal::one() {
-        Err(D::Error::custom(
-            "provided decimal percent is larger than 100%",
-        ))
-    } else {
-        Ok(v)
-    }
-}
+use serde::{Deserialize, Serialize};

 // TODO: there's no reason this couldn't be used for proper binaries, but in that case
 // perhaps the struct should get renamed and moved to a "more" common crate
@@ -152,47 +31,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};

@@ -36,11 +34,13 @@ pub struct Delegation {
    pub owner: Addr,

    /// Id of the MixNode that this delegation was performed against.
+    #[serde(alias = "node_id")]
    pub mix_id: MixId,

    // Note to UI/UX devs: there's absolutely no point in displaying this value to the users,
    // it would serve them no purpose. It's only used for calculating rewards
    /// Value of the "unit delegation" associated with the mixnode at the time of delegation.
+    #[serde(alias = "crr")]
    pub cumulative_reward_ratio: Decimal,

    /// Original delegation amount. Note that it is never mutated as delegation accumulates rewards.
@@ -62,11 +62,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 +89,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,
@@ -4,7 +4,7 @@
 use crate::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
 use crate::reward_params::{IntervalRewardParams, IntervalRewardingParamsUpdate};
 use crate::rewarding::RewardDistribution;
-use crate::{BlockHeight, ContractStateParams, IdentityKeyRef, Interval, Layer, MixId};
+use crate::{ContractStateParams, IdentityKeyRef, Interval, Layer, MixId};
 pub use contracts_common::events::*;
 use cosmwasm_std::{Addr, Coin, Decimal, Event};

@@ -96,7 +96,7 @@ pub const PROXY_KEY: &str = "proxy";
 // delegation/undelegation
 pub const DELEGATOR_KEY: &str = "delegator";
 pub const DELEGATION_TARGET_KEY: &str = "delegation_target";
-pub const UNIT_REWARD_KEY: &str = "unit_reward";
+pub const DELEGATION_HEIGHT_KEY: &str = "delegation_latest_block_height";

 // bonding/unbonding
 pub const MIX_ID_KEY: &str = "mix_id";
@@ -120,45 +120,52 @@ pub const UPDATED_MIXNODE_COST_PARAMS_KEY: &str = "updated_mixnode_cost_params";

 // rewarding
 pub const INTERVAL_KEY: &str = "interval_details";
+pub const TOTAL_MIXNODE_REWARD_KEY: &str = "total_node_reward";
+pub const TOTAL_PLEDGE_KEY: &str = "pledge";
+pub const TOTAL_DELEGATIONS_KEY: &str = "delegated";
 pub const OPERATOR_REWARD_KEY: &str = "operator_reward";
 pub const DELEGATES_REWARD_KEY: &str = "delegates_reward";
 pub const APPROXIMATE_TIME_LEFT_SECS_KEY: &str = "approximate_time_left_secs";
 pub const INTERVAL_REWARDING_PARAMS_UPDATE_KEY: &str = "interval_rewarding_params_update";
 pub const UPDATED_INTERVAL_REWARDING_PARAMS_KEY: &str = "updated_interval_rewarding_params";
 pub const PRIOR_DELEGATES_KEY: &str = "prior_delegates";
-pub const PRIOR_UNIT_REWARD_KEY: &str = "prior_unit_reward";
+pub const PRIOR_UNIT_REWARD: &str = "prior_unit_reward";

+pub const DISTRIBUTED_DELEGATION_REWARDS_KEY: &str = "distributed_delegation_rewards";
+pub const FURTHER_DELEGATIONS_TO_REWARD_KEY: &str = "further_delegations";
 pub const NO_REWARD_REASON_KEY: &str = "no_reward_reason";
 pub const BOND_NOT_FOUND_VALUE: &str = "bond_not_found";
+pub const BOND_TOO_FRESH_VALUE: &str = "bond_too_fresh";
 pub const ZERO_PERFORMANCE_VALUE: &str = "zero_performance";

 // rewarded set update
 pub const ACTIVE_SET_SIZE_KEY: &str = "active_set_size";
+pub const REWARDED_SET_SIZE_KEY: &str = "rewarded_set_size";
+pub const NODES_IN_REWARDED_SET_KEY: &str = "nodes_in_rewarded_set";
+pub const CURRENT_INTERVAL_ID_KEY: &str = "current_interval";

+pub const NEW_CURRENT_INTERVAL_KEY: &str = "new_current_interval";
 pub const NEW_CURRENT_EPOCH_KEY: &str = "new_current_epoch";
+pub const BLOCK_HEIGHT_KEY: &str = "block_height";
+pub const RECONCILIATION_ERROR_EVENT: &str = "reconciliation_error";

 // interval
 pub const EVENTS_EXECUTED_KEY: &str = "number_of_events_executed";
-pub const EVENT_CREATION_HEIGHT_KEY: &str = "created_at";
 pub const REWARDED_SET_NODES_KEY: &str = "rewarded_set_nodes";
 pub const NEW_EPOCHS_DURATION_SECS_KEY: &str = "new_epoch_durations_secs";
 pub const NEW_EPOCHS_IN_INTERVAL: &str = "new_epochs_in_interval";

 pub fn new_delegation_event(
-    created_at: BlockHeight,
    delegator: &Addr,
    proxy: &Option<Addr>,
    amount: &Coin,
    mix_id: MixId,
-    unit_reward: Decimal,
 ) -> Event {
    Event::new(MixnetEventType::Delegation)
-        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
        .add_attribute(DELEGATOR_KEY, delegator)
        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
        .add_attribute(AMOUNT_KEY, amount.to_string())
        .add_attribute(DELEGATION_TARGET_KEY, mix_id.to_string())
-        .add_attribute(UNIT_REWARD_KEY, unit_reward.to_string())
 }

 pub fn new_delegation_on_unbonded_node_event(
@@ -211,9 +218,8 @@ pub fn new_withdraw_delegator_reward_event(
        .add_attribute(DELEGATION_TARGET_KEY, mix_id.to_string())
 }

-pub fn new_active_set_update_event(created_at: BlockHeight, new_size: u32) -> Event {
+pub fn new_active_set_update_event(new_size: u32) -> Event {
    Event::new(MixnetEventType::ActiveSetUpdate)
-        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
        .add_attribute(ACTIVE_SET_SIZE_KEY, new_size.to_string())
 }

@@ -230,13 +236,10 @@ pub fn new_pending_active_set_update_event(
 }

 pub fn new_rewarding_params_update_event(
-    created_at: BlockHeight,
-
    update: IntervalRewardingParamsUpdate,
    updated: IntervalRewardParams,
 ) -> Event {
    Event::new(MixnetEventType::IntervalRewardingParamsUpdate)
-        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
        .add_attribute(
            INTERVAL_REWARDING_PARAMS_UPDATE_KEY,
            update.to_inline_json(),
@@ -262,14 +265,8 @@ pub fn new_pending_rewarding_params_update_event(
        )
 }

-pub fn new_undelegation_event(
-    created_at: BlockHeight,
-    delegator: &Addr,
-    proxy: &Option<Addr>,
-    mix_id: MixId,
-) -> Event {
+pub fn new_undelegation_event(delegator: &Addr, proxy: &Option<Addr>, mix_id: MixId) -> Event {
    Event::new(MixnetEventType::Undelegation)
-        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
        .add_attribute(DELEGATOR_KEY, delegator)
        .add_optional_attribute(PROXY_KEY, proxy.as_ref())
        .add_attribute(MIX_ID_KEY, mix_id.to_string())
@@ -330,10 +327,8 @@ pub fn new_mixnode_bonding_event(
        .add_attribute(AMOUNT_KEY, amount.to_string())
 }

-pub fn new_mixnode_unbonding_event(created_at: BlockHeight, mix_id: MixId) -> Event {
-    Event::new(MixnetEventType::MixnodeUnbonding)
-        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
-        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+pub fn new_mixnode_unbonding_event(mix_id: MixId) -> Event {
+    Event::new(MixnetEventType::MixnodeUnbonding).add_attribute(MIX_ID_KEY, mix_id.to_string())
 }

 pub fn new_pending_mixnode_unbonding_event(
@@ -375,13 +370,8 @@ pub fn new_mixnode_pending_cost_params_update_event(
        .add_attribute(UPDATED_MIXNODE_COST_PARAMS_KEY, new_costs.to_inline_json())
 }

-pub fn new_mixnode_cost_params_update_event(
-    created_at: BlockHeight,
-    mix_id: MixId,
-    new_costs: &MixNodeCostParams,
-) -> Event {
+pub fn new_mixnode_cost_params_update_event(mix_id: MixId, new_costs: &MixNodeCostParams) -> Event {
    Event::new(MixnetEventType::MixnodeCostParamsUpdate)
-        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
        .add_attribute(MIX_ID_KEY, mix_id.to_string())
        .add_attribute(UPDATED_MIXNODE_COST_PARAMS_KEY, new_costs.to_inline_json())
 }
@@ -471,7 +461,7 @@ pub fn new_mix_rewarding_event(
            interval.current_epoch_absolute_id().to_string(),
        )
        .add_attribute(PRIOR_DELEGATES_KEY, prior_delegates.to_string())
-        .add_attribute(PRIOR_UNIT_REWARD_KEY, prior_unit_reward.to_string())
+        .add_attribute(PRIOR_UNIT_REWARD, prior_unit_reward.to_string())
        .add_attribute(MIX_ID_KEY, mix_id.to_string())
        .add_attribute(
            OPERATOR_REWARD_KEY,
@@ -507,13 +497,11 @@ pub fn new_reconcile_pending_events() -> Event {
 }

 pub fn new_interval_config_update_event(
-    created_at: BlockHeight,
    epochs_in_interval: u32,
    epoch_duration_secs: u64,
    updated_rewarding_params: IntervalRewardParams,
 ) -> Event {
    Event::new(MixnetEventType::IntervalConfigUpdate)
-        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
        .add_attribute(
            NEW_EPOCHS_DURATION_SECS_KEY,
            epoch_duration_secs.to_string(),
@@ -1,33 +1,13 @@
 // 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));
+pub fn compare_decimals(a: Decimal, b: Decimal) {
+    let epsilon = Decimal::from_ratio(1u128, 100_000_000u128);
    if a > b {
        assert!(a - b < epsilon, "{} != {}", a, b)
    } else {
        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."),
-        })
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Gala	0a9978b81e	fix build a rever console utility addition	2022-10-27 12:37:18 +02:00
Gala	7cdfdf8437	requested changes	2022-10-27 11:05:19 +02:00
Gala	fca32424b4	fix build	2022-10-24 12:01:37 +02:00
Gala	7ad9c15c9e	PR requested changes	2022-10-24 11:51:46 +02:00
Gala	54716c7c09	fix build	2022-10-21 10:55:45 +02:00
Gala	2a0b1a3734	adding correct toolpit text and cleaning	2022-10-20 17:53:17 +02:00
Gala	7f35b3660b	remove gateway name and desc	2022-10-20 17:02:17 +02:00
Gala	8470288079	fixing gateways pagination	2022-10-20 15:33:31 +02:00
Gala	d5a65841af	adding link style	2022-10-20 15:27:55 +02:00
Gala	76144928a0	adding loading state for gateways	2022-10-20 15:19:27 +02:00
Gala	d6ffdb86ce	adding uptime chart	2022-10-20 15:11:38 +02:00
Gala	74f9205be1	create gateway details page	2022-10-20 15:04:36 +02:00