Merge branch 'release/v1.1.3'

updated changelogs
bumped everything by one patch version
2022-12-13 13:24:01 +01:00 · 2022-12-13 13:23:27 +01:00 · 2022-12-13 13:15:51 +01:00 · 2022-12-12 16:34:56 +02:00 · 2022-12-09 22:35:37 +01:00 · 2022-12-09 21:43:37 +01:00
276 changed files with 8779 additions and 5011 deletions
@@ -5,7 +5,7 @@ on:
    - cron: '5 9 * * *'
 jobs:
  cargo-deny:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - name: Checkout repository code
        uses: actions/checkout@v2
@@ -26,7 +26,7 @@ jobs:
          path: .github/workflows/support-files/notifications/deny.message
  notification:
    needs: cargo-deny
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - name: Check out repository code
        uses: actions/checkout@v2
@@ -1,6 +1,6 @@
 [
  {
-    "os":"ubuntu-latest",
+    "os":"ubuntu-20.04",
    "rust":"stable",
    "runOnEvent":"always"
  },
@@ -6,7 +6,7 @@ on:

 jobs:
  build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2
      
@@ -10,7 +10,7 @@ on:

 jobs:
  matrix_prep:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -24,7 +24,7 @@ jobs:
  contracts:
    # since it's going to be compiled into wasm, there's absolutely
    # no point in running CI on different OS-es
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    continue-on-error: ${{ matrix.rust == 'nightly' }}
    needs: matrix_prep
    strategy:
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest]
+        platform: [ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -5,7 +5,7 @@ on:
    - cron: '14 1 * * *'
 jobs:
  matrix_prep:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -25,7 +25,7 @@ jobs:
    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
-        if: matrix.os == 'ubuntu-latest'
+        if: matrix.os == 'ubuntu-20.04'

      - name: Check out repository code
        uses: actions/checkout@v2
@@ -96,7 +96,7 @@ jobs:

      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
        with:
          command: clean

@@ -160,7 +160,7 @@ jobs:

  notification:
    needs: build
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
@@ -1,6 +1,6 @@
 [
  {
-    "os":"ubuntu-latest",
+    "os":"ubuntu-20.04",
    "rust":"stable",
    "runOnEvent":"schedule"
  },
@@ -17,7 +17,7 @@
  },

  {
-    "os":"ubuntu-latest",
+    "os":"ubuntu-20.04",
    "rust":"beta",
    "runOnEvent":"schedule"
  },
@@ -33,7 +33,7 @@
  },

  {
-    "os":"ubuntu-latest",
+    "os":"ubuntu-20.04",
    "rust":"nightly",
    "runOnEvent":"schedule"
  },
@@ -5,7 +5,7 @@ on:
    - cron: '14 2 * * *'
 jobs:
  matrix_prep:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -17,7 +17,7 @@ jobs:
          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
  get_release:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    needs: matrix_prep
    outputs:
      output1: ${{ steps.step2.outputs.latest_release }}
@@ -38,7 +38,7 @@ jobs:
    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
-        if: matrix.os == 'ubuntu-latest'
+        if: matrix.os == 'ubuntu-20.04'

      - name: Check out latest release branch
        uses: actions/checkout@v3
@@ -111,7 +111,7 @@ jobs:

      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
        with:
          command: clean

@@ -175,7 +175,7 @@ jobs:

  notification:
    needs: [build,get_release]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
@@ -192,7 +192,7 @@ jobs:
          NYM_PROJECT_NAME: "Nym nightly build on latest release"
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "https://github.com/nymtech/nym/tree/${{needs.get_release.outputs.output1}}"
+          GIT_BRANCH_NAME: "${{needs.get_release.outputs.output1}}"
          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
@@ -5,7 +5,7 @@ on:
    - cron: '24 2 * * *'
 jobs:
  matrix_prep:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
@@ -17,7 +17,7 @@ jobs:
          inputFile: '.github/workflows/nightly_build_matrix_includes.json'
          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
  get_release:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    needs: matrix_prep
    outputs:
      output1: ${{ steps.step2.outputs.latest_release }}
@@ -38,7 +38,7 @@ jobs:
    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
-        if: matrix.os == 'ubuntu-latest'
+        if: matrix.os == 'ubuntu-20.04'

      - name: Check out latest release branch
        uses: actions/checkout@v3
@@ -111,7 +111,7 @@ jobs:

      - name: Reclaim some disk space
        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-latest' }}
+        if: ${{ matrix.os == 'windows-latest' || matrix.os == 'ubuntu-20.04' }}
        with:
          command: clean

@@ -175,7 +175,7 @@ jobs:

  notification:
    needs: [build,get_release]
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - name: Collect jobs status
        uses: technote-space/workflow-conclusion-action@v2
@@ -192,7 +192,7 @@ jobs:
          NYM_PROJECT_NAME: "Nym nightly build on latest release"
          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "https://github.com/nymtech/nym/tree/${{needs.get_release.outputs.output1}}"
+          GIT_BRANCH_NAME: "${{needs.get_release.outputs.output1}}"
          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest, windows-latest, macos-latest]
+        platform: [ubuntu-20.04, windows-latest, macos-latest]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -13,7 +13,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest]
+        platform: [ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -19,7 +19,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest]
+        platform: [ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -12,7 +12,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest]
+        platform: [ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -12,7 +12,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-latest]
+        platform: [ubuntu-20.04]
    runs-on: ${{ matrix.platform }}
    steps:
      - uses: actions/checkout@v2
@@ -12,7 +12,7 @@ defaults:
 jobs:
  test:
    name: wallet tests
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2

@@ -85,7 +85,7 @@ async function getMessageBody(context) {
            ...
          ],
          check_run_url: 'https://api.github.com/repos/nymtech/nym/check-runs/5182940024',
-          labels: [ 'ubuntu-latest' ],
+          labels: [ 'ubuntu-20.04' ],
          runner_id: 1,
          runner_name: 'Hosted Agent',
          runner_group_id: 2,
@@ -7,7 +7,7 @@ on:

 jobs:
  wasm:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
    steps:
      - uses: actions/checkout@v2

@@ -2,7 +2,35 @@

 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

-## Unreleased
+## [Unreleased]
+
+## [v1.1.3] (2022-12-13)
+
+### Changed
+
+- validator-api: can recover from shutdown during DKG process ([#1872])
+- clients: deduplicate gateway inititialization, part of work towards a rust-sdk
+- clients: keep all transmission lanes going at all times by making priority probabilistic
+
+### Fixed
+
+- network-requester: fix bug where websocket connection disconnect resulted in success error code
+- clients: fix a few panics handling the gateway-client
+- mixnode, gateway, validator-api: Use mainnet values as defaults for URLs and mixnet contract  ([#1884])
+
+[#1872]: https://github.com/nymtech/nym/pull/1872
+[#1884]: https://github.com/nymtech/nym/pull/1884
+
+
+## [v1.1.2]
+
+### Changed
+
+- gateway: Renamed flag from `enabled/disabled_credentials_mode` to `only-coconut-credentials`
+- "Family" feature for node families + layers
+- Initial coconut functionality including credentials and distributed key generation 
+
+## [v1.1.1](https://github.com/nymtech/nym/tree/v1.1.1) (2022-11-29)

 ### Added

@@ -586,7 +586,7 @@ dependencies = [

 [[package]]
 name = "client-core"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "client-connections",
 "config",
@@ -603,12 +603,14 @@ dependencies = [
 "pemstore",
 "rand 0.7.3",
 "serde",
+ "serde_json",
 "sled",
 "tap",
 "task",
 "tempfile",
 "thiserror",
 "tokio",
+ "tokio-stream",
 "topology",
 "url",
 "validator-client",
@@ -923,7 +925,6 @@ dependencies = [
 name = "credential"
 version = "0.1.0"
 dependencies = [
- "async-trait",
 "bip39",
 "cfg-if 0.1.10",
 "clap 3.2.8",
@@ -935,7 +936,6 @@ dependencies = [
 "crypto",
 "network-defaults",
 "pemstore",
- "pickledb",
 "rand 0.7.3",
 "serde",
 "thiserror",
@@ -1633,7 +1633,7 @@ dependencies = [

 [[package]]
 name = "explorer-api"
-version = "1.1.0"
+version = "1.1.1"
 dependencies = [
 "chrono",
 "clap 3.2.8",
@@ -2669,7 +2669,7 @@ checksum = "fe435806c197dfeaa5efcded5e623c4b8230fd28fdf1e91e7a86e40ef2acbf90"
 dependencies = [
 "arrayref",
 "no-std-compat",
- "snafu 0.7.1",
+ "snafu",
 ]

 [[package]]
@@ -2745,12 +2745,6 @@ dependencies = [
 "vcpkg",
 ]

-[[package]]
-name = "linked-hash-map"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"
-
 [[package]]
 name = "lioness"
 version = "0.1.2"
@@ -3122,7 +3116,7 @@ dependencies = [

 [[package]]
 name = "nym-cli"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "anyhow",
 "base64",
@@ -3176,7 +3170,7 @@ dependencies = [

 [[package]]
 name = "nym-client"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "clap 3.2.8",
 "client-connections",
@@ -3216,7 +3210,7 @@ dependencies = [

 [[package]]
 name = "nym-gateway"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3263,7 +3257,7 @@ dependencies = [

 [[package]]
 name = "nym-mixnode"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "anyhow",
 "bs58",
@@ -3305,7 +3299,7 @@ dependencies = [

 [[package]]
 name = "nym-network-requester"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "async-trait",
 "clap 3.2.8",
@@ -3337,7 +3331,7 @@ dependencies = [

 [[package]]
 name = "nym-network-statistics"
-version = "1.0.2"
+version = "1.1.2"
 dependencies = [
 "dirs",
 "log",
@@ -3353,7 +3347,7 @@ dependencies = [

 [[package]]
 name = "nym-socks5-client"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "clap 3.2.8",
 "client-connections",
@@ -3379,7 +3373,7 @@ dependencies = [
 "proxy-helpers",
 "rand 0.7.3",
 "serde",
- "snafu 0.6.10",
+ "serde_json",
 "socks5-requests",
 "tap",
 "task",
@@ -3420,7 +3414,7 @@ dependencies = [

 [[package]]
 name = "nym-validator-api"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3934,19 +3928,6 @@ dependencies = [
 "indexmap",
 ]

-[[package]]
-name = "pickledb"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9161694d67f6c5163519d42be942ae36bbdb55f439460144f105bc4f9f7d1d61"
-dependencies = [
- "bincode",
- "serde",
- "serde_cbor",
- "serde_json",
- "serde_yaml",
-]
-
 [[package]]
 name = "pin-project"
 version = "1.0.10"
@@ -5025,9 +5006,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.83"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38dd04e3c8279e75b31ef29dbdceebfe5ad89f4d0937213c53f7d49d01b3d5a7"
+checksum = "020ff22c755c2ed3f8cf162dbb41a7268d934702f3ed3631656ea597e08fc3db"
 dependencies = [
 "itoa 1.0.1",
 "ryu",
@@ -5057,18 +5038,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "serde_yaml"
-version = "0.8.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a521f2940385c165a24ee286aa8599633d162077a54bdcae2a6fd5a7bfa7a0"
-dependencies = [
- "indexmap",
- "ryu",
- "serde",
- "yaml-rust",
-]
-
 [[package]]
 name = "sha-1"
 version = "0.8.2"
@@ -5227,16 +5196,6 @@ version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83"

-[[package]]
-name = "snafu"
-version = "0.6.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eab12d3c261b2308b0d80c26fffb58d17eba81a4be97890101f416b478c79ca7"
-dependencies = [
- "doc-comment",
- "snafu-derive 0.6.10",
-]
-
 [[package]]
 name = "snafu"
 version = "0.7.1"
@@ -5244,18 +5203,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5177903bf45656592d9eb5c0e22f408fc023aae51dbe2088889b71633ba451f2"
 dependencies = [
 "doc-comment",
- "snafu-derive 0.7.1",
-]
-
-[[package]]
-name = "snafu-derive"
-version = "0.6.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1508efa03c362e23817f96cde18abed596a25219a8b2c66e8db33c03543d315b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "snafu-derive",
 ]

 [[package]]
@@ -5699,6 +5647,8 @@ dependencies = [
 "log",
 "thiserror",
 "tokio",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
 ]

 [[package]]
@@ -6567,7 +6517,7 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"

 [[package]]
 name = "vesting-contract"
-version = "1.1.0"
+version = "1.1.2"
 dependencies = [
 "contracts-common",
 "cosmwasm-std",
@@ -6938,15 +6888,6 @@ dependencies = [
 "zeroize",
 ]

-[[package]]
-name = "yaml-rust"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
-dependencies = [
- "linked-hash-map",
-]
-
 [[package]]
 name = "yansi"
 version = "0.5.1"
@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.0"
+version = "1.1.3"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"

@@ -13,9 +13,11 @@ humantime-serde = "1.0"
 log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.89"
 sled = { version = "0.34", optional = true }
 tap = "1.0.1"
 thiserror = "1.0.34"
+tokio = { version = "1.21.2", features = ["time", "macros"]}
 url = { version ="2.2", features = ["serde"] }

 # internal
@@ -30,8 +32,11 @@ nymsphinx = { path = "../../common/nymsphinx" }
 pemstore = { path = "../../common/pemstore" }
 topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
+task = { path = "../../common/task" }

-tokio = { version = "1.21.2", features = ["time", "macros"]}
+[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
+version = "0.1.9"
+features = ["time"]

 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
 version = "0.4"
@@ -47,8 +52,8 @@ rev = "b9d1a54ad514c2f230a026afe0dde341e98cd7b6"
 version = "0.2.4"
 features = ["futures"]

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.task]
-path = "../../common/task"
+#[target."cfg(not(target_arch = \"wasm32\"))".dependencies.task]
+#path = "../../common/task"

 [dev-dependencies]
 tempfile = "3.1.0"
@@ -0,0 +1,441 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::client::cover_traffic_stream::LoopCoverTrafficStream;
+use crate::client::inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender};
+use crate::client::key_manager::KeyManager;
+use crate::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
+use crate::client::real_messages_control;
+use crate::client::real_messages_control::RealMessagesController;
+use crate::client::received_buffer::{
+    ReceivedBufferRequestReceiver, ReceivedBufferRequestSender, ReceivedMessagesBufferController,
+};
+use crate::client::topology_control::{
+    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
+};
+use crate::config::{Config, DebugConfig, GatewayEndpointConfig};
+use crate::error::ClientCoreError;
+use client_connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
+use crypto::asymmetric::identity;
+use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
+use gateway_client::{
+    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
+    MixnetMessageSender,
+};
+use log::{debug, info};
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::addressing::nodes::NodeIdentity;
+#[cfg(feature = "reply-surb")]
+use std::path::PathBuf;
+use tap::TapFallible;
+use task::{ShutdownListener, ShutdownNotifier};
+use url::Url;
+
+// it's fine to do this disgusting compilation flag business here as this problem
+// is going to go away in 1.2.0
+#[cfg(feature = "reply-surb")]
+use crate::client::reply_key_storage::ReplyKeyStorage;
+
+pub struct ClientInput {
+    pub shared_lane_queue_lengths: LaneQueueLengths,
+    pub connection_command_sender: ConnectionCommandSender,
+    pub input_sender: InputMessageSender,
+}
+
+pub struct ClientOutput {
+    pub received_buffer_request_sender: ReceivedBufferRequestSender,
+}
+
+pub enum ClientInputStatus {
+    AwaitingProducer { client_input: ClientInput },
+    Connected,
+}
+
+impl ClientInputStatus {
+    pub fn register_producer(&mut self) -> ClientInput {
+        match std::mem::replace(self, ClientInputStatus::Connected) {
+            ClientInputStatus::AwaitingProducer { client_input } => client_input,
+            ClientInputStatus::Connected => panic!("producer was already registered before"),
+        }
+    }
+}
+
+pub enum ClientOutputStatus {
+    AwaitingConsumer { client_output: ClientOutput },
+    Connected,
+}
+
+impl ClientOutputStatus {
+    pub fn register_consumer(&mut self) -> ClientOutput {
+        match std::mem::replace(self, ClientOutputStatus::Connected) {
+            ClientOutputStatus::AwaitingConsumer { client_output } => client_output,
+            ClientOutputStatus::Connected => panic!("consumer was already registered before"),
+        }
+    }
+}
+
+pub struct BaseClientBuilder<'a> {
+    // due to wasm limitations I had to split it like this : (
+    gateway_config: &'a GatewayEndpointConfig,
+    debug_config: &'a DebugConfig,
+    disabled_credentials: bool,
+    validator_api_endpoints: Vec<Url>,
+
+    #[cfg(feature = "reply-surb")]
+    reply_surb_keys_store_path: PathBuf,
+
+    bandwidth_controller: Option<BandwidthController>,
+    key_manager: KeyManager,
+}
+
+impl<'a> BaseClientBuilder<'a> {
+    pub fn new_from_base_config<T>(
+        base_config: &'a Config<T>,
+        key_manager: KeyManager,
+        bandwidth_controller: Option<BandwidthController>,
+    ) -> BaseClientBuilder<'a> {
+        BaseClientBuilder {
+            gateway_config: base_config.get_gateway_endpoint_config(),
+            debug_config: base_config.get_debug_config(),
+            disabled_credentials: base_config.get_disabled_credentials_mode(),
+            validator_api_endpoints: base_config.get_validator_api_endpoints(),
+            bandwidth_controller,
+            key_manager,
+            #[cfg(feature = "reply-surb")]
+            reply_surb_keys_store_path: base_config.get_reply_encryption_key_store_path(),
+        }
+    }
+
+    pub fn new(
+        gateway_config: &'a GatewayEndpointConfig,
+        debug_config: &'a DebugConfig,
+        key_manager: KeyManager,
+        bandwidth_controller: Option<BandwidthController>,
+        disabled_credentials: bool,
+        validator_api_endpoints: Vec<Url>,
+        #[cfg(feature = "reply-surb")] reply_surb_keys_store_path: PathBuf,
+    ) -> BaseClientBuilder<'a> {
+        BaseClientBuilder {
+            gateway_config,
+            debug_config,
+            disabled_credentials,
+            validator_api_endpoints,
+            bandwidth_controller,
+            key_manager,
+            #[cfg(feature = "reply-surb")]
+            reply_surb_keys_store_path,
+        }
+    }
+
+    pub fn as_mix_recipient(&self) -> Recipient {
+        Recipient::new(
+            *self.key_manager.identity_keypair().public_key(),
+            *self.key_manager.encryption_keypair().public_key(),
+            // TODO: below only works under assumption that gateway address == gateway id
+            // (which currently is true)
+            NodeIdentity::from_base58_string(&self.gateway_config.gateway_id).unwrap(),
+        )
+    }
+
+    // future constantly pumping loop cover traffic at some specified average rate
+    // the pumped traffic goes to the MixTrafficController
+    fn start_cover_traffic_stream(
+        &self,
+        topology_accessor: TopologyAccessor,
+        mix_tx: BatchMixMessageSender,
+        shutdown: ShutdownListener,
+    ) {
+        info!("Starting loop cover traffic stream...");
+
+        let mut stream = LoopCoverTrafficStream::new(
+            self.key_manager.ack_key(),
+            self.debug_config.average_ack_delay,
+            self.debug_config.average_packet_delay,
+            self.debug_config.loop_cover_traffic_average_delay,
+            mix_tx,
+            self.as_mix_recipient(),
+            topology_accessor,
+        );
+
+        if let Some(size) = self.debug_config.use_extended_packet_size {
+            log::debug!("Setting extended packet size: {:?}", size);
+            stream.set_custom_packet_size(size.into());
+        }
+
+        stream.start_with_shutdown(shutdown);
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn start_real_traffic_controller(
+        &self,
+        topology_accessor: TopologyAccessor,
+        ack_receiver: AcknowledgementReceiver,
+        input_receiver: InputMessageReceiver,
+        mix_sender: BatchMixMessageSender,
+        lane_queue_lengths: LaneQueueLengths,
+        client_connection_rx: ConnectionCommandReceiver,
+        shutdown: ShutdownListener,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
+    ) {
+        let mut controller_config = real_messages_control::Config::new(
+            self.key_manager.ack_key(),
+            self.debug_config.ack_wait_multiplier,
+            self.debug_config.ack_wait_addition,
+            self.debug_config.average_ack_delay,
+            self.debug_config.message_sending_average_delay,
+            self.debug_config.average_packet_delay,
+            self.debug_config.disable_main_poisson_packet_distribution,
+            self.as_mix_recipient(),
+        );
+
+        if let Some(size) = self.debug_config.use_extended_packet_size {
+            log::debug!("Setting extended packet size: {:?}", size);
+            controller_config.set_custom_packet_size(size.into());
+        }
+
+        info!("Starting real traffic stream...");
+
+        RealMessagesController::new(
+            controller_config,
+            ack_receiver,
+            input_receiver,
+            mix_sender,
+            topology_accessor,
+            lane_queue_lengths,
+            client_connection_rx,
+            #[cfg(feature = "reply-surb")]
+            reply_key_storage,
+        )
+        .start_with_shutdown(shutdown);
+    }
+
+    // buffer controlling all messages fetched from provider
+    // required so that other components would be able to use them (say the websocket)
+    fn start_received_messages_buffer_controller(
+        &self,
+        query_receiver: ReceivedBufferRequestReceiver,
+        mixnet_receiver: MixnetMessageReceiver,
+        shutdown: ShutdownListener,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
+    ) {
+        info!("Starting received messages buffer controller...");
+        ReceivedMessagesBufferController::new(
+            self.key_manager.encryption_keypair(),
+            query_receiver,
+            mixnet_receiver,
+            #[cfg(feature = "reply-surb")]
+            reply_key_storage,
+        )
+        .start_with_shutdown(shutdown)
+    }
+
+    async fn start_gateway_client(
+        &mut self,
+        mixnet_message_sender: MixnetMessageSender,
+        ack_sender: AcknowledgementSender,
+        shutdown: ShutdownListener,
+    ) -> Result<GatewayClient, ClientCoreError> {
+        let gateway_id = self.gateway_config.gateway_id.clone();
+        if gateway_id.is_empty() {
+            return Err(ClientCoreError::GatewayIdUnknown);
+        }
+        let gateway_owner = self.gateway_config.gateway_owner.clone();
+        if gateway_owner.is_empty() {
+            return Err(ClientCoreError::GatewayOwnerUnknown);
+        }
+        let gateway_address = self.gateway_config.gateway_listener.clone();
+        if gateway_address.is_empty() {
+            return Err(ClientCoreError::GatwayAddressUnknown);
+        }
+
+        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
+            .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;
+
+        // disgusting wasm workaround since there's no key persistence there (nor `client init`)
+        let shared_key = if self.key_manager.gateway_key_set() {
+            Some(self.key_manager.gateway_shared_key())
+        } else {
+            None
+        };
+
+        let mut gateway_client = GatewayClient::new(
+            gateway_address,
+            self.key_manager.identity_keypair(),
+            gateway_identity,
+            gateway_owner,
+            shared_key,
+            mixnet_message_sender,
+            ack_sender,
+            self.debug_config.gateway_response_timeout,
+            self.bandwidth_controller.take(),
+            shutdown,
+        );
+
+        gateway_client.set_disabled_credentials_mode(self.disabled_credentials);
+
+        gateway_client
+            .authenticate_and_start()
+            .await
+            .tap_err(|err| {
+                log::error!("Could not authenticate and start up the gateway connection - {err}")
+            })?;
+        Ok(gateway_client)
+    }
+
+    // future responsible for periodically polling directory server and updating
+    // the current global view of topology
+    async fn start_topology_refresher(
+        &mut self,
+        topology_accessor: TopologyAccessor,
+        shutdown: ShutdownListener,
+    ) -> Result<(), ClientCoreError> {
+        let topology_refresher_config = TopologyRefresherConfig::new(
+            self.validator_api_endpoints.clone(),
+            self.debug_config.topology_refresh_rate,
+            env!("CARGO_PKG_VERSION").to_string(),
+        );
+        let mut topology_refresher =
+            TopologyRefresher::new(topology_refresher_config, topology_accessor);
+        // before returning, block entire runtime to refresh the current network view so that any
+        // components depending on topology would see a non-empty view
+        info!("Obtaining initial network topology");
+        topology_refresher.refresh().await;
+
+        // 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 \
+                - check if enough nodes and a gateway are online"
+            );
+            return Err(ClientCoreError::InsufficientNetworkTopology);
+        }
+
+        info!("Starting topology refresher...");
+        topology_refresher.start_with_shutdown(shutdown);
+        Ok(())
+    }
+
+    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
+    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
+    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
+    // requests?
+    fn start_mix_traffic_controller(
+        gateway_client: GatewayClient,
+        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
+    }
+
+    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError> {
+        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
+
+        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
+        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
+        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
+
+        // used for announcing connection or disconnection of a channel for pushing re-assembled messages to
+        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();
+
+        // channels responsible for controlling real messages
+        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
+
+        // channels responsible for controlling ack messages
+        let (ack_sender, ack_receiver) = mpsc::unbounded();
+        let shared_topology_accessor = TopologyAccessor::new();
+
+        #[cfg(feature = "reply-surb")]
+        let reply_key_storage =
+            ReplyKeyStorage::load(&self.reply_surb_keys_store_path).tap_err(|err| {
+                log::error!("Failed to load reply key storage - is it perhaps already in use?");
+                log::error!("{:?}", err);
+            })?;
+
+        // Shutdown notifier for signalling tasks to stop
+        let shutdown = ShutdownNotifier::default();
+
+        // the components are started in very specific order. Unless you know what you are doing,
+        // do not change that.
+        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
+            .await?;
+        self.start_received_messages_buffer_controller(
+            received_buffer_request_receiver,
+            mixnet_messages_receiver,
+            shutdown.subscribe(),
+            #[cfg(feature = "reply-surb")]
+            reply_key_storage.clone(),
+        );
+
+        let gateway_client = self
+            .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 (client_connection_tx, client_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_real_traffic_controller(
+            shared_topology_accessor.clone(),
+            ack_receiver,
+            input_receiver,
+            sphinx_message_sender.clone(),
+            shared_lane_queue_lengths.clone(),
+            client_connection_rx,
+            shutdown.subscribe(),
+            #[cfg(feature = "reply-surb")]
+            reply_key_storage,
+        );
+
+        if !self.debug_config.disable_loop_cover_traffic_stream {
+            self.start_cover_traffic_stream(
+                shared_topology_accessor,
+                sphinx_message_sender,
+                shutdown.subscribe(),
+            );
+        }
+
+        debug!("Core client startup finished!");
+        debug!("The address of this client is: {}", self.as_mix_recipient());
+
+        Ok(BaseClient {
+            client_input: ClientInputStatus::AwaitingProducer {
+                client_input: ClientInput {
+                    shared_lane_queue_lengths,
+                    connection_command_sender: client_connection_tx,
+                    input_sender,
+                },
+            },
+            client_output: ClientOutputStatus::AwaitingConsumer {
+                client_output: ClientOutput {
+                    received_buffer_request_sender,
+                },
+            },
+            shutdown_notifier: shutdown,
+        })
+    }
+}
+
+pub struct BaseClient {
+    pub client_input: ClientInputStatus,
+    pub client_output: ClientOutputStatus,
+
+    pub shutdown_notifier: ShutdownNotifier,
+}
@@ -143,6 +143,16 @@ impl LoopCoverTrafficStream<OsRng> {
        self.packet_size = packet_size;
    }

+    fn set_next_delay(&mut self, amount: Duration) {
+        #[cfg(not(target_arch = "wasm32"))]
+        let next_delay = Box::pin(time::sleep(amount));
+
+        #[cfg(target_arch = "wasm32")]
+        let next_delay = Box::pin(wasm_timer::Delay::new(amount));
+
+        self.next_delay = next_delay;
+    }
+
    async fn on_new_message(&mut self) {
        trace!("next cover message!");

@@ -181,7 +191,7 @@ impl LoopCoverTrafficStream<OsRng> {
                    // 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");
+                    log::warn!("Failed to send sphinx packet - gateway or connection to gatway can't keep up");
                }
                TrySendError::Closed(_) => {
                    log::warn!("Failed to send cover message - channel closed");
@@ -202,12 +212,11 @@ impl LoopCoverTrafficStream<OsRng> {
        tokio::task::yield_now().await;
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub fn start_with_shutdown(mut self, mut shutdown: task::ShutdownListener) {
        // we should set initial delay only when we actually start the stream
        let sampled =
            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
-        self.next_delay = Box::pin(time::sleep(sampled));
+        self.set_next_delay(sampled);

        spawn_future(async move {
            debug!("Started LoopCoverTrafficStream with graceful shutdown support");
@@ -228,19 +237,16 @@ impl LoopCoverTrafficStream<OsRng> {
                    }
                }
            }
-            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-                .await
-                .expect("Task stopped without shutdown called");
+            shutdown.recv_timeout().await;
            log::debug!("LoopCoverTrafficStream: Exiting");
        })
    }

-    #[cfg(target_arch = "wasm32")]
    pub fn start(mut self) {
        // we should set initial delay only when we actually start the stream
        let sampled =
            sample_poisson_duration(&mut self.rng, self.average_cover_message_sending_delay);
-        self.next_delay = Box::pin(wasm_timer::Delay::new(sampled));
+        self.set_next_delay(sampled);

        spawn_future(async move {
            debug!("Started LoopCoverTrafficStream without graceful shutdown support");
@@ -149,6 +149,10 @@ impl KeyManager {
        )
    }

+    pub fn gateway_key_set(&self) -> bool {
+        self.gateway_shared_key.is_some()
+    }
+
    /// Gets an atomically reference counted pointer to [`AckKey`].
    pub fn ack_key(&self) -> Arc<AckKey> {
        Arc::clone(&self.ack_key)
@@ -67,10 +67,7 @@ impl MixTrafficController {
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub fn start_with_shutdown(mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        spawn_future(async move {
            debug!("Started MixTrafficController with graceful shutdown support");

@@ -90,14 +87,11 @@ impl MixTrafficController {
                    }
                }
            }
-            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-                .await
-                .expect("Task stopped without shutdown called");
+            shutdown.recv_timeout().await;
            log::debug!("MixTrafficController: Exiting");
        })
    }

-    #[cfg(target_arch = "wasm32")]
    pub fn start(mut self) {
        spawn_future(async move {
            debug!("Started MixTrafficController without graceful shutdown support");
@@ -1,3 +1,7 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod base_client;
 pub mod cover_traffic_stream;
 pub mod inbound_messages;
 pub mod key_manager;
@@ -70,10 +70,7 @@ impl AcknowledgementListener {
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started AcknowledgementListener with graceful shutdown support");

        while !shutdown.is_shutdown() {
@@ -90,13 +87,12 @@ impl AcknowledgementListener {
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        shutdown.recv_timeout().await;
        log::debug!("AcknowledgementListener: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    pub(super) async fn run(&mut self) {
        debug!("Started AcknowledgementListener without graceful shutdown support");

@@ -245,7 +245,6 @@ impl ActionController {
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
        debug!("Started ActionController with graceful shutdown support");

@@ -272,13 +271,15 @@ impl ActionController {
                }
            }
        }
+        #[cfg(not(target_arch = "wasm32"))]
        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
            .await
            .expect("Task stopped without shutdown called");
        log::debug!("ActionController: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    pub(super) async fn run(&mut self) {
        debug!("Started ActionController without graceful shutdown support");

@@ -194,10 +194,7 @@ where
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started InputMessageListener with graceful shutdown support");

        while !shutdown.is_shutdown() {
@@ -216,13 +213,12 @@ where
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        shutdown.recv_timeout().await;
        log::debug!("InputMessageListener: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    pub(super) async fn run(&mut self) {
        debug!("Started InputMessageListener without graceful shutdown support");
        while let Some(input_msg) = self.input_receiver.recv().await {
@@ -234,7 +234,6 @@ where
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub(super) fn start_with_shutdown(self, shutdown: task::ShutdownListener) {
        let mut acknowledgement_listener = self.acknowledgement_listener;
        let mut input_message_listener = self.input_message_listener;
@@ -280,7 +279,8 @@ where
        });
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    pub(super) fn start(self) {
        let mut acknowledgement_listener = self.acknowledgement_listener;
        let mut input_message_listener = self.input_message_listener;
@@ -125,10 +125,7 @@ where
            .expect("BatchRealMessageReceiver has stopped receiving!");
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started RetransmissionRequestListener with graceful shutdown support");

        while !shutdown.is_shutdown() {
@@ -145,13 +142,12 @@ where
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        shutdown.recv_timeout().await;
        log::debug!("RetransmissionRequestListener: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    pub(super) async fn run(&mut self) {
        debug!("Started RetransmissionRequestListener without graceful shutdown support");

@@ -42,7 +42,6 @@ impl SentNotificationListener {
            .unwrap();
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
        debug!("Started SentNotificationListener with graceful shutdown support");

@@ -66,7 +65,8 @@ impl SentNotificationListener {
        log::debug!("SentNotificationListener: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    pub(super) async fn run(&mut self) {
        debug!("Started SentNotificationListener without graceful shutdown support");

@@ -113,9 +113,9 @@ impl RealMessagesController<OsRng> {
        input_receiver: InputMessageReceiver,
        mix_sender: BatchMixMessageSender,
        topology_access: TopologyAccessor,
-        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
+        #[cfg(feature = "reply-surb")] reply_key_storage: ReplyKeyStorage,
    ) -> Self {
        let rng = OsRng;

@@ -175,7 +175,6 @@ impl RealMessagesController<OsRng> {
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub fn start_with_shutdown(self, shutdown: task::ShutdownListener) {
        let mut out_queue_control = self.out_queue_control;
        let ack_control = self.ack_control;
@@ -489,46 +489,67 @@ where
    fn log_status_infrequent(&self) {
        if self.sending_delay_controller.current_multiplier() > 1 {
            log::warn!(
-                "Unable to send packets fast enough - sending delay multiplier set to: {}",
+                "Unable to send packets at the default rate - rate reduced by setting the delay multiplier set to: {}",
                self.sending_delay_controller.current_multiplier()
            );
        }
    }

-    #[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(5));
-        let mut infrequent_status_timer = tokio::time::interval(Duration::from_secs(60));
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            let mut status_timer = tokio::time::interval(Duration::from_secs(5));
+            let mut infrequent_status_timer = tokio::time::interval(Duration::from_secs(60));

-        while !shutdown.is_shutdown() {
-            tokio::select! {
-                biased;
-                _ = shutdown.recv() => {
-                    log::trace!("OutQueueControl: Received shutdown");
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    biased;
+                    _ = shutdown.recv() => {
+                        log::trace!("OutQueueControl: Received shutdown");
+                    }
+                    _ = status_timer.tick() => {
+                        self.log_status();
+                    }
+                    _ = infrequent_status_timer.tick() => {
+                        self.log_status_infrequent();
+                    }
+                    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;
+                    }
                }
-                _ = status_timer.tick() => {
-                    self.log_status();
-                }
-                _ = infrequent_status_timer.tick() => {
-                    self.log_status_infrequent();
-                }
-                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;
+            }
+            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
+                .await
+                .expect("Task stopped without shutdown called");
+        }
+
+        #[cfg(target_arch = "wasm32")]
+        {
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    biased;
+                    _ = shutdown.recv() => {
+                        log::trace!("OutQueueControl: Received shutdown");
+                    }
+                    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;
+                    }
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
        log::debug!("OutQueueControl: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    pub(super) async fn run(&mut self) {
        debug!("Started OutQueueControl without graceful shutdown support");

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

 use client_connections::TransmissionLane;
-use rand::seq::SliceRandom;
+use rand::{seq::SliceRandom, Rng};
 use std::{
    collections::{HashMap, HashSet, VecDeque},
    time::Duration,
@@ -116,9 +116,15 @@ impl TransmissionBuffer {
        lanes.choose(&mut rand::thread_rng()).copied()
    }

+    // 2/3 chance to pick from the old lanes
    fn pick_random_old_lane(&self) -> Option<TransmissionLane> {
-        let lanes = self.get_oldest_set();
-        lanes.choose(&mut rand::thread_rng()).copied()
+        let rand = &mut rand::thread_rng();
+        if rand.gen_ratio(2, 3) {
+            let lanes = self.get_oldest_set();
+            lanes.choose(rand).copied()
+        } else {
+            self.pick_random_lane().copied()
+        }
    }

    fn pop_front_from_lane(&mut self, lane: &TransmissionLane) -> Option<RealMessage> {
@@ -320,10 +320,7 @@ impl RequestReceiver {
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started RequestReceiver with graceful shutdown support");
        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -342,13 +339,12 @@ impl RequestReceiver {
                },
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        shutdown.recv_timeout().await;
        log::debug!("RequestReceiver: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    async fn run(&mut self) {
        debug!("Started RequestReceiver without graceful shutdown support");

@@ -374,10 +370,7 @@ impl FragmentedMessageReceiver {
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    async fn run_with_shutdown(&mut self, mut shutdown: task::ShutdownListener) {
-        use std::time::Duration;
-
        debug!("Started FragmentedMessageReceiver with graceful shutdown support");
        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -395,13 +388,12 @@ impl FragmentedMessageReceiver {
                }
            }
        }
-        tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-            .await
-            .expect("Task stopped without shutdown called");
+        shutdown.recv_timeout().await;
        log::debug!("FragmentedMessageReceiver: Exiting");
    }

-    #[cfg(target_arch = "wasm32")]
+    // todo: think whether this is still required
+    #[allow(dead_code)]
    async fn run(&mut self) {
        debug!("Started FragmentedMessageReceiver without graceful shutdown support");

@@ -438,7 +430,6 @@ impl ReceivedMessagesBufferController {
        }
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub fn start_with_shutdown(self, shutdown: task::ShutdownListener) {
        let mut fragmented_message_receiver = self.fragmented_message_receiver;
        let mut request_receiver = self.request_receiver;
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::spawn_future;
+use futures::StreamExt;
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::params::DEFAULT_NUM_MIX_HOPS;
@@ -186,13 +187,10 @@ impl TopologyRefresher {
    /// # Arguments
    ///
    /// * `topology`: active topology constructed from validator api data
-    /// * `mixnodes_count`: total number of active mixnodes
-    fn check_layer_distribution(
-        &self,
-        active_topology: &NymTopology,
-        mixnodes_count: usize,
-    ) -> bool {
+    fn check_layer_distribution(&self, active_topology: &NymTopology) -> bool {
        let mixes = active_topology.mixes();
+        let mixnodes_count = active_topology.num_mixnodes();
+
        if active_topology.gateways().is_empty() {
            return false;
        }
@@ -257,11 +255,10 @@ impl TopologyRefresher {
            Ok(gateways) => gateways,
        };

-        let mixnodes_count = mixnodes.len();
        let topology = nym_topology_from_detailed(mixnodes, gateways)
            .filter_system_version(&self.client_version);

-        if !self.check_layer_distribution(&topology, mixnodes_count) {
+        if !self.check_layer_distribution(&topology) {
            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
            None
        } else {
@@ -296,14 +293,22 @@ impl TopologyRefresher {
        self.topology_accessor.is_routable().await
    }

-    #[cfg(not(target_arch = "wasm32"))]
    pub fn start_with_shutdown(mut self, mut shutdown: task::ShutdownListener) {
        spawn_future(async move {
            debug!("Started TopologyRefresher with graceful shutdown support");

+            #[cfg(not(target_arch = "wasm32"))]
+            let mut interval = tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(
+                self.refresh_rate,
+            ));
+
+            #[cfg(target_arch = "wasm32")]
+            let mut interval =
+                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
+
            while !shutdown.is_shutdown() {
                tokio::select! {
-                    _ = tokio::time::sleep(self.refresh_rate) => {
+                    _ = interval.next() => {
                        self.refresh().await;
                    },
                    _ = shutdown.recv() => {
@@ -311,21 +316,23 @@ impl TopologyRefresher {
                    },
                }
            }
-            tokio::time::timeout(Duration::from_secs(5), shutdown.recv())
-                .await
-                .expect("Task stopped without shutdown called");
+            shutdown.recv_timeout().await;
            log::debug!("TopologyRefresher: Exiting");
        })
    }

-    #[cfg(target_arch = "wasm32")]
    pub fn start(mut self) {
-        use futures::StreamExt;
-
        spawn_future(async move {
+            #[cfg(not(target_arch = "wasm32"))]
+            let mut interval = tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(
+                self.refresh_rate,
+            ));
+
+            #[cfg(target_arch = "wasm32")]
            let mut interval =
                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
-            while let Some(_) = interval.next().await {
+
+            while (interval.next().await).is_some() {
                self.refresh().await;
            }
        })
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use config::NymConfig;
+use config::{NymConfig, DB_FILE_NAME};
 use nymsphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
@@ -34,7 +34,11 @@ pub fn missing_string_value() -> String {
    MISSING_VALUE.to_string()
 }

-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+pub trait ClientCoreConfigTrait {
+    fn get_gateway_endpoint(&self) -> &GatewayEndpointConfig;
+}
+
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Config<T> {
    client: Client<T>,
@@ -42,17 +46,29 @@ pub struct Config<T> {
    #[serde(default)]
    logging: Logging,
    #[serde(default)]
-    debug: Debug,
+    debug: DebugConfig,
 }

-impl<T: NymConfig> Config<T> {
-    pub fn new<S: Into<String>>(id: S) -> Self {
+impl<T> ClientCoreConfigTrait for Config<T> {
+    fn get_gateway_endpoint(&self) -> &GatewayEndpointConfig {
+        &self.client.gateway_endpoint
+    }
+}
+
+impl<T> Config<T> {
+    pub fn new<S: Into<String>>(id: S) -> Self
+    where
+        T: NymConfig,
+    {
        let mut cfg = Config::default();
        cfg.with_id(id);
        cfg
    }

-    pub fn with_id<S: Into<String>>(&mut self, id: S) {
+    pub fn with_id<S: Into<String>>(&mut self, id: S)
+    where
+        T: NymConfig,
+    {
        let id = id.into();

        // identity key setting
@@ -117,7 +133,7 @@ impl<T: NymConfig> Config<T> {
        self.client.disabled_credentials_mode = disabled_credentials_mode;
    }

-    pub fn with_gateway_endpoint(&mut self, gateway_endpoint: GatewayEndpoint) {
+    pub fn with_gateway_endpoint(&mut self, gateway_endpoint: GatewayEndpointConfig) {
        self.client.gateway_endpoint = gateway_endpoint;
    }

@@ -135,8 +151,15 @@ impl<T: NymConfig> Config<T> {

    pub fn set_high_default_traffic_volume(&mut self) {
        self.debug.average_packet_delay = Duration::from_millis(10);
-        self.debug.loop_cover_traffic_average_delay = Duration::from_millis(2_000_000); // basically don't really send cover messages
-        self.debug.message_sending_average_delay = Duration::from_millis(4); // 250 "real" messages / s
+        // basically don't really send cover messages
+        self.debug.loop_cover_traffic_average_delay = Duration::from_millis(2_000_000);
+        // 250 "real" messages / s
+        self.debug.message_sending_average_delay = Duration::from_millis(4);
+    }
+
+    pub fn set_no_cover_traffic(&mut self) {
+        self.debug.disable_loop_cover_traffic_stream = true;
+        self.debug.disable_main_poisson_packet_distribution = true;
    }

    pub fn set_custom_version(&mut self, version: &str) {
@@ -203,7 +226,7 @@ impl<T: NymConfig> Config<T> {
        self.client.gateway_endpoint.gateway_listener.clone()
    }

-    pub fn get_gateway_endpoint(&self) -> &GatewayEndpoint {
+    pub fn get_gateway_endpoint_config(&self) -> &GatewayEndpointConfig {
        &self.client.gateway_endpoint
    }

@@ -212,6 +235,10 @@ impl<T: NymConfig> Config<T> {
    }

    // Debug getters
+    pub fn get_debug_config(&self) -> &DebugConfig {
+        &self.debug
+    }
+
    pub fn get_average_packet_delay(&self) -> Duration {
        self.debug.average_packet_delay
    }
@@ -257,7 +284,7 @@ impl<T: NymConfig> Config<T> {
    }

    pub fn get_use_extended_packet_size(&self) -> Option<ExtendedPacketSize> {
-        self.debug.use_extended_packet_size.clone()
+        self.debug.use_extended_packet_size
    }

    pub fn get_version(&self) -> &str {
@@ -277,7 +304,7 @@ impl<T: NymConfig> Default for Config<T> {

 #[derive(Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen(getter_with_clone))]
-pub struct GatewayEndpoint {
+pub struct GatewayEndpointConfig {
    /// gateway_id specifies ID of the gateway to which the client should send messages.
    /// If initially omitted, a random gateway will be chosen from the available topology.
    pub gateway_id: String,
@@ -289,10 +316,10 @@ pub struct GatewayEndpoint {
    pub gateway_listener: String,
 }

-impl From<topology::gateway::Node> for GatewayEndpoint {
-    fn from(node: topology::gateway::Node) -> GatewayEndpoint {
+impl From<topology::gateway::Node> for GatewayEndpointConfig {
+    fn from(node: topology::gateway::Node) -> GatewayEndpointConfig {
        let gateway_listener = node.clients_address();
-        GatewayEndpoint {
+        GatewayEndpointConfig {
            gateway_id: node.identity_key.to_base58_string(),
            gateway_owner: node.owner,
            gateway_listener,
@@ -300,7 +327,7 @@ impl From<topology::gateway::Node> for GatewayEndpoint {
    }
 }

-#[derive(Debug, Deserialize, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, Deserialize, PartialEq, Eq, Serialize)]
 pub struct Client<T> {
    /// Version of the client for which this configuration was created.
    #[serde(default = "missing_string_value")]
@@ -346,7 +373,7 @@ pub struct Client<T> {
    reply_encryption_key_store_path: PathBuf,

    /// Information regarding how the client should send data to gateway.
-    gateway_endpoint: GatewayEndpoint,
+    gateway_endpoint: GatewayEndpointConfig,

    /// Path to the database containing bandwidth credentials of this client.
    database_path: PathBuf,
@@ -412,17 +439,17 @@ impl<T: NymConfig> Client<T> {
        T::default_data_directory(Some(id)).join("reply_key_store")
    }
    fn default_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(Some(id)).join("db.sqlite")
+        T::default_data_directory(Some(id)).join(DB_FILE_NAME)
    }
 }

-#[derive(Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
+#[derive(Debug, Clone, Default, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Logging {}

-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct Debug {
+pub struct DebugConfig {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent packet is going to be delayed at any given mix node.
    /// So for a packet going through three mix nodes, on average, it will take three times this value
@@ -488,7 +515,7 @@ pub struct Debug {
    pub use_extended_packet_size: Option<ExtendedPacketSize>,
 }

-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(rename_all = "lowercase")]
 pub enum ExtendedPacketSize {
    Extended8,
@@ -496,9 +523,9 @@ pub enum ExtendedPacketSize {
    Extended32,
 }

-impl Default for Debug {
+impl Default for DebugConfig {
    fn default() -> Self {
-        Debug {
+        DebugConfig {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
@@ -1,6 +1,8 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+#[cfg(feature = "reply-surb")]
+use crate::client::reply_key_storage::ReplyKeyStorageError;
 use crypto::asymmetric::identity::Ed25519RecoveryError;
 use gateway_client::error::GatewayClientError;
 use validator_client::ValidatorClientError;
@@ -16,10 +18,16 @@ pub enum ClientCoreError {
    #[error("Validator client error: {0}")]
    ValidatorClientError(#[from] ValidatorClientError),

+    #[cfg(feature = "reply-surb")]
+    #[error("Reply key storage error: {0}")]
+    ReplyKeyStorageError(#[from] ReplyKeyStorageError),
+
    #[error("No gateway with id: {0}")]
    NoGatewayWithId(String),
    #[error("No gateways on network")]
    NoGatewaysOnNetwork,
+    #[error("Failed to setup gateway")]
+    FailedToSetupGateway,
    #[error("List of validator apis is empty")]
    ListOfValidatorApisIsEmpty,
    #[error("Could not load existing gateway configuration: {0}")]
@@ -27,6 +35,16 @@ pub enum ClientCoreError {
    #[error("The current network topology seem to be insufficient to route any packets through")]
    InsufficientNetworkTopology,

+    #[error("The gateway id is invalid - {0}")]
+    UnableToCreatePublicKeyFromGatewayId(Ed25519RecoveryError),
+
+    #[error("The identity of the gateway is unknwown - did you run init?")]
+    GatewayIdUnknown,
+    #[error("The owner of the gateway is unknown - did you run init?")]
+    GatewayOwnerUnknown,
+    #[error("The address of the gateway is unknown - did you run init?")]
+    GatwayAddressUnknown,
+
    #[error("Unexpected exit")]
    UnexpectedExit,
 }
@@ -1,22 +1,14 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-//! Collection of initialization steps used by client implementations
-
 use std::{sync::Arc, time::Duration};

+use rand::{rngs::OsRng, seq::SliceRandom, thread_rng};
+use tap::TapFallible;
+use url::Url;
+
 use config::NymConfig;
-use crypto::asymmetric::{encryption, identity};
+use crypto::asymmetric::identity;
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::addressing::nodes::NodeIdentity;
-use rand::rngs::OsRng;
-use rand::seq::SliceRandom;
-use rand::thread_rng;
-use tap::TapFallible;
 use topology::{filter::VersionFilterable, gateway};
-use url::Url;

 use crate::{
    client::key_manager::KeyManager,
@@ -24,9 +16,9 @@ use crate::{
    error::ClientCoreError,
 };

-pub async fn query_gateway_details(
+pub(super) async fn query_gateway_details(
    validator_servers: Vec<Url>,
-    chosen_gateway_id: Option<&str>,
+    chosen_gateway_id: Option<String>,
 ) -> Result<gateway::Node, ClientCoreError> {
    let validator_api = validator_servers
        .choose(&mut thread_rng())
@@ -59,7 +51,30 @@ pub async fn query_gateway_details(
    }
 }

-pub async fn register_with_gateway_and_store_keys<T>(
+async fn register_with_gateway(
+    gateway: &gateway::Node,
+    our_identity: Arc<identity::KeyPair>,
+) -> Result<Arc<SharedKeys>, ClientCoreError> {
+    let timeout = Duration::from_millis(1500);
+    let mut gateway_client = GatewayClient::new_init(
+        gateway.clients_address(),
+        gateway.identity_key,
+        gateway.owner.clone(),
+        our_identity.clone(),
+        timeout,
+    );
+    gateway_client
+        .establish_connection()
+        .await
+        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
+    let shared_keys = gateway_client
+        .perform_initial_authentication()
+        .await
+        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
+    Ok(shared_keys)
+}
+
+pub(super) async fn register_with_gateway_and_store_keys<T>(
    gateway_details: gateway::Node,
    config: &Config<T>,
 ) -> Result<(), ClientCoreError>
@@ -78,72 +93,3 @@ where
        .store_keys(&pathfinder)
        .tap_err(|err| log::error!("Failed to generate keys: {err}"))?)
 }
-
-async fn register_with_gateway(
-    gateway: &gateway::Node,
-    our_identity: Arc<identity::KeyPair>,
-) -> Result<Arc<SharedKeys>, ClientCoreError> {
-    let timeout = Duration::from_millis(1500);
-    let mut gateway_client = GatewayClient::new_init(
-        gateway.clients_address(),
-        gateway.identity_key,
-        gateway.owner.clone(),
-        our_identity.clone(),
-        timeout,
-        #[cfg(not(target_arch = "wasm32"))]
-        None,
-    );
-    gateway_client
-        .establish_connection()
-        .await
-        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
-    let shared_keys = gateway_client
-        .perform_initial_authentication()
-        .await
-        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
-    Ok(shared_keys)
-}
-
-pub fn show_address<T>(config: &Config<T>) -> Result<(), ClientCoreError>
-where
-    T: config::NymConfig,
-{
-    fn load_identity_keys(
-        pathfinder: &ClientKeyPathfinder,
-    ) -> Result<identity::KeyPair, ClientCoreError> {
-        let identity_keypair: identity::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_identity_key().to_owned(),
-                pathfinder.public_identity_key().to_owned(),
-            ))
-            .tap_err(|_| log::error!("Failed to read stored identity key files"))?;
-        Ok(identity_keypair)
-    }
-
-    fn load_sphinx_keys(
-        pathfinder: &ClientKeyPathfinder,
-    ) -> Result<encryption::KeyPair, ClientCoreError> {
-        let sphinx_keypair: encryption::KeyPair =
-            pemstore::load_keypair(&pemstore::KeyPairPath::new(
-                pathfinder.private_encryption_key().to_owned(),
-                pathfinder.public_encryption_key().to_owned(),
-            ))
-            .tap_err(|_| log::error!("Failed to read stored sphinx key files"))?;
-        Ok(sphinx_keypair)
-    }
-
-    let pathfinder = ClientKeyPathfinder::new_from_config(config);
-    let identity_keypair = load_identity_keys(&pathfinder)?;
-    let sphinx_keypair = load_sphinx_keys(&pathfinder)?;
-
-    let client_recipient = Recipient::new(
-        *identity_keypair.public_key(),
-        *sphinx_keypair.public_key(),
-        // TODO: below only works under assumption that gateway address == gateway id
-        // (which currently is true)
-        NodeIdentity::from_base58_string(config.get_gateway_id())?,
-    );
-
-    println!("\nThe address of this client is: {}", client_recipient);
-    Ok(())
-}
@@ -0,0 +1,191 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+//! Collection of initialization steps used by client implementations
+
+use std::fmt::Display;
+
+use nymsphinx::addressing::{clients::Recipient, nodes::NodeIdentity};
+use serde::Serialize;
+use tap::TapFallible;
+
+use config::NymConfig;
+use crypto::asymmetric::{encryption, identity};
+
+use crate::{
+    config::{
+        persistence::key_pathfinder::ClientKeyPathfinder, ClientCoreConfigTrait, Config,
+        GatewayEndpointConfig,
+    },
+    error::ClientCoreError,
+    init::helpers::{query_gateway_details, register_with_gateway_and_store_keys},
+};
+
+mod helpers;
+
+#[derive(Debug, Serialize)]
+pub struct InitResults {
+    version: String,
+    id: String,
+    identity_key: String,
+    encryption_key: String,
+    gateway_id: String,
+    gateway_listener: String,
+}
+
+impl InitResults {
+    pub fn new<T>(config: &Config<T>, address: &Recipient) -> Self
+    where
+        T: NymConfig,
+    {
+        Self {
+            version: config.get_version().to_string(),
+            id: config.get_id(),
+            identity_key: address.identity().to_base58_string(),
+            encryption_key: address.encryption_key().to_base58_string(),
+            gateway_id: config.get_gateway_id(),
+            gateway_listener: config.get_gateway_listener(),
+        }
+    }
+}
+
+impl Display for InitResults {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "Version: {}", self.version)?;
+        writeln!(f, "ID: {}", self.id)?;
+        writeln!(f, "Identity key: {}", self.identity_key)?;
+        writeln!(f, "Encryption: {}", self.encryption_key)?;
+        writeln!(f, "Gateway ID: {}", self.gateway_id)?;
+        write!(f, "Gateway: {}", self.gateway_listener)
+    }
+}
+
+/// Convenience function for setting up the gateway for a client. Depending on the arguments given
+/// it will do the sensible thing.
+pub async fn setup_gateway<C: NymConfig + ClientCoreConfigTrait, T: NymConfig>(
+    register_gateway: bool,
+    user_chosen_gateway_id: Option<String>,
+    config: &Config<T>,
+) -> Result<GatewayEndpointConfig, ClientCoreError> {
+    let id = config.get_id();
+    if register_gateway {
+        register_with_gateway(user_chosen_gateway_id, config).await
+    } else if let Some(user_chosen_gateway_id) = user_chosen_gateway_id {
+        config_gateway_with_existing_keys(user_chosen_gateway_id, config).await
+    } else {
+        reuse_existing_gateway_config::<C>(&id)
+    }
+}
+
+/// Get the gateway details by querying the validator-api. Either pick one at random or use
+/// the chosen one if it's among the available ones.
+/// Saves keys to disk, specified by the paths in `config`.
+pub async fn register_with_gateway<T: NymConfig>(
+    user_chosen_gateway_id: Option<String>,
+    config: &Config<T>,
+) -> Result<GatewayEndpointConfig, ClientCoreError> {
+    println!("Configuring gateway");
+    let gateway =
+        query_gateway_details(config.get_validator_api_endpoints(), user_chosen_gateway_id).await?;
+    log::debug!("Querying gateway gives: {}", gateway);
+
+    // Registering with gateway by setting up and writing shared keys to disk
+    log::trace!("Registering gateway");
+    register_with_gateway_and_store_keys(gateway.clone(), config).await?;
+    println!("Saved all generated keys");
+
+    Ok(gateway.into())
+}
+
+/// Set the gateway using the usual procedue of querying the validator-api, but don't register or
+/// create any keys.
+/// This assumes that the user knows what they are doing, and that the existing keys are valid for
+/// the gateway being used
+pub async fn config_gateway_with_existing_keys<T: NymConfig>(
+    user_chosen_gateway_id: String,
+    config: &Config<T>,
+) -> Result<GatewayEndpointConfig, ClientCoreError> {
+    println!("Using gateway provided by user, keeping existing keys");
+    let gateway = query_gateway_details(
+        config.get_validator_api_endpoints(),
+        Some(user_chosen_gateway_id),
+    )
+    .await?;
+    log::debug!("Querying gateway gives: {}", gateway);
+    Ok(gateway.into())
+}
+
+/// Read and reuse the existing gateway configuration from a file that was generate earlier.
+pub fn reuse_existing_gateway_config<T: NymConfig + ClientCoreConfigTrait>(
+    id: &str,
+) -> Result<GatewayEndpointConfig, ClientCoreError> {
+    println!("Not registering gateway, will reuse existing config and keys");
+    T::load_from_file(Some(id))
+        .map(|existing_config| existing_config.get_gateway_endpoint().clone())
+        .map_err(|err| {
+            log::error!(
+                "Unable to configure gateway: {err}. \n
+                Seems like the client was already initialized but it was not possible to read \
+                the existing configuration file. \n
+                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
+                removing the existing configuration and starting over."
+            );
+            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
+        })
+}
+
+/// Get the client address by loading the keys from stored files.
+pub fn get_client_address_from_stored_keys<T>(
+    config: &Config<T>,
+) -> Result<Recipient, ClientCoreError>
+where
+    T: config::NymConfig,
+{
+    fn load_identity_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<identity::KeyPair, ClientCoreError> {
+        let identity_keypair: identity::KeyPair =
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+                pathfinder.private_identity_key().to_owned(),
+                pathfinder.public_identity_key().to_owned(),
+            ))
+            .tap_err(|_| log::error!("Failed to read stored identity key files"))?;
+        Ok(identity_keypair)
+    }
+
+    fn load_sphinx_keys(
+        pathfinder: &ClientKeyPathfinder,
+    ) -> Result<encryption::KeyPair, ClientCoreError> {
+        let sphinx_keypair: encryption::KeyPair =
+            pemstore::load_keypair(&pemstore::KeyPairPath::new(
+                pathfinder.private_encryption_key().to_owned(),
+                pathfinder.public_encryption_key().to_owned(),
+            ))
+            .tap_err(|_| log::error!("Failed to read stored sphinx key files"))?;
+        Ok(sphinx_keypair)
+    }
+
+    let pathfinder = ClientKeyPathfinder::new_from_config(config);
+    let identity_keypair = load_identity_keys(&pathfinder)?;
+    let sphinx_keypair = load_sphinx_keys(&pathfinder)?;
+
+    let client_recipient = Recipient::new(
+        *identity_keypair.public_key(),
+        *sphinx_keypair.public_key(),
+        // TODO: below only works under assumption that gateway address == gateway id
+        // (which currently is true)
+        NodeIdentity::from_base58_string(config.get_gateway_id())?,
+    );
+
+    Ok(client_recipient)
+}
+
+pub fn output_to_json<T: Serialize>(init_results: &T, output_file: &str) {
+    match std::fs::File::create(output_file) {
+        Ok(file) => match serde_json::to_writer_pretty(file, init_results) {
+            Ok(_) => println!("Saved: {}", output_file),
+            Err(err) => eprintln!("Could not save {}: {}", output_file, err),
+        },
+        Err(err) => eprintln!("Could not save {}: {}", output_file, err),
+    }
+}
@@ -6,11 +6,9 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-async-trait = "0.1.52"
 bip39 = "1.0.1"
 cfg-if = "0.1"
 clap = { version = "3.2", features = ["cargo", "derive"] }
-pickledb = "0.4.1"
 rand = "0.7.3"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
@@ -1,14 +1,12 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use async_trait::async_trait;
 use clap::{Args, Subcommand};
 use completions::ArgShell;
-use pickledb::PickleDb;
 use rand::rngs::OsRng;
 use std::str::FromStr;

-use coconut_interface::{Attribute, Base58, BlindSignRequest, Bytable, Parameters};
+use coconut_interface::{Base58, Parameters};
 use credential_storage::storage::Storage;
 use credential_storage::PersistentStorage;
 use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
@@ -20,16 +18,12 @@ use validator_client::{CoconutApiClient, Config};

 use crate::client::Client;
 use crate::error::{CredentialClientError, Result};
-use crate::state::{KeyPair, RequestData, State};
+use crate::state::{KeyPair, State};

 #[derive(Subcommand)]
-pub(crate) enum Commands {
-    /// Deposit funds for buying coconut credential
-    Deposit(Deposit),
-    /// Lists the tx hashes of previous deposits
-    ListDeposits(ListDeposits),
-    /// Get a credential for a given deposit
-    GetCredential(GetCredential),
+pub(crate) enum Command {
+    /// Run the binary
+    Run(Run),

    /// Generate shell completions
    Completions(ArgShell),
@@ -38,169 +32,82 @@ pub(crate) enum Commands {
    GenerateFigSpec,
 }

-#[async_trait]
-pub(crate) trait Execute {
-    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()>;
-}
+#[derive(Args)]
+pub(crate) struct Run {
+    /// Home directory of the client that is supposed to use the credential.
+    #[clap(long)]
+    pub(crate) client_home_directory: std::path::PathBuf,

-#[derive(Args, Clone)]
-pub(crate) struct Deposit {
    /// The nymd URL that should be used
    #[clap(long)]
-    nymd_url: String,
-    /// A mnemonic for the account that does the deposit
+    pub(crate) nymd_url: String,
+
+    /// A mnemonic for the account that buys the credential
    #[clap(long)]
-    mnemonic: String,
-    /// The amount that needs to be deposited
+    pub(crate) mnemonic: String,
+
+    /// The amount of utokens the credential will hold
    #[clap(long)]
-    amount: u64,
+    pub(crate) amount: u64,
 }

-#[async_trait]
-impl Execute for Deposit {
-    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
-        let mut rng = OsRng;
-        let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
-        let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
+pub(crate) async fn deposit(nymd_url: &str, mnemonic: &str, amount: u64) -> Result<State> {
+    let mut rng = OsRng;
+    let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
+    let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));

-        let client = Client::new(&self.nymd_url, &self.mnemonic);
-        let tx_hash = client
-            .deposit(
-                self.amount,
-                signing_keypair.public_key.clone(),
-                encryption_keypair.public_key.clone(),
-                None,
-            )
-            .await?;
-
-        let state = State {
-            amount: self.amount,
-            tx_hash: tx_hash.clone(),
-            signing_keypair,
-            encryption_keypair,
-            blind_request_data: None,
-            signature: None,
-        };
-        db.set(&tx_hash, &state).unwrap();
-
-        println!("{:?}", state);
-
-        Ok(())
-    }
-}
-
-#[derive(Args, Clone)]
-pub(crate) struct ListDeposits {}
-
-#[async_trait]
-impl Execute for ListDeposits {
-    async fn execute(&self, db: &mut PickleDb, _shared_storage: PersistentStorage) -> Result<()> {
-        for kv in db.iter() {
-            println!("{:?}", kv.get_value::<State>());
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Args, Clone)]
-pub(crate) struct GetCredential {
-    /// The hash of a successful deposit transaction
-    #[clap(long)]
-    tx_hash: String,
-    /// The nymd URL that should be used
-    #[clap(long)]
-    nymd_url: String,
-    /// If we want to get the signature without attaching a blind sign request; it is expected that
-    /// there is already a signature stored on the signer
-    #[clap(long, parse(from_flag))]
-    __no_request: bool,
-}
-
-#[async_trait]
-impl Execute for GetCredential {
-    async fn execute(&self, db: &mut PickleDb, shared_storage: PersistentStorage) -> Result<()> {
-        let mut state = db
-            .get::<State>(&self.tx_hash)
-            .ok_or(CredentialClientError::NoDeposit)?;
-
-        let network_details = NymNetworkDetails::new_from_env();
-        let config = Config::try_from_nym_network_details(&network_details)?;
-        let client = validator_client::Client::new_query(config)?;
-        let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client).await?;
-
-        let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-        let bandwidth_credential_attributes = if self.__no_request {
-            if let Some(blind_request_data) = state.blind_request_data {
-                let serial_number =
-                    Attribute::try_from_byte_slice(&blind_request_data.serial_number)
-                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
-                let binding_number =
-                    Attribute::try_from_byte_slice(&blind_request_data.binding_number)
-                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
-                let pedersen_commitments_openings = vec![
-                    Attribute::try_from_byte_slice(&blind_request_data.first_attribute)
-                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
-                    Attribute::try_from_byte_slice(&blind_request_data.second_attribute)
-                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?,
-                ];
-                let blind_sign_request =
-                    BlindSignRequest::from_bytes(blind_request_data.blind_sign_req.as_slice())
-                        .map_err(|_| CredentialClientError::CorruptedBlindSignRequest)?;
-                BandwidthVoucher::new_with_blind_sign_req(
-                    [serial_number, binding_number],
-                    [&state.amount.to_string(), VOUCHER_INFO],
-                    Hash::from_str(&self.tx_hash)
-                        .map_err(|_| CredentialClientError::InvalidTxHash)?,
-                    identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
-                    encryption::PrivateKey::from_base58_string(
-                        &state.encryption_keypair.private_key,
-                    )?,
-                    pedersen_commitments_openings,
-                    blind_sign_request,
-                )
-            } else {
-                return Err(CredentialClientError::NoLocalBlindSignRequest);
-            }
-        } else {
-            BandwidthVoucher::new(
-                &params,
-                state.amount.to_string(),
-                VOUCHER_INFO.to_string(),
-                Hash::from_str(&self.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
-                identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
-                encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
-            )
-        };
-
-        // Back up the blind sign req data, in case of sporadic failures
-        state.blind_request_data = Some(RequestData::new(
-            bandwidth_credential_attributes.get_private_attributes(),
-            bandwidth_credential_attributes.pedersen_commitments_openings(),
-            bandwidth_credential_attributes.blind_sign_request(),
-        )?);
-        db.set(&self.tx_hash, &state).unwrap();
-
-        let signature = obtain_aggregate_signature(
-            &params,
-            &bandwidth_credential_attributes,
-            &coconut_api_clients,
+    let client = Client::new(nymd_url, mnemonic);
+    let tx_hash = client
+        .deposit(
+            amount,
+            signing_keypair.public_key.clone(),
+            encryption_keypair.public_key.clone(),
+            None,
        )
        .await?;
-        shared_storage
-            .insert_coconut_credential(
-                state.amount.to_string(),
-                VOUCHER_INFO.to_string(),
-                bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
-                bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
-                signature.to_bs58(),
-            )
-            .await?;
-        state.signature = Some(signature.to_bs58());
-        db.set(&self.tx_hash, &state).unwrap();

-        println!("Signature: {:?}", state.signature);
+    let state = State {
+        amount,
+        tx_hash,
+        signing_keypair,
+        encryption_keypair,
+    };

-        Ok(())
-    }
+    Ok(state)
+}
+
+pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStorage) -> Result<()> {
+    let network_details = NymNetworkDetails::new_from_env();
+    let config = Config::try_from_nym_network_details(&network_details)?;
+    let client = validator_client::Client::new_query(config)?;
+    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client).await?;
+
+    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+    let bandwidth_credential_attributes = BandwidthVoucher::new(
+        &params,
+        state.amount.to_string(),
+        VOUCHER_INFO.to_string(),
+        Hash::from_str(&state.tx_hash).map_err(|_| CredentialClientError::InvalidTxHash)?,
+        identity::PrivateKey::from_base58_string(&state.signing_keypair.private_key)?,
+        encryption::PrivateKey::from_base58_string(&state.encryption_keypair.private_key)?,
+    );
+
+    let signature = obtain_aggregate_signature(
+        &params,
+        &bandwidth_credential_attributes,
+        &coconut_api_clients,
+    )
+    .await?;
+    println!("Signature: {:?}", signature.to_bs58());
+    shared_storage
+        .insert_coconut_credential(
+            state.amount.to_string(),
+            VOUCHER_INFO.to_string(),
+            bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
+            bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
+            signature.to_bs58(),
+        )
+        .await?;
+
+    Ok(())
 }
@@ -23,18 +23,6 @@ pub enum CredentialClientError {
    #[error("Credential error: {0}")]
    Credential(#[from] CredentialError),

-    #[error("No previous deposit with that tx hash")]
-    NoDeposit,
-
-    #[error("Wrong number of attributes")]
-    WrongAttributeNumber,
-
-    #[error("Could not find any backed up blind sign request data")]
-    NoLocalBlindSignRequest,
-
-    #[error("The local blind sign request data is corrupted")]
-    CorruptedBlindSignRequest,
-
    #[error("The tx hash provided is not valid")]
    InvalidTxHash,

@@ -9,14 +9,13 @@ cfg_if::cfg_if! {
        mod error;
        mod state;

-        use commands::{Commands, Execute};
        use error::Result;
        use network_defaults::setup_env;
-        use clap::CommandFactory;
        use completions::fig_generate;
+        use commands::*;
+        use config::{DATA_DIR, DB_FILE_NAME};

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

        #[derive(Parser)]
        #[clap(author = "Nymtech", version, about)]
@@ -25,43 +24,26 @@ cfg_if::cfg_if! {
            #[clap(short, long)]
            pub(crate) config_env_file: Option<std::path::PathBuf>,

-            /// Path where the sqlite credental database will be located.
-            /// It should point to a $HOME/$CLIENT_ID/data/db.sqlite file of
-            /// the client that is supposed to use the credential.
-            #[clap(long)]
-            pub(crate) credential_db_path: std::path::PathBuf,
-
            #[clap(subcommand)]
-            command: Commands,
+            pub(crate) command: Command,
        }

        #[tokio::main]
        async fn main() -> Result<()> {
            let args = Cli::parse();
            setup_env(args.config_env_file.clone());
-
-            let shared_storage = credential_storage::initialise_storage(args.credential_db_path.clone()).await;
-            let mut db = match PickleDb::load(
-                "credential.db",
-                PickleDbDumpPolicy::AutoDump,
-                SerializationMethod::Json,
-            ) {
-                Ok(db) => db,
-                Err(_) => PickleDb::new(
-                    "credential.db",
-                    PickleDbDumpPolicy::AutoDump,
-                    SerializationMethod::Json,
-                ),
-            };
-
            let bin_name = "nym-credential-client";

-            match &args.command {
-                Commands::Deposit(m) => m.execute(&mut db, shared_storage).await?,
-                Commands::ListDeposits(m) => m.execute(&mut db, shared_storage).await?,
-                Commands::GetCredential(m) => m.execute(&mut db, shared_storage).await?,
-                Commands::Completions(s) => s.generate(&mut crate::Cli::into_app(), bin_name),
-                Commands::GenerateFigSpec => fig_generate(&mut crate::Cli::into_app(), bin_name)
+            match args.command {
+                Command::Run(r) => {
+                    let db_path = r.client_home_directory.join(DATA_DIR).join(DB_FILE_NAME);
+                    let shared_storage = credential_storage::initialise_storage(db_path).await;
+
+                    let state = deposit(&r.nymd_url, &r.mnemonic, r.amount).await?;
+                    get_credential(&state, shared_storage).await?;
+                }
+                Command::Completions(c) => c.generate(&mut crate::Cli::into_app(), bin_name),
+                Command::GenerateFigSpec => fig_generate(&mut crate::Cli::into_app(), bin_name)
            }

            Ok(())
@@ -1,13 +1,10 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use coconut_interface::{Attribute, BlindSignRequest, Bytable, PrivateAttribute};
 use serde::{Deserialize, Serialize};

 use crypto::asymmetric::{encryption, identity};

-use crate::error::{CredentialClientError, Result};
-
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub(crate) struct KeyPair {
    pub public_key: String,
@@ -38,35 +35,4 @@ pub(crate) struct State {
    pub tx_hash: String,
    pub signing_keypair: KeyPair,
    pub encryption_keypair: KeyPair,
-    pub blind_request_data: Option<RequestData>,
-    pub signature: Option<String>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub(crate) struct RequestData {
-    pub serial_number: Vec<u8>,
-    pub binding_number: Vec<u8>,
-    pub first_attribute: Vec<u8>,
-    pub second_attribute: Vec<u8>,
-    pub blind_sign_req: Vec<u8>,
-}
-
-impl RequestData {
-    pub fn new(
-        private_attributes: Vec<PrivateAttribute>,
-        attributes: &[Attribute],
-        blind_sign_request: &BlindSignRequest,
-    ) -> Result<Self> {
-        if private_attributes.len() != 2 || attributes.len() != 2 {
-            Err(CredentialClientError::WrongAttributeNumber)
-        } else {
-            Ok(RequestData {
-                serial_number: private_attributes[0].to_byte_vec(),
-                binding_number: private_attributes[1].to_byte_vec(),
-                first_attribute: attributes[0].to_byte_vec(),
-                second_attribute: attributes[1].to_byte_vec(),
-                blind_sign_req: blind_sign_request.to_bytes(),
-            })
-        }
-    }
 }
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.0"
+version = "1.1.3"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -26,7 +26,9 @@ log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
 rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
+serde_json = "1.0"
 sled = "0.34" # for storage of replySURB decryption keys
+tap = "1.0.1"
 thiserror = "1.0.34"
 tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = "0.14" # websocket
@@ -51,7 +53,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"]
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::template::config_template;
-use client_core::config::Config as BaseConfig;
 pub use client_core::config::MISSING_VALUE;
+use client_core::config::{ClientCoreConfigTrait, Config as BaseConfig};
 use config::defaults::DEFAULT_WEBSOCKET_LISTENING_PORT;
 use config::NymConfig;
 use serde::{Deserialize, Serialize};
@@ -27,6 +27,10 @@ impl SocketType {
            _ => SocketType::None,
        }
    }
+
+    pub fn is_websocket(self) -> bool {
+        matches!(self, SocketType::WebSocket)
+    }
 }

 #[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
@@ -69,6 +73,12 @@ impl NymConfig for Config {
    }
 }

+impl ClientCoreConfigTrait for Config {
+    fn get_gateway_endpoint(&self) -> &client_core::config::GatewayEndpointConfig {
+        self.base.get_gateway_endpoint()
+    }
+}
+
 impl Config {
    pub fn new<S: Into<String>>(id: S) -> Self {
        Config {
@@ -1,210 +1,64 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_connections::{
-    ConnectionCommandReceiver, ConnectionCommandSender, 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::real_messages_control;
-use client_core::client::real_messages_control::RealMessagesController;
-use client_core::client::received_buffer::{
-    ReceivedBufferMessage, ReceivedBufferRequestReceiver, ReceivedBufferRequestSender,
-    ReceivedMessagesBufferController, ReconstructedMessagesReceiver,
-};
-use client_core::client::reply_key_storage::ReplyKeyStorage;
-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;
-use gateway_client::{
-    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
-    MixnetMessageSender,
-};
-use log::*;
-use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::addressing::nodes::NodeIdentity;
-use nymsphinx::anonymous_replies::ReplySurb;
-use nymsphinx::receiver::ReconstructedMessage;
-use tap::TapFallible;
-use task::{wait_for_signal, ShutdownListener, ShutdownNotifier};
-
-use crate::client::config::{Config, SocketType};
+use crate::client::config::Config;
 use crate::error::ClientError;
 use crate::websocket;
+use client_connections::TransmissionLane;
+use client_core::client::base_client::{BaseClientBuilder, ClientInput, ClientOutput};
+use client_core::client::inbound_messages::InputMessage;
+use client_core::client::key_manager::KeyManager;
+use client_core::client::received_buffer::{ReceivedBufferMessage, ReconstructedMessagesReceiver};
+use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
+use futures::channel::mpsc;
+use gateway_client::bandwidth::BandwidthController;
+use log::*;
+use nymsphinx::addressing::clients::Recipient;
+use nymsphinx::anonymous_replies::ReplySurb;
+use nymsphinx::receiver::ReconstructedMessage;
+use task::{wait_for_signal, ShutdownNotifier};

 pub(crate) mod config;

-pub struct NymClient {
+pub struct SocketClient {
    /// Client configuration options, including, among other things, packet sending rates,
    /// key filepaths, etc.
    config: Config,

    /// KeyManager object containing smart pointers to all relevant keys used by the client.
    key_manager: KeyManager,
-
-    /// Channel used for transforming 'raw' messages into sphinx packets and sending them
-    /// through the mix network.
-    /// It is only available if the client started with the websocket listener disabled.
-    input_tx: Option<InputMessageSender>,
-
-    /// Channel used for obtaining reconstructed messages received from the mix network.
-    /// It is only available if the client started with the websocket listener disabled.
-    receive_tx: Option<ReconstructedMessagesReceiver>,
 }

-impl NymClient {
+impl SocketClient {
    pub fn new(config: Config) -> Self {
        let pathfinder = ClientKeyPathfinder::new_from_config(config.get_base());
        let key_manager = KeyManager::load_keys(&pathfinder).expect("failed to load stored keys");

-        NymClient {
+        SocketClient {
            config,
            key_manager,
-            input_tx: None,
-            receive_tx: None,
        }
    }

-    pub fn as_mix_recipient(&self) -> Recipient {
-        Recipient::new(
-            *self.key_manager.identity_keypair().public_key(),
-            *self.key_manager.encryption_keypair().public_key(),
-            // TODO: below only works under assumption that gateway address == gateway id
-            // (which currently is true)
-            NodeIdentity::from_base58_string(self.config.get_base().get_gateway_id()).unwrap(),
-        )
-    }
-
-    // future constantly pumping loop cover traffic at some specified average rate
-    // the pumped traffic goes to the MixTrafficController
-    fn start_cover_traffic_stream(
-        &self,
-        topology_accessor: TopologyAccessor,
-        mix_tx: BatchMixMessageSender,
-        shutdown: ShutdownListener,
-    ) {
-        info!("Starting loop cover traffic stream...");
-
-        let mut stream = LoopCoverTrafficStream::new(
-            self.key_manager.ack_key(),
-            self.config.get_base().get_average_ack_delay(),
-            self.config.get_base().get_average_packet_delay(),
-            self.config
-                .get_base()
-                .get_loop_cover_traffic_average_delay(),
-            mix_tx,
-            self.as_mix_recipient(),
-            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());
-        }
-
-        stream.start_with_shutdown(shutdown);
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn start_real_traffic_controller(
-        &self,
-        topology_accessor: TopologyAccessor,
-        reply_key_storage: ReplyKeyStorage,
-        ack_receiver: AcknowledgementReceiver,
-        input_receiver: InputMessageReceiver,
-        mix_sender: BatchMixMessageSender,
-        lane_queue_lengths: LaneQueueLengths,
-        client_connection_rx: ConnectionCommandReceiver,
-        shutdown: ShutdownListener,
-    ) {
-        let mut controller_config = real_messages_control::Config::new(
-            self.key_manager.ack_key(),
-            self.config.get_base().get_ack_wait_multiplier(),
-            self.config.get_base().get_ack_wait_addition(),
-            self.config.get_base().get_average_ack_delay(),
-            self.config.get_base().get_message_sending_average_delay(),
-            self.config.get_base().get_average_packet_delay(),
-            self.config
-                .get_base()
-                .get_disabled_main_poisson_packet_distribution(),
-            self.as_mix_recipient(),
-        );
-
-        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
-            log::debug!("Setting extended packet size: {:?}", size);
-            controller_config.set_custom_packet_size(size.into());
-        }
-
-        info!("Starting real traffic stream...");
-
-        RealMessagesController::new(
-            controller_config,
-            ack_receiver,
-            input_receiver,
-            mix_sender,
-            topology_accessor,
-            reply_key_storage,
-            lane_queue_lengths,
-            client_connection_rx,
-        )
-        .start_with_shutdown(shutdown);
-    }
-
-    // buffer controlling all messages fetched from provider
-    // required so that other components would be able to use them (say the websocket)
-    fn start_received_messages_buffer_controller(
-        &self,
-        query_receiver: ReceivedBufferRequestReceiver,
-        mixnet_receiver: MixnetMessageReceiver,
-        reply_key_storage: ReplyKeyStorage,
-        shutdown: ShutdownListener,
-    ) {
-        info!("Starting received messages buffer controller...");
-        ReceivedMessagesBufferController::new(
-            self.key_manager.encryption_keypair(),
-            query_receiver,
-            mixnet_receiver,
-            reply_key_storage,
-        )
-        .start_with_shutdown(shutdown)
-    }
-
-    async fn start_gateway_client(
-        &mut self,
-        mixnet_message_sender: MixnetMessageSender,
-        ack_sender: AcknowledgementSender,
-        shutdown: ShutdownListener,
-    ) -> GatewayClient {
-        let gateway_id = self.config.get_base().get_gateway_id();
-        if gateway_id.is_empty() {
-            panic!("The identity of the gateway is unknown - did you run `nym-client` init?")
-        }
-        let gateway_owner = self.config.get_base().get_gateway_owner();
-        if gateway_owner.is_empty() {
-            panic!("The owner of the gateway is unknown - did you run `nym-client` init?")
-        }
-        let gateway_address = self.config.get_base().get_gateway_listener();
-        if gateway_address.is_empty() {
-            panic!("The address of the gateway is unknown - did you run `nym-client` init?")
-        }
-
-        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
-            .expect("provided gateway id is invalid!");
-
+    async fn create_bandwidth_controller(config: &Config) -> BandwidthController {
        #[cfg(feature = "coconut")]
        let bandwidth_controller = {
            let details = network_defaults::NymNetworkDetails::new_from_env();
-            let client_config = validator_client::Config::try_from_nym_network_details(&details)
-                .expect("failed to construct validator client config");
+            let mut client_config =
+                validator_client::Config::try_from_nym_network_details(&details)
+                    .expect("failed to construct validator client config");
+            let nymd_url = config
+                .get_base()
+                .get_validator_endpoints()
+                .pop()
+                .expect("No nymd validator endpoint provided");
+            let api_url = config
+                .get_base()
+                .get_validator_api_endpoints()
+                .pop()
+                .expect("No validator api endpoint provided");
+            // overwrite env configuration with config URLs
+            client_config = client_config.with_urls(nymd_url, api_url);
            let client = validator_client::Client::new_query(client_config)
                .expect("Could not construct query client");
            let coconut_api_clients =
@@ -212,163 +66,48 @@ impl NymClient {
                    .await
                    .expect("Could not query api clients");
            BandwidthController::new(
-                credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                    .await,
+                credential_storage::initialise_storage(config.get_base().get_database_path()).await,
                coconut_api_clients,
            )
        };
        #[cfg(not(feature = "coconut"))]
        let bandwidth_controller = BandwidthController::new(
-            credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                .await,
+            credential_storage::initialise_storage(config.get_base().get_database_path()).await,
        )
        .expect("Could not create bandwidth controller");
-
-        let mut gateway_client = GatewayClient::new(
-            gateway_address,
-            self.key_manager.identity_keypair(),
-            gateway_identity,
-            gateway_owner,
-            Some(self.key_manager.gateway_shared_key()),
-            mixnet_message_sender,
-            ack_sender,
-            self.config.get_base().get_gateway_response_timeout(),
-            Some(bandwidth_controller),
-            Some(shutdown),
-        );
-
-        gateway_client
-            .set_disabled_credentials_mode(self.config.get_base().get_disabled_credentials_mode());
-
-        gateway_client
-            .authenticate_and_start()
-            .await
-            .expect("could not authenticate and start up the gateway connection");
-
-        gateway_client
-    }
-
-    // future responsible for periodically polling directory server and updating
-    // the current global view of topology
-    async fn start_topology_refresher(
-        &mut self,
-        topology_accessor: TopologyAccessor,
-        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(),
-            env!("CARGO_PKG_VERSION").to_string(),
-        );
-        let mut topology_refresher =
-            TopologyRefresher::new(topology_refresher_config, topology_accessor);
-        // before returning, block entire runtime to refresh the current network view so that any
-        // components depending on topology would see a non-empty view
-        info!("Obtaining initial network topology");
-        topology_refresher.refresh().await;
-
-        // 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 \
-                - 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)
-    // 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,
-        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
+        bandwidth_controller
    }

    fn start_websocket_listener(
-        &self,
-        buffer_requester: ReceivedBufferRequestSender,
-        msg_input: InputMessageSender,
-        shared_lane_queue_lengths: LaneQueueLengths,
-        client_connection_tx: ConnectionCommandSender,
+        config: &Config,
+        client_input: ClientInput,
+        client_output: ClientOutput,
+        self_address: Recipient,
    ) {
        info!("Starting websocket listener...");

+        let ClientInput {
+            shared_lane_queue_lengths,
+            connection_command_sender,
+            input_sender,
+        } = client_input;
+
+        let received_buffer_request_sender = client_output.received_buffer_request_sender;
+
        let websocket_handler = websocket::Handler::new(
-            msg_input,
-            client_connection_tx,
-            buffer_requester,
-            &self.as_mix_recipient(),
+            input_sender,
+            connection_command_sender,
+            received_buffer_request_sender,
+            self_address,
            shared_lane_queue_lengths,
        );

-        websocket::Listener::new(self.config.get_listening_port()).start(websocket_handler);
+        websocket::Listener::new(config.get_listening_port()).start(websocket_handler);
    }

-    /// 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);
-
-        self.input_tx
-            .as_ref()
-            .expect("start method was not called before!")
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
-    }
-
-    /// 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>) {
-        let input_msg = InputMessage::new_reply(reply_surb, message);
-
-        self.input_tx
-            .as_ref()
-            .expect("start method was not called before!")
-            .send(input_msg)
-            .await
-            .expect("InputMessageReceiver has stopped receiving!");
-    }
-
-    /// 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)
-    /// Note: it waits for the first occurrence of messages being sent to ourselves. If you expect multiple
-    /// messages, you might have to call this function repeatedly.
-    // TODO: I guess this should really return something that `impl Stream<Item=ReconstructedMessage>`
-    pub async fn wait_for_messages(&mut self) -> Vec<ReconstructedMessage> {
-        use futures::StreamExt;
-
-        self.receive_tx
-            .as_mut()
-            .expect("start method was not called before!")
-            .next()
-            .await
-            .expect("buffer controller seems to have somehow died!")
-    }
-
-    /// 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?;
+    /// blocking version of `start_socket` method. Will run forever (or until SIGINT is sent)
+    pub async fn run_socket_forever(self) -> Result<(), ClientError> {
+        let shutdown = self.start_socket().await?;
        wait_for_signal().await;

        println!(
@@ -388,117 +127,117 @@ impl NymClient {
        Ok(())
    }

-    pub async fn start(&mut self) -> Result<ShutdownNotifier, ClientError> {
-        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
-
-        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
-        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
-        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
-
-        // used for announcing connection or disconnection of a channel for pushing re-assembled messages to
-        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();
-
-        // channels responsible for controlling real messages
-        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
-
-        // channels responsible for controlling ack messages
-        let (ack_sender, ack_receiver) = mpsc::unbounded();
-        let shared_topology_accessor = TopologyAccessor::new();
-
-        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);
-                })?;
-
-        // Shutdown notifier for signalling tasks to stop
-        let shutdown = ShutdownNotifier::default();
-
-        // the components are started in very specific order. Unless you know what you are doing,
-        // do not change that.
-        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
-            .await?;
-        self.start_received_messages_buffer_controller(
-            received_buffer_request_receiver,
-            mixnet_messages_receiver,
-            reply_key_storage.clone(),
-            shutdown.subscribe(),
-        );
-
-        let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender, 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 (client_connection_tx, client_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_real_traffic_controller(
-            shared_topology_accessor.clone(),
-            reply_key_storage,
-            ack_receiver,
-            input_receiver,
-            sphinx_message_sender.clone(),
-            shared_lane_queue_lengths.clone(),
-            client_connection_rx,
-            shutdown.subscribe(),
-        );
-
-        if !self
-            .config
-            .get_base()
-            .get_disabled_loop_cover_traffic_stream()
-        {
-            self.start_cover_traffic_stream(
-                shared_topology_accessor,
-                sphinx_message_sender,
-                shutdown.subscribe(),
-            );
+    pub async fn start_socket(self) -> Result<ShutdownNotifier, ClientError> {
+        if !self.config.get_socket_type().is_websocket() {
+            return Err(ClientError::InvalidSocketMode);
        }

-        match self.config.get_socket_type() {
-            SocketType::WebSocket => self.start_websocket_listener(
-                received_buffer_request_sender,
-                input_sender,
-                shared_lane_queue_lengths,
-                client_connection_tx,
-            ),
-            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
-                let (reconstructed_sender, reconstructed_receiver) = mpsc::unbounded();
+        let base_builder = BaseClientBuilder::new_from_base_config(
+            self.config.get_base(),
+            self.key_manager,
+            Some(Self::create_bandwidth_controller(&self.config).await),
+        );

-                // tell the buffer to start sending stuff to us
-                received_buffer_request_sender
-                    .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
-                        reconstructed_sender,
-                    ))
-                    .expect("the buffer request failed!");
+        let self_address = base_builder.as_mix_recipient();
+        let mut started_client = base_builder.start_base().await?;
+        let client_input = started_client.client_input.register_producer();
+        let client_output = started_client.client_output.register_consumer();

-                self.receive_tx = Some(reconstructed_receiver);
-                self.input_tx = Some(input_sender);
-            }
-        }
+        Self::start_websocket_listener(&self.config, client_input, client_output, self_address);

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

-        Ok(shutdown)
+        Ok(started_client.shutdown_notifier)
+    }
+
+    pub async fn start_direct(self) -> Result<DirectClient, ClientError> {
+        if self.config.get_socket_type().is_websocket() {
+            return Err(ClientError::InvalidSocketMode);
+        }
+
+        let base_client = BaseClientBuilder::new_from_base_config(
+            self.config.get_base(),
+            self.key_manager,
+            Some(Self::create_bandwidth_controller(&self.config).await),
+        );
+
+        let mut started_client = base_client.start_base().await?;
+        let client_input = started_client.client_input.register_producer();
+        let client_output = started_client.client_output.register_consumer();
+
+        // register our receiver
+        let (reconstructed_sender, reconstructed_receiver) = mpsc::unbounded();
+
+        // tell the buffer to start sending stuff to us
+        client_output
+            .received_buffer_request_sender
+            .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
+                reconstructed_sender,
+            ))
+            .expect("the buffer request failed!");
+
+        Ok(DirectClient {
+            client_input,
+            reconstructed_receiver,
+            _shutdown_notifier: started_client.shutdown_notifier,
+        })
+    }
+}
+
+pub struct DirectClient {
+    client_input: ClientInput,
+    reconstructed_receiver: ReconstructedMessagesReceiver,
+
+    // we need to keep reference to this guy otherwise things will start dropping
+    _shutdown_notifier: ShutdownNotifier,
+}
+
+impl DirectClient {
+    /// 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);
+
+        self.client_input
+            .input_sender
+            .send(input_msg)
+            .await
+            .expect("InputMessageReceiver has stopped receiving!");
+    }
+
+    /// 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>) {
+        let input_msg = InputMessage::new_reply(reply_surb, message);
+
+        self.client_input
+            .input_sender
+            .send(input_msg)
+            .await
+            .expect("InputMessageReceiver has stopped receiving!");
+    }
+
+    /// 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)
+    /// Note: it waits for the first occurrence of messages being sent to ourselves. If you expect multiple
+    /// messages, you might have to call this function repeatedly.
+    // TODO: I guess this should really return something that `impl Stream<Item=ReconstructedMessage>`
+    pub async fn wait_for_messages(&mut self) -> Vec<ReconstructedMessage> {
+        use futures::StreamExt;
+
+        self.reconstructed_receiver
+            .next()
+            .await
+            .expect("buffer controller seems to have somehow died!")
    }
 }
@@ -1,13 +1,18 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use std::fmt::Display;
+
 use clap::Args;
-use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;
+use nymsphinx::addressing::clients::Recipient;
+use serde::Serialize;
+use tap::TapFallible;

 use crate::{
    client::config::Config,
    commands::{override_config, OverrideConfig},
+    error::ClientError,
 };

 #[derive(Args, Clone)]
@@ -46,11 +51,19 @@ pub(crate) struct Init {
    #[clap(long, hidden = true)]
    fastmode: bool,

+    /// Disable loop cover traffic and the Poisson rate limiter (for debugging only)
+    #[clap(long, hidden = true)]
+    no_cover: bool,
+
    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
    /// with bandwidth credential requirement.
    #[cfg(feature = "coconut")]
    #[clap(long)]
    enabled_credentials_mode: bool,
+
+    /// Save a summary of the initialization to a json file
+    #[clap(long)]
+    output_json: bool,
 }

 impl From<Init> for OverrideConfig {
@@ -61,6 +74,7 @@ impl From<Init> for OverrideConfig {
            disable_socket: init_config.disable_socket,
            port: init_config.port,
            fastmode: init_config.fastmode,
+            no_cover: init_config.no_cover,

            #[cfg(feature = "coconut")]
            enabled_credentials_mode: init_config.enabled_credentials_mode,
@@ -68,7 +82,30 @@ impl From<Init> for OverrideConfig {
    }
 }

-pub(crate) async fn execute(args: &Init) {
+#[derive(Debug, Serialize)]
+pub struct InitResults {
+    #[serde(flatten)]
+    client_core: client_core::init::InitResults,
+    client_listening_port: String,
+}
+
+impl InitResults {
+    fn new(config: &Config, address: &Recipient) -> Self {
+        Self {
+            client_core: client_core::init::InitResults::new(config.get_base(), address),
+            client_listening_port: config.get_listening_port().to_string(),
+        }
+    }
+}
+
+impl Display for InitResults {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}", self.client_core)?;
+        write!(f, "Client listening port: {}", self.client_listening_port)
+    }
+}
+
+pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
    println!("Initialising client...");

    let id = &args.id;
@@ -92,25 +129,44 @@ pub(crate) async fn execute(args: &Init) {
    let register_gateway = !already_init || user_wants_force_register;

    // Attempt to use a user-provided gateway, if possible
-    let user_chosen_gateway_id = args.gateway.as_deref();
+    let user_chosen_gateway_id = args.gateway.clone();

-    let mut config = Config::new(id);
-    let override_config_fields = OverrideConfig::from(args.clone());
-    config = override_config(config, override_config_fields);
+    // Load and potentially override config
+    let mut config = override_config(Config::new(id), OverrideConfig::from(args.clone()));
+
+    // Setup gateway by either registering a new one, or creating a new config from the selected
+    // one but with keys kept, or reusing the gateway configuration.
+    let gateway = client_core::init::setup_gateway::<Config, _>(
+        register_gateway,
+        user_chosen_gateway_id,
+        config.get_base(),
+    )
+    .await
+    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?;

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

-    let config_save_location = config.get_config_file_save_location();
-    config
-        .save_to_file(None)
-        .expect("Failed to save the config file");
+    config.save_to_file(None).tap_err(|_| {
+        log::error!("Failed to save the config file");
+    })?;

+    print_saved_config(&config);
+
+    let address = client_core::init::get_client_address_from_stored_keys(config.get_base())?;
+    let init_results = InitResults::new(&config, &address);
+    println!("{}", init_results);
+
+    // Output summary to a json file, if specified
+    if args.output_json {
+        client_core::init::output_to_json(&init_results, "client_init_results.json");
+    }
+
+    println!("\nThe address of this client is: {}\n", address);
+    Ok(())
+}
+
+fn print_saved_config(config: &Config) {
+    let config_save_location = config.get_config_file_save_location();
    println!("Saved configuration file to {:?}", config_save_location);
    println!("Using gateway: {}", config.get_base().get_gateway_id());
    log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
@@ -119,63 +175,5 @@ pub(crate) async fn execute(args: &Init) {
        "Gateway listener: {}",
        config.get_base().get_gateway_listener()
    );
-    println!("Client configuration completed.");
-
-    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
-        eprintln!("Failed to show address\nError: {err}");
-        std::process::exit(1)
-    });
-}
-
-async fn setup_gateway(
-    id: &str,
-    register: bool,
-    user_chosen_gateway_id: Option<&str>,
-    config: &Config,
-) -> Result<GatewayEndpoint, ClientCoreError> {
-    if register {
-        // Get the gateway details by querying the validator-api. Either pick one at random or use
-        // the chosen one if it's among the available ones.
-        println!("Configuring gateway");
-        let gateway = client_core::init::query_gateway_details(
-            config.get_base().get_validator_api_endpoints(),
-            user_chosen_gateway_id,
-        )
-        .await?;
-        log::debug!("Querying gateway gives: {}", gateway);
-
-        // Registering with gateway by setting up and writing shared keys to disk
-        log::trace!("Registering gateway");
-        client_core::init::register_with_gateway_and_store_keys(gateway.clone(), config.get_base())
-            .await?;
-        println!("Saved all generated keys");
-
-        Ok(gateway.into())
-    } else if user_chosen_gateway_id.is_some() {
-        // Just set the config, don't register or create any keys
-        // This assumes that the user knows what they are doing, and that the existing keys are
-        // valid for the gateway being used
-        println!("Using gateway provided by user, keeping existing keys");
-        let gateway = client_core::init::query_gateway_details(
-            config.get_base().get_validator_api_endpoints(),
-            user_chosen_gateway_id,
-        )
-        .await?;
-        log::debug!("Querying gateway gives: {}", gateway);
-        Ok(gateway.into())
-    } else {
-        println!("Not registering gateway, will reuse existing config and keys");
-        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
-            log::error!(
-                "Unable to configure gateway: {err}. \n
-                Seems like the client was already initialized but it was not possible to read \
-                the existing configuration file. \n
-                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
-                removing the existing configuration and starting over."
-            );
-            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
-        })?;
-
-        Ok(existing_config.get_base().get_gateway_endpoint().clone())
-    }
+    println!("Client configuration completed.\n");
 }
@@ -80,6 +80,7 @@ pub(crate) struct OverrideConfig {
    disable_socket: bool,
    port: Option<u16>,
    fastmode: bool,
+    no_cover: bool,

    #[cfg(feature = "coconut")]
    enabled_credentials_mode: bool,
@@ -89,7 +90,7 @@ pub(crate) async fn execute(args: &Cli) -> Result<(), ClientError> {
    let bin_name = "nym-native-client";

    match &args.command {
-        Commands::Init(m) => init::execute(m).await,
+        Commands::Init(m) => init::execute(m).await?,
        Commands::Run(m) => run::execute(m).await?,
        Commands::Upgrade(m) => upgrade::execute(m),
        Commands::Completions(s) => s.generate(&mut Cli::into_app(), bin_name),
@@ -141,6 +142,10 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
        config.get_base_mut().set_high_default_traffic_volume();
    }

+    if args.no_cover {
+        config.get_base_mut().set_no_cover_traffic();
+    }
+
    config
 }

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

 use crate::{
-    client::{config::Config, NymClient},
+    client::{config::Config, SocketClient},
    commands::{override_config, OverrideConfig},
    error::ClientError,
 };
@@ -39,6 +39,15 @@ pub(crate) struct Run {
    #[clap(short, long)]
    port: Option<u16>,

+    /// Mostly debug-related option to increase default traffic rate so that you would not need to
+    /// modify config post init
+    #[clap(long, hidden = true)]
+    fastmode: bool,
+
+    /// Disable loop cover traffic and the Poisson rate limiter (for debugging only)
+    #[clap(long, hidden = true)]
+    no_cover: bool,
+
    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
    /// with bandwidth credential requirement.
    #[cfg(feature = "coconut")]
@@ -53,7 +62,8 @@ impl From<Run> for OverrideConfig {
            api_validators: run_config.api_validators,
            disable_socket: run_config.disable_socket,
            port: run_config.port,
-            fastmode: false,
+            fastmode: run_config.fastmode,
+            no_cover: run_config.no_cover,
            #[cfg(feature = "coconut")]
            enabled_credentials_mode: run_config.enabled_credentials_mode,
        }
@@ -98,5 +108,5 @@ pub(crate) async fn execute(args: &Run) -> Result<(), ClientError> {
        return Err(ClientError::FailedLocalVersionCheck);
    }

-    NymClient::new(config).run_forever().await
+    SocketClient::new(config).run_socket_forever().await
 }
@@ -1,25 +1,17 @@
-use client_core::{client::reply_key_storage::ReplyKeyStorageError, error::ClientCoreError};
-use crypto::asymmetric::identity::Ed25519RecoveryError;
-use gateway_client::error::GatewayClientError;
-use validator_client::ValidatorClientError;
+use client_core::error::ClientCoreError;

 #[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,
+
+    #[error("Attempted to start the client in invalid socket mode")]
+    InvalidSocketMode,
 }
@@ -73,14 +73,14 @@ impl Handler {
        msg_input: InputMessageSender,
        client_connection_tx: ConnectionCommandSender,
        buffer_requester: ReceivedBufferRequestSender,
-        self_full_address: &Recipient,
+        self_full_address: Recipient,
        lane_queue_lengths: LaneQueueLengths,
    ) -> Self {
        Handler {
            msg_input,
            client_connection_tx,
            buffer_requester,
-            self_full_address: *self_full_address,
+            self_full_address,
            socket: None,
            received_response_type: Default::default(),
            lane_queue_lengths,
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.0"
+version = "1.1.3"
 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"
@@ -19,7 +19,8 @@ pin-project = "1.0"
 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"
+serde_json = "1.0.89"
+tap = "1.0.1"
 thiserror = "1.0.34"
 tokio = { version = "1.21.2", features = ["rt-multi-thread", "net", "signal"] }
 url = "2.2"
@@ -46,7 +47,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"]
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::config::template::config_template;
-use client_core::config::Config as BaseConfig;
 pub use client_core::config::MISSING_VALUE;
+use client_core::config::{ClientCoreConfigTrait, Config as BaseConfig};
 use config::defaults::DEFAULT_SOCKS5_LISTENING_PORT;
 use config::NymConfig;
 use nymsphinx::addressing::clients::Recipient;
@@ -52,6 +52,12 @@ impl NymConfig for Config {
    }
 }

+impl ClientCoreConfigTrait for Config {
+    fn get_gateway_endpoint(&self) -> &client_core::config::GatewayEndpointConfig {
+        self.base.get_gateway_endpoint()
+    }
+}
+
 impl Config {
    pub fn new<S: Into<String>>(id: S, provider_mix_address: S) -> Self {
        Config {
@@ -60,11 +66,13 @@ impl Config {
        }
    }

+    #[must_use]
    pub fn with_port(mut self, port: u16) -> Self {
        self.socks5.listening_port = port;
        self
    }

+    #[must_use]
    pub fn with_provider_mix_address(mut self, address: String) -> Self {
        self.socks5.provider_mix_address = address;
        self
@@ -1,43 +1,21 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::error::Error;
-
 use crate::client::config::Config;
 use crate::error::Socks5ClientError;
 use crate::socks::{
    authentication::{AuthenticationMethods, Authenticator, User},
    server::SphinxSocksServer,
 };
-use client_connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
-use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
-use client_core::client::inbound_messages::{
-    InputMessage, InputMessageReceiver, InputMessageSender,
-};
+use client_core::client::base_client::{BaseClientBuilder, ClientInput, ClientOutput};
 use client_core::client::key_manager::KeyManager;
-use client_core::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
-use client_core::client::real_messages_control::RealMessagesController;
-use client_core::client::received_buffer::{
-    ReceivedBufferRequestReceiver, ReceivedBufferRequestSender, ReceivedMessagesBufferController,
-};
-use client_core::client::reply_key_storage::ReplyKeyStorage;
-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;
 use gateway_client::bandwidth::BandwidthController;
-use gateway_client::{
-    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
-    MixnetMessageSender,
-};
 use log::*;
 use nymsphinx::addressing::clients::Recipient;
-use nymsphinx::addressing::nodes::NodeIdentity;
-use tap::TapFallible;
+use std::error::Error;
 use task::{wait_for_signal_and_error, ShutdownListener, ShutdownNotifier};

 pub mod config;
@@ -72,137 +50,25 @@ impl NymClient {
        }
    }

-    pub fn as_mix_recipient(&self) -> Recipient {
-        Recipient::new(
-            *self.key_manager.identity_keypair().public_key(),
-            *self.key_manager.encryption_keypair().public_key(),
-            // TODO: below only works under assumption that gateway address == gateway id
-            // (which currently is true)
-            NodeIdentity::from_base58_string(self.config.get_base().get_gateway_id()).unwrap(),
-        )
-    }
-
-    // future constantly pumping loop cover traffic at some specified average rate
-    // the pumped traffic goes to the MixTrafficController
-    fn start_cover_traffic_stream(
-        &self,
-        topology_accessor: TopologyAccessor,
-        mix_tx: BatchMixMessageSender,
-        shutdown: ShutdownListener,
-    ) {
-        info!("Starting loop cover traffic stream...");
-
-        let mut stream = LoopCoverTrafficStream::new(
-            self.key_manager.ack_key(),
-            self.config.get_base().get_average_ack_delay(),
-            self.config.get_base().get_average_packet_delay(),
-            self.config
-                .get_base()
-                .get_loop_cover_traffic_average_delay(),
-            mix_tx,
-            self.as_mix_recipient(),
-            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());
-        }
-
-        stream.start_with_shutdown(shutdown);
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn start_real_traffic_controller(
-        &self,
-        topology_accessor: TopologyAccessor,
-        reply_key_storage: ReplyKeyStorage,
-        ack_receiver: AcknowledgementReceiver,
-        input_receiver: InputMessageReceiver,
-        mix_sender: BatchMixMessageSender,
-        client_connection_rx: ConnectionCommandReceiver,
-        lane_queue_lengths: LaneQueueLengths,
-        shutdown: ShutdownListener,
-    ) {
-        let mut controller_config = client_core::client::real_messages_control::Config::new(
-            self.key_manager.ack_key(),
-            self.config.get_base().get_ack_wait_multiplier(),
-            self.config.get_base().get_ack_wait_addition(),
-            self.config.get_base().get_average_ack_delay(),
-            self.config.get_base().get_message_sending_average_delay(),
-            self.config.get_base().get_average_packet_delay(),
-            self.config
-                .get_base()
-                .get_disabled_main_poisson_packet_distribution(),
-            self.as_mix_recipient(),
-        );
-
-        if let Some(size) = self.config.get_base().get_use_extended_packet_size() {
-            log::debug!("Setting extended packet size: {:?}", size);
-            controller_config.set_custom_packet_size(size.into());
-        }
-
-        info!("Starting real traffic stream...");
-
-        RealMessagesController::new(
-            controller_config,
-            ack_receiver,
-            input_receiver,
-            mix_sender,
-            topology_accessor,
-            reply_key_storage,
-            lane_queue_lengths,
-            client_connection_rx,
-        )
-        .start_with_shutdown(shutdown);
-    }
-
-    // buffer controlling all messages fetched from provider
-    // required so that other components would be able to use them (say the websocket)
-    fn start_received_messages_buffer_controller(
-        &self,
-        query_receiver: ReceivedBufferRequestReceiver,
-        mixnet_receiver: MixnetMessageReceiver,
-        reply_key_storage: ReplyKeyStorage,
-        shutdown: ShutdownListener,
-    ) {
-        info!("Starting received messages buffer controller...");
-        ReceivedMessagesBufferController::new(
-            self.key_manager.encryption_keypair(),
-            query_receiver,
-            mixnet_receiver,
-            reply_key_storage,
-        )
-        .start_with_shutdown(shutdown);
-    }
-
-    async fn start_gateway_client(
-        &mut self,
-        mixnet_message_sender: MixnetMessageSender,
-        ack_sender: AcknowledgementSender,
-        shutdown: ShutdownListener,
-    ) -> GatewayClient {
-        let gateway_id = self.config.get_base().get_gateway_id();
-        if gateway_id.is_empty() {
-            panic!("The identity of the gateway is unknown - did you run `nym-client` init?")
-        }
-        let gateway_owner = self.config.get_base().get_gateway_owner();
-        if gateway_owner.is_empty() {
-            panic!("The owner of the gateway is unknown - did you run `nym-client` init?")
-        }
-        let gateway_address = self.config.get_base().get_gateway_listener();
-        if gateway_address.is_empty() {
-            panic!("The address of the gateway is unknown - did you run `nym-client` init?")
-        }
-
-        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
-            .expect("provided gateway id is invalid!");
-
+    async fn create_bandwidth_controller(config: &Config) -> BandwidthController {
        #[cfg(feature = "coconut")]
        let bandwidth_controller = {
            let details = network_defaults::NymNetworkDetails::new_from_env();
-            let client_config = validator_client::Config::try_from_nym_network_details(&details)
-                .expect("failed to construct validator client config");
+            let mut client_config =
+                validator_client::Config::try_from_nym_network_details(&details)
+                    .expect("failed to construct validator client config");
+            let nymd_url = config
+                .get_base()
+                .get_validator_endpoints()
+                .pop()
+                .expect("No nymd validator endpoint provided");
+            let api_url = config
+                .get_base()
+                .get_validator_api_endpoints()
+                .pop()
+                .expect("No validator api endpoint provided");
+            // overwrite env configuration with config URLs
+            client_config = client_config.with_urls(nymd_url, api_url);
            let client = validator_client::Client::new_query(client_config)
                .expect("Could not construct query client");
            let coconut_api_clients =
@@ -210,133 +76,63 @@ impl NymClient {
                    .await
                    .expect("Could not query api clients");
            BandwidthController::new(
-                credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                    .await,
+                credential_storage::initialise_storage(config.get_base().get_database_path()).await,
                coconut_api_clients,
            )
        };
        #[cfg(not(feature = "coconut"))]
        let bandwidth_controller = BandwidthController::new(
-            credential_storage::initialise_storage(self.config.get_base().get_database_path())
-                .await,
+            credential_storage::initialise_storage(config.get_base().get_database_path()).await,
        )
        .expect("Could not create bandwidth controller");
-
-        let mut gateway_client = GatewayClient::new(
-            gateway_address,
-            self.key_manager.identity_keypair(),
-            gateway_identity,
-            gateway_owner,
-            Some(self.key_manager.gateway_shared_key()),
-            mixnet_message_sender,
-            ack_sender,
-            self.config.get_base().get_gateway_response_timeout(),
-            Some(bandwidth_controller),
-            Some(shutdown),
-        );
-
-        gateway_client
-            .set_disabled_credentials_mode(self.config.get_base().get_disabled_credentials_mode());
-
-        gateway_client
-            .authenticate_and_start()
-            .await
-            .expect("could not authenticate and start up the gateway connection");
-
-        gateway_client
-    }
-
-    // future responsible for periodically polling directory server and updating
-    // the current global view of topology
-    async fn start_topology_refresher(
-        &mut self,
-        topology_accessor: TopologyAccessor,
-        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(),
-            env!("CARGO_PKG_VERSION").to_string(),
-        );
-        let mut topology_refresher =
-            TopologyRefresher::new(topology_refresher_config, topology_accessor);
-        // before returning, block entire runtime to refresh the current network view so that any
-        // components depending on topology would see a non-empty view
-        info!("Obtaining initial network topology");
-        topology_refresher.refresh().await;
-
-        // 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 \
-                - 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)
-    // 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,
-        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
+        bandwidth_controller
    }

    fn start_socks5_listener(
-        &self,
-        buffer_requester: ReceivedBufferRequestSender,
-        msg_input: InputMessageSender,
-        client_connection_tx: ConnectionCommandSender,
-        lane_queue_lengths: LaneQueueLengths,
-        mut shutdown: ShutdownListener,
+        config: &Config,
+        client_input: ClientInput,
+        client_output: ClientOutput,
+        self_address: Recipient,
+        shutdown: ShutdownListener,
    ) {
        info!("Starting socks5 listener...");
        let auth_methods = vec![AuthenticationMethods::NoAuth as u8];
        let allowed_users: Vec<User> = Vec::new();

+        let ClientInput {
+            shared_lane_queue_lengths,
+            connection_command_sender,
+            input_sender,
+        } = client_input;
+
+        let received_buffer_request_sender = client_output.received_buffer_request_sender;
+
        let authenticator = Authenticator::new(auth_methods, allowed_users);
        let mut sphinx_socks = SphinxSocksServer::new(
-            self.config.get_listening_port(),
+            config.get_listening_port(),
            authenticator,
-            self.config.get_provider_mix_address(),
-            self.as_mix_recipient(),
-            lane_queue_lengths,
+            config.get_provider_mix_address(),
+            self_address,
+            shared_lane_queue_lengths,
            shutdown.clone(),
        );
-        tokio::spawn(async move {
-            // Ideally we should have a fully fledged task manager to check for errors in all
-            // tasks.
-            // However, pragmatically, we start out by at least reporting errors for some of the
-            // tasks that interact with the outside world and can fail in normal operation, such as
-            // network issues.
-            // TODO: replace this by a generic solution, such as a task manager that stores all
-            // JoinHandles of all spawned tasks.
-            if let Err(res) = sphinx_socks
-                .serve(msg_input, buffer_requester, client_connection_tx)
-                .await
-            {
-                shutdown.send_we_stopped(Box::new(res));
-            }
-        });
+        task::spawn_with_report_error(
+            async move {
+                sphinx_socks
+                    .serve(
+                        input_sender,
+                        received_buffer_request_sender,
+                        connection_command_sender,
+                    )
+                    .await
+            },
+            shutdown,
+        );
    }

    /// blocking version of `start` method. Will run forever (or until SIGINT is sent)
-    pub async fn run_forever(&mut self) -> Result<(), Box<dyn Error + Send>> {
-        let mut shutdown = self
-            .start()
-            .await
-            .map_err(|err| Box::new(err) as Box<dyn Error + Send>)?;
+    pub async fn run_forever(self) -> Result<(), Box<dyn Error + Send + Sync>> {
+        let mut shutdown = self.start().await?;

        let res = wait_for_signal_and_error(&mut shutdown).await;

@@ -352,14 +148,11 @@ impl NymClient {

    // Variant of `run_forever` that listends for remote control messages
    pub async fn run_and_listen(
-        &mut self,
+        self,
        mut receiver: Socks5ControlMessageReceiver,
-    ) -> Result<(), Box<dyn Error + Send>> {
+    ) -> Result<(), Box<dyn Error + Send + Sync>> {
        // Start the main task
-        let mut shutdown = self
-            .start()
-            .await
-            .map_err(|err| Box::new(err) as Box<dyn Error + Send>)?;
+        let mut shutdown = self.start().await?;

        let res = tokio::select! {
            biased;
@@ -395,101 +188,29 @@ impl NymClient {
        res
    }

-    pub async fn start(&mut self) -> Result<ShutdownNotifier, Socks5ClientError> {
-        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
-
-        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
-        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
-        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
-
-        // used for announcing connection or disconnection of a channel for pushing re-assembled messages to
-        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();
-
-        // channels responsible for controlling real messages
-        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
-
-        // channels responsible for controlling ack messages
-        let (ack_sender, ack_receiver) = mpsc::unbounded();
-        let shared_topology_accessor = TopologyAccessor::new();
-
-        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);
-                })?;
-
-        // Shutdown notifier for signalling tasks to stop
-        let shutdown = ShutdownNotifier::default();
-
-        // the components are started in very specific order. Unless you know what you are doing,
-        // do not change that.
-        self.start_topology_refresher(shared_topology_accessor.clone(), shutdown.subscribe())
-            .await?;
-        self.start_received_messages_buffer_controller(
-            received_buffer_request_receiver,
-            mixnet_messages_receiver,
-            reply_key_storage.clone(),
-            shutdown.subscribe(),
+    pub async fn start(self) -> Result<ShutdownNotifier, Socks5ClientError> {
+        let base_builder = BaseClientBuilder::new_from_base_config(
+            self.config.get_base(),
+            self.key_manager,
+            Some(Self::create_bandwidth_controller(&self.config).await),
        );

-        let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender, shutdown.subscribe())
-            .await;
+        let self_address = base_builder.as_mix_recipient();
+        let mut started_client = base_builder.start_base().await?;
+        let client_input = started_client.client_input.register_producer();
+        let client_output = started_client.client_output.register_consumer();

-        // 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 (client_connection_tx, client_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_real_traffic_controller(
-            shared_topology_accessor.clone(),
-            reply_key_storage,
-            ack_receiver,
-            input_receiver,
-            sphinx_message_sender.clone(),
-            client_connection_rx,
-            shared_lane_queue_lengths.clone(),
-            shutdown.subscribe(),
-        );
-
-        if !self
-            .config
-            .get_base()
-            .get_disabled_loop_cover_traffic_stream()
-        {
-            self.start_cover_traffic_stream(
-                shared_topology_accessor,
-                sphinx_message_sender,
-                shutdown.subscribe(),
-            );
-        }
-
-        self.start_socks5_listener(
-            received_buffer_request_sender,
-            input_sender,
-            client_connection_tx,
-            shared_lane_queue_lengths,
-            shutdown.subscribe(),
+        Self::start_socks5_listener(
+            &self.config,
+            client_input,
+            client_output,
+            self_address,
+            started_client.shutdown_notifier.subscribe(),
        );

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

-        Ok(shutdown)
+        Ok(started_client.shutdown_notifier)
    }
 }
@@ -1,13 +1,18 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use std::fmt::Display;
+
 use clap::Args;
-use client_core::{config::GatewayEndpoint, error::ClientCoreError};
 use config::NymConfig;
+use nymsphinx::addressing::clients::Recipient;
+use serde::Serialize;
+use tap::TapFallible;

 use crate::{
    client::config::Config,
    commands::{override_config, OverrideConfig},
+    error::Socks5ClientError,
 };

 #[derive(Args, Clone)]
@@ -46,11 +51,19 @@ pub(crate) struct Init {
    #[clap(long, hidden = true)]
    fastmode: bool,

+    /// Disable loop cover traffic and the Poisson rate limiter (for debugging only)
+    #[clap(long, hidden = true)]
+    no_cover: bool,
+
    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
    /// with bandwidth credential requirement.
    #[cfg(feature = "coconut")]
    #[clap(long)]
    enabled_credentials_mode: bool,
+
+    /// Save a summary of the initialization to a json file
+    #[clap(long)]
+    output_json: bool,
 }

 impl From<Init> for OverrideConfig {
@@ -60,13 +73,37 @@ impl From<Init> for OverrideConfig {
            api_validators: init_config.api_validators,
            port: init_config.port,
            fastmode: init_config.fastmode,
+            no_cover: init_config.no_cover,
            #[cfg(feature = "coconut")]
            enabled_credentials_mode: init_config.enabled_credentials_mode,
        }
    }
 }

-pub(crate) async fn execute(args: &Init) {
+#[derive(Debug, Serialize)]
+pub struct InitResults {
+    #[serde(flatten)]
+    client_core: client_core::init::InitResults,
+    socks5_listening_port: String,
+}
+
+impl InitResults {
+    fn new(config: &Config, address: &Recipient) -> Self {
+        Self {
+            client_core: client_core::init::InitResults::new(config.get_base(), address),
+            socks5_listening_port: config.get_listening_port().to_string(),
+        }
+    }
+}
+
+impl Display for InitResults {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}", self.client_core)?;
+        write!(f, "SOCKS5 listening port: {}", self.socks5_listening_port)
+    }
+}
+
+pub(crate) async fn execute(args: &Init) -> Result<(), Socks5ClientError> {
    println!("Initialising client...");

    let id = &args.id;
@@ -91,25 +128,47 @@ pub(crate) async fn execute(args: &Init) {
    let register_gateway = !already_init || user_wants_force_register;

    // Attempt to use a user-provided gateway, if possible
-    let user_chosen_gateway_id = args.gateway.as_deref();
+    let user_chosen_gateway_id = args.gateway.clone();

-    let mut config = Config::new(id, provider_address);
-    let override_config_fields = OverrideConfig::from(args.clone());
-    config = override_config(config, override_config_fields);
+    // Load and potentially override config
+    let mut config = override_config(
+        Config::new(id, provider_address),
+        OverrideConfig::from(args.clone()),
+    );
+
+    // Setup gateway by either registering a new one, or creating a new config from the selected
+    // one but with keys kept, or reusing the gateway configuration.
+    let gateway = client_core::init::setup_gateway::<Config, _>(
+        register_gateway,
+        user_chosen_gateway_id,
+        config.get_base(),
+    )
+    .await
+    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?;

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

-    let config_save_location = config.get_config_file_save_location();
-    config
-        .save_to_file(None)
-        .expect("Failed to save the config file");
+    config.save_to_file(None).tap_err(|_| {
+        log::error!("Failed to save the config file");
+    })?;

+    print_saved_config(&config);
+
+    let address = client_core::init::get_client_address_from_stored_keys(config.get_base())?;
+    let init_results = InitResults::new(&config, &address);
+    println!("{}", init_results);
+
+    // Output summary to a json file, if specified
+    if args.output_json {
+        client_core::init::output_to_json(&init_results, "socks5_client_init_results.json");
+    }
+
+    println!("\nThe address of this client is: {}\n", address);
+    Ok(())
+}
+
+fn print_saved_config(config: &Config) {
+    let config_save_location = config.get_config_file_save_location();
    println!("Saved configuration file to {:?}", config_save_location);
    println!("Using gateway: {}", config.get_base().get_gateway_id());
    log::debug!("Gateway id: {}", config.get_base().get_gateway_id());
@@ -118,62 +177,5 @@ pub(crate) async fn execute(args: &Init) {
        "Gateway listener: {}",
        config.get_base().get_gateway_listener()
    );
-    println!("Client configuration completed.");
-
-    client_core::init::show_address(config.get_base()).unwrap_or_else(|err| {
-        eprintln!("Failed to show address\nError: {err}");
-        std::process::exit(1)
-    });
-}
-
-async fn setup_gateway(
-    id: &str,
-    register: bool,
-    user_chosen_gateway_id: Option<&str>,
-    config: &Config,
-) -> Result<GatewayEndpoint, ClientCoreError> {
-    if register {
-        // Get the gateway details by querying the validator-api. Either pick one at random or use
-        // the chosen one if it's among the available ones.
-        println!("Configuring gateway");
-        let gateway = client_core::init::query_gateway_details(
-            config.get_base().get_validator_api_endpoints(),
-            user_chosen_gateway_id,
-        )
-        .await?;
-        log::debug!("Querying gateway gives: {}", gateway);
-
-        // Registering with gateway by setting up and writing shared keys to disk
-        log::trace!("Registering gateway");
-        client_core::init::register_with_gateway_and_store_keys(gateway.clone(), config.get_base())
-            .await?;
-        println!("Saved all generated keys");
-
-        Ok(gateway.into())
-    } else if user_chosen_gateway_id.is_some() {
-        // Just set the config, don't register or create any keys
-        // This assumes that the user knows what they are doing, and that the existing keys are
-        // valid for the gateway being used
-        println!("Using gateway provided by user, keeping existing keys");
-        let gateway = client_core::init::query_gateway_details(
-            config.get_base().get_validator_api_endpoints(),
-            user_chosen_gateway_id,
-        )
-        .await?;
-        log::debug!("Querying gateway gives: {}", gateway);
-        Ok(gateway.into())
-    } else {
-        println!("Not registering gateway, will reuse existing config and keys");
-        let existing_config = Config::load_from_file(Some(id)).map_err(|err| {
-            log::error!(
-                "Unable to configure gateway: {err}. \n
-                Seems like the client was already initialized but it was not possible to read \
-                the existing configuration file. \n
-                CAUTION: Consider backing up your gateway keys and try force gateway registration, or \
-                removing the existing configuration and starting over."
-            );
-            ClientCoreError::CouldNotLoadExistingGatewayConfiguration(err)
-        })?;
-        Ok(existing_config.get_base().get_gateway_endpoint().clone())
-    }
+    println!("Client configuration completed.\n");
 }
@@ -83,16 +83,17 @@ pub(crate) struct OverrideConfig {
    api_validators: Option<String>,
    port: Option<u16>,
    fastmode: bool,
+    no_cover: bool,

    #[cfg(feature = "coconut")]
    enabled_credentials_mode: bool,
 }

-pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send>> {
+pub(crate) async fn execute(args: &Cli) -> Result<(), Box<dyn Error + Send + Sync>> {
    let bin_name = "nym-socks5-client";

    match &args.command {
-        Commands::Init(m) => init::execute(m).await,
+        Commands::Init(m) => init::execute(m).await?,
        Commands::Run(m) => run::execute(m).await?,
        Commands::Upgrade(m) => upgrade::execute(m),
        Commands::Completions(s) => s.generate(&mut Cli::into_app(), bin_name),
@@ -136,6 +137,10 @@ pub(crate) fn override_config(mut config: Config, args: OverrideConfig) -> Confi
        config.get_base_mut().set_high_default_traffic_volume();
    }

+    if args.no_cover {
+        config.get_base_mut().set_no_cover_traffic();
+    }
+
    config
 }

@@ -43,6 +43,15 @@ pub(crate) struct Run {
    #[clap(short, long)]
    port: Option<u16>,

+    /// Mostly debug-related option to increase default traffic rate so that you would not need to
+    /// modify config post init
+    #[clap(long, hidden = true)]
+    fastmode: bool,
+
+    /// Disable loop cover traffic and the Poisson rate limiter (for debugging only)
+    #[clap(long, hidden = true)]
+    no_cover: bool,
+
    /// Set this client to work in a enabled credentials mode that would attempt to use gateway
    /// with bandwidth credential requirement.
    #[cfg(feature = "coconut")]
@@ -56,8 +65,8 @@ impl From<Run> for OverrideConfig {
            nymd_validators: run_config.nymd_validators,
            api_validators: run_config.api_validators,
            port: run_config.port,
-            fastmode: false,
-
+            fastmode: run_config.fastmode,
+            no_cover: run_config.no_cover,
            #[cfg(feature = "coconut")]
            enabled_credentials_mode: run_config.enabled_credentials_mode,
        }
@@ -86,7 +95,7 @@ fn version_check(cfg: &Config) -> bool {
    }
 }

-pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error + Send>> {
+pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let id = &args.id;

    let mut config = match Config::load_from_file(Some(id)) {
@@ -1,7 +1,4 @@
-use client_core::{client::reply_key_storage::ReplyKeyStorageError, error::ClientCoreError};
-use crypto::asymmetric::identity::Ed25519RecoveryError;
-use gateway_client::error::GatewayClientError;
-use validator_client::ValidatorClientError;
+use client_core::error::ClientCoreError;

 use crate::socks::types::SocksProxyError;

@@ -9,16 +6,8 @@ use crate::socks::types::SocksProxyError;
 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("SOCKS proxy error")]
    SocksProxyError(SocksProxyError),
@@ -13,7 +13,7 @@ pub mod error;
 pub mod socks;

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

@@ -2,8 +2,8 @@

 use super::authentication::{AuthenticationMethods, Authenticator, User};
 use super::request::{SocksCommand, SocksRequest};
-use super::types::{ResponseCode, SocksProxyError};
-use super::{RESERVED, SOCKS_VERSION};
+use super::types::{ResponseCodeV4, ResponseCodeV5, SocksProxyError};
+use super::{SocksVersion, RESERVED, SOCKS4_VERSION, SOCKS5_VERSION};
 use client_connections::{LaneQueueLengths, TransmissionLane};
 use client_core::client::inbound_messages::{InputMessage, InputMessageSender};
 use futures::channel::mpsc;
@@ -129,13 +129,13 @@ impl AsyncWrite for StreamState {
 /// A client connecting to the Socks proxy server, because
 /// it wants to make a Nym-protected outbound request. Typically, this is
 /// something like e.g. a wallet app running on your laptop connecting to
-/// SphinxSocksServer.
+/// `SphinxSocksServer`.
 pub(crate) struct SocksClient {
    controller_sender: ControllerSender,
    stream: StreamState,
    auth_nmethods: u8,
    authenticator: Authenticator,
-    socks_version: u8,
+    socks_version: Option<SocksVersion>,
    input_sender: InputMessageSender,
    connection_id: ConnectionId,
    service_provider: Recipient,
@@ -158,29 +158,32 @@ impl Drop for SocksClient {
 }

 impl SocksClient {
-    /// Create a new SOCKClient
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        stream: TcpStream,
        authenticator: Authenticator,
        input_sender: InputMessageSender,
-        service_provider: Recipient,
+        service_provider: &Recipient,
        controller_sender: ControllerSender,
-        self_address: Recipient,
+        self_address: &Recipient,
        lane_queue_lengths: LaneQueueLengths,
-        shutdown_listener: ShutdownListener,
+        mut shutdown_listener: ShutdownListener,
    ) -> Self {
+        // If this task fails and exits, we don't want to send shutdown signal
+        shutdown_listener.mark_as_success();
+
        let connection_id = Self::generate_random();
+
        SocksClient {
            controller_sender,
            connection_id,
            stream: StreamState::Available(stream),
            auth_nmethods: 0,
-            socks_version: 0,
+            socks_version: None,
            authenticator,
            input_sender,
-            service_provider,
-            self_address,
+            service_provider: *service_provider,
+            self_address: *self_address,
            started_proxy: false,
            lane_queue_lengths,
            shutdown_listener,
@@ -192,13 +195,45 @@ impl SocksClient {
        rng.next_u64()
    }

+    pub async fn send_error(&mut self, err: SocksProxyError) -> Result<(), SocksProxyError> {
+        let error_text = format!("{}", err);
+        let Some(ref version) = self.socks_version else {
+            log::error!("Trying to send error without knowing the version");
+            return Ok(());
+        };
+
+        match version {
+            SocksVersion::V4 => {
+                let response = ResponseCodeV4::RequestRejected;
+                self.send_error_v4(response).await
+            }
+            SocksVersion::V5 => {
+                let response = if error_text.contains("Host") {
+                    ResponseCodeV5::HostUnreachable
+                } else if error_text.contains("Network") {
+                    ResponseCodeV5::NetworkUnreachable
+                } else if error_text.contains("ttl") {
+                    ResponseCodeV5::TtlExpired
+                } else {
+                    ResponseCodeV5::Failure
+                };
+                self.send_error_v5(response).await
+            }
+        }
+    }
+
    // Send an error back to the client
-    pub async fn error(&mut self, r: ResponseCode) -> Result<(), SocksProxyError> {
-        self.stream.write_all(&[5, r as u8]).await?;
+    pub async fn send_error_v4(&mut self, r: ResponseCodeV4) -> Result<(), SocksProxyError> {
+        self.stream.write_all(&[SOCKS4_VERSION, r as u8]).await?;
        Ok(())
    }

-    /// Shutdown the TcpStream to the client and end the session
+    pub async fn send_error_v5(&mut self, r: ResponseCodeV5) -> Result<(), SocksProxyError> {
+        self.stream.write_all(&[SOCKS5_VERSION, r as u8]).await?;
+        Ok(())
+    }
+
+    /// Shutdown the `TcpStream` to the client and end the session
    pub async fn shutdown(&mut self) -> Result<(), SocksProxyError> {
        info!("client is shutting down its TCP stream");
        self.stream.shutdown().await?;
@@ -210,25 +245,27 @@ impl SocksClient {
    /// is in use and that the client is authenticated, then runs the request.
    pub async fn run(&mut self) -> Result<(), SocksProxyError> {
        debug!("New connection from: {}", self.stream.peer_addr()?.ip());
-        let mut header = [0u8; 2];
+
        // Read a byte from the stream and determine the version being requested
+        let mut header = [0u8];
        self.stream.read_exact(&mut header).await?;

-        self.socks_version = header[0];
-        self.auth_nmethods = header[1];
+        self.socks_version = match SocksVersion::try_from(header[0]) {
+            Ok(version) => Some(version),
+            Err(_err) => {
+                warn!("Init: Unsupported version: SOCKS{}", header[0]);
+                return self.shutdown().await;
+            }
+        };

-        // Handle SOCKS4 requests
-        if header[0] != SOCKS_VERSION {
-            warn!("Init: Unsupported version: SOCKS{}", self.socks_version);
-            self.shutdown().await
-        }
-        // Valid SOCKS5
-        else {
-            // Authenticate w/ client
-            self.authenticate().await?;
-            // Handle requests
-            self.handle_request().await
+        if self.socks_version == Some(SocksVersion::V5) {
+            let mut auth = [0u8];
+            self.stream.read_exact(&mut auth).await?;
+            self.auth_nmethods = auth[0];
+            self.authenticate_socks5().await?;
        }
+
+        self.handle_request().await
    }

    async fn send_connect_to_mixnet(&mut self, remote_address: RemoteAddress) {
@@ -252,10 +289,15 @@ impl SocksClient {
            .await;

        let stream = self.stream.run_proxy();
-        let local_stream_remote = stream
-            .peer_addr()
-            .expect("failed to extract peer address")
-            .to_string();
+        let peer_addr = match stream.peer_addr() {
+            Ok(peer_addr) => peer_addr,
+            Err(err) => {
+                log::error!("Unable to extract the remote peer address: {err}");
+                return;
+            }
+        };
+        let local_stream_remote = peer_addr.to_string();
+
        let connection_id = self.connection_id;
        let input_sender = self.input_sender.clone();

@@ -286,8 +328,17 @@ impl SocksClient {
    async fn handle_request(&mut self) -> Result<(), SocksProxyError> {
        debug!("Handling CONNECT Command");

-        let request = SocksRequest::from_stream(&mut self.stream).await?;
-        let remote_address = request.to_string();
+        let version = self
+            .socks_version
+            .as_ref()
+            .expect("Must read version before parsing request");
+
+        let request = match version {
+            SocksVersion::V4 => SocksRequest::from_stream_socks4(&mut self.stream).await?,
+            SocksVersion::V5 => SocksRequest::from_stream_socks5(&mut self.stream).await?,
+        };
+
+        let remote_address = request.address_string();

        // setup for receiving from the mixnet
        let (mix_sender, mix_receiver) = mpsc::unbounded();
@@ -296,7 +347,10 @@ impl SocksClient {
            // Use the Proxy to connect to the specified addr/port
            SocksCommand::Connect => {
                trace!("Connecting to: {:?}", remote_address.clone());
-                self.acknowledge_socks5().await;
+                match version {
+                    SocksVersion::V4 => self.acknowledge_socks4().await,
+                    SocksVersion::V5 => self.acknowledge_socks5().await,
+                }

                self.started_proxy = true;
                self.controller_sender
@@ -319,7 +373,6 @@ impl SocksClient {
            SocksCommand::UdpAssociate => unimplemented!(), // not handled
        };

-        self.shutdown_listener.mark_as_success();
        Ok(())
    }

@@ -328,8 +381,8 @@ impl SocksClient {
    async fn acknowledge_socks5(&mut self) {
        self.stream
            .write_all(&[
-                SOCKS_VERSION,
-                ResponseCode::Success as u8,
+                SOCKS5_VERSION,
+                ResponseCodeV5::Success as u8,
                RESERVED,
                1,
                127,
@@ -343,13 +396,30 @@ impl SocksClient {
            .unwrap();
    }

+    /// Writes a Socks4 header back to the requesting client's TCP stream,
+    async fn acknowledge_socks4(&mut self) {
+        self.stream
+            .write_all(&[
+                0, //SOCKS4_VERSION,
+                ResponseCodeV4::Granted as u8,
+                0,
+                0,
+                127,
+                0,
+                0,
+                1,
+            ])
+            .await
+            .unwrap();
+    }
+
    /// Authenticate the incoming request. Each request is checked for its
    /// authentication method. A user/password request will extract the
    /// username and password from the stream, then check with the Authenticator
    /// to see if the resulting user is allowed.
    ///
    /// A lot of this could probably be put into the `SocksRequest::from_stream()`
-    /// constructor, and/or cleaned up with tokio::codec. It's mostly just
+    /// constructor, and/or cleaned up with `tokio::codec`. It's mostly just
    /// read-a-byte-or-two. The bytes being extracted look like this:
    ///
    /// +----+------+----------+------+------------+
@@ -361,7 +431,7 @@ impl SocksClient {
    /// Pulling out the stream code into its own home, and moving the if/else logic
    /// into the Authenticator (where it'll be more easily testable)
    /// would be a good next step.
-    async fn authenticate(&mut self) -> Result<(), SocksProxyError> {
+    async fn authenticate_socks5(&mut self) -> Result<(), SocksProxyError> {
        debug!("Authenticating w/ {}", self.stream.peer_addr()?.ip());
        // Get valid auth methods
        let methods = self.get_available_methods().await?;
@@ -370,7 +440,7 @@ impl SocksClient {
        let mut response = [0u8; 2];

        // Set the version in the response
-        response[0] = SOCKS_VERSION;
+        response[0] = SOCKS5_VERSION;
        if methods.contains(&(AuthenticationMethods::UserPass as u8)) {
            // Set the default auth method (NO AUTH)
            response[1] = AuthenticationMethods::UserPass as u8;
@@ -406,11 +476,11 @@ impl SocksClient {
            // Authenticate passwords
            if self.authenticator.is_allowed(&user) {
                debug!("Access Granted. User: {}", user.username);
-                let response = [1, ResponseCode::Success as u8];
+                let response = [1, ResponseCodeV5::Success as u8];
                self.stream.write_all(&response).await?;
            } else {
                debug!("Access Denied. User: {}", user.username);
-                let response = [1, ResponseCode::Failure as u8];
+                let response = [1, ResponseCodeV5::Failure as u8];
                self.stream.write_all(&response).await?;

                // Shutdown
@@ -429,7 +499,7 @@ impl SocksClient {
            response[1] = AuthenticationMethods::NoMethods as u8;
            self.stream.write_all(&response).await?;
            self.shutdown().await?;
-            Err(ResponseCode::Failure.into())
+            Err(ResponseCodeV5::Failure.into())
        }
    }

@@ -105,6 +105,7 @@ impl MixnetResponseListener {
                }
            }
        }
+        #[cfg(not(target_arch = "wasm32"))]
        tokio::time::timeout(Duration::from_secs(5), self.shutdown.recv())
            .await
            .expect("Task stopped without shutdown called");
@@ -1,5 +1,9 @@
 #![forbid(unsafe_code)]

+use std::convert::TryFrom;
+
+use self::types::SocksProxyError;
+
 pub mod authentication;
 mod client;
 pub(crate) mod mixnet_responses;
@@ -9,6 +13,27 @@ pub mod types;
 pub mod utils;

 /// Version of socks
-const SOCKS_VERSION: u8 = 0x05;
+const SOCKS4_VERSION: u8 = 0x04;
+const SOCKS5_VERSION: u8 = 0x05;

 const RESERVED: u8 = 0x00;
+
+#[derive(Clone, PartialEq, Eq)]
+pub enum SocksVersion {
+    V4 = 0x04,
+    V5 = 0x05,
+}
+
+pub struct InvalidSocksVersion;
+
+impl TryFrom<u8> for SocksVersion {
+    type Error = SocksProxyError;
+
+    fn try_from(version: u8) -> Result<Self, Self::Error> {
+        match version {
+            SOCKS4_VERSION => Ok(Self::V4),
+            SOCKS5_VERSION => Ok(Self::V5),
+            _ => Err(SocksProxyError::UnsupportedProxyVersion(version)),
+        }
+    }
+}
@@ -1,5 +1,7 @@
-use super::types::{AddrType, ResponseCode, SocksProxyError};
-use super::{utils as socks_utils, SOCKS_VERSION};
+use crate::socks::SOCKS4_VERSION;
+
+use super::types::{AddrType, ResponseCodeV5, SocksProxyError};
+use super::{utils as socks_utils, SOCKS5_VERSION};
 use log::*;
 use std::fmt::{self, Display};
 use tokio::io::{AsyncRead, AsyncReadExt};
@@ -15,80 +17,114 @@ pub(crate) struct SocksRequest {
 }

 impl SocksRequest {
-    /// Parse a SOCKS5 request from a TcpStream
-    pub async fn from_stream<R>(stream: &mut R) -> Result<Self, SocksProxyError>
+    /// Parse a SOCKS4 request from a `TcpStream`
+    /// From documents at:
+    ///  - SOCKS4: https://www.openssh.com/txt/socks4.protocol
+    ///  - SOCKS4a: https://www.openssh.com/txt/socks4a.protocol
+    pub async fn from_stream_socks4<R>(stream: &mut R) -> Result<Self, SocksProxyError>
    where
        R: AsyncRead + Unpin,
    {
+        log::trace!("read from stream socks4");
+
+        let mut packet = [0u8; 3];
+        stream.read_exact(&mut packet).await?;
+
+        // CD (command)
+        let Some(command) = SocksCommand::from(packet[0] as usize) else {
+            log::warn!("Invalid Command");
+            return Err(ResponseCodeV5::CommandNotSupported.into());
+        };
+
+        // DSTPORT
+        let mut port = [0u8; 2];
+        port.copy_from_slice(&packet[1..]);
+        let port = merge_u8_into_u16(port[0], port[1]);
+
+        // DSTIP
+        let mut ip = [0u8; 4];
+        stream.read_exact(&mut ip).await?;
+
+        // USERID
+        let _userid = read_until_zero(stream).await;
+
+        // SOCKS4a extension
+        // https://www.openssh.com/txt/socks4a.protocol
+        // If the IP is 0.0.0.x with x nonzero, read the domain name
+        let (addr, addr_type) = if ip[..3] == [0, 0, 0] && ip[3] != 0 {
+            (read_until_zero(stream).await?, AddrType::Domain)
+        } else {
+            (ip.to_vec(), AddrType::V4)
+        };
+
+        // Return parsed request
+        Ok(SocksRequest {
+            version: SOCKS4_VERSION,
+            command,
+            addr_type,
+            addr,
+            port,
+        })
+    }
+    /// Parse a SOCKS5 request from a `TcpStream`
+    /// From: https://www.rfc-editor.org/rfc/rfc1928
+    pub async fn from_stream_socks5<R>(stream: &mut R) -> Result<Self, SocksProxyError>
+    where
+        R: AsyncRead + Unpin,
+    {
+        log::info!("read from stream socks5");
+
        let mut packet = [0u8; 4];
        // Read a byte from the stream and determine the version being requested
        stream.read_exact(&mut packet).await?;

-        if packet[0] != SOCKS_VERSION {
-            warn!("from_stream Unsupported version: SOCKS{}", packet[0]);
+        // VER
+        if packet[0] != SOCKS5_VERSION {
+            warn!("Unsupported version: SOCKS{}", packet[0]);
            return Err(SocksProxyError::UnsupportedProxyVersion(packet[0]));
        }

-        // Get command
-        let mut command: SocksCommand = SocksCommand::Connect;
-        match SocksCommand::from(packet[1] as usize) {
-            Some(com) => {
-                command = com;
-                Ok(())
-            }
-            None => {
-                warn!("Invalid Command");
-                Err(ResponseCode::CommandNotSupported)
-            }
-        }?;
+        // CMD
+        let Some(command) = SocksCommand::from(packet[1] as usize) else {
+            warn!("Invalid Command");
+            return Err(ResponseCodeV5::CommandNotSupported.into());
+        };

-        // DST.address
+        // RSV
+        // packet[2] is reserved

-        let mut addr_type: AddrType = AddrType::V6;
-        match AddrType::from(packet[3] as usize) {
-            Some(addr) => {
-                addr_type = addr;
-                Ok(())
-            }
-            None => {
-                error!("No Addr");
-                Err(ResponseCode::AddrTypeNotSupported)
-            }
-        }?;
+        // ATYP
+        let Some(addr_type) = AddrType::from(packet[3] as usize) else {
+            error!("No Addr");
+            return Err(ResponseCodeV5::AddrTypeNotSupported.into())
+        };

-        trace!("Getting Addr");
-        // Get Addr from addr_type and stream
-        let addr: Result<Vec<u8>, SocksProxyError> = match addr_type {
+        // DST.ADDR
+        let addr = match addr_type {
            AddrType::Domain => {
-                let mut domain_length = [0u8; 1];
+                let mut domain_length = [0u8];
                stream.read_exact(&mut domain_length).await?;
-
                let mut domain = vec![0u8; domain_length[0] as usize];
                stream.read_exact(&mut domain).await?;
-
-                Ok(domain)
+                domain
            }
            AddrType::V4 => {
                let mut addr = [0u8; 4];
                stream.read_exact(&mut addr).await?;
-                Ok(addr.to_vec())
+                addr.to_vec()
            }
            AddrType::V6 => {
                let mut addr = [0u8; 16];
                stream.read_exact(&mut addr).await?;
-                Ok(addr.to_vec())
+                addr.to_vec()
            }
        };

-        let addr = addr?;
-
-        // read DST.port
+        // DST.PORT
        let mut port = [0u8; 2];
        stream.read_exact(&mut port).await?;
-        // Merge two u8s into u16
-        let port = (u16::from(port[0]) << 8) | u16::from(port[1]);
+        let port = merge_u8_into_u16(port[0], port[1]);

-        // Return parsed request
        Ok(SocksRequest {
            version: packet[0],
            command,
@@ -97,14 +133,18 @@ impl SocksRequest {
            port,
        })
    }
+
+    /// Print out the address and port to a String.
+    /// This might return domain:port, ipv6:port, or ipv4:port.
+    pub fn address_string(&self) -> String {
+        let address = socks_utils::pretty_print_addr(&self.addr_type, &self.addr);
+        format!("{}:{}", address, self.port)
+    }
 }

 impl Display for SocksRequest {
-    /// Print out the address and port to a String.
-    /// This might return domain:port, ipv6:port, or ipv4:port.
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let address = socks_utils::pretty_print_addr(&self.addr_type, &self.addr);
-        write!(f, "{}:{}", address, self.port)
+        write!(f, "{}", self.address_string())
    }
 }

@@ -127,3 +167,23 @@ impl SocksCommand {
        }
    }
 }
+
+fn merge_u8_into_u16(a: u8, b: u8) -> u16 {
+    (u16::from(a) << 8) | u16::from(b)
+}
+
+async fn read_until_zero<R>(stream: &mut R) -> Result<Vec<u8>, SocksProxyError>
+where
+    R: AsyncRead + Unpin,
+{
+    let mut result = Vec::new();
+    let mut char = [0u8];
+    loop {
+        stream.read_exact(&mut char).await?;
+        if char[0] == 0 {
+            break;
+        }
+        result.push(char[0]);
+    }
+    Ok(result)
+}
@@ -1,8 +1,8 @@
 use crate::error::Socks5ClientError;

-use super::authentication::Authenticator;
-use super::client::SocksClient;
-use super::{mixnet_responses::MixnetResponseListener, types::ResponseCode};
+use super::{
+    authentication::Authenticator, client::SocksClient, mixnet_responses::MixnetResponseListener,
+};
 use client_connections::{ConnectionCommandSender, LaneQueueLengths};
 use client_core::client::{
    inbound_messages::InputMessageSender, received_buffer::ReceivedBufferRequestSender,
@@ -85,47 +85,26 @@ impl SphinxSocksServer {
        loop {
            tokio::select! {
                Ok((stream, _remote)) = listener.accept() => {
-                    // TODO Optimize this
                    let mut client = SocksClient::new(
                        stream,
                        self.authenticator.clone(),
                        input_sender.clone(),
-                        self.service_provider,
+                        &self.service_provider,
                        controller_sender.clone(),
-                        self.self_address,
+                        &self.self_address,
                        self.lane_queue_lengths.clone(),
                        self.shutdown.clone(),
                    );

                    tokio::spawn(async move {
-                        {
-                            match client.run().await {
-                                Ok(_) => {}
-                                Err(error) => {
-                                    error!("Error! {}", error);
-                                    let error_text = format!("{}", error);
-
-                                    let response: ResponseCode;
-
-                                    if error_text.contains("Host") {
-                                        response = ResponseCode::HostUnreachable;
-                                    } else if error_text.contains("Network") {
-                                        response = ResponseCode::NetworkUnreachable;
-                                    } else if error_text.contains("ttl") {
-                                        response = ResponseCode::TtlExpired
-                                    } else {
-                                        response = ResponseCode::Failure
-                                    }
-
-                                    if client.error(response).await.is_err() {
-                                        warn!("Failed to send error code");
-                                    };
-                                    if client.shutdown().await.is_err() {
-                                        warn!("Failed to shutdown TcpStream");
-                                    };
-                                }
+                        if let Err(err) = client.run().await {
+                            error!("Error! {}", err);
+                            if client.send_error(err).await.is_err() {
+                                warn!("Failed to send error code");
+                            };
+                            if client.shutdown().await.is_err() {
+                                warn!("Failed to shutdown TcpStream");
                            };
-                            // client gets dropped here
                        }
                    });
                },
@@ -1,23 +1,33 @@
-use snafu::Snafu;
-#[derive(Debug, Snafu)]
+/// SOCKS4 Response codes
+#[allow(dead_code)]
+pub(crate) enum ResponseCodeV4 {
+    Granted = 0x5a,
+    RequestRejected = 0x5b,
+    CannotConnectToIdent = 0x5c,
+    DifferentUserId = 0x5d,
+}
+
 /// Possible SOCKS5 Response Codes
-pub(crate) enum ResponseCode {
+#[allow(dead_code)]
+#[derive(Debug, thiserror::Error)]
+pub(crate) enum ResponseCodeV5 {
+    #[error("SOCKS5 Server Success")]
    Success = 0x00,
-    #[snafu(display("SOCKS5 Server Failure"))]
+    #[error("SOCKS5 Server Failure")]
    Failure = 0x01,
-    #[snafu(display("SOCKS5 Rule failure"))]
+    #[error("SOCKS5 Rule failure")]
    RuleFailure = 0x02,
-    #[snafu(display("network unreachable"))]
+    #[error("network unreachable")]
    NetworkUnreachable = 0x03,
-    #[snafu(display("host unreachable"))]
+    #[error("host unreachable")]
    HostUnreachable = 0x04,
-    #[snafu(display("connection refused"))]
+    #[error("connection refused")]
    ConnectionRefused = 0x05,
-    #[snafu(display("TTL expired"))]
+    #[error("TTL expired")]
    TtlExpired = 0x06,
-    #[snafu(display("Command not supported"))]
+    #[error("Command not supported")]
    CommandNotSupported = 0x07,
-    #[snafu(display("Addr Type not supported"))]
+    #[error("Addr Type not supported")]
    AddrTypeNotSupported = 0x08,
 }

@@ -48,7 +58,7 @@ where
 }

 /// DST.addr variant types
-#[derive(PartialEq)]
+#[derive(Debug, PartialEq)]
 pub(crate) enum AddrType {
    V4 = 0x01,
    Domain = 0x03,
@@ -39,7 +39,7 @@ topology = { path = "../../common/topology" }
 gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 wasm-utils = { path = "../../common/wasm-utils" }
-
+task = { path = "../../common/task" }
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires
 # all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
@@ -24,7 +24,7 @@
    },
    "../pkg": {
      "name": "@nymproject/nym-client-wasm",
-      "version": "1.0.0",
+      "version": "1.1.0",
      "license": "Apache-2.0"
    },
    "node_modules/@discoveryjs/json-ext": {
@@ -61,16 +61,9 @@ async function main() {
  // sets up better stack traces in case of in-rust panics
  set_panic_hook();

-  console.error("the current mainnet is not compatible with v2! - either use the pre-merge branch or explicitly set the client to use one of V2 QA networks")
-  return
-
  // validator server we will use to get topology from
-  // MAINNET (V1):
  const validator = 'https://validator.nymtech.net/api'; //"http://localhost:8081";
  const preferredGateway = 'E3mvZTHQCdBvhfr178Swx9g4QG3kkRUun7YnToLMcMbM';
-  // QA (V2):
-  // const validator = 'https://qa-validator-api.nymtech.net/api'; //"http://localhost:8081";
-  // const preferredGateway = 'CgQrYP8etksSBf4nALNqp93SHPpgFwEUyTsjBNNLj5WM';

  const gatewayEndpoint = await get_gateway(validator, preferredGateway);
  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
@@ -4,12 +4,15 @@
 // 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::{DebugConfig as ConfigDebug, ExtendedPacketSize, GatewayEndpointConfig};
+use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
 use wasm_bindgen::prelude::*;

 #[wasm_bindgen]
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
 pub struct Config {
    /// ID specifies the human readable ID of this particular client.
    pub(crate) id: String,
@@ -19,7 +22,7 @@ pub struct Config {
    pub(crate) disabled_credentials_mode: bool,

    /// Information regarding how the client should send data to gateway.
-    pub(crate) gateway_endpoint: GatewayEndpoint,
+    pub(crate) gateway_endpoint: GatewayEndpointConfig,

    pub(crate) debug: ConfigDebug,
 }
@@ -30,7 +33,7 @@ impl Config {
    pub fn new(
        id: String,
        validator_server: String,
-        gateway_endpoint: GatewayEndpoint,
+        gateway_endpoint: GatewayEndpointConfig,
        debug: Option<Debug>,
    ) -> Self {
        Config {
@@ -2,51 +2,44 @@
 // SPDX-License-Identifier: Apache-2.0

 use self::config::Config;
-use client_connections::{ConnectionCommandReceiver, LaneQueueLengths, TransmissionLane};
-use client_core::client::{
-    cover_traffic_stream::LoopCoverTrafficStream,
-    inbound_messages::{InputMessage, InputMessageReceiver, InputMessageSender},
-    key_manager::KeyManager,
-    mix_traffic::{BatchMixMessageSender, MixTrafficController},
-    real_messages_control::{self, RealMessagesController},
-    received_buffer::{
-        ReceivedBufferMessage, ReceivedBufferRequestReceiver, ReceivedBufferRequestSender,
-        ReceivedMessagesBufferController,
-    },
-    topology_control::{TopologyAccessor, TopologyRefresher, TopologyRefresherConfig},
-};
+use crate::client::response_pusher::ResponsePusher;
+use client_connections::TransmissionLane;
+use client_core::client::base_client::{BaseClientBuilder, ClientInput, ClientOutput};
+use client_core::client::{inbound_messages::InputMessage, key_manager::KeyManager};
 use crypto::asymmetric::identity;
-use futures::channel::mpsc;
-use futures::StreamExt;
-use gateway_client::{
-    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
-    MixnetMessageSender,
-};
 use nymsphinx::addressing::clients::Recipient;
 use rand::rngs::OsRng;
+use task::ShutdownNotifier;
 use wasm_bindgen::prelude::*;
-use wasm_bindgen_futures::spawn_local;
-use wasm_utils::console_log;
+use wasm_utils::{console_error, console_log};

 pub mod config;
+mod response_pusher;

 #[wasm_bindgen]
 pub struct NymClient {
    config: Config,

    /// KeyManager object containing smart pointers to all relevant keys used by the client.
-    key_manager: KeyManager,
+    // due to disgusting workaround I had to wrap the key_manager in an Option
+    // so that the interface wouldn't change (i.e. both `start` and `new` would still return a `NymClient`)
+    key_manager: Option<KeyManager>,
+    self_address: Option<String>,

    // TODO: this should be stored somewhere persistently
    // received_keys: HashSet<SURBEncryptionKey>,
    /// Channel used for transforming 'raw' messages into sphinx packets and sending them
    /// through the mix network.
-    input_tx: Option<InputMessageSender>,
+    client_input: Option<ClientInput>,

    // callbacks
    on_message: Option<js_sys::Function>,
    on_binary_message: Option<js_sys::Function>,
    on_gateway_connect: Option<js_sys::Function>,
+
+    // even though we don't use graceful shutdowns, other components rely on existence of this struct
+    // and if it's dropped, everything will start going offline
+    _shutdown: Option<ShutdownNotifier>,
 }

 #[wasm_bindgen]
@@ -55,14 +48,19 @@ impl NymClient {
    pub fn new(config: Config) -> Self {
        Self {
            config,
-            key_manager: Self::setup_key_manager(),
+            key_manager: Some(Self::setup_key_manager()),
            on_message: None,
            on_binary_message: None,
            on_gateway_connect: None,
-            input_tx: None,
+            client_input: None,
+            self_address: None,
+            _shutdown: None,
        }
    }

+    // TODO: once we make keys persistent, we'll require some kind of `init` method to generate
+    // a prior shared keypair between the client and the gateway
+
    // perhaps this should be public?
    fn setup_key_manager() -> KeyManager {
        let mut rng = OsRng;
@@ -84,298 +82,26 @@ impl NymClient {
    }

    fn as_mix_recipient(&self) -> Recipient {
+        // another disgusting (and hopefully temporary) workaround
+        let key_manager_ref = self
+            .key_manager
+            .as_ref()
+            .expect("attempting to call 'as_mix_recipient' after 'start'");
+
        Recipient::new(
-            *self.key_manager.identity_keypair().public_key(),
-            *self.key_manager.encryption_keypair().public_key(),
+            *key_manager_ref.identity_keypair().public_key(),
+            *key_manager_ref.encryption_keypair().public_key(),
            identity::PublicKey::from_base58_string(&self.config.gateway_endpoint.gateway_id)
                .expect("no gateway has been selected"),
        )
    }

    pub fn self_address(&self) -> String {
-        self.as_mix_recipient().to_string()
-    }
-
-    // future constantly pumping loop cover traffic at some specified average rate
-    // the pumped traffic goes to the MixTrafficController
-    fn start_cover_traffic_stream(
-        &self,
-        topology_accessor: TopologyAccessor,
-        mix_tx: BatchMixMessageSender,
-    ) {
-        console_log!("Starting loop cover traffic stream...");
-
-        let mut stream = LoopCoverTrafficStream::new(
-            self.key_manager.ack_key(),
-            self.config.debug.average_ack_delay,
-            self.config.debug.average_packet_delay,
-            self.config.debug.loop_cover_traffic_average_delay,
-            mix_tx,
-            self.as_mix_recipient(),
-            topology_accessor,
-        );
-
-        if let Some(size) = &self.config.debug.use_extended_packet_size {
-            stream.set_custom_packet_size(size.clone().into());
+        if let Some(address) = &self.self_address {
+            address.clone()
+        } else {
+            self.as_mix_recipient().to_string()
        }
-
-        stream.start();
-    }
-
-    fn start_real_traffic_controller(
-        &self,
-        topology_accessor: TopologyAccessor,
-        ack_receiver: AcknowledgementReceiver,
-        input_receiver: InputMessageReceiver,
-        mix_sender: BatchMixMessageSender,
-        client_connection_rx: ConnectionCommandReceiver,
-        lane_queue_lengths: LaneQueueLengths,
-    ) {
-        let mut controller_config = real_messages_control::Config::new(
-            self.key_manager.ack_key(),
-            self.config.debug.ack_wait_multiplier,
-            self.config.debug.ack_wait_addition,
-            self.config.debug.average_ack_delay,
-            self.config.debug.message_sending_average_delay,
-            self.config.debug.average_packet_delay,
-            self.config.debug.disable_main_poisson_packet_distribution,
-            self.as_mix_recipient(),
-        );
-
-        if let Some(size) = &self.config.debug.use_extended_packet_size {
-            controller_config.set_custom_packet_size(size.clone().into());
-        }
-
-        console_log!("Starting real traffic stream...");
-
-        RealMessagesController::new(
-            controller_config,
-            ack_receiver,
-            input_receiver,
-            mix_sender,
-            topology_accessor,
-            lane_queue_lengths,
-            client_connection_rx,
-        )
-        .start();
-    }
-
-    // buffer controlling all messages fetched from provider
-    // required so that other components would be able to use them (say the websocket)
-    fn start_received_messages_buffer_controller(
-        &self,
-        query_receiver: ReceivedBufferRequestReceiver,
-        mixnet_receiver: MixnetMessageReceiver,
-    ) {
-        console_log!("Starting received messages buffer controller...");
-        ReceivedMessagesBufferController::new(
-            self.key_manager.encryption_keypair(),
-            query_receiver,
-            mixnet_receiver,
-        )
-        .start()
-    }
-
-    async fn start_gateway_client(
-        &mut self,
-        mixnet_message_sender: MixnetMessageSender,
-        ack_sender: AcknowledgementSender,
-    ) -> GatewayClient {
-        let gateway_id = self.config.gateway_endpoint.gateway_id.clone();
-        if gateway_id.is_empty() {
-            panic!("The identity of the gateway is unknown - did you run `get_gateway()`?")
-        }
-        let gateway_owner = self.config.gateway_endpoint.gateway_owner.clone();
-        if gateway_owner.is_empty() {
-            panic!("The owner of the gateway is unknown - did you run `get_gateway()`?")
-        }
-        let gateway_address = self.config.gateway_endpoint.gateway_listener.clone();
-        if gateway_address.is_empty() {
-            panic!("The address of the gateway is unknown - did you run `get_gateway()`?")
-        }
-
-        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
-            .expect("provided gateway id is invalid!");
-
-        let mut gateway_client = GatewayClient::new(
-            gateway_address,
-            self.key_manager.identity_keypair(),
-            gateway_identity,
-            gateway_owner,
-            None,
-            mixnet_message_sender,
-            ack_sender,
-            self.config.debug.gateway_response_timeout,
-            None,
-        );
-
-        gateway_client.set_disabled_credentials_mode(self.config.disabled_credentials_mode);
-
-        let shared_keys = gateway_client
-            .authenticate_and_start()
-            .await
-            .expect("could not authenticate and start up the gateway connection");
-        self.key_manager.insert_gateway_shared_key(shared_keys);
-
-        match self.on_gateway_connect.as_ref() {
-            Some(callback) => {
-                callback
-                    .call0(&JsValue::null())
-                    .expect("on connect callback failed!");
-            }
-            None => console_log!("Gateway connection established - no callback specified"),
-        };
-
-        gateway_client
-    }
-
-    // future responsible for periodically polling directory server and updating
-    // the current global view of topology
-    async fn start_topology_refresher(&mut self, topology_accessor: TopologyAccessor) {
-        let topology_refresher_config = TopologyRefresherConfig::new(
-            vec![self.config.validator_api_url.clone()],
-            self.config.debug.topology_refresh_rate,
-            env!("CARGO_PKG_VERSION").to_string(),
-        );
-        let mut topology_refresher =
-            TopologyRefresher::new(topology_refresher_config, topology_accessor);
-        // before returning, block entire runtime to refresh the current network view so that any
-        // components depending on topology would see a non-empty view
-        console_log!("Obtaining initial network topology");
-        topology_refresher.refresh().await;
-
-        // TODO: a slightly more graceful termination here
-        if !topology_refresher.is_topology_routable().await {
-            panic!(
-                "The current network topology seem to be insufficient to route any packets through\
-                - check if enough nodes and a gateway are online"
-            );
-        }
-
-        console_log!("Starting topology refresher...");
-
-        // TODO: re-enable
-        topology_refresher.start();
-    }
-
-    // controller for sending sphinx packets to mixnet (either real traffic or cover traffic)
-    // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership
-    // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
-    // requests?
-    fn start_mix_traffic_controller(gateway_client: GatewayClient) -> BatchMixMessageSender {
-        console_log!("Starting mix traffic controller...");
-        let (mix_traffic_controller, mix_tx) = MixTrafficController::new(gateway_client);
-        mix_traffic_controller.start();
-        mix_tx
-    }
-
-    // TODO: this procedure is extremely overcomplicated, because it's based off native client's behaviour
-    // which doesn't fully apply in this case
-    fn start_reconstructed_pusher(
-        &mut self,
-        received_buffer_request_sender: ReceivedBufferRequestSender,
-    ) {
-        let on_message = self.on_message.take();
-        let on_binary_message = self.on_binary_message.take();
-
-        spawn_local(async move {
-            let (reconstructed_sender, mut reconstructed_receiver) = mpsc::unbounded();
-
-            // tell the buffer to start sending stuff to us
-            received_buffer_request_sender
-                .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
-                    reconstructed_sender,
-                ))
-                .expect("the buffer request failed!");
-
-            let this = JsValue::null();
-
-            while let Some(reconstructed) = reconstructed_receiver.next().await {
-                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 msg.reply_surb.is_some() {
-                            console_log!("the received message contained a reply-surb that we do not know how to handle (yet)")
-                        }
-                        let stringified = String::from_utf8_lossy(&msg.message).into_owned();
-                        let arg1 = serde_wasm_bindgen::to_value(&stringified).unwrap();
-                        callback.call1(&this, &arg1).expect("on message failed!");
-                    }
-                }
-            }
-        });
-    }
-
-    pub async fn start(mut self) -> NymClient {
-        console_log!("Starting wasm client '{}'", self.config.id);
-        // channels for inter-component communication
-        // TODO: make the channels be internally created by the relevant components
-        // rather than creating them here, so say for example the buffer controller would create the request channels
-        // and would allow anyone to clone the sender channel
-
-        // unwrapped_sphinx_sender is the transmitter of mixnet messages received from the gateway
-        // unwrapped_sphinx_receiver is the receiver for said messages - used by ReceivedMessagesBuffer
-        let (mixnet_messages_sender, mixnet_messages_receiver) = mpsc::unbounded();
-
-        // used for announcing connection or disconnection of a channel for pushing re-assembled messages to
-        let (received_buffer_request_sender, received_buffer_request_receiver) = mpsc::unbounded();
-
-        // channels responsible for controlling real messages
-        let (input_sender, input_receiver) = tokio::sync::mpsc::channel::<InputMessage>(1);
-
-        // 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 (_client_connection_tx, client_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())
-            .await;
-        self.start_received_messages_buffer_controller(
-            received_buffer_request_receiver,
-            mixnet_messages_receiver,
-        );
-
-        let gateway_client = self
-            .start_gateway_client(mixnet_messages_sender, ack_sender)
-            .await;
-
-        // The sphinx_message_sender is the transmitter for any component generating sphinx packets
-        // that are to be sent to the mixnet. They are used by cover traffic stream and real
-        // traffic stream.
-        // The MixTrafficController then sends the actual traffic
-        let sphinx_message_sender = Self::start_mix_traffic_controller(gateway_client);
-
-        // 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_real_traffic_controller(
-            shared_topology_accessor.clone(),
-            ack_receiver,
-            input_receiver,
-            sphinx_message_sender.clone(),
-            client_connection_rx,
-            shared_lane_queue_lengths,
-        );
-
-        if !self.config.debug.disable_loop_cover_traffic_stream {
-            self.start_cover_traffic_stream(shared_topology_accessor, sphinx_message_sender);
-        }
-
-        self.start_reconstructed_pusher(received_buffer_request_sender);
-        self.input_tx = Some(input_sender);
-
-        self
    }

    // Right now it's impossible to have async exported functions to take `&mut self` rather than mut self
@@ -395,13 +121,65 @@ impl NymClient {

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

-        self.input_tx
+        self.client_input
            .as_ref()
            .expect("start method was not called before!")
+            .input_sender
            .send(input_msg)
            .await
            .expect("InputMessageReceiver has stopped receiving!");

        self
    }
+
+    fn start_reconstructed_pusher(
+        client_output: ClientOutput,
+        on_message: Option<js_sys::Function>,
+        on_binary_message: Option<js_sys::Function>,
+    ) {
+        ResponsePusher::new(client_output, on_message, on_binary_message).start()
+    }
+
+    pub async fn start(mut self) -> NymClient {
+        console_log!("Starting the wasm client");
+
+        let base_builder = BaseClientBuilder::new(
+            &self.config.gateway_endpoint,
+            &self.config.debug,
+            self.key_manager.take().unwrap(),
+            None,
+            true,
+            vec![self.config.validator_api_url.clone()],
+        );
+
+        self.self_address = Some(base_builder.as_mix_recipient().to_string());
+        let mut started_client = match base_builder.start_base().await {
+            Ok(base_client) => base_client,
+            Err(err) => {
+                console_error!("failed to start base client components - {}", err);
+                // proper error handling is left here as an exercise for the reader (hi Mark : ))
+                panic!("failed to start base client components - {err}")
+            }
+        };
+        match self.on_gateway_connect.as_ref() {
+            Some(callback) => {
+                callback
+                    .call0(&JsValue::null())
+                    .expect("on connect callback failed!");
+            }
+            None => console_log!("Gateway connection established - no callback specified"),
+        };
+
+        // those should be moved to a completely different struct, but I don't want to break compatibility for now
+        let client_input = started_client.client_input.register_producer();
+        let client_output = started_client.client_output.register_consumer();
+
+        let on_message = self.on_message.take();
+        let on_binary_message = self.on_binary_message.take();
+        Self::start_reconstructed_pusher(client_output, on_message, on_binary_message);
+        self.client_input = Some(client_input);
+        self._shutdown = Some(started_client.shutdown_notifier);
+
+        self
+    }
 }
@@ -0,0 +1,71 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use client_core::client::base_client::ClientOutput;
+use client_core::client::received_buffer::{ReceivedBufferMessage, ReconstructedMessagesReceiver};
+use futures::channel::mpsc;
+use futures::StreamExt;
+use wasm_bindgen::JsValue;
+use wasm_bindgen_futures::spawn_local;
+use wasm_utils::console_log;
+
+pub(crate) struct ResponsePusher {
+    reconstructed_receiver: ReconstructedMessagesReceiver,
+    on_message: Option<js_sys::Function>,
+    on_binary_message: Option<js_sys::Function>,
+}
+
+impl ResponsePusher {
+    pub(crate) fn new(
+        client_output: ClientOutput,
+        on_message: Option<js_sys::Function>,
+        on_binary_message: Option<js_sys::Function>,
+    ) -> Self {
+        if on_message.is_none() && on_binary_message.is_none() {
+            // exercise for the reader : )
+            panic!("neither 'on_message' nor 'on_binary_message' was set!")
+        }
+
+        // register our output
+        let (reconstructed_sender, reconstructed_receiver) = mpsc::unbounded();
+
+        // tell the buffer to start sending stuff to us
+        client_output
+            .received_buffer_request_sender
+            .unbounded_send(ReceivedBufferMessage::ReceiverAnnounce(
+                reconstructed_sender,
+            ))
+            .expect("the buffer request failed!");
+
+        ResponsePusher {
+            reconstructed_receiver,
+            on_message,
+            on_binary_message,
+        }
+    }
+
+    pub(crate) fn start(mut self) {
+        spawn_local(async move {
+            let this = JsValue::null();
+
+            while let Some(reconstructed) = self.reconstructed_receiver.next().await {
+                for msg in reconstructed {
+                    if let Some(ref callback_binary) = self.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) = self.on_message {
+                        if msg.reply_surb.is_some() {
+                            console_log!("the received message contained a reply-surb that we do not know how to handle (yet)")
+                        }
+                        let stringified = String::from_utf8_lossy(&msg.message).into_owned();
+                        let arg1 = serde_wasm_bindgen::to_value(&stringified).unwrap();
+                        callback.call1(&this, &arg1).expect("on message failed!");
+                    }
+                }
+            }
+        })
+    }
+}
@@ -1,15 +1,15 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use client_core::config::GatewayEndpoint;
+use client_core::config::GatewayEndpointConfig;
 use wasm_bindgen::prelude::*;

 #[wasm_bindgen]
-pub async fn get_gateway(api_server: String, preferred: Option<String>) -> GatewayEndpoint {
+pub async fn get_gateway(api_server: String, preferred: Option<String>) -> GatewayEndpointConfig {
    let validator_client = validator_client::client::ApiClient::new(api_server.parse().unwrap());

    let gateways = match validator_client.get_cached_gateways().await {
-        Err(err) => panic!("failed to obtain list of all gateways - {}", err),
+        Err(err) => panic!("failed to obtain list of all gateways - {err}"),
        Ok(gateways) => gateways,
    };

@@ -18,7 +18,7 @@ pub async fn get_gateway(api_server: String, preferred: Option<String>) -> Gatew
            .iter()
            .find(|g| g.gateway.identity_key == preferred)
        {
-            return GatewayEndpoint {
+            return GatewayEndpointConfig {
                gateway_id: details.gateway.identity_key.clone(),
                gateway_owner: details.owner.to_string(),
                gateway_listener: format!(
@@ -33,7 +33,7 @@ pub async fn get_gateway(api_server: String, preferred: Option<String>) -> Gatew
        .first()
        .expect("current topology holds no gateways");

-    GatewayEndpoint {
+    GatewayEndpointConfig {
        gateway_id: details.gateway.identity_key.clone(),
        gateway_owner: details.owner.to_string(),
        gateway_listener: format!(
@@ -26,6 +26,7 @@ network-defaults = { path = "../../network-defaults" }
 nymsphinx = { path = "../../nymsphinx" }
 pemstore = { path = "../../pemstore" }
 validator-client = { path = "../validator-client", optional = true }
+task = { path = "../../task" }


 [dependencies.tungstenite]
@@ -47,9 +48,6 @@ version = "0.14"
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.credential-storage]
 path = "../../credential-storage"

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.task]
-path = "../../task"
-
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
 version = "0.2"
@@ -26,8 +26,15 @@ use {
    },
 };

+// TODO: make it nicer for wasm (I don't want to touch it for this experiment)
+#[cfg(target_arch = "wasm32")]
+use crate::wasm_storage::PersistentStorage;
+
+#[cfg(not(target_arch = "wasm32"))]
+use credential_storage::PersistentStorage;
+
 #[derive(Clone)]
-pub struct BandwidthController<St: Storage> {
+pub struct BandwidthController<St: Storage = PersistentStorage> {
    #[allow(dead_code)]
    storage: St,
    #[cfg(feature = "coconut")]
@@ -54,7 +61,7 @@ where
    #[cfg(feature = "coconut")]
    pub async fn prepare_coconut_credential(
        &self,
-    ) -> Result<coconut_interface::Credential, GatewayClientError> {
+    ) -> Result<(coconut_interface::Credential, i64), GatewayClientError> {
        let verification_key = obtain_aggregate_verification_key(&self.coconut_api_clients).await?;
        let bandwidth_credential = self.storage.get_next_coconut_credential().await?;
        let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
@@ -68,13 +75,21 @@ where
            coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;

        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
-        Ok(prepare_for_spending(
-            voucher_value,
-            voucher_info,
-            serial_number,
-            binding_number,
-            &signature,
-            &verification_key,
-        )?)
+        Ok((
+            prepare_for_spending(
+                voucher_value,
+                voucher_info,
+                serial_number,
+                binding_number,
+                &signature,
+                &verification_key,
+            )?,
+            bandwidth_credential.id,
+        ))
+    }
+
+    #[cfg(feature = "coconut")]
+    pub async fn consume_credential(&self, id: i64) -> Result<(), GatewayClientError> {
+        Ok(self.storage.consume_coconut_credential(id).await?)
    }
 }
@@ -10,7 +10,7 @@ pub use crate::packet_router::{
 use crate::socket_state::{PartiallyDelegated, SocketState};
 use crate::{cleanup_socket_message, try_decrypt_binary_message};
 use crypto::asymmetric::identity;
-use futures::{FutureExt, SinkExt, StreamExt};
+use futures::{SinkExt, StreamExt};
 use gateway_requests::authentication::encrypted_address::EncryptedAddressBytes;
 use gateway_requests::iv::IV;
 use gateway_requests::registration::handshake::{client_handshake, SharedKeys};
@@ -22,6 +22,7 @@ use rand::rngs::OsRng;
 use std::convert::TryFrom;
 use std::sync::Arc;
 use std::time::Duration;
+use task::ShutdownListener;
 use tungstenite::protocol::Message;

 #[cfg(feature = "coconut")]
@@ -30,8 +31,6 @@ use coconut_interface::Credential;
 #[cfg(not(target_arch = "wasm32"))]
 use credential_storage::PersistentStorage;
 #[cfg(not(target_arch = "wasm32"))]
-use task::ShutdownListener;
-#[cfg(not(target_arch = "wasm32"))]
 use tokio_tungstenite::connect_async;

 #[cfg(target_arch = "wasm32")]
@@ -67,9 +66,8 @@ pub struct GatewayClient {
    /// Delay between each subsequent reconnection attempt.
    reconnection_backoff: Duration,

-    #[cfg(not(target_arch = "wasm32"))]
    /// Listen to shutdown messages.
-    shutdown: Option<ShutdownListener>,
+    shutdown: ShutdownListener,
 }

 impl GatewayClient {
@@ -85,7 +83,7 @@ impl GatewayClient {
        ack_sender: AcknowledgementSender,
        response_timeout_duration: Duration,
        bandwidth_controller: Option<BandwidthController<PersistentStorage>>,
-        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
+        shutdown: ShutdownListener,
    ) -> Self {
        GatewayClient {
            authenticated: false,
@@ -97,18 +95,12 @@ impl GatewayClient {
            local_identity,
            shared_key,
            connection: SocketState::NotConnected,
-            packet_router: PacketRouter::new(
-                ack_sender,
-                mixnet_message_sender,
-                #[cfg(not(target_arch = "wasm32"))]
-                shutdown.clone(),
-            ),
+            packet_router: PacketRouter::new(ack_sender, mixnet_message_sender, shutdown.clone()),
            response_timeout_duration,
            bandwidth_controller,
            should_reconnect_on_failure: true,
            reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
            reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
-            #[cfg(not(target_arch = "wasm32"))]
            shutdown,
        }
    }
@@ -136,7 +128,6 @@ impl GatewayClient {
        gateway_owner: String,
        local_identity: Arc<identity::KeyPair>,
        response_timeout_duration: Duration,
-        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
    ) -> Self {
        use futures::channel::mpsc;

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

        GatewayClient {
            authenticated: false,
@@ -167,7 +154,6 @@ impl GatewayClient {
            should_reconnect_on_failure: false,
            reconnection_attempts: DEFAULT_RECONNECTION_ATTEMPTS,
            reconnection_backoff: DEFAULT_RECONNECTION_BACKOFF,
-            #[cfg(not(target_arch = "wasm32"))]
            shutdown,
        }
    }
@@ -295,44 +281,19 @@ impl GatewayClient {
        // technically the `wasm_timer` also works outside wasm, but unless required,
        // I really prefer to just stick to tokio
        #[cfg(target_arch = "wasm32")]
-        let timeout = wasm_timer::Delay::new(self.response_timeout_duration);
-
-        let mut fused_timeout = timeout.fuse();
-        let mut fused_stream = conn.fuse();
-
-        // Bit of an ugly workaround for selecting on an `Option` without having access to
-        // `tokio::select`
-        #[cfg(not(target_arch = "wasm32"))]
-        let shutdown = {
-            let m_shutdown = self.shutdown.clone();
-            async {
-                if let Some(mut s) = m_shutdown {
-                    // TODO: fix this by marking as success _after_ the select
-                    s.mark_as_success();
-                    s.recv().await
-                } else {
-                    std::future::pending::<()>().await
-                }
-            }
-            .fuse()
-        };
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::pin!(shutdown);
-
-        #[cfg(target_arch = "wasm32")]
-        let mut shutdown = std::future::pending::<()>().fuse();
+        let mut timeout = wasm_timer::Delay::new(self.response_timeout_duration);

        loop {
-            futures::select! {
-                _ = shutdown => {
+            tokio::select! {
+                _ = self.shutdown.recv() => {
                    log::trace!("GatewayClient control response: Received shutdown");
                    log::debug!("GatewayClient control response: Exiting");
                    break Err(GatewayClientError::ConnectionClosedGatewayShutdown);
                }
-                _ = &mut fused_timeout => {
+                _ = &mut timeout => {
                    break Err(GatewayClientError::Timeout);
                }
-                msg = fused_stream.next() => {
+                msg = conn.next() => {
                    let ws_msg = match cleanup_socket_message(msg) {
                        Err(err) => break Err(err),
                        Ok(msg) => msg
@@ -403,13 +364,10 @@ impl GatewayClient {
                    .batch_send_without_response(messages)
                    .await
                {
-                    error!("failed to batch send messages - {}...", err);
+                    error!("failed to batch send messages - {err}...");
                    // we must ensure we do not leave the task still active
                    if let Err(err) = self.recover_socket_connection().await {
-                        error!(
-                            "... and the delegated stream has also errored out - {}",
-                            err
-                        )
+                        error!("... and the delegated stream has also errored out - {err}")
                    }
                    Err(err)
                } else {
@@ -429,13 +387,10 @@ impl GatewayClient {
            SocketState::Available(ref mut conn) => Ok(conn.send(msg).await?),
            SocketState::PartiallyDelegated(ref mut partially_delegated) => {
                if let Err(err) = partially_delegated.send_without_response(msg).await {
-                    error!("failed to send message without response - {}...", err);
+                    error!("failed to send message without response - {err}...");
                    // we must ensure we do not leave the task still active
                    if let Err(err) = self.recover_socket_connection().await {
-                        error!(
-                            "... and the delegated stream has also errored out - {}",
-                            err
-                        )
+                        error!("... and the delegated stream has also errored out - {err}")
                    }
                    Err(err)
                } else {
@@ -632,7 +587,7 @@ impl GatewayClient {
        let _gateway_owner = self.gateway_owner.clone();

        #[cfg(feature = "coconut")]
-        let credential = self
+        let (credential, credential_id) = self
            .bandwidth_controller
            .as_ref()
            .unwrap()
@@ -642,7 +597,15 @@ impl GatewayClient {
        return self.try_claim_testnet_bandwidth().await;

        #[cfg(feature = "coconut")]
-        return self.claim_coconut_bandwidth(credential).await;
+        {
+            self.claim_coconut_bandwidth(credential).await?;
+            self.bandwidth_controller
+                .as_ref()
+                .unwrap()
+                .consume_credential(credential_id)
+                .await?;
+            Ok(())
+        }
    }

    fn estimate_required_bandwidth(&self, packets: &[MixPacket]) -> i64 {
@@ -788,7 +751,6 @@ impl GatewayClient {
                                .as_ref()
                                .expect("no shared key present even though we're authenticated!"),
                        ),
-                        #[cfg(not(target_arch = "wasm32"))]
                        self.shutdown.clone(),
                    )
                }
@@ -4,15 +4,13 @@
 // JS: I personally don't like this name very much, but could not think of anything better.
 // I will gladly take any suggestions on how to rename this.

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

-use crate::error::GatewayClientError;
-
 pub type MixnetMessageSender = mpsc::UnboundedSender<Vec<Vec<u8>>>;
 pub type MixnetMessageReceiver = mpsc::UnboundedReceiver<Vec<Vec<u8>>>;

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

 impl PacketRouter {
    pub fn new(
        ack_sender: AcknowledgementSender,
        mixnet_message_sender: MixnetMessageSender,
-        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
+        shutdown: ShutdownListener,
    ) -> Self {
        PacketRouter {
            ack_sender,
            mixnet_message_sender,
-            #[cfg(not(target_arch = "wasm32"))]
            shutdown,
        }
    }
@@ -86,13 +82,10 @@ impl PacketRouter {
        if !received_messages.is_empty() {
            trace!("routing 'real'");
            if let Err(err) = self.mixnet_message_sender.unbounded_send(received_messages) {
-                #[cfg(not(target_arch = "wasm32"))]
-                if let Some(shutdown) = &mut self.shutdown {
-                    if shutdown.is_shutdown_poll() {
-                        // This should ideally not happen, but it's ok
-                        log::warn!("Failed to send mixnet message due to receiver task shutdown");
-                        return Err(GatewayClientError::MixnetMsgSenderFailedToSend);
-                    }
+                if self.shutdown.is_shutdown_poll() || self.shutdown.is_dummy() {
+                    // This should ideally not happen, but it's ok
+                    log::warn!("Failed to send mixnet message due to receiver task shutdown");
+                    return Err(GatewayClientError::MixnetMsgSenderFailedToSend);
                }
                // This should never happen during ordinary operation the way it's currently used.
                // Abort to be on the safe side
@@ -10,7 +10,6 @@ use futures::{SinkExt, StreamExt};
 use gateway_requests::registration::handshake::SharedKeys;
 use log::*;
 use std::sync::Arc;
-#[cfg(not(target_arch = "wasm32"))]
 use task::ShutdownListener;
 use tungstenite::Message;

@@ -85,7 +84,7 @@ impl PartiallyDelegated {
        conn: WsConn,
        packet_router: PacketRouter,
        shared_key: Arc<SharedKeys>,
-        #[cfg(not(target_arch = "wasm32"))] shutdown: Option<ShutdownListener>,
+        mut shutdown: ShutdownListener,
    ) -> Self {
        // when called for, it NEEDS TO yield back the stream so that we could merge it and
        // read control request responses.
@@ -99,27 +98,9 @@ impl PartiallyDelegated {
            let mut chunk_stream = (&mut stream).ready_chunks(8);
            let mut packet_router = packet_router;

-            // Bit of an ugly workaround for selecting on an `Option` without having access to
-            // `tokio::select`
-            #[cfg(not(target_arch = "wasm32"))]
-            let shutdown = {
-                async {
-                    if let Some(mut s) = shutdown {
-                        s.recv().await
-                    } else {
-                        std::future::pending::<()>().await
-                    }
-                }
-            };
-            #[cfg(not(target_arch = "wasm32"))]
-            tokio::pin!(shutdown);
-
-            #[cfg(target_arch = "wasm32")]
-            let mut shutdown = std::future::pending::<()>();
-
            let ret_err = loop {
                tokio::select! {
-                    _ = &mut shutdown => {
+                    _ = shutdown.recv() => {
                        log::trace!("GatewayClient listener: Received shutdown");
                        log::debug!("GatewayClient listener: Exiting");
                        return;
@@ -142,7 +123,10 @@ impl PartiallyDelegated {

            if match ret_err {
                Err(err) => stream_sender.send(Err(err)),
-                Ok(_) => stream_sender.send(Ok(stream)),
+                Ok(_) => {
+                    shutdown.mark_as_success();
+                    stream_sender.send(Ok(stream))
+                }
            }
            .is_err()
            {
@@ -39,7 +39,7 @@ pub trait Storage: Send + Sync {

    async fn get_next_coconut_credential(&self) -> Result<CoconutCredential, StorageError>;

-    async fn remove_coconut_credential(&self, id: i64) -> Result<(), StorageError>;
+    async fn consume_coconut_credential(&self, id: i64) -> Result<(), StorageError>;
 }

 #[async_trait]
@@ -59,7 +59,7 @@ impl Storage for PersistentStorage {
        Err(StorageError::WasmNotSupported)
    }

-    async fn remove_coconut_credential(&self, _id: i64) -> Result<(), StorageError> {
+    async fn consume_coconut_credential(&self, _id: i64) -> Result<(), StorageError> {
        Err(StorageError::WasmNotSupported)
    }
 }
@@ -1,6 +1,5 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
-
 use crate::{validator_api, ValidatorClientError};
 use coconut_dkg_common::types::NodeIndex;
 #[cfg(feature = "nymd-client")]
@@ -10,9 +9,10 @@ use coconut_dkg_common::{
 #[cfg(feature = "nymd-client")]
 use coconut_interface::Base58;
 use coconut_interface::VerificationKey;
+use mixnet_contract_common::families::{Family, FamilyHead};
 use mixnet_contract_common::mixnode::MixNodeDetails;
-use mixnet_contract_common::MixId;
 use mixnet_contract_common::{GatewayBond, IdentityKeyRef};
+use mixnet_contract_common::{IdentityKey, MixId};
 #[cfg(feature = "nymd-client")]
 use std::str::FromStr;
 use validator_api_requests::coconut::{
@@ -220,6 +220,7 @@ impl Client<QueryNymdClient> {
 impl<C> Client<C> {
    // use case: somebody initialised client without a contract in order to upload and initialise one
    // and now they want to actually use it without making new client
+
    pub fn set_mixnet_contract_address(&mut self, mixnet_contract_address: cosmrs::AccountId) {
        self.nymd
            .set_mixnet_contract_address(mixnet_contract_address)
@@ -229,6 +230,56 @@ impl<C> Client<C> {
        self.nymd.mixnet_contract_address().clone()
    }

+    pub async fn get_all_node_families(&self) -> Result<Vec<Family>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut families = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let paged_response = self
+                .nymd
+                .get_all_node_families_paged(start_after.take(), None)
+                .await?;
+            families.extend(paged_response.families);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(families)
+    }
+
+    pub async fn get_all_family_members(
+        &self,
+    ) -> Result<Vec<(IdentityKey, FamilyHead)>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync + Send,
+    {
+        let mut members = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let paged_response = self
+                .nymd
+                .get_all_family_members_paged(start_after.take(), None)
+                .await?;
+            members.extend(paged_response.members);
+
+            if let Some(start_after_res) = paged_response.start_next_after {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(members)
+    }
+
    // basically handles paging for us
    pub async fn get_all_nymd_rewarded_set_mixnodes(
        &self,
@@ -15,12 +15,12 @@ pub use coconut_dkg_common::event_attributes::*;
 pub struct Log {
    #[serde(default)]
    // weird thing is that the first msg_index seems to always be undefined on the raw logs
-    msg_index: usize,
+    pub msg_index: usize,
    // unless I'm missing something obvious, the "log" type in cosmjs is always an empty string
    // and launchpad cosmos validator was setting it to what essentially is just the raw version of what
    // we received (and we don't care about launchpad, we, as the time of writing this, work on the stargate)
    // log: String,
-    events: Vec<cosmwasm_std::Event>,
+    pub events: Vec<cosmwasm_std::Event>,
 }

 /// Searches in logs for the first event of the given event type and in that event
@@ -7,6 +7,7 @@ use crate::nymd::NymdClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
 use mixnet_contract_common::delegation::{MixNodeDelegationResponse, OwnerProxySubKey};
+use mixnet_contract_common::families::Family;
 use mixnet_contract_common::mixnode::{
    MixNodeDetails, MixnodeRewardingDetailsResponse, PagedMixnodesDetailsResponse,
    PagedUnbondedMixnodesResponse, StakeSaturationResponse, UnbondedMixnodeResponse,
@@ -20,9 +21,9 @@ use mixnet_contract_common::{
    CurrentIntervalResponse, EpochEventId, GatewayBondResponse, GatewayOwnershipResponse,
    IdentityKey, IntervalEventId, LayerDistribution, MixId, MixOwnershipResponse,
    MixnodeDetailsResponse, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
-    PagedGatewayResponse, PagedMixNodeDelegationsResponse, PagedMixnodeBondsResponse,
-    PagedRewardedSetResponse, PendingEpochEventsResponse, PendingIntervalEventsResponse,
-    QueryMsg as MixnetQueryMsg,
+    PagedFamiliesResponse, PagedGatewayResponse, PagedMembersResponse,
+    PagedMixNodeDelegationsResponse, PagedMixnodeBondsResponse, PagedRewardedSetResponse,
+    PendingEpochEventsResponse, PendingIntervalEventsResponse, QueryMsg as MixnetQueryMsg,
 };
 use serde::Deserialize;

@@ -73,6 +74,24 @@ pub trait MixnetQueryClient {
            .await
    }

+    async fn get_all_node_families_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedFamiliesResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetAllFamiliesPaged { limit, start_after })
+            .await
+    }
+
+    async fn get_all_family_members_paged(
+        &self,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedMembersResponse, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetAllMembersPaged { limit, start_after })
+            .await
+    }
+
    // mixnode-related:

    async fn get_mixnode_bonds_paged(
@@ -357,6 +376,20 @@ pub trait MixnetQueryClient {
        })
        .await
    }
+
+    async fn get_node_family_by_label(&self, label: &str) -> Result<Option<Family>, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyByLabel {
+            label: label.to_string(),
+        })
+        .await
+    }
+
+    async fn get_node_family_by_head(&self, head: &str) -> Result<Option<Family>, NymdError> {
+        self.query_mixnet_contract(MixnetQueryMsg::GetFamilyByHead {
+            head: head.to_string(),
+        })
+        .await
+    }
 }

 #[async_trait]
@@ -11,7 +11,7 @@ use cosmrs::AccountId;
 use mixnet_contract_common::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
 use mixnet_contract_common::reward_params::{IntervalRewardingParamsUpdate, Performance};
 use mixnet_contract_common::{
-    ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, MixId, MixNode,
+    ContractStateParams, ExecuteMsg as MixnetExecuteMsg, Gateway, LayerAssignment, MixId, MixNode,
 };

 #[async_trait]
@@ -108,7 +108,7 @@ pub trait MixnetSigningClient {

    async fn advance_current_epoch(
        &self,
-        new_rewarded_set: Vec<MixId>,
+        new_rewarded_set: Vec<LayerAssignment>,
        expected_active_set_size: u32,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError> {
@@ -136,6 +136,147 @@ pub trait MixnetSigningClient {
        .await
    }

+    // family related
+    async fn create_family(
+        &self,
+        owner_signature: String,
+        label: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::CreateFamily {
+                owner_signature,
+                label,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn create_family_on_behalf(
+        &self,
+        owner_address: String,
+        owner_signature: String,
+        label: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::CreateFamilyOnBehalf {
+                owner_address,
+                owner_signature,
+                label,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn join_family(
+        &self,
+        signature: String,
+        family_head: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::JoinFamily {
+                signature,
+                family_head,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn join_family_on_behalf(
+        &self,
+        member_address: String,
+        signature: String,
+        family_head: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::JoinFamilyOnBehalf {
+                member_address,
+                signature,
+                family_head,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn leave_family(
+        &self,
+        signature: String,
+        family_head: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::LeaveFamily {
+                signature,
+                family_head,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn leave_family_on_behalf(
+        &self,
+        member_address: String,
+        signature: String,
+        family_head: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::LeaveFamilyOnBehalf {
+                member_address,
+                signature,
+                family_head,
+            },
+            vec![],
+        )
+        .await
+    }
+
+    async fn kick_family_member(
+        &self,
+        signature: String,
+        member: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::KickFamilyMember { signature, member },
+            vec![],
+        )
+        .await
+    }
+
+    async fn kick_family_member_on_behalf(
+        &self,
+        head_address: String,
+        signature: String,
+        member: String,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::KickFamilyMemberOnBehalf {
+                head_address,
+                signature,
+                member,
+            },
+            vec![],
+        )
+        .await
+    }
    // mixnode-related:

    async fn bond_mixnode(
@@ -180,6 +321,35 @@ pub trait MixnetSigningClient {
        .await
    }

+    async fn pledge_more(
+        &self,
+        additional_pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::PledgeMore {},
+            vec![additional_pledge],
+        )
+        .await
+    }
+
+    async fn pledge_more_on_behalf(
+        &self,
+        owner: AccountId,
+        additional_pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_mixnet_contract(
+            fee,
+            MixnetExecuteMsg::PledgeMoreOnBehalf {
+                owner: owner.to_string(),
+            },
+            vec![additional_pledge],
+        )
+        .await
+    }
+
    async fn unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError> {
        self.execute_mixnet_contract(fee, MixnetExecuteMsg::UnbondMixnode {}, vec![])
            .await
@@ -64,6 +64,21 @@ pub trait VestingSigningClient {
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NymdError>;

+    async fn vesting_pledge_more(
+        &self,
+        additional_pledge: Coin,
+        fee: Option<Fee>,
+    ) -> Result<ExecuteResult, NymdError> {
+        self.execute_vesting_contract(
+            fee,
+            VestingExecuteMsg::PledgeMore {
+                amount: additional_pledge.into(),
+            },
+            vec![],
+        )
+        .await
+    }
+
    async fn vesting_unbond_mixnode(&self, fee: Option<Fee>) -> Result<ExecuteResult, NymdError>;

    async fn vesting_track_unbond_mixnode(
@@ -136,7 +136,12 @@ impl Client {
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorAPIError> {
        self.query_validator_api(
-            &[routes::API_VERSION, routes::MIXNODES, routes::DETAILED],
+            &[
+                routes::API_VERSION,
+                routes::STATUS,
+                routes::MIXNODES,
+                routes::DETAILED,
+            ],
            NO_PARAMS,
        )
        .await
@@ -161,6 +166,7 @@ impl Client {
        self.query_validator_api(
            &[
                routes::API_VERSION,
+                routes::STATUS,
                routes::MIXNODES,
                routes::ACTIVE,
                routes::DETAILED,
@@ -252,6 +258,7 @@ impl Client {
        self.query_validator_api(
            &[
                routes::API_VERSION,
+                routes::STATUS,
                routes::MIXNODES,
                routes::REWARDED,
                routes::DETAILED,
@@ -11,6 +11,10 @@ use std::{fs, io};

 pub mod defaults;

+pub const CONFIG_DIR: &str = "config";
+pub const DATA_DIR: &str = "data";
+pub const DB_FILE_NAME: &str = "db.sqlite";
+
 pub trait NymConfig: Default + Serialize + DeserializeOwned {
    fn template() -> &'static str;

@@ -23,17 +27,17 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {
    // default, most probable, implementations; can be easily overridden where required
    fn default_config_directory(id: Option<&str>) -> PathBuf {
        if let Some(id) = id {
-            Self::default_root_directory().join(id).join("config")
+            Self::default_root_directory().join(id).join(CONFIG_DIR)
        } else {
-            Self::default_root_directory().join("config")
+            Self::default_root_directory().join(CONFIG_DIR)
        }
    }

    fn default_data_directory(id: Option<&str>) -> PathBuf {
        if let Some(id) = id {
-            Self::default_root_directory().join(id).join("data")
+            Self::default_root_directory().join(id).join(DATA_DIR)
        } else {
-            Self::default_root_directory().join("data")
+            Self::default_root_directory().join(DATA_DIR)
        }
    }

@@ -47,17 +51,17 @@ pub trait NymConfig: Default + Serialize + DeserializeOwned {

    fn try_default_config_directory(id: Option<&str>) -> Option<PathBuf> {
        if let Some(id) = id {
-            Self::try_default_root_directory().map(|d| d.join(id).join("config"))
+            Self::try_default_root_directory().map(|d| d.join(id).join(CONFIG_DIR))
        } else {
-            Self::try_default_root_directory().map(|d| d.join("config"))
+            Self::try_default_root_directory().map(|d| d.join(CONFIG_DIR))
        }
    }

    fn try_default_data_directory(id: Option<&str>) -> Option<PathBuf> {
        if let Some(id) = id {
-            Self::try_default_root_directory().map(|d| d.join(id).join("data"))
+            Self::try_default_root_directory().map(|d| d.join(id).join(DATA_DIR))
        } else {
-            Self::try_default_root_directory().map(|d| d.join("data"))
+            Self::try_default_root_directory().map(|d| d.join(DATA_DIR))
        }
    }

@@ -15,7 +15,7 @@ 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>);
+pub struct ContractSafeBytes(pub Vec<u8>);

 impl Deref for ContractSafeBytes {
    type Target = Vec<u8>;
@@ -1,7 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::MixId;
+use crate::{IdentityKey, MixId};
 use cosmwasm_std::{Addr, Coin, Decimal};
 use thiserror::Error;

@@ -133,4 +133,40 @@ pub enum MixnetContractError {

    #[error("Mixnode {mix_id} appears multiple times in the provided rewarded set update!")]
    DuplicateRewardedSetNode { mix_id: MixId },
+
+    #[error("Family with head {head} does not exist!")]
+    FamilyDoesNotExist { head: String },
+
+    #[error("Family with label '{0}' already exists")]
+    FamilyWithLabelExists(String),
+
+    #[error("Invalid layer expected 1, 2 or 3, got {0}")]
+    InvalidLayer(u8),
+
+    #[error("Head already has a family")]
+    FamilyCanHaveOnlyOne,
+
+    #[error("Already member of family {0}")]
+    AlreadyMemberOfFamily(String),
+
+    #[error("Can't join own family, family head {head}, member {member}")]
+    CantJoinOwnFamily {
+        head: IdentityKey,
+        member: IdentityKey,
+    },
+
+    #[error("Can't leave own family, family head {head}, member {member}")]
+    CantLeaveOwnFamily {
+        head: IdentityKey,
+        member: IdentityKey,
+    },
+
+    #[error("{member} is not a member of family {head}")]
+    NotAMember {
+        head: IdentityKey,
+        member: IdentityKey,
+    },
+
+    #[error("Feature is not yet implemented")]
+    NotImplemented,
 }
@@ -12,6 +12,8 @@ pub const EVENT_VERSION_PREFIX: &str = "v2_";

 pub enum MixnetEventType {
    MixnodeBonding,
+    PendingPledgeIncrease,
+    PledgeIncrease,
    GatewayBonding,
    GatewayUnbonding,
    PendingMixnodeUnbonding,
@@ -51,6 +53,8 @@ impl ToString for MixnetEventType {
    fn to_string(&self) -> String {
        let event_name = match self {
            MixnetEventType::MixnodeBonding => "mixnode_bonding",
+            MixnetEventType::PendingPledgeIncrease => "pending_pledge_increase",
+            MixnetEventType::PledgeIncrease => "pledge_increase",
            MixnetEventType::GatewayBonding => "gateway_bonding",
            MixnetEventType::GatewayUnbonding => "gateway_unbonding",
            MixnetEventType::PendingMixnodeUnbonding => "pending_mixnode_unbonding",
@@ -330,6 +334,19 @@ pub fn new_mixnode_bonding_event(
        .add_attribute(AMOUNT_KEY, amount.to_string())
 }

+pub fn new_pending_pledge_increase_event(mix_id: MixId, amount: &Coin) -> Event {
+    Event::new(MixnetEventType::PendingPledgeIncrease)
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .add_attribute(AMOUNT_KEY, amount.to_string())
+}
+
+pub fn new_pledge_increase_event(created_at: BlockHeight, mix_id: MixId, amount: &Coin) -> Event {
+    Event::new(MixnetEventType::PledgeIncrease)
+        .add_attribute(EVENT_CREATION_HEIGHT_KEY, created_at.to_string())
+        .add_attribute(MIX_ID_KEY, mix_id.to_string())
+        .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())
@@ -0,0 +1,63 @@
+use crate::{IdentityKey, IdentityKeyRef};
+use cosmwasm_std::Addr;
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
+#[cfg_attr(
+    feature = "generate-ts",
+    ts(export_to = "ts-packages/types/src/types/rust/NodeFamily.ts")
+)]
+#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq, JsonSchema)]
+pub struct Family {
+    head: FamilyHead,
+    proxy: Option<String>,
+    label: String,
+}
+
+#[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
+#[cfg_attr(
+    feature = "generate-ts",
+    ts(export_to = "ts-packages/types/src/types/rust/NodeFamilyHead.ts")
+)]
+#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq, JsonSchema)]
+pub struct FamilyHead(IdentityKey);
+
+impl FamilyHead {
+    pub fn new(identity: IdentityKeyRef<'_>) -> Self {
+        FamilyHead(identity.to_string())
+    }
+
+    pub fn identity(&self) -> IdentityKeyRef<'_> {
+        &self.0
+    }
+}
+
+impl Family {
+    pub fn new(head: FamilyHead, proxy: Option<Addr>, label: &str) -> Self {
+        Family {
+            head,
+            proxy: proxy.map(|p| p.to_string()),
+            label: label.to_string(),
+        }
+    }
+
+    #[allow(dead_code)]
+    pub fn head(&self) -> &FamilyHead {
+        &self.head
+    }
+
+    pub fn head_identity(&self) -> IdentityKeyRef<'_> {
+        self.head.identity()
+    }
+
+    #[allow(dead_code)]
+    pub fn proxy(&self) -> Option<&String> {
+        self.proxy.as_ref()
+    }
+
+    #[allow(dead_code)]
+    pub fn label(&self) -> &str {
+        &self.label
+    }
+}
@@ -8,6 +8,7 @@ mod constants;
 pub mod delegation;
 pub mod error;
 pub mod events;
+pub mod families;
 pub mod gateway;
 pub mod helpers;
 mod interval;
@@ -36,7 +36,6 @@ impl RewardedSetNodeStatus {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct MixNodeDetails {
    pub bond_information: MixNodeBond,
-
    pub rewarding_details: MixNodeRewarding,
 }

@@ -325,6 +324,14 @@ impl MixNodeRewarding {
        Ok(())
    }

+    pub fn increase_operator_uint128(
+        &mut self,
+        amount: Uint128,
+    ) -> Result<(), MixnetContractError> {
+        self.operator += amount.into_base_decimal()?;
+        Ok(())
+    }
+
    pub fn increase_delegates_uint128(
        &mut self,
        amount: Uint128,
@@ -571,6 +578,29 @@ impl From<Layer> for String {
    }
 }

+impl TryFrom<u8> for Layer {
+    type Error = MixnetContractError;
+
+    fn try_from(i: u8) -> Result<Layer, MixnetContractError> {
+        match i {
+            1 => Ok(Layer::One),
+            2 => Ok(Layer::Two),
+            3 => Ok(Layer::Three),
+            _ => Err(MixnetContractError::InvalidLayer(i)),
+        }
+    }
+}
+
+impl From<Layer> for u8 {
+    fn from(layer: Layer) -> u8 {
+        match layer {
+            Layer::One => 1,
+            Layer::Two => 2,
+            Layer::Three => 3,
+        }
+    }
+}
+
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
@@ -8,7 +8,7 @@ use crate::mixnode::{MixNodeConfigUpdate, MixNodeCostParams};
 use crate::reward_params::{
    IntervalRewardParams, IntervalRewardingParamsUpdate, Performance, RewardingParams,
 };
-use crate::{delegation, ContractStateParams, MixId, Percent};
+use crate::{delegation, ContractStateParams, Layer, LayerAssignment, MixId, Percent};
 use crate::{Gateway, IdentityKey, MixNode};
 use cosmwasm_std::Decimal;
 use schemars::JsonSchema;
@@ -73,6 +73,51 @@ impl InitialRewardingParams {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
+    AssignNodeLayer {
+        mix_id: MixId,
+        layer: Layer,
+    },
+    // Families
+    /// Only owner of the node can crate the family with node as head
+    CreateFamily {
+        owner_signature: String,
+        label: String,
+    },
+    /// Family head needs to sign the joining node IdentityKey
+    JoinFamily {
+        signature: String,
+        family_head: IdentityKey,
+    },
+    LeaveFamily {
+        signature: String,
+        family_head: IdentityKey,
+    },
+    KickFamilyMember {
+        signature: String,
+        member: IdentityKey,
+    },
+    CreateFamilyOnBehalf {
+        owner_address: String,
+        owner_signature: String,
+        label: String,
+    },
+    /// Family head needs to sign the joining node IdentityKey
+    JoinFamilyOnBehalf {
+        member_address: String,
+        signature: String,
+        family_head: IdentityKey,
+    },
+    LeaveFamilyOnBehalf {
+        member_address: String,
+        signature: String,
+        family_head: IdentityKey,
+    },
+    KickFamilyMemberOnBehalf {
+        head_address: String,
+        signature: String,
+        member: IdentityKey,
+    },
+
    // state/sys-params-related
    UpdateRewardingValidatorAddress {
        address: String,
@@ -94,7 +139,8 @@ pub enum ExecuteMsg {
        force_immediately: bool,
    },
    AdvanceCurrentEpoch {
-        new_rewarded_set: Vec<MixId>,
+        new_rewarded_set: Vec<LayerAssignment>,
+        // families_in_layer: HashMap<String, Layer>,
        expected_active_set_size: u32,
    },
    ReconcileEpochEvents {
@@ -113,6 +159,10 @@ pub enum ExecuteMsg {
        owner_signature: String,
        owner: String,
    },
+    PledgeMore {},
+    PledgeMoreOnBehalf {
+        owner: String,
+    },
    UnbondMixnode {},
    UnbondMixnodeOnBehalf {
        owner: String,
@@ -190,6 +240,29 @@ pub enum ExecuteMsg {
 impl ExecuteMsg {
    pub fn default_memo(&self) -> String {
        match self {
+            ExecuteMsg::AssignNodeLayer { mix_id, layer } => {
+                format!("assigning mix {} for layer {:?}", mix_id, layer)
+            }
+            ExecuteMsg::CreateFamily { .. } => "crating node family with".to_string(),
+            ExecuteMsg::JoinFamily { family_head, .. } => {
+                format!("joining family {}", family_head)
+            }
+            ExecuteMsg::LeaveFamily { family_head, .. } => {
+                format!("leaving family {}", family_head)
+            }
+            ExecuteMsg::KickFamilyMember { member, .. } => {
+                format!("kicking {} from family", member)
+            }
+            ExecuteMsg::CreateFamilyOnBehalf { .. } => "crating node family with".to_string(),
+            ExecuteMsg::JoinFamilyOnBehalf { family_head, .. } => {
+                format!("joining family {}", family_head)
+            }
+            ExecuteMsg::LeaveFamilyOnBehalf { family_head, .. } => {
+                format!("leaving family {}", family_head)
+            }
+            ExecuteMsg::KickFamilyMemberOnBehalf { member, .. } => {
+                format!("kicking {} from family", member)
+            }
            ExecuteMsg::UpdateRewardingValidatorAddress { address } => {
                format!("updating rewarding validator to {}", address)
            }
@@ -223,6 +296,8 @@ impl ExecuteMsg {
            ExecuteMsg::BondMixnodeOnBehalf { mix_node, .. } => {
                format!("bonding mixnode {} on behalf", mix_node.identity_key)
            }
+            ExecuteMsg::PledgeMore {} => "pledging additional tokens".into(),
+            ExecuteMsg::PledgeMoreOnBehalf { .. } => "pledging additional tokens on behalf".into(),
            ExecuteMsg::UnbondMixnode { .. } => "unbonding mixnode".into(),
            ExecuteMsg::UnbondMixnodeOnBehalf { .. } => "unbonding mixnode on behalf".into(),
            ExecuteMsg::UpdateMixnodeCostParams { .. } => "updating mixnode cost parameters".into(),
@@ -280,6 +355,27 @@ impl ExecuteMsg {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryMsg {
+    // families
+    GetAllFamiliesPaged {
+        limit: Option<u32>,
+        start_after: Option<String>,
+    },
+    GetAllMembersPaged {
+        limit: Option<u32>,
+        start_after: Option<String>,
+    },
+    GetFamilyByHead {
+        head: String,
+    },
+    GetFamilyByLabel {
+        label: String,
+    },
+    GetFamilyMembersByHead {
+        head: String,
+    },
+    GetFamilyMembersByLabel {
+        label: String,
+    },
    // state/sys-params-related
    GetContractVersion {},
    GetRewardingValidatorAddress {},
@@ -334,7 +430,6 @@ pub enum QueryMsg {
        mix_identity: IdentityKey,
    },
    GetLayerDistribution {},
-
    // gateway-related:
    GetGateways {
        start_after: Option<IdentityKey>,
@@ -34,6 +34,10 @@ pub enum PendingEpochEventKind {
        mix_id: MixId,
        proxy: Option<Addr>,
    },
+    PledgeMore {
+        mix_id: MixId,
+        amount: Coin,
+    },
    UnbondMixnode {
        mix_id: MixId,
    },
@@ -78,7 +82,6 @@ pub enum PendingIntervalEventKind {
        mix_id: MixId,
        new_costs: MixNodeCostParams,
    },
-
    UpdateRewardingParams {
        update: IntervalRewardingParamsUpdate,
    },
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::MixnetContractError;
+use crate::families::{Family, FamilyHead};
 use crate::{Layer, RewardedSetNodeStatus};
 use cosmwasm_std::Addr;
 use cosmwasm_std::Coin;
@@ -21,6 +22,27 @@ pub type BlockHeight = u64;
 pub type EpochEventId = u32;
 pub type IntervalEventId = u32;

+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Serialize, Deserialize, Debug, Clone, JsonSchema, PartialEq)]
+pub struct LayerAssignment {
+    mix_id: MixId,
+    layer: Layer,
+}
+
+impl LayerAssignment {
+    pub fn new(mix_id: MixId, layer: Layer) -> Self {
+        LayerAssignment { mix_id, layer }
+    }
+
+    pub fn mix_id(&self) -> MixId {
+        self.mix_id
+    }
+
+    pub fn layer(&self) -> Layer {
+        self.layer
+    }
+}
+
 #[derive(Debug, Default, Serialize, Deserialize, Copy, Clone, Eq, PartialEq)]
 pub struct LayerDistribution {
    pub layer1: u64,
@@ -126,3 +148,15 @@ pub struct PagedRewardedSetResponse {
    pub nodes: Vec<(MixId, RewardedSetNodeStatus)>,
    pub start_next_after: Option<MixId>,
 }
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, JsonSchema)]
+pub struct PagedFamiliesResponse {
+    pub families: Vec<Family>,
+    pub start_next_after: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq, JsonSchema)]
+pub struct PagedMembersResponse {
+    pub members: Vec<(IdentityKey, FamilyHead)>,
+    pub start_next_after: Option<String>,
+}
@@ -14,6 +14,7 @@ pub const VESTING_UNDELEGATION_EVENT_TYPE: &str = "vesting_undelegation";
 pub const VESTING_GATEWAY_BONDING_EVENT_TYPE: &str = "vesting_gateway_bonding";
 pub const VESTING_GATEWAY_UNBONDING_EVENT_TYPE: &str = "vesting_gateway_unbonding";
 pub const VESTING_MIXNODE_BONDING_EVENT_TYPE: &str = "vesting_mixnode_bonding";
+pub const VESTING_PLEDGE_MORE_EVENT_TYPE: &str = "vesting_pledge_more";
 pub const VESTING_MIXNODE_UNBONDING_EVENT_TYPE: &str = "vesting_mixnode_unbonding";
 pub const VESTING_UPDATE_MIXNODE_CONFIG_EVENT_TYPE: &str = "vesting_update_mixnode_config";
 pub const VESTING_UPDATE_MIXNODE_COST_PARAMS_EVENT_TYPE: &str =
@@ -112,6 +113,10 @@ pub fn new_vesting_mixnode_bonding_event() -> Event {
    Event::new(VESTING_MIXNODE_BONDING_EVENT_TYPE)
 }

+pub fn new_vesting_pledge_more_event() -> Event {
+    Event::new(VESTING_PLEDGE_MORE_EVENT_TYPE)
+}
+
 pub fn new_vesting_update_mixnode_config_event() -> Event {
    Event::new(VESTING_UPDATE_MIXNODE_CONFIG_EVENT_TYPE)
 }
@@ -1,7 +1,7 @@
 use cosmwasm_std::{Coin, Timestamp};
 use mixnet_contract_common::{
    mixnode::{MixNodeConfigUpdate, MixNodeCostParams},
-    Gateway, MixId, MixNode,
+    Gateway, IdentityKey, MixId, MixNode,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -57,6 +57,25 @@ impl VestingSpecification {
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
+    // Families
+    /// Only owner of the node can crate the family with node as head
+    CreateFamily {
+        owner_signature: String,
+        label: String,
+    },
+    /// Family head needs to sign the joining node IdentityKey
+    JoinFamily {
+        signature: String,
+        family_head: IdentityKey,
+    },
+    LeaveFamily {
+        signature: String,
+        family_head: IdentityKey,
+    },
+    KickFamilyMember {
+        signature: String,
+        member: IdentityKey,
+    },
    TrackReward {
        amount: Coin,
        address: String,
@@ -101,6 +120,9 @@ pub enum ExecuteMsg {
        owner_signature: String,
        amount: Coin,
    },
+    PledgeMore {
+        amount: Coin,
+    },
    UnbondMixnode {},
    TrackUnbondMixnode {
        owner: String,
@@ -131,6 +153,10 @@ pub enum ExecuteMsg {
 impl ExecuteMsg {
    pub fn name(&self) -> &str {
        match self {
+            ExecuteMsg::CreateFamily { .. } => "VestingExecuteMsg::CreateFamily",
+            ExecuteMsg::JoinFamily { .. } => "VestingExecuteMsg::JoinFamily",
+            ExecuteMsg::LeaveFamily { .. } => "VestingExecuteMsg::LeaveFamily",
+            ExecuteMsg::KickFamilyMember { .. } => "VestingExecuteMsg::KickFamilyMember",
            ExecuteMsg::TrackReward { .. } => "VestingExecuteMsg::TrackReward",
            ExecuteMsg::ClaimOperatorReward { .. } => "VestingExecuteMsg::ClaimOperatorReward",
            ExecuteMsg::ClaimDelegatorReward { .. } => "VestingExecuteMsg::ClaimDelegatorReward",
@@ -145,6 +171,7 @@ impl ExecuteMsg {
            ExecuteMsg::WithdrawVestedCoins { .. } => "VestingExecuteMsg::WithdrawVestedCoins",
            ExecuteMsg::TrackUndelegation { .. } => "VestingExecuteMsg::TrackUndelegation",
            ExecuteMsg::BondMixnode { .. } => "VestingExecuteMsg::BondMixnode",
+            ExecuteMsg::PledgeMore { .. } => "VestingExecuteMsg::PledgeMore",
            ExecuteMsg::UnbondMixnode { .. } => "VestingExecuteMsg::UnbondMixnode",
            ExecuteMsg::TrackUnbondMixnode { .. } => "VestingExecuteMsg::TrackUnbondMixnode",
            ExecuteMsg::BondGateway { .. } => "VestingExecuteMsg::BondGateway",
@@ -0,0 +1,16 @@
+/*
+ * Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+DROP TABLE coconut_credentials;
+CREATE TABLE coconut_credentials
+(
+    id                  INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    voucher_value       TEXT    NOT NULL,
+    voucher_info        TEXT    NOT NULL,
+    serial_number       TEXT    NOT NULL,
+    binding_number      TEXT    NOT NULL,
+    signature           TEXT    NOT NULL UNIQUE,
+    consumed            BOOLEAN NOT NULL
+);
@@ -36,8 +36,8 @@ impl CoconutCredentialManager {
        signature: String,
    ) -> Result<(), sqlx::Error> {
        sqlx::query!(
-            "INSERT INTO coconut_credentials(voucher_value, voucher_info, serial_number, binding_number, signature) VALUES (?, ?, ?, ?, ?)",
-            voucher_value, voucher_info, serial_number, binding_number, signature
+            "INSERT INTO coconut_credentials(voucher_value, voucher_info, serial_number, binding_number, signature, consumed) VALUES (?, ?, ?, ?, ?, ?)",
+            voucher_value, voucher_info, serial_number, binding_number, signature, false
        )
        .execute(&self.connection_pool)
        .await?;
@@ -48,20 +48,26 @@ impl CoconutCredentialManager {
    pub(crate) async fn get_next_coconut_credential(
        &self,
    ) -> Result<CoconutCredential, sqlx::Error> {
-        sqlx::query_as!(CoconutCredential, "SELECT * FROM coconut_credentials")
-            .fetch_one(&self.connection_pool)
-            .await
+        sqlx::query_as!(
+            CoconutCredential,
+            "SELECT * FROM coconut_credentials WHERE NOT consumed"
+        )
+        .fetch_one(&self.connection_pool)
+        .await
    }

-    /// Removes from the database the specified credential.
+    /// Consumes in the database the specified credential.
    ///
    /// # Arguments
    ///
    /// * `id`: Database id.
-    pub(crate) async fn remove_coconut_credential(&self, id: i64) -> Result<(), sqlx::Error> {
-        sqlx::query!("DELETE FROM coconut_credentials WHERE id = ?", id)
-            .execute(&self.connection_pool)
-            .await?;
+    pub(crate) async fn consume_coconut_credential(&self, id: i64) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "UPDATE coconut_credentials SET consumed = TRUE WHERE id = ?",
+            id
+        )
+        .execute(&self.connection_pool)
+        .await?;
        Ok(())
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
farbanas	a096f9d54e	Merge branch 'release/v1.1.3'	2022-12-13 13:24:01 +01:00
farbanas	5456b16e3b	updated changelogs	2022-12-13 13:23:27 +01:00
farbanas	3b5eab5342	bumped everything by one patch version	2022-12-13 13:15:51 +01:00
Bogdan-Ștefan Neacşu	00f17c376a	Use default mainnet values when nothing is specified (#1884 )	2022-12-12 16:34:56 +02:00
Jon Häggblad	5283329914	changelog: fix wording	2022-12-09 22:35:37 +01:00
Jon Häggblad	29dd121282	clients: dont panic in base client gateway client handling (#1878 ) * client-core: fix some panics related to gateway-client * changelog: update * fix	2022-12-09 21:43:37 +01:00
Jon Häggblad	cd1d9d1a0d	client: pick from old lanes probabilisticlly (#1877 ) * Pick from old lanes probabilisticly * changelog: update	2022-12-09 18:44:40 +01:00
Jon Häggblad	b694e675e6	clients: further deduplicate init code (#1873 ) * client-core: move init helpers to module * WIP * socks5: return error instead of terminate in init * Extract out reuse_existing_gateway_config * rustfmt * Remove comment out code * nym-connect: use setup_gateway * Linebreak * changelog: update * Tweak log * rustfmt	2022-12-09 16:12:30 +01:00
Jon Häggblad	39cb6f6ec0	network-requester: return error on socket close (#1876 ) * network-requester: return error when the socket closes * changelog: add note	2022-12-09 15:04:47 +01:00
Bogdan-Ștefan Neacşu	ebaf99fadb	Feature/dkg state to disk (#1872 ) * Add PersistentState * Save and load state to/from disk * If in progress, don't continually write the same state * Fix tests and add serde one * Update changelog * Fix clippy	2022-12-09 13:00:27 +02:00
Jon Häggblad	85515fe16e	Client: dedup setup gateway during init (#1871 ) * clients: dedup gateway setup logic * nym-connect: extract out print_save_config	2022-12-08 22:59:11 +01:00
Jon Häggblad	ec60966a85	Clients: save init results to JSON (#1865 ) * clients: output results of init to json * Remove leftover dbg * Tidy * Fix nym-connect	2022-12-08 19:39:11 +01:00
Jon Häggblad	d1df407bac	nym-connect: update Cargo.lock to 1.1.2	2022-12-08 16:58:41 +01:00
Bogdan-Ștefan Neacşu	9ff4051b0f	Properly add consumed to table (#1870 )	2022-12-08 17:47:41 +02:00
Fouad	fea9ec0f9f	use mix_id for account to get correct pending cost event (#1869 ) * use mix_id for account to get correct pending cost event	2022-12-08 15:42:26 +00:00
Pierre Dommerc	d48d094672	Wallet - Buy, copy changes (#1855 )	2022-12-08 15:54:33 +01:00
Bogdan-Ștefan Neacşu	e1b511e788	Feature/verify bte proof (#1866 ) * Update lock file * Include bte public key verification	2022-12-08 14:06:24 +02:00
Bogdan-Ștefan Neacşu	1500d27ce5	Feature/fix client multi cred consume (#1859 ) * Mark consumed credentials in the db * Add signature log * Fix wasm mock Storage trait * Fix clippy	2022-12-08 11:06:31 +02:00
Fouad	a0eba073ec	refresh balance after sending tokens (#1857 )	2022-12-07 17:17:58 +00:00
Fouad	2c3e716ba1	introduce minimize button in custom title bar (#1843 )	2022-12-07 17:17:30 +00:00
Bogdan-Ștefan Neacşu	b76051832f	Add ignore to dkg expensive tests (#1856 )	2022-12-07 13:53:28 +02:00
farbanas	d9b6823106	Merge branch 'release/v1.1.2'	2022-12-07 12:37:14 +01:00
farbanas	c966680bba	Merge branch 'release/v1.1.2' into develop	2022-12-07 12:36:55 +01:00
farbanas	7f7d30c9b5	docs: updated changelog for contracts release v1.1.2 and updated versions of mixnet and vesting contracts as well	2022-12-07 12:36:24 +01:00
farbanas	b08dace119	changed ubuntu-latest on GH actions to ubuntu-20.04	2022-12-07 12:23:33 +01:00
Jon Häggblad	58255857e5	Merge remote-tracking branch 'origin/release/v1.1.2' into develop	2022-12-07 12:14:15 +01:00
Raphaël Walther	edf38e6356	Fixed URL to branch	2022-12-07 10:40:43 +01:00
Tommy Verrall	e258f62a26	Update qa-qwerty.env	2022-12-07 08:11:11 +01:00
durch	940427776c	Resolve merge conflicts	2022-12-06 20:30:57 +01:00
Dave Hrycyszyn	2f7d9254b8	Updated changelog for wallet	2022-12-06 19:13:08 +01:00
farbanas	67321d7d04	update nym-connect CHANGELOG	2022-12-06 19:13:07 +01:00
farbanas	e38a20fb58	changed nym-connect version to 1.1.2	2022-12-06 19:12:30 +01:00
Dave Hrycyszyn	8e45e3e995	Modifying changelog for v1.1.2	2022-12-06 19:12:27 +01:00
farbanas	2f63d916b6	changed nym-connect version to 1.1.1	2022-12-06 19:12:07 +01:00
farbanas	0b465e1f09	update versions for platfrom, nym-connect and nym-wallet to v1.1.2	2022-12-06 19:12:02 +01:00
pierre	f93aab2f5b	fix(wallet): buy tutorial ui responsivness	2022-12-06 19:09:38 +01:00
pierre	7ff06cfe3e	fix(wallet): typo	2022-12-06 19:09:38 +01:00
pierre	8c7e7dfcd1	fix(wallet): typo	2022-12-06 19:09:38 +01:00
pierre	31ca88fd7f	refactor(wallet): clean code	2022-12-06 19:09:38 +01:00
pierre	51b29a9dcf	feat(wallet): add link to nym exchange interface	2022-12-06 19:09:38 +01:00
pierre	d58c2da463	feat(wallet-buy-nym): update signature modal ui	2022-12-06 19:09:38 +01:00
pierre	5644726a7b	fix(wallet-buy-nym): signature output	2022-12-06 19:09:38 +01:00
pierre	e9ba34ba52	feat(wallet-buy-nym): buy page new ui	2022-12-06 19:09:38 +01:00
pierre	a33e848d6d	Revert "feat(explorer-api): add route to fetch nym terms&cdts" This reverts commit 876f752697d89061b1904e1ddd1d5bcb7045dc5c.	2022-12-06 19:09:38 +01:00
pierre	3da9d2944b	feat(explorer-api): add route to fetch nym terms&cdts	2022-12-06 19:09:38 +01:00
pierre	e2c9f69ab9	feat(wallet-buy): tutorial	2022-12-06 19:09:38 +01:00
pierre	8a21f183f9	feat(wallet): buy page bootstrap	2022-12-06 19:09:38 +01:00
Bogdan-Ștefan Neacșu	cb2a89dceb	Fix clippy	2022-12-06 19:09:38 +01:00
Bogdan-Ștefan Neacşu	502e23b42c	Feature/simplify credential binary (#1841 ) * Expose name of standard directories * Use one command instead of two	2022-12-06 19:09:38 +01:00
Jon Häggblad	2676c68b77	nym-connect/changelog: add note about disconnect fix	2022-12-06 19:09:36 +01:00
Bogdan-Ștefan Neacşu	c5252f348d	Fix comment in configuration file (#1836 )	2022-12-06 19:09:15 +01:00
Bogdan-Ștefan Neacşu	bd8cea3ba3	Use better naming on gateway credential handling (#1834 )	2022-12-06 19:09:13 +01:00
Jędrzej Stuczyński	7ddc8e80e6	Fixed layer distribution skewness check (#1766 )	2022-12-06 19:08:10 +01:00
Drazen Urch	03a974ec34	Node family management (#1670 ) * Family management messages * Add family queries * Add queries to client * Layer assignment message * Paged family queries, annotate mixnodes with family * Add layer assignments to epoch operations * Remove family layer peristence * Add NotImplemented error for kick Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com>	2022-12-06 19:08:07 +01:00
Bogdan-Ștefan Neacşu	5c841de6ae	Feature/dkg integration tests (#1815 ) * DKG contract e2e test * Refactor to the same format as other contracts * Vk share tests * State tests * Dealings tests * Dealer tests * Api dkg tests * Fix path to contract after refactor * Fix test target clippy	2022-12-06 19:06:31 +01:00
Bogdan-Ștefan Neacşu	9a8218905e	Use config URLs in clients before the env values (#1813 )	2022-12-06 19:06:31 +01:00
farbanas	89bcb5649b	changed ubuntu-latest on GH actions to ubuntu-20.04	2022-12-06 17:23:08 +01:00
Raphaël Walther	f6fca0ad37	Corrected env variable name in workflows	2022-12-06 15:45:32 +01:00
Fouad	9a8c5c3708	Feature/wallet content updates (#1825 ) * fix up balance screen * fix up app bar and nym logo alignment * fix up delegation action icon font weight * fix up bond page	2022-12-06 14:11:04 +00:00
Dave Hrycyszyn	c39afd0b65	Updated changelog for wallet	2022-12-06 13:58:59 +00:00
farbanas	31be7a6170	update nym-connect CHANGELOG	2022-12-06 14:42:12 +01:00
farbanas	fee780489c	changed nym-connect version to 1.1.2	2022-12-06 14:08:33 +01:00
Dave Hrycyszyn	957c6fbba0	Modifying changelog for v1.1.2	2022-12-06 13:04:31 +00:00
farbanas	7e56a7a8b2	changed nym-connect version to 1.1.1	2022-12-06 13:53:35 +01:00
farbanas	b273df297a	update versions for platfrom, nym-connect and nym-wallet to v1.1.2	2022-12-06 13:50:45 +01:00
Dave Hrycyszyn	d4979c1f0a	Merge branch 'feature/buy' into release/v1.1.2	2022-12-06 12:35:26 +00:00
Raphaël Walther	52136d727b	Set explorer to use rpc.nymtech.net	2022-12-06 11:00:33 +01:00
Fouad	edd5c363bb	remove extra checks to display vesting schedule(#1826 )	2022-12-06 09:37:11 +00:00
Bogdan-Ștefan Neacșu	1171f18399	Fix clippy	2022-12-06 10:48:32 +02:00
Jon Häggblad	028bee804b	nym-connect: append error to failed message (#1839 ) * nym-connect: append error to failed message * changelog: add note	2022-12-05 15:58:59 +01:00
Bogdan-Ștefan Neacşu	2515646075	Feature/simplify credential binary (#1841 ) * Expose name of standard directories * Use one command instead of two	2022-12-05 16:58:36 +02:00
Jon Häggblad	74d34aeebc	nym-connect/changelog: add note about disconnect fix	2022-12-05 14:53:05 +01:00
Jon Häggblad	a16c566719	common/task: extract out spawn_with_report_error (#1837 )	2022-12-05 14:44:44 +01:00
Bogdan-Ștefan Neacşu	d495aefb0d	Fix comment in configuration file (#1836 )	2022-12-05 15:03:01 +02:00
Gala	667d5f3033	Merge pull request #1828 from nymtech/feat-508-bond-more Feat 508 bond more	2022-12-05 13:13:57 +01:00
Bogdan-Ștefan Neacşu	ce4fd0588c	Use better naming on gateway credential handling (#1834 )	2022-12-05 14:02:30 +02:00
Gala	b51aac6047	Merge branch 'develop' into feat-508-bond-more	2022-12-05 12:18:13 +01:00
Gala	a21be84833	adding a oversaturaded bonding more modal	2022-12-05 12:13:14 +01:00
Jon Häggblad	49f7c48b1b	client: add --no-cover and update --fastmode (#1831 )	2022-12-05 11:14:41 +01:00
Jędrzej Stuczyński	29c073d25c	Fixed layer distribution skewness check (#1766 )	2022-12-05 09:28:32 +00:00
Drazen Urch	7e3bc2d6bb	Node family management (#1670 ) * Family management messages * Add family queries * Add queries to client * Layer assignment message * Paged family queries, annotate mixnodes with family * Add layer assignments to epoch operations * Remove family layer peristence * Add NotImplemented error for kick Co-authored-by: Jędrzej Stuczyński <jedrzej.stuczynski@gmail.com>	2022-12-05 09:36:06 +01:00
Jon Häggblad	6943271942	validator-api: remove storage dependency in contract cache (#1685 ) * validator-api: remove storage dependency in contract cache * validator-client: update detailed routes * contract_cache: forward to new endpoints for compat * Move reward_estimate	2022-12-02 14:40:19 +01:00
Jon Häggblad	a872b478d2	gateway-client: handle shutdown listener (#1829 ) * WIP * WIP: try another approach * WIP * Reworked * Tidy * fix	2022-12-02 12:36:06 +01:00
Jon Häggblad	11051ba929	validator-api: add missing shortform for --config-env-file (#1830 )	2022-12-02 09:23:34 +01:00
Jon Häggblad	10e28c6e5c	envs/mainnet: update to latest mixnet contract and nymd validator url	2022-12-01 23:09:37 +01:00
Gala	78af0bff71	amount error	2022-12-01 16:47:46 +01:00
pierre	e15183029b	fix(wallet): buy tutorial ui responsivness	2022-12-01 16:39:27 +01:00
pierre	39ab252941	fix(wallet): typo	2022-12-01 16:00:42 +01:00
Gala	3d2dee3e1c	avoid mix tokens pools	2022-12-01 15:46:58 +01:00
pierre	4ccd4d258a	fix(wallet): typo	2022-12-01 15:40:09 +01:00
Jon Häggblad	25212f23ad	nym-connect: update lock file	2022-12-01 14:40:27 +01:00
Jon Häggblad	ab4e39e1b3	Fix a few errors in socks5 client and network-requester (backport) (#1824 ) * Fix two unwraps in socks5 and network-requester * Make sure client task never sends shutdown signal	2022-12-01 14:25:59 +01:00
Jędrzej Stuczyński	66e5119114	Feature/pledge more (#1679 ) * New transactions for increasing amount of pledged tokens * unit tests * Added an option to pledge extra tokens through the vesting contract * Introduced wallet endpoints for new operations * Using updated pledge cap in the vesting contract * Changelog update	2022-12-01 12:51:32 +00:00
Gala	96c0256154	Merge branch 'develop' into feat-508-bond-more	2022-12-01 13:46:21 +01:00
Jędrzej Stuczyński	033333bb52	Feature/pledge more (#1679 ) * New transactions for increasing amount of pledged tokens * unit tests * Added an option to pledge extra tokens through the vesting contract * Introduced wallet endpoints for new operations * Using updated pledge cap in the vesting contract * Changelog update	2022-12-01 12:44:20 +00:00
Gala	bf207abe55	logs removal	2022-12-01 13:25:32 +01:00
Gala	4069b0349d	display details modal	2022-12-01 13:15:16 +01:00
Gala	bca20e1dfd	connecting to the back and making the requests work	2022-12-01 12:57:28 +01:00
Gala	1bc94d8fd4	Merge branch 'feature/pledge-more' into feat-508-bond-more	2022-12-01 11:47:44 +01:00
Gala	a269bd8289	wip	2022-12-01 11:46:58 +01:00
Jon Häggblad	eedf3d996a	Merge remote-tracking branch 'origin/release/v1.1.1' into release/v1.1.3	2022-12-01 11:38:36 +01:00
Jon Häggblad	52d06785fb	Fix a few errors in socks5 client and network-requester (#1823 ) * Fix two unwraps in socks5 and network-requester * Make sure client task never sends shutdown signal * Fix panic on getting socks version	2022-12-01 11:20:31 +01:00
Jon Häggblad	1507938c65	socks5-client: SOCKS4a support (#1822 ) * socks5-client: SOCKS4a support * Tidy	2022-12-01 09:19:17 +01:00
Dave Hrycyszyn	41b37984a4	Bumping nym-cli version, missed it last time	2022-11-29 17:51:37 +00:00
Dave Hrycyszyn	b541d1a034	Merge branch 'master' into develop	2022-11-29 17:40:30 +00:00
Dave Hrycyszyn	e4f34833ef	Bumping final version numbers for 1.1.1	2022-11-29 17:22:33 +00:00
Dave Hrycyszyn	5044764a80	Changelog for v1.1.1	2022-11-29 17:21:05 +00:00
Dave Hrycyszyn	c178438f06	Bumping version numbers	2022-11-29 17:18:57 +00:00
Bogdan-Ștefan Neacşu	5d51f4dc71	Feature/dkg integration tests (#1815 ) * DKG contract e2e test * Refactor to the same format as other contracts * Vk share tests * State tests * Dealings tests * Dealer tests * Api dkg tests * Fix path to contract after refactor * Fix test target clippy	2022-11-29 18:32:37 +02:00
Jędrzej Stuczyński	bc25288d08	Using updated pledge cap in the vesting contract	2022-11-29 16:18:21 +00:00
Jędrzej Stuczyński	3a001e2f9f	Introduced wallet endpoints for new operations	2022-11-29 16:08:55 +00:00
Jędrzej Stuczyński	09cad3c589	Added an option to pledge extra tokens through the vesting contract	2022-11-29 16:08:11 +00:00
Jędrzej Stuczyński	ab0180c5ce	unit tests	2022-11-29 16:08:11 +00:00
Jędrzej Stuczyński	a77f364466	New transactions for increasing amount of pledged tokens	2022-11-29 16:03:54 +00:00
Jon Häggblad	a9be8a6abd	Merge remote-tracking branch 'origin/release/v1.1.2' into develop	2022-11-29 16:49:33 +01:00
Jędrzej Stuczyński	8de9f36b69	Experiment/client refactoring (#1814 ) * experimenting with extracting more common client code * drying up the wasm client * allowing some dead code for the time being * fixed formatting in nym-connect * made socks5 client inside nym-connect immutable * made clippy a bit happier * hidden away target locking for recv timeout	2022-11-29 15:48:12 +00:00
Fouad	22f3c8aa40	Update CHANGELOG.md	2022-11-29 14:57:04 +00:00
Jon Häggblad	de2e721ba7	Fix typo in changelog	2022-11-29 15:36:54 +01:00
Jon Häggblad	b94fbcb6db	More entries in nym-connect CHANGELOG	2022-11-29 15:36:14 +01:00
Jon Häggblad	7735f64c6d	Fix links in nym-connect changelog	2022-11-29 15:29:59 +01:00
Jon Häggblad	3857313808	Add socks5-client changes to nym-connect changelog	2022-11-29 15:19:34 +01:00
Jon Häggblad	9d60de0091	Merge remote-tracking branch 'origin/release/v1.1.2' into release/v1.1.3	2022-11-29 12:57:48 +01:00
Bogdan-Ștefan Neacşu	ca7c5d80ce	Use config URLs in clients before the env values (#1813 )	2022-11-29 13:52:08 +02:00
pierre	731780993f	refactor(wallet): clean code	2022-11-28 16:01:08 +01:00
pierre	c02bcb460f	feat(wallet): add link to nym exchange interface	2022-11-28 13:36:17 +01:00
pierre	bdb6aa848e	feat(wallet-buy-nym): update signature modal ui	2022-11-28 10:35:15 +01:00
pierre	32b535d67f	fix(wallet-buy-nym): signature output	2022-11-28 10:35:15 +01:00
pierre	9e1109a577	feat(wallet-buy-nym): buy page new ui	2022-11-28 10:35:15 +01:00
pierre	247a7ba1dc	Revert "feat(explorer-api): add route to fetch nym terms&cdts" This reverts commit 876f752697d89061b1904e1ddd1d5bcb7045dc5c.	2022-11-28 10:35:15 +01:00
pierre	77d10358d4	feat(explorer-api): add route to fetch nym terms&cdts	2022-11-28 10:35:15 +01:00
pierre	fb2a61bed3	feat(wallet-buy): tutorial	2022-11-28 10:35:15 +01:00
pierre	4c2c101e57	feat(wallet): buy page bootstrap	2022-11-28 10:35:15 +01:00