add yarn install

trying to fix workflow on our custom mac runner
chore: changed mac runner to our new custom one
2023-02-27 13:10:09 +01:00 · 2023-02-27 13:04:58 +01:00 · 2023-02-27 11:31:58 +01:00
634 changed files with 9329 additions and 29125 deletions
@@ -79,9 +79,6 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Install wasm-opt
-        run: cargo install --version 0.112.0 wasm-opt
-
      - name: Build release contracts
        run: make wasm

@@ -99,14 +96,9 @@ jobs:
          cp target/release/nym-network-statistics $OUTPUT_DIR
          cp target/release/nym-cli $OUTPUT_DIR
          cp target/release/credential $OUTPUT_DIR
-          cp target/release/explorer-api $OUTPUT_DIR
          
          cp contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_bandwidth.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_dkg.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -6,7 +6,7 @@ on:

 jobs:
  build:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-contracts-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-contracts-') && github.event_name == 'release' }}
    runs-on: [self-hosted, custom-runner-linux]
    steps:
      - uses: actions/checkout@v2
@@ -19,9 +19,6 @@ jobs:
          override: true
          components: rustfmt, clippy

-      - name: Install wasm-opt
-        run: cargo install --version 0.112.0 wasm-opt
-
      - name: Build release contracts
        run: make wasm

@@ -0,0 +1,57 @@
+name: CI for Network Explorer API
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet    
+
+jobs:
+  publish-nym:
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-explorer-api-') && (github.event_name == 'release' || github.event_name == 'workflow_dispatch') }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-20.04]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
+        continue-on-error: true
+
+      - name: Check the release tag starts with `nym-explorer-api-`
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-explorer-api-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build all explorer-api
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path explorer-api/Cargo.toml --workspace --release
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: my-artifact
+          path: |
+            target/release/explorer-api
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            target/release/explorer-api
@@ -0,0 +1,50 @@
+name: Publish Nym CLI binaries
+
+on:
+  workflow_dispatch:
+  release:
+    types: [created]
+    
+env:
+  NETWORK: mainnet
+
+jobs:
+  publish-nym-cli:
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-cli-') && (github.event_name == 'release' || github.event_name == 'workflow_dispatch') }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-20.04, windows-latest, macos-latest]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Check the release tag starts with `nym-cli-`
+        uses: actions/github-script@v3
+        with:
+          script: |
+            core.setFailed('Release tag did not start with nym-cli-...')
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Build binary
+        run: make build-nym-cli
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: nym-cli-${{ matrix.platform }}
+          path: |
+            target/release/nym-cli*
+          retention-days: 30
+
+      - name: Upload to release based on tag name
+        uses: softprops/action-gh-release@v1
+        if: github.event_name == 'release'
+        with:
+          files: |
+            target/release/nym-cli
@@ -14,7 +14,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [macos-latest]
+        platform: [custom-runner-mac-m1]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -24,10 +24,15 @@ jobs:
        uses: actions/setup-node@v3
        with:
          node-version: 16
+
+      - name: Setup yarn
+        run: npm install -g yarn
+
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
+
      - name: Install the Apple developer certificate for code signing
        env:
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
@@ -39,7 +44,7 @@ jobs:
          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db

          # import certificate and provisioning profile from secrets
-          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output $CERTIFICATE_PATH
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode --output=$CERTIFICATE_PATH

          # create temporary keychain
          security create-keychain -p "$KEYCHAIN_PASSWORD" $KEYCHAIN_PATH
@@ -10,7 +10,7 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -16,7 +16,7 @@ env:

 jobs:
  publish-nym:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -10,7 +10,7 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -9,7 +9,7 @@ defaults:

 jobs:
  publish-tauri:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
+    if: ${{ startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release' }}
    strategy:
      fail-fast: false
      matrix:
@@ -39,5 +39,7 @@ validator-api-config.toml
 dist
 storybook-static
 envs/qwerty.env
+Cargo.lock
+nym-connect/Cargo.lock
 .parcel-cache
 **/.DS_Store
@@ -4,72 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [v1.1.14] (2023-04-04)
-
- Investigate cause of qwerty validator being in invalid rewarding state ([#3224])
- Fix NR config due to changes in #3199 ([#3223])
- [Issue] Mixnodes and gateway do not close connections properly  ([#3187])
- disable sign-ext when using wasm-opt + update wasm-opt ([#3203])
- chore: tidy up client `Debug` config section ([#3199])
-
-[#3224]: https://github.com/nymtech/nym/issues/3224
-[#3223]: https://github.com/nymtech/nym/issues/3223
-[#3187]: https://github.com/nymtech/nym/issues/3187
-[#3203]: https://github.com/nymtech/nym/pull/3203
-[#3199]: https://github.com/nymtech/nym/pull/3199
-
-## [v1.1.13] (2023-03-15)
-
- NE - instead of throwing a "Mixnode/Gateway not found" error for blacklisted nodes due to bad performance, show their history but tag them as "Having poor performance" ([#2979])
- NE - Upgrade Sandbox and make below changes:  ([#2332])
- Explorer - Updates ([#3168])
- Website v2 - deploy infrastructure for strapi and CI ([#2213])
- add blockstream green to sp list ([#3180])
- mock-nym-api: fix .storybook lint error ([#3178])
- Validating new interval config parameters to prevent division by zero ([#3153])
-
-[#2979]: https://github.com/nymtech/nym/issues/2979
-[#2332]: https://github.com/nymtech/nym/issues/2332
-[#3168]: https://github.com/nymtech/nym/issues/3168
-[#2213]: https://github.com/nymtech/nym/issues/2213
-[#3180]: https://github.com/nymtech/nym/pull/3180
-[#3178]: https://github.com/nymtech/nym/pull/3178
-[#3153]: https://github.com/nymtech/nym/pull/3153
-
-## [v1.1.12] (2023-03-07)
-
- Fix generated docs for mixnet and vesting contract on docs.rs ([#3093])
- Introduce a way of injecting topology into the client ([#3044])
- Update mixnet TypeScript client methods #1 ([#2783])
- Update tooltips for routing and average score ([#3133])
- update selected service provider description style ([#3128])
-
-[#3093]: https://github.com/nymtech/nym/issues/3093
-[#3044]: https://github.com/nymtech/nym/issues/3044
-[#2783]: https://github.com/nymtech/nym/issues/2783
-[#3133]: https://github.com/nymtech/nym/pull/3133
-[#3128]: https://github.com/nymtech/nym/pull/3128
-
-## [v1.1.11] (2023-02-28)
-
- Fix empty dealer set loop ([#3105])
- The nym-api db.sqlite is broken when trying to run against it it in `enabled-credentials-mode true` there is an ordering issue with migrations when using the credential binary to purchase bandwidth ([#3100])
- Feature/latency based gateway selection ([#3081])
- Fix the credential binary to handle transactions to sleep when in non-inProgress epochs ([#3057])
- Publish mixnet contract to crates.io ([#1919])
- Publish vesting contract to crates.io ([#1920])
- Feature/update checker to use master ([#3097])
- Feature/improve binary checks ([#3094])
-
-[#3105]: https://github.com/nymtech/nym/issues/3105
-[#3100]: https://github.com/nymtech/nym/issues/3100
-[#3081]: https://github.com/nymtech/nym/pull/3081
-[#3057]: https://github.com/nymtech/nym/issues/3057
-[#1919]: https://github.com/nymtech/nym/issues/1919
-[#1920]: https://github.com/nymtech/nym/issues/1920
-[#3097]: https://github.com/nymtech/nym/pull/3097
-[#3094]: https://github.com/nymtech/nym/pull/3094
-
 ## [v1.1.10] (2023-02-21)

 - Verloc listener causing mixnode unexpected shutdown ([#3038])
@@ -22,6 +22,7 @@ members = [
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
+    "common/bandwidth-claim-contract",
    "common/bin-common",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
@@ -104,20 +105,9 @@ edition = "2021"
 license = "Apache-2.0"

 [workspace.dependencies]
-async-trait = "0.1.64"
-bip39 = { version = "2.0.0", features = ["zeroize"] }
+async-trait = "0.1.63"
 cfg-if = "1.0.0"
-cosmwasm-derive = "=1.0.0"
-cosmwasm-schema = "=1.0.0"
-cosmwasm-std = "=1.0.0"
-cosmwasm-storage = "=1.0.0"
-cw-utils = "=0.13.4"
-cw-storage-plus = "=0.13.4"
-cw2 = { version = "=0.13.4" }
-cw3 = { version = "=0.13.4" }
-cw3-fixed-multisig = { version = "=0.13.4" }
-cw4 = { version = "=0.13.4" }
-dotenvy = "0.15.6"
+dotenv = "0.15.0"
 lazy_static = "1.4.0"
 log = "0.4"
 once_cell = "1.7.2"
@@ -1,90 +1,132 @@
-# Default target
-all: test
-
 test: clippy-all cargo-test wasm fmt
-
 test-all: test cargo-test-expensive
-
 no-clippy: build cargo-test wasm fmt
-
 happy: fmt clippy-happy test
+clippy-all: clippy-main clippy-main-examples clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-connect-mobile clippy-all-wasm-client
+clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect clippy-happy-connect-mobile
+cargo-test: test-main test-contracts test-wallet test-connect test-connect-mobile
+cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive
+build: build-contracts build-wallet build-main build-main-examples build-connect build-connect-mobile build-wasm-client
+fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-connect-mobile fmt-wasm-client

-# -----------------------------------------------------------------------------
-# Define targets for a given workspace
-#  $(1): name
-#  $(2): path to workspace
-#  $(3): extra arguments to cargo
-# -----------------------------------------------------------------------------
-define add_cargo_workspace
+clippy-happy-main:
+	cargo clippy

-clippy-happy-$(1):
-	cargo clippy --manifest-path $(2)/Cargo.toml $(3)
+clippy-happy-contracts:
+	cargo clippy --manifest-path contracts/Cargo.toml --target wasm32-unknown-unknown

-clippy-$(1):
-	cargo clippy --manifest-path $(2)/Cargo.toml --workspace $(3) -- -D warnings
+clippy-happy-wallet:
+	cargo clippy --manifest-path nym-wallet/Cargo.toml

-clippy-$(1)-examples:
-	cargo clippy --manifest-path $(2)/Cargo.toml --workspace --examples -- -D warnings
+clippy-happy-connect:
+	cargo clippy --manifest-path nym-connect/desktop/Cargo.toml

-test-$(1):
-	cargo test --manifest-path $(2)/Cargo.toml --workspace
+clippy-happy-connect-mobile:
+	cargo clippy --manifest-path nym-connect/mobile/src-tauri/Cargo.toml

-test-$(1)-expensive:
-	cargo test --manifest-path $(2)/Cargo.toml --workspace -- --ignored
+clippy-main:
+	cargo clippy --workspace -- -D warnings

-build-$(1):
-	cargo build --manifest-path $(2)/Cargo.toml --workspace $(3)
+clippy-main-examples:
+	cargo clippy --workspace --examples -- -D warnings

-build-$(1)-examples:
-	cargo build --manifest-path $(2)/Cargo.toml --workspace --examples
+clippy-wasm:
+	cargo clippy --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --workspace -- -D warnings

-fmt-$(1):
-	cargo fmt --manifest-path $(2)/Cargo.toml --all

-clippy-happy: clippy-happy-$(1)
-clippy-all: clippy-$(1) clippy-$(1)-examples
-cargo-test: test-$(1)
-cargo-test-expensive: test-$(1)-expensive
-build: build-$(1) build-$(1)-examples
-fmt: fmt-$(1)
+clippy-all-contracts:
+	cargo clippy --workspace --manifest-path contracts/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings

-endef
+clippy-all-wallet:
+	cargo clippy --workspace --manifest-path nym-wallet/Cargo.toml --all-features -- -D warnings

-# -----------------------------------------------------------------------------
-# Rust workspaces
-# -----------------------------------------------------------------------------
+clippy-all-connect:
+	cargo clippy --workspace --manifest-path nym-connect/desktop/Cargo.toml --all-features -- -D warnings

-# Generate targets for the various cargo workspaces
+clippy-all-connect-mobile:
+	cargo clippy --workspace --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- -D warnings

-$(eval $(call add_cargo_workspace,main,.))
-$(eval $(call add_cargo_workspace,contracts,contracts,--target wasm32-unknown-unknown))
-$(eval $(call add_cargo_workspace,wasm-client,clients/webassembly,--target wasm32-unknown-unknown))
-$(eval $(call add_cargo_workspace,wallet,nym-wallet,))
-$(eval $(call add_cargo_workspace,connect,nym-connect/desktop))
-ifndef NYM_NO_MOBILE
-$(eval $(call add_cargo_workspace,connect-mobile,nym-connect/mobile/src-tauri))
-endif
+clippy-all-wasm-client:
+	cargo clippy --workspace --manifest-path clients/webassembly/Cargo.toml --all-features --target wasm32-unknown-unknown -- -D warnings

-# -----------------------------------------------------------------------------
-# Convenience targets for crates that are already part of the main workspace
-# -----------------------------------------------------------------------------
+test-main:
+	cargo test --workspace
+
+test-main-expensive:
+	cargo test --workspace -- --ignored
+
+test-contracts:
+	cargo test --manifest-path contracts/Cargo.toml --all-features
+
+test-contracts-expensive:
+	cargo test --manifest-path contracts/Cargo.toml --all-features -- --ignored
+
+test-wallet:
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features
+
+test-wallet-expensive:
+	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored
+
+test-connect:
+	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features
+
+test-connect-expensive:
+	cargo test --manifest-path nym-connect/desktop/Cargo.toml --all-features -- --ignored
+
+test-connect-mobile:
+	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features
+
+test-connect-mobile-expensive:
+	cargo test --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all-features -- --ignored
+
+build-main:
+	cargo build --workspace
+
+build-main-examples:
+	cargo build --workspace --examples
+
+build-contracts:
+	cargo build --manifest-path contracts/Cargo.toml --workspace
+
+build-wallet:
+	cargo build --manifest-path nym-wallet/Cargo.toml --workspace
+
+build-connect:
+	cargo build --manifest-path nym-connect/desktop/Cargo.toml --workspace
+
+build-connect-mobile:
+	cargo build --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --workspace

 build-explorer-api:
-	cargo build -p explorer-api
+	cargo build --manifest-path explorer-api/Cargo.toml --workspace
+
+build-wasm-client:
+	cargo build --manifest-path clients/webassembly/Cargo.toml --workspace --target wasm32-unknown-unknown

 build-nym-cli:
-	cargo build -p nym-cli --release
+	cargo build --release --manifest-path tools/nym-cli/Cargo.toml

-# -----------------------------------------------------------------------------
-# Misc
-# -----------------------------------------------------------------------------
+fmt-main:
+	cargo fmt --all
+
+fmt-contracts:
+	cargo fmt --manifest-path contracts/Cargo.toml --all
+
+fmt-wallet:
+	cargo fmt --manifest-path nym-wallet/Cargo.toml --all
+
+fmt-connect:
+	cargo fmt --manifest-path nym-connect/desktop/Cargo.toml --all
+
+fmt-connect-mobile:
+	cargo fmt --manifest-path nym-connect/mobile/src-tauri/Cargo.toml --all
+
+fmt-wasm-client:
+	cargo fmt --manifest-path clients/webassembly/Cargo.toml --all

 wasm:
 	RUSTFLAGS='-C link-arg=-s' cargo build --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
-	wasm-opt --disable-sign-ext -Os contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm
-	wasm-opt --disable-sign-ext -Os contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm -o contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm

-# NOTE: this seems deprecated an not needed anymore?
 mixnet-opt: wasm
 	cd contracts/mixnet && make opt

@@ -16,7 +16,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 

 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
-[![Build Status](https://img.shields.io/github/actions/workflow/status/nymtech/nym/build.yml?branch=develop&style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
+[![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)


 ### Building
@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.14"
+version = "1.1.10"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -8,7 +8,7 @@ rust-version = "1.66"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-async-trait = { workspace = true }
+async-trait = { version = "0.1.58" }
 dirs = "4.0"
 dashmap = "5.4.0"
 futures = "0.3"
@@ -20,7 +20,6 @@ serde_json = "1.0.89"
 tap = "1.0.1"
 thiserror = "1.0.34"
 url = { version ="2.2", features = ["serde"] }
-tungstenite = { version = "0.13.0", default-features = false }
 tokio = { version = "1.24.1", features = ["macros"]}
 time = "0.3.17"

@@ -37,10 +36,6 @@ nym-topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
 nym-task = { path = "../../common/task" }

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.validator-client]
-path = "../../common/client-libs/validator-client"
-features = ["nyxd-client"]
-
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
 version = "0.1.11"
 features = ["time"]
@@ -49,9 +44,6 @@ features = ["time"]
 version = "1.24.1"
 features = ["time"]

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
-version = "0.14"
-
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 version = "0.6.2"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
@@ -73,7 +65,6 @@ features = ["futures"]

 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
 path = "../../common/wasm-utils"
-features = ["websocket"]

 [target."cfg(target_arch = \"wasm32\")".dependencies.time]
 version = "0.3.17"
@@ -5,11 +5,7 @@ use crate::{client::replies::reply_storage, config::DebugConfig};

 pub fn setup_empty_reply_surb_backend(debug_config: &DebugConfig) -> reply_storage::Empty {
    reply_storage::Empty {
-        min_surb_threshold: debug_config
-            .reply_surbs
-            .minimum_reply_surb_storage_threshold,
-        max_surb_threshold: debug_config
-            .reply_surbs
-            .maximum_reply_surb_storage_threshold,
+        min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold,
+        max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
    }
 }
@@ -15,7 +15,6 @@ use crate::client::replies::reply_controller::{ReplyControllerReceiver, ReplyCon
 use crate::client::replies::reply_storage::{
    CombinedReplyStorage, PersistentReplyStorage, ReplyStorageBackend, SentReplyKeys,
 };
-use crate::client::topology_control::nym_api_provider::NymApiTopologyProvider;
 use crate::client::topology_control::{
    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
@@ -35,15 +34,13 @@ use nym_crypto::asymmetric::{encryption, identity};
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::addressing::nodes::NodeIdentity;
-use nym_sphinx::receiver::{ReconstructedMessage, SphinxMessageReceiver};
+use nym_sphinx::receiver::ReconstructedMessage;
 use nym_task::connections::{ConnectionCommandReceiver, ConnectionCommandSender, LaneQueueLengths};
 use nym_task::{TaskClient, TaskManager};
-use nym_topology::provider_trait::TopologyProvider;
 use std::sync::Arc;
 use std::time::Duration;
 use tap::TapFallible;
 use url::Url;
-
 #[cfg(not(target_arch = "wasm32"))]
 use validator_client::nyxd::CosmWasmClient;

@@ -93,7 +90,6 @@ impl ClientOutput {
 pub struct ClientState {
    pub shared_lane_queue_lengths: LaneQueueLengths,
    pub reply_controller_sender: ReplyControllerSender,
-    pub topology_accessor: TopologyAccessor,
 }

 pub enum ClientInputStatus {
@@ -158,7 +154,6 @@ pub struct BaseClientBuilder<'a, B, C: Clone> {
    nym_api_endpoints: Vec<Url>,
    reply_storage_backend: B,

-    custom_topology_provider: Option<Box<dyn TopologyProvider>>,
    bandwidth_controller: Option<BandwidthController<C>>,
    key_manager: KeyManager,
 }
@@ -182,7 +177,6 @@ where
            bandwidth_controller,
            reply_storage_backend,
            key_manager,
-            custom_topology_provider: None,
        }
    }

@@ -201,17 +195,11 @@ where
            disabled_credentials: credentials_toggle.is_disabled(),
            nym_api_endpoints,
            reply_storage_backend,
-            custom_topology_provider: None,
            bandwidth_controller,
            key_manager,
        }
    }

-    pub fn with_topology_provider(mut self, provider: Box<dyn TopologyProvider>) -> Self {
-        self.custom_topology_provider = Some(provider);
-        self
-    }
-
    pub fn as_mix_recipient(&self) -> Recipient {
        Recipient::new(
            *self.key_manager.identity_keypair().public_key(),
@@ -236,15 +224,15 @@ where

        let mut stream = LoopCoverTrafficStream::new(
            ack_key,
-            debug_config.acknowledgements.average_ack_delay,
-            debug_config.traffic.average_packet_delay,
-            debug_config.cover_traffic.loop_cover_traffic_average_delay,
+            debug_config.average_ack_delay,
+            debug_config.average_packet_delay,
+            debug_config.loop_cover_traffic_average_delay,
            mix_tx,
            self_address,
            topology_accessor,
        );

-        if let Some(size) = debug_config.traffic.use_extended_packet_size {
+        if let Some(size) = debug_config.use_extended_packet_size {
            log::debug!("Setting extended packet size: {:?}", size);
            stream.set_custom_packet_size(size.into());
        }
@@ -294,15 +282,14 @@ where
        shutdown: TaskClient,
    ) {
        info!("Starting received messages buffer controller...");
-        let controller: ReceivedMessagesBufferController<SphinxMessageReceiver> =
-            ReceivedMessagesBufferController::new(
-                local_encryption_keypair,
-                query_receiver,
-                mixnet_receiver,
-                reply_key_storage,
-                reply_controller_sender,
-            );
-        controller.start_with_shutdown(shutdown)
+        ReceivedMessagesBufferController::new(
+            local_encryption_keypair,
+            query_receiver,
+            mixnet_receiver,
+            reply_key_storage,
+            reply_controller_sender,
+        )
+        .start_with_shutdown(shutdown)
    }

    async fn start_gateway_client(
@@ -317,7 +304,7 @@ where
        }
        let gateway_address = self.gateway_config.gateway_listener.clone();
        if gateway_address.is_empty() {
-            return Err(ClientCoreError::GatewayAddressUnknown);
+            return Err(ClientCoreError::GatwayAddressUnknown);
        }

        let gateway_identity = identity::PublicKey::from_base58_string(gateway_id)
@@ -338,9 +325,7 @@ where
            shared_key,
            mixnet_message_sender,
            ack_sender,
-            self.debug_config
-                .gateway_connection
-                .gateway_response_timeout,
+            self.debug_config.gateway_response_timeout,
            self.bandwidth_controller.take(),
            shutdown,
        );
@@ -356,38 +341,25 @@ where
        Ok(gateway_client)
    }

-    fn setup_topology_provider(
-        custom_provider: Option<Box<dyn TopologyProvider>>,
-        nym_api_urls: Vec<Url>,
-    ) -> Box<dyn TopologyProvider> {
-        // if no custom provider was ... provided ..., create one using nym-api
-        custom_provider.unwrap_or_else(|| {
-            Box::new(NymApiTopologyProvider::new(
-                nym_api_urls,
-                env!("CARGO_PKG_VERSION").to_string(),
-            ))
-        })
-    }
-
    // future responsible for periodically polling directory server and updating
    // the current global view of topology
    async fn start_topology_refresher(
-        topology_provider: Box<dyn TopologyProvider>,
+        nym_api_urls: Vec<Url>,
        refresh_rate: Duration,
        topology_accessor: TopologyAccessor,
        shutdown: TaskClient,
    ) -> Result<(), ClientCoreError> {
-        let topology_refresher_config = TopologyRefresherConfig::new(refresh_rate);
-
-        let mut topology_refresher = TopologyRefresher::new(
-            topology_refresher_config,
-            topology_accessor,
-            topology_provider,
+        let topology_refresher_config = TopologyRefresherConfig::new(
+            nym_api_urls,
+            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.try_refresh().await;
+        topology_refresher.refresh().await;

        if let Err(err) = topology_refresher.ensure_topology_is_routable().await {
            log::error!(
@@ -496,13 +468,9 @@ where
        )
        .await?;

-        let topology_provider = Self::setup_topology_provider(
-            self.custom_topology_provider.take(),
-            self.nym_api_endpoints,
-        );
        Self::start_topology_refresher(
-            topology_provider,
-            self.debug_config.topology.topology_refresh_rate,
+            self.nym_api_endpoints.clone(),
+            self.debug_config.topology_refresh_rate,
            shared_topology_accessor.clone(),
            task_manager.subscribe(),
        )
@@ -538,7 +506,7 @@ where
            self_address,
        );

-        if let Some(size) = self.debug_config.traffic.use_extended_packet_size {
+        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());
        }
@@ -557,16 +525,12 @@ where
            task_manager.subscribe(),
        );

-        if !self
-            .debug_config
-            .cover_traffic
-            .disable_loop_cover_traffic_stream
-        {
+        if !self.debug_config.disable_loop_cover_traffic_stream {
            Self::start_cover_traffic_stream(
                self.debug_config,
                self.key_manager.ack_key(),
                self_address,
-                shared_topology_accessor.clone(),
+                shared_topology_accessor,
                sphinx_message_sender,
                task_manager.subscribe(),
            );
@@ -590,7 +554,6 @@ where
            client_state: ClientState {
                shared_lane_queue_lengths,
                reply_controller_sender,
-                topology_accessor: shared_topology_accessor,
            },
            task_manager,
        })
@@ -30,12 +30,8 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
    // it will only be happening on the very first run and in practice won't incur huge
    // costs since the storage is going to be empty
    let mem_store = CombinedReplyStorage::new(
-        debug_config
-            .reply_surbs
-            .minimum_reply_surb_storage_threshold,
-        debug_config
-            .reply_surbs
-            .maximum_reply_surb_storage_threshold,
+        debug_config.minimum_reply_surb_storage_threshold,
+        debug_config.maximum_reply_surb_storage_threshold,
    );
    storage_backend
        .init_fresh(&mem_store)
@@ -50,12 +46,8 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
 fn setup_inactive_backend(debug_config: &DebugConfig) -> fs_backend::Backend {
    info!("creating inactive surb database");
    fs_backend::Backend::new_inactive(
-        debug_config
-            .reply_surbs
-            .minimum_reply_surb_storage_threshold,
-        debug_config
-            .reply_surbs
-            .maximum_reply_surb_storage_threshold,
+        debug_config.minimum_reply_surb_storage_threshold,
+        debug_config.maximum_reply_surb_storage_threshold,
    )
 }

@@ -10,7 +10,6 @@ use nym_sphinx::{
    chunking::fragment::{FragmentIdentifier, COVER_FRAG_ID},
 };
 use std::sync::Arc;
-use std::time::{SystemTime, UNIX_EPOCH};

 /// Module responsible for listening for any data resembling acknowledgements from the network
 /// and firing actions to remove them from the 'Pending' state.
@@ -49,20 +48,10 @@ impl AcknowledgementListener {
        // because nothing was inserted in the first place
        if frag_id == COVER_FRAG_ID {
            trace!("Received an ack for a cover message - no need to do anything");
-            let time = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_millis();
-            println!("cover ack : _{}", time);
            return;
        }

        trace!("Received {} from the mix network", frag_id);
-        let time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_millis();
-        println!("real ack : /{:?}/{}", frag_id, time);

        self.action_sender
            .unbounded_send(Action::new_remove(frag_id))
@@ -9,7 +9,6 @@ use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_task::connections::TransmissionLane;
 use rand::{CryptoRng, Rng};
-use std::time::{SystemTime, UNIX_EPOCH};

 /// Module responsible for dealing with the received messages: splitting them, creating acknowledgements,
 /// putting everything into sphinx packets, etc.
@@ -49,11 +48,6 @@ where
        lane: TransmissionLane,
    ) {
        // offload reply handling to the dedicated task
-        let time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_millis();
-        println!("sending reply: _{}_{}", time, data.len());
        self.reply_controller_sender
            .send_reply(recipient_tag, data, lane)
    }
@@ -64,11 +58,6 @@ where
        content: Vec<u8>,
        lane: TransmissionLane,
    ) {
-        let time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_millis();
-        println!("sending plain: _{}_{}", time, content.len());
        if let Err(err) = self
            .message_handler
            .try_send_plain_message(recipient, content, lane)
@@ -85,11 +74,6 @@ where
        reply_surbs: u32,
        lane: TransmissionLane,
    ) {
-        let time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_millis();
-        println!("sending anonymous: _{}_{}", time, content.len());
        if let Err(err) = self
            .message_handler
            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane)
@@ -153,35 +153,25 @@ impl Config {
            ack_key,
            self_recipient,
            packet_size: Default::default(),
-            ack_wait_addition: base_client_debug_config.acknowledgements.ack_wait_addition,
-            ack_wait_multiplier: base_client_debug_config
-                .acknowledgements
-                .ack_wait_multiplier,
-            average_message_sending_delay: base_client_debug_config
-                .traffic
-                .message_sending_average_delay,
-            average_packet_delay_duration: base_client_debug_config.traffic.average_packet_delay,
-            average_ack_delay_duration: base_client_debug_config.acknowledgements.average_ack_delay,
+            ack_wait_addition: base_client_debug_config.ack_wait_addition,
+            ack_wait_multiplier: base_client_debug_config.ack_wait_multiplier,
+            average_message_sending_delay: base_client_debug_config.message_sending_average_delay,
+            average_packet_delay_duration: base_client_debug_config.average_packet_delay,
+            average_ack_delay_duration: base_client_debug_config.average_ack_delay,
            disable_main_poisson_packet_distribution: base_client_debug_config
-                .traffic
                .disable_main_poisson_packet_distribution,
            minimum_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
                .minimum_reply_surb_request_size,
            maximum_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
                .maximum_reply_surb_request_size,
            maximum_allowed_reply_surb_request_size: base_client_debug_config
-                .reply_surbs
                .maximum_allowed_reply_surb_request_size,
            maximum_reply_surb_rerequest_waiting_period: base_client_debug_config
-                .reply_surbs
                .maximum_reply_surb_rerequest_waiting_period,
            maximum_reply_surb_drop_waiting_period: base_client_debug_config
-                .reply_surbs
                .maximum_reply_surb_drop_waiting_period,
-            maximum_reply_surb_age: base_client_debug_config.reply_surbs.maximum_reply_surb_age,
-            maximum_reply_key_age: base_client_debug_config.reply_surbs.maximum_reply_key_age,
+            maximum_reply_surb_age: base_client_debug_config.maximum_reply_surb_age,
+            maximum_reply_key_age: base_client_debug_config.maximum_reply_key_age,
        }
    }

@@ -24,7 +24,6 @@ use rand::{CryptoRng, Rng};
 use std::pin::Pin;
 use std::sync::Arc;
 use std::time::Duration;
-use std::time::{SystemTime, UNIX_EPOCH};

 #[cfg(not(target_arch = "wasm32"))]
 use tokio::time;
@@ -233,11 +232,7 @@ where
                        return;
                    }
                };
-                let time = SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_millis();
-                println!("cover sent_{}_{:?}",time, self.config.cover_packet_size.size());
+
                (
                    generate_loop_cover_packet(
                        &mut self.rng,
@@ -255,11 +250,6 @@ where
                )
            }
            StreamMessage::Real(real_message) => {
-                let time = SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_millis();
-                println!("real sent: /{:?}/{}/{}", real_message.fragment_id, time, real_message.mix_packet.sphinx_packet().payload.len());
                (real_message.mix_packet, Some(real_message.fragment_id))
            }
        };
@@ -307,29 +297,22 @@ where
            self.sending_delay_controller.current_multiplier()
        );

-        if self
-            .sending_delay_controller
-            .is_backpressure_currently_detected(used_slots)
-        {
+        // Even just a single used slot is enough to signal backpressure
+        if used_slots > 0 {
            log::trace!("Backpressure detected");
            self.sending_delay_controller.record_backpressure_detected();
        }

-        // If the buffer is running out, slow down the sending rate by increasing the delay
-        // multiplier.
+        // If the buffer is running out, slow down the sending rate
        if self.mix_tx.capacity() == 0
            && self.sending_delay_controller.not_increased_delay_recently()
        {
            self.sending_delay_controller.increase_delay_multiplier();
        }

-        // If it looks like we are sending reliably, increase the sending rate by decreasing the
-        // sending delay multiplier.
-        if !self
-            .sending_delay_controller
-            .was_backpressure_detected_recently()
-            && self.sending_delay_controller.not_decreased_delay_recently()
-        {
+        // Very carefully step up the sending rate in case it seems like we can solidly handle the
+        // current rate.
+        if self.sending_delay_controller.is_sending_reliable() {
            self.sending_delay_controller.decrease_delay_multiplier();
        }
    }
@@ -11,14 +11,11 @@ const INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 1;
 // The minimum time between decreasing the average delay between packets. We don't want to change
 // to quickly to keep things somewhat stable. Also there are buffers downstreams meaning we need to
 // wait a little to see the effect before we decrease further.
-const DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 3;
-// The queue length that is required for us to register that backpressure occured. If there are
-// more than this many packets waiting to be sent, we consider the channel to be under
-// backpressure.
-const BACKPRESSURE_THRESHOLD: usize = 10;
+const DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS: u64 = 30;
 // If we enough time passes without any sign of backpressure in the channel, we can consider
-// lowering the average delay.
-const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 1;
+// lowering the average delay. The goal is to keep somewhat stable, rather than maxing out
+// bandwidth at all times.
+const ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS: u64 = 30;
 // The maximum multiplier we apply to the base average Poisson delay.
 const MAX_DELAY_MULTIPLIER: u32 = 6;
 // The minium multiplier we apply to the base average Poisson delay.
@@ -103,27 +100,22 @@ impl SendingDelayController {
        }
    }

+    pub(crate) fn record_backpressure_detected(&mut self) {
+        self.time_when_backpressure_detected = get_time_now();
+    }
+
    pub(crate) fn not_increased_delay_recently(&self) -> bool {
        get_time_now()
            > self.time_when_changed + Duration::from_secs(INCREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
    }

-    pub(crate) fn not_decreased_delay_recently(&self) -> bool {
-        get_time_now()
-            > self.time_when_changed + Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS)
-    }
+    pub(crate) fn is_sending_reliable(&self) -> bool {
+        let now = get_time_now();
+        let delay_change_interval = Duration::from_secs(DECREASE_DELAY_MIN_CHANGE_INTERVAL_SECS);
+        let acceptable_time_without_backpressure =
+            Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS);

-    pub(crate) fn is_backpressure_currently_detected(&self, queue_length: usize) -> bool {
-        queue_length > BACKPRESSURE_THRESHOLD
-    }
-
-    pub(crate) fn record_backpressure_detected(&mut self) {
-        self.time_when_backpressure_detected = get_time_now();
-    }
-
-    pub(crate) fn was_backpressure_detected_recently(&self) -> bool {
-        get_time_now()
-            < self.time_when_backpressure_detected
-                + Duration::from_secs(ACCEPTABLE_TIME_WITHOUT_BACKPRESSURE_SECS)
+        now > self.time_when_backpressure_detected + acceptable_time_without_backpressure
+            && now > self.time_when_changed + delay_change_interval
    }
 }
@@ -20,7 +20,6 @@ use nym_sphinx::params::ReplySurbKeyDigestAlgorithm;
 use nym_sphinx::receiver::{MessageReceiver, MessageRecoveryError, ReconstructedMessage};
 use std::collections::HashSet;
 use std::sync::Arc;
-use std::time::{SystemTime, UNIX_EPOCH};

 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
 // or to say "hey, I'm going offline, don't send anything more to me. Just buffer them instead"
@@ -31,13 +30,13 @@ pub type ReceivedBufferRequestReceiver = mpsc::UnboundedReceiver<ReceivedBufferM
 pub type ReconstructedMessagesSender = mpsc::UnboundedSender<Vec<ReconstructedMessage>>;
 pub type ReconstructedMessagesReceiver = mpsc::UnboundedReceiver<Vec<ReconstructedMessage>>;

-struct ReceivedMessagesBufferInner<R: MessageReceiver> {
+struct ReceivedMessagesBufferInner {
    messages: Vec<ReconstructedMessage>,
    local_encryption_keypair: Arc<encryption::KeyPair>,

    // TODO: looking how it 'looks' here, perhaps `MessageReceiver` should be renamed to something
    // else instead.
-    message_receiver: R,
+    message_receiver: MessageReceiver,
    message_sender: Option<ReconstructedMessagesSender>,

    // TODO: this will get cleared upon re-running the client
@@ -46,16 +45,10 @@ struct ReceivedMessagesBufferInner<R: MessageReceiver> {
    recently_reconstructed: HashSet<i32>,
 }

-impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
+impl ReceivedMessagesBufferInner {
    fn recover_from_fragment(&mut self, fragment_data: &[u8]) -> Option<NymMessage> {
-        let fragment_len = fragment_data.len();
        if nym_sphinx::cover::is_cover(fragment_data) {
            trace!("The message was a loop cover message! Skipping it");
-            let time = SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap()
-            .as_millis();
-            println!("Cover received_{}_{}",time, fragment_len);
            return None;
        }

@@ -67,12 +60,6 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
            Ok(frag) => frag,
        };

-        let time = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .unwrap()
-        .as_millis();
-        println!("real received : _{:?}_{}_{}_{}", &fragment.id(),&fragment.current_fragment(),time, fragment_len);
-
        if self.recently_reconstructed.contains(&fragment.id()) {
            debug!("Received a chunk of already re-assembled message ({:?})! It probably got here because the ack got lost", fragment.id());
            return None;
@@ -115,13 +102,13 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
        &mut self,
        reply_ciphertext: &mut [u8],
        reply_key: SurbEncryptionKey,
-    ) -> Result<Option<NymMessage>, MessageRecoveryError> {
+    ) -> Option<NymMessage> {
        // note: this performs decryption IN PLACE without extra allocation
        self.message_receiver
-            .recover_plaintext_from_reply(reply_ciphertext, reply_key)?;
+            .recover_plaintext_from_reply(reply_ciphertext, reply_key);
        let fragment_data = reply_ciphertext;

-        Ok(self.recover_from_fragment(fragment_data))
+        self.recover_from_fragment(fragment_data)
    }

    fn process_received_regular_packet(&mut self, mut raw_fragment: Vec<u8>) -> Option<NymMessage> {
@@ -143,13 +130,13 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
 #[derive(Debug, Clone)]
 // Note: you should NEVER create more than a single instance of this using 'new()'.
 // You should always use .clone() to create additional instances
-struct ReceivedMessagesBuffer<R: MessageReceiver> {
-    inner: Arc<Mutex<ReceivedMessagesBufferInner<R>>>,
+struct ReceivedMessagesBuffer {
+    inner: Arc<Mutex<ReceivedMessagesBufferInner>>,
    reply_key_storage: SentReplyKeys,
    reply_controller_sender: ReplyControllerSender,
 }

-impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
+impl ReceivedMessagesBuffer {
    fn new(
        local_encryption_keypair: Arc<encryption::KeyPair>,
        reply_key_storage: SentReplyKeys,
@@ -159,7 +146,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
            inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
                messages: Vec::new(),
                local_encryption_keypair,
-                message_receiver: R::new(),
+                message_receiver: MessageReceiver::new(),
                message_sender: None,
                recently_reconstructed: HashSet::new(),
            })),
@@ -341,10 +328,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
            })
    }

-    async fn handle_new_received(
-        &mut self,
-        msgs: Vec<Vec<u8>>,
-    ) -> Result<(), MessageRecoveryError> {
+    async fn handle_new_received(&mut self, msgs: Vec<Vec<u8>>) {
        trace!(
            "Processing {:?} new message that might get added to the buffer!",
            msgs.len()
@@ -360,7 +344,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
            // if yes - this is a reply message
            let completed_message =
                if let Some((reply_key, reply_message)) = self.get_reply_key(&mut msg) {
-                    inner_guard.process_received_reply(reply_message, reply_key)?
+                    inner_guard.process_received_reply(reply_message, reply_key)
                } else {
                    inner_guard.process_received_regular_packet(msg)
                };
@@ -376,7 +360,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
        if !completed_messages.is_empty() {
            self.handle_reconstructed_messages(completed_messages).await
        }
-        Ok(())
    }
 }

@@ -389,14 +372,14 @@ pub enum ReceivedBufferMessage {
    ReceiverDisconnect,
 }

-struct RequestReceiver<R: MessageReceiver> {
-    received_buffer: ReceivedMessagesBuffer<R>,
+struct RequestReceiver {
+    received_buffer: ReceivedMessagesBuffer,
    query_receiver: ReceivedBufferRequestReceiver,
 }

-impl<R: MessageReceiver> RequestReceiver<R> {
+impl RequestReceiver {
    fn new(
-        received_buffer: ReceivedMessagesBuffer<R>,
+        received_buffer: ReceivedMessagesBuffer,
        query_receiver: ReceivedBufferRequestReceiver,
    ) -> Self {
        RequestReceiver {
@@ -439,14 +422,14 @@ impl<R: MessageReceiver> RequestReceiver<R> {
    }
 }

-struct FragmentedMessageReceiver<R: MessageReceiver> {
-    received_buffer: ReceivedMessagesBuffer<R>,
+struct FragmentedMessageReceiver {
+    received_buffer: ReceivedMessagesBuffer,
    mixnet_packet_receiver: MixnetMessageReceiver,
 }

-impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
+impl FragmentedMessageReceiver {
    fn new(
-        received_buffer: ReceivedMessagesBuffer<R>,
+        received_buffer: ReceivedMessagesBuffer,
        mixnet_packet_receiver: MixnetMessageReceiver,
    ) -> Self {
        FragmentedMessageReceiver {
@@ -455,16 +438,13 @@ impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
        }
    }

-    async fn run_with_shutdown(
-        &mut self,
-        mut shutdown: nym_task::TaskClient,
-    ) -> Result<(), MessageRecoveryError> {
+    async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
        debug!("Started FragmentedMessageReceiver with graceful shutdown support");
        while !shutdown.is_shutdown() {
            tokio::select! {
                new_messages = self.mixnet_packet_receiver.next() => {
                    if let Some(new_messages) = new_messages {
-                        self.received_buffer.handle_new_received(new_messages).await?;
+                        self.received_buffer.handle_new_received(new_messages).await;
                    } else {
                        log::trace!("FragmentedMessageReceiver: Stopping since channel closed");
                        break;
@@ -477,16 +457,15 @@ impl<R: MessageReceiver> FragmentedMessageReceiver<R> {
        }
        shutdown.recv_timeout().await;
        log::debug!("FragmentedMessageReceiver: Exiting");
-        Ok(())
    }
 }

-pub(crate) struct ReceivedMessagesBufferController<R: MessageReceiver> {
-    fragmented_message_receiver: FragmentedMessageReceiver<R>,
-    request_receiver: RequestReceiver<R>,
+pub(crate) struct ReceivedMessagesBufferController {
+    fragmented_message_receiver: FragmentedMessageReceiver,
+    request_receiver: RequestReceiver,
 }

-impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferController<R> {
+impl ReceivedMessagesBufferController {
    pub(crate) fn new(
        local_encryption_keypair: Arc<encryption::KeyPair>,
        query_receiver: ReceivedBufferRequestReceiver,
@@ -515,13 +494,9 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll

        let shutdown_handle = shutdown.clone();
        spawn_future(async move {
-            match fragmented_message_receiver
+            fragmented_message_receiver
                .run_with_shutdown(shutdown_handle)
-                .await
-            {
-                Ok(_) => {}
-                Err(e) => error!("{e}"),
-            }
+                .await;
        });
        spawn_future(async move {
            request_receiver.run_with_shutdown(shutdown).await;
@@ -35,12 +35,8 @@ impl ReplyStorageBackend for Backend {
    ) -> Result<Self, Self::StorageError> {
        Ok(Backend {
            empty: Empty {
-                min_surb_threshold: debug_config
-                    .reply_surbs
-                    .minimum_reply_surb_storage_threshold,
-                max_surb_threshold: debug_config
-                    .reply_surbs
-                    .maximum_reply_surb_storage_threshold,
+                min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold,
+                max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
            },
        })
    }
@@ -155,21 +155,18 @@ impl Backend {
        // (assuming no key rotation has happened)
        // but the way it's currently coded, everyone will purge old data
        let since_last_flush = OffsetDateTime::now_utc() - last_flush;
-        let days = since_last_flush.whole_days();
-        let hours = since_last_flush.whole_hours() % 24;
-
-        if days > 0 {
-            info!("it's been over {days} days and {hours} hours since we last used our data store. our reply surbs are already outdated - we're going to purge them now.");
+        if since_last_flush.whole_days() > 0 {
+            info!("it's been over {} days and {} hours since we last used our data store. our reply surbs are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
            manager.delete_all_reply_surb_data().await?;
        }

-        if days > 1 {
-            info!("it's been over {days} days and {hours} hours since we last used our data store. our reply keys are already outdated - we're going to purge them now.");
+        if since_last_flush.whole_days() > 1 {
+            info!("it's been over {} days and {} hours since we last used our data store. our reply keys are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
            manager.delete_all_reply_keys().await?;
        }

-        if days > 2 {
-            info!("it's been over {days} days and {hours} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.");
+        if since_last_flush.whole_days() > 2 {
+            info!("it's been over {} days and {} hours since we last used our data store. our used sender tags are already outdated - we're going to purge them now.", since_last_flush.whole_days(), since_last_flush.whole_hours());
            manager.delete_all_tags().await?;
        }

@@ -35,12 +35,8 @@ impl ReplyStorageBackend for Empty {
        _db_path: Option<PathBuf>,
    ) -> Result<Self, Self::StorageError> {
        Ok(Self {
-            min_surb_threshold: debug_config
-                .reply_surbs
-                .minimum_reply_surb_storage_threshold,
-            max_surb_threshold: debug_config
-                .reply_surbs
-                .maximum_reply_surb_storage_threshold,
+            min_surb_threshold: debug_config.minimum_reply_surb_storage_threshold,
+            max_surb_threshold: debug_config.maximum_reply_surb_storage_threshold,
        })
    }

@@ -0,0 +1,336 @@
+// Copyright 2021-2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::spawn_future;
+use futures::StreamExt;
+use log::*;
+use nym_sphinx::addressing::clients::Recipient;
+use nym_sphinx::params::DEFAULT_NUM_MIX_HOPS;
+use nym_topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
+use rand::seq::SliceRandom;
+use rand::thread_rng;
+use std::ops::Deref;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::{RwLock, RwLockReadGuard};
+use url::Url;
+
+// I'm extremely curious why compiler NEVER complained about lack of Debug here before
+#[derive(Debug)]
+pub struct TopologyAccessorInner(Option<NymTopology>);
+
+impl AsRef<Option<NymTopology>> for TopologyAccessorInner {
+    fn as_ref(&self) -> &Option<NymTopology> {
+        &self.0
+    }
+}
+
+impl TopologyAccessorInner {
+    fn new() -> Self {
+        TopologyAccessorInner(None)
+    }
+
+    fn update(&mut self, new: Option<NymTopology>) {
+        self.0 = new;
+    }
+}
+
+pub struct TopologyReadPermit<'a> {
+    permit: RwLockReadGuard<'a, TopologyAccessorInner>,
+}
+
+impl<'a> Deref for TopologyReadPermit<'a> {
+    type Target = TopologyAccessorInner;
+
+    fn deref(&self) -> &Self::Target {
+        &self.permit
+    }
+}
+
+impl<'a> TopologyReadPermit<'a> {
+    /// Using provided topology read permit, tries to get an immutable reference to the underlying
+    /// topology. For obvious reasons the lifetime of the topology reference is bound to the permit.
+    pub(super) fn try_get_valid_topology_ref(
+        &'a self,
+        ack_recipient: &Recipient,
+        packet_recipient: Option<&Recipient>,
+    ) -> Result<&'a NymTopology, NymTopologyError> {
+        // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
+        let topology = self
+            .permit
+            .as_ref()
+            .as_ref()
+            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
+
+        // 2. does it have any mixnode at all?
+        // 3. does it have any gateways at all?
+        // 4. does it have a mixnode on each layer?
+        topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS)?;
+
+        // 5. does it contain OUR gateway (so that we could create an ack packet)?
+        if !topology.gateway_exists(ack_recipient.gateway()) {
+            return Err(NymTopologyError::NonExistentGatewayError {
+                identity_key: ack_recipient.gateway().to_base58_string(),
+            });
+        }
+
+        // 6. for our target recipient, does it contain THEIR gateway (so that we could create
+        if let Some(recipient) = packet_recipient {
+            if !topology.gateway_exists(recipient.gateway()) {
+                return Err(NymTopologyError::NonExistentGatewayError {
+                    identity_key: recipient.gateway().to_base58_string(),
+                });
+            }
+        }
+
+        Ok(topology)
+    }
+}
+
+impl<'a> From<RwLockReadGuard<'a, TopologyAccessorInner>> for TopologyReadPermit<'a> {
+    fn from(read_permit: RwLockReadGuard<'a, TopologyAccessorInner>) -> Self {
+        TopologyReadPermit {
+            permit: read_permit,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TopologyAccessor {
+    // `RwLock` *seems to* be the better approach for this as write access is only requested every
+    // few seconds, while reads are needed every single packet generated.
+    // However, proper benchmarks will be needed to determine if `RwLock` is indeed a better
+    // approach than a `Mutex`
+    inner: Arc<RwLock<TopologyAccessorInner>>,
+}
+
+impl TopologyAccessor {
+    pub fn new() -> Self {
+        TopologyAccessor {
+            inner: Arc::new(RwLock::new(TopologyAccessorInner::new())),
+        }
+    }
+
+    pub async fn get_read_permit(&self) -> TopologyReadPermit<'_> {
+        self.inner.read().await.into()
+    }
+
+    async fn update_global_topology(&self, new_topology: Option<NymTopology>) {
+        self.inner.write().await.update(new_topology);
+    }
+
+    // only used by the client at startup to get a slightly more reasonable error message
+    // (currently displays as unused because health checker is disabled due to required changes)
+    pub async fn ensure_is_routable(&self) -> Result<(), NymTopologyError> {
+        match &self.inner.read().await.0 {
+            None => Err(NymTopologyError::EmptyNetworkTopology),
+            Some(ref topology) => topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
+        }
+    }
+}
+
+impl Default for TopologyAccessor {
+    fn default() -> Self {
+        TopologyAccessor::new()
+    }
+}
+
+pub struct TopologyRefresherConfig {
+    nym_api_urls: Vec<Url>,
+    refresh_rate: Duration,
+    client_version: String,
+}
+
+impl TopologyRefresherConfig {
+    pub fn new(nym_api_urls: Vec<Url>, refresh_rate: Duration, client_version: String) -> Self {
+        TopologyRefresherConfig {
+            nym_api_urls,
+            refresh_rate,
+            client_version,
+        }
+    }
+}
+
+pub struct TopologyRefresher {
+    validator_client: validator_client::client::NymApiClient,
+    client_version: String,
+
+    nym_api_urls: Vec<Url>,
+    topology_accessor: TopologyAccessor,
+    refresh_rate: Duration,
+
+    currently_used_api: usize,
+    was_latest_valid: bool,
+}
+
+impl TopologyRefresher {
+    pub fn new(mut cfg: TopologyRefresherConfig, topology_accessor: TopologyAccessor) -> Self {
+        cfg.nym_api_urls.shuffle(&mut thread_rng());
+
+        TopologyRefresher {
+            validator_client: validator_client::client::NymApiClient::new(
+                cfg.nym_api_urls[0].clone(),
+            ),
+            client_version: cfg.client_version,
+            nym_api_urls: cfg.nym_api_urls,
+            topology_accessor,
+            refresh_rate: cfg.refresh_rate,
+            currently_used_api: 0,
+            was_latest_valid: true,
+        }
+    }
+
+    fn use_next_nym_api(&mut self) {
+        if self.nym_api_urls.len() == 1 {
+            warn!("There's only a single nym API available - it won't be possible to use a different one");
+            return;
+        }
+
+        self.currently_used_api = (self.currently_used_api + 1) % self.nym_api_urls.len();
+        self.validator_client
+            .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
+    }
+
+    /// Verifies whether nodes a reasonably distributed among all mix layers.
+    ///
+    /// In ideal world we would have 33% nodes on layer 1, 33% on layer 2 and 33% on layer 3.
+    /// However, this is a rather unrealistic expectation, instead we check whether there exists
+    /// a layer with more than 66% of nodes or with fewer than 15% and if so, we trigger a failure.
+    ///
+    /// # Arguments
+    ///
+    /// * `topology`: active topology constructed from validator api data
+    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;
+        }
+
+        // trivial check to see if have at least a single node on each layer (regardless of active set size)
+        if mixes.get(&1).is_none() || mixes.get(&2).is_none() || mixes.get(&3).is_none() {
+            return false;
+        }
+
+        let upper_bound = (mixnodes_count as f32 * 0.66) as usize;
+        let lower_bound = (mixnodes_count as f32 * 0.15) as usize;
+
+        let layer1 = mixes.get(&1).unwrap().len();
+        let layer2 = mixes.get(&2).unwrap().len();
+        let layer3 = mixes.get(&3).unwrap().len();
+
+        if layer1 < lower_bound || layer1 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        if layer2 < lower_bound || layer2 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        if layer3 < lower_bound || layer3 > upper_bound {
+            warn!(
+                "nodes: {}, layer1: {}, layer2: {}, layer3: {}",
+                mixnodes_count, layer1, layer2, layer3
+            );
+            return false;
+        }
+
+        true
+    }
+
+    async fn get_current_compatible_topology(&self) -> Option<NymTopology> {
+        // TODO: optimization for the future:
+        // only refresh mixnodes on timer and refresh gateways only when
+        // we have to send to a new, unknown, gateway
+
+        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
+            Err(err) => {
+                error!("failed to get network mixnodes - {err}");
+                return None;
+            }
+            Ok(mixes) => mixes,
+        };
+
+        let gateways = match self.validator_client.get_cached_gateways().await {
+            Err(err) => {
+                error!("failed to get network gateways - {err}");
+                return None;
+            }
+            Ok(gateways) => gateways,
+        };
+
+        let topology = nym_topology_from_detailed(mixnodes, gateways)
+            .filter_system_version(&self.client_version);
+
+        if !self.check_layer_distribution(&topology) {
+            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used.");
+            None
+        } else {
+            Some(topology)
+        }
+    }
+
+    pub async fn refresh(&mut self) {
+        trace!("Refreshing the topology");
+        let new_topology = self.get_current_compatible_topology().await;
+
+        if new_topology.is_none() {
+            self.use_next_nym_api();
+        }
+
+        if new_topology.is_none() && self.was_latest_valid {
+            // if we failed to grab this topology, but the one before it was alright, let's assume
+            // validator had a tiny hiccup and use the old data
+            warn!("we're going to keep on using the old topology for this iteration");
+            self.was_latest_valid = false;
+            return;
+        } else if new_topology.is_some() {
+            self.was_latest_valid = true;
+        }
+
+        self.topology_accessor
+            .update_global_topology(new_topology)
+            .await;
+    }
+
+    pub async fn ensure_topology_is_routable(&self) -> Result<(), NymTopologyError> {
+        self.topology_accessor.ensure_is_routable().await
+    }
+
+    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
+        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! {
+                    _ = interval.next() => {
+                        self.refresh().await;
+                    },
+                    _ = shutdown.recv() => {
+                        log::trace!("TopologyRefresher: Received shutdown");
+                    },
+                }
+            }
+            shutdown.recv_timeout().await;
+            log::debug!("TopologyRefresher: Exiting");
+        })
+    }
+}
@@ -1,154 +0,0 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_sphinx::addressing::clients::Recipient;
-use nym_sphinx::params::DEFAULT_NUM_MIX_HOPS;
-use nym_topology::{NymTopology, NymTopologyError};
-use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-use tokio::sync::{Notify, RwLock, RwLockReadGuard};
-
-#[derive(Debug)]
-pub struct TopologyAccessorInner {
-    controlled_manually: AtomicBool,
-    released_manual_control: Notify,
-    // `RwLock` *seems to* be the better approach for this as write access is only requested every
-    // few seconds, while reads are needed every single packet generated.
-    // However, proper benchmarks will be needed to determine if `RwLock` is indeed a better
-    // approach than a `Mutex`
-    topology: RwLock<Option<NymTopology>>,
-}
-
-impl TopologyAccessorInner {
-    fn new() -> Self {
-        TopologyAccessorInner {
-            controlled_manually: AtomicBool::new(false),
-            released_manual_control: Notify::new(),
-            topology: RwLock::new(None),
-        }
-    }
-
-    async fn update(&self, new: Option<NymTopology>) {
-        *self.topology.write().await = new;
-    }
-}
-
-pub struct TopologyReadPermit<'a> {
-    permit: RwLockReadGuard<'a, Option<NymTopology>>,
-}
-
-impl<'a> Deref for TopologyReadPermit<'a> {
-    type Target = Option<NymTopology>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.permit
-    }
-}
-
-impl<'a> TopologyReadPermit<'a> {
-    /// Using provided topology read permit, tries to get an immutable reference to the underlying
-    /// topology. For obvious reasons the lifetime of the topology reference is bound to the permit.
-    pub(crate) fn try_get_valid_topology_ref(
-        &'a self,
-        ack_recipient: &Recipient,
-        packet_recipient: Option<&Recipient>,
-    ) -> Result<&'a NymTopology, NymTopologyError> {
-        // 1. Have we managed to get anything from the refresher, i.e. have the nym-api queries gone through?
-        let topology = self
-            .permit
-            .as_ref()
-            .ok_or(NymTopologyError::EmptyNetworkTopology)?;
-
-        // 2. does it have any mixnode at all?
-        // 3. does it have any gateways at all?
-        // 4. does it have a mixnode on each layer?
-        topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS)?;
-
-        // 5. does it contain OUR gateway (so that we could create an ack packet)?
-        if !topology.gateway_exists(ack_recipient.gateway()) {
-            return Err(NymTopologyError::NonExistentGatewayError {
-                identity_key: ack_recipient.gateway().to_base58_string(),
-            });
-        }
-
-        // 6. for our target recipient, does it contain THEIR gateway (so that we could create
-        if let Some(recipient) = packet_recipient {
-            if !topology.gateway_exists(recipient.gateway()) {
-                return Err(NymTopologyError::NonExistentGatewayError {
-                    identity_key: recipient.gateway().to_base58_string(),
-                });
-            }
-        }
-
-        Ok(topology)
-    }
-}
-
-impl<'a> From<RwLockReadGuard<'a, Option<NymTopology>>> for TopologyReadPermit<'a> {
-    fn from(read_permit: RwLockReadGuard<'a, Option<NymTopology>>) -> Self {
-        TopologyReadPermit {
-            permit: read_permit,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct TopologyAccessor {
-    inner: Arc<TopologyAccessorInner>,
-}
-
-impl TopologyAccessor {
-    pub fn new() -> Self {
-        TopologyAccessor {
-            inner: Arc::new(TopologyAccessorInner::new()),
-        }
-    }
-
-    pub fn controlled_manually(&self) -> bool {
-        self.inner.controlled_manually.load(Ordering::SeqCst)
-    }
-
-    pub async fn get_read_permit(&self) -> TopologyReadPermit<'_> {
-        self.inner.topology.read().await.into()
-    }
-
-    pub(crate) async fn update_global_topology(&self, new_topology: Option<NymTopology>) {
-        self.inner.update(new_topology).await;
-    }
-
-    pub(crate) async fn wait_for_released_manual_control(&self) {
-        self.inner.released_manual_control.notified().await
-    }
-
-    pub async fn current_topology(&self) -> Option<NymTopology> {
-        self.inner.topology.read().await.clone()
-    }
-
-    pub async fn manually_change_topology(&self, new_topology: NymTopology) {
-        self.inner.controlled_manually.store(true, Ordering::SeqCst);
-        self.inner.update(Some(new_topology)).await;
-    }
-
-    pub fn release_manual_control(&self) {
-        self.inner
-            .controlled_manually
-            .store(false, Ordering::SeqCst);
-        self.inner.released_manual_control.notify_waiters();
-    }
-
-    // only used by the client at startup to get a slightly more reasonable error message
-    // (currently displays as unused because health checker is disabled due to required changes)
-    pub async fn ensure_is_routable(&self) -> Result<(), NymTopologyError> {
-        match self.inner.topology.read().await.deref() {
-            None => Err(NymTopologyError::EmptyNetworkTopology),
-            Some(ref topology) => topology.ensure_can_construct_path_through(DEFAULT_NUM_MIX_HOPS),
-        }
-    }
-}
-
-impl Default for TopologyAccessor {
-    fn default() -> Self {
-        TopologyAccessor::new()
-    }
-}
@@ -1,115 +0,0 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::spawn_future;
-pub(crate) use accessor::{TopologyAccessor, TopologyReadPermit};
-use futures::StreamExt;
-use log::*;
-use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::NymTopologyError;
-use std::time::Duration;
-
-mod accessor;
-pub(crate) mod nym_api_provider;
-
-// TODO: move it to config later
-const MAX_FAILURE_COUNT: usize = 10;
-
-pub struct TopologyRefresherConfig {
-    refresh_rate: Duration,
-}
-
-impl TopologyRefresherConfig {
-    pub fn new(refresh_rate: Duration) -> Self {
-        TopologyRefresherConfig { refresh_rate }
-    }
-}
-
-pub struct TopologyRefresher {
-    topology_provider: Box<dyn TopologyProvider>,
-    topology_accessor: TopologyAccessor,
-
-    refresh_rate: Duration,
-    consecutive_failure_count: usize,
-}
-
-impl TopologyRefresher {
-    pub fn new(
-        cfg: TopologyRefresherConfig,
-        topology_accessor: TopologyAccessor,
-        topology_provider: Box<dyn TopologyProvider>,
-    ) -> Self {
-        TopologyRefresher {
-            topology_provider,
-            topology_accessor,
-            refresh_rate: cfg.refresh_rate,
-            consecutive_failure_count: 0,
-        }
-    }
-
-    pub fn change_topology_provider(&mut self, provider: Box<dyn TopologyProvider>) {
-        self.topology_provider = provider;
-    }
-
-    pub async fn try_refresh(&mut self) {
-        trace!("Refreshing the topology");
-
-        if self.topology_accessor.controlled_manually() {
-            info!("topology is being controlled manually - we're going to wait until the control is released...");
-            self.topology_accessor
-                .wait_for_released_manual_control()
-                .await;
-        }
-
-        let new_topology = self.topology_provider.get_new_topology().await;
-        if new_topology.is_none() {
-            warn!("failed to obtain new network topology");
-        }
-
-        if new_topology.is_none() && self.consecutive_failure_count < MAX_FAILURE_COUNT {
-            // if we failed to grab this topology, but the one before it was alright, let's assume
-            // validator had a tiny hiccup and use the old data
-            warn!("we're going to keep on using the old topology for this iteration");
-            self.consecutive_failure_count += 1;
-            return;
-        } else if new_topology.is_some() {
-            self.consecutive_failure_count = 0;
-        }
-
-        self.topology_accessor
-            .update_global_topology(new_topology)
-            .await;
-    }
-
-    pub async fn ensure_topology_is_routable(&self) -> Result<(), NymTopologyError> {
-        self.topology_accessor.ensure_is_routable().await
-    }
-
-    pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
-        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! {
-                    _ = interval.next() => {
-                        self.try_refresh().await;
-                    },
-                    _ = shutdown.recv() => {
-                        log::trace!("TopologyRefresher: Received shutdown");
-                    },
-                }
-            }
-            shutdown.recv_timeout().await;
-            log::debug!("TopologyRefresher: Exiting");
-        })
-    }
-}
@@ -1,106 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use async_trait::async_trait;
-use log::{error, warn};
-use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
-use rand::prelude::SliceRandom;
-use rand::thread_rng;
-use url::Url;
-
-pub(crate) struct NymApiTopologyProvider {
-    validator_client: validator_client::client::NymApiClient,
-    nym_api_urls: Vec<Url>,
-
-    client_version: String,
-    currently_used_api: usize,
-}
-
-impl NymApiTopologyProvider {
-    pub(crate) fn new(mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
-        nym_api_urls.shuffle(&mut thread_rng());
-
-        NymApiTopologyProvider {
-            validator_client: validator_client::client::NymApiClient::new(nym_api_urls[0].clone()),
-            nym_api_urls,
-            client_version,
-            currently_used_api: 0,
-        }
-    }
-
-    fn use_next_nym_api(&mut self) {
-        if self.nym_api_urls.len() == 1 {
-            warn!("There's only a single nym API available - it won't be possible to use a different one");
-            return;
-        }
-
-        self.currently_used_api = (self.currently_used_api + 1) % self.nym_api_urls.len();
-        self.validator_client
-            .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
-    }
-
-    /// Verifies whether nodes a reasonably distributed among all mix layers.
-    ///
-    /// In ideal world we would have 33% nodes on layer 1, 33% on layer 2 and 33% on layer 3.
-    /// However, this is a rather unrealistic expectation, instead we check whether there exists
-    /// a layer with more than 66% of nodes or with fewer than 15% and if so, we trigger a failure.
-    ///
-    /// # Arguments
-    ///
-    /// * `topology`: active topology constructed from validator api data
-    fn check_layer_distribution(
-        &self,
-        active_topology: &NymTopology,
-    ) -> Result<(), NymTopologyError> {
-        let lower_threshold = 0.15;
-        let upper_threshold = 0.66;
-        active_topology.ensure_even_layer_distribution(lower_threshold, upper_threshold)
-    }
-
-    async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
-        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
-            Err(err) => {
-                error!("failed to get network mixnodes - {err}");
-                return None;
-            }
-            Ok(mixes) => mixes,
-        };
-
-        let gateways = match self.validator_client.get_cached_gateways().await {
-            Err(err) => {
-                error!("failed to get network gateways - {err}");
-                return None;
-            }
-            Ok(gateways) => gateways,
-        };
-
-        let topology = nym_topology_from_detailed(mixnodes, gateways)
-            .filter_system_version(&self.client_version);
-
-        if let Err(err) = self.check_layer_distribution(&topology) {
-            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used: {err}");
-            self.use_next_nym_api();
-            None
-        } else {
-            Some(topology)
-        }
-    }
-}
-
-// hehe, wasm
-#[cfg(not(target_arch = "wasm32"))]
-#[async_trait]
-impl TopologyProvider for NymApiTopologyProvider {
-    async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        self.get_current_compatible_topology().await
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-#[async_trait(?Send)]
-impl TopologyProvider for NymApiTopologyProvider {
-    async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        self.get_current_compatible_topology().await
-    }
-}
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use nym_config::defaults::NymNetworkDetails;
-use nym_config::{NymConfig, OptionalSet, CRED_DB_FILE_NAME};
+use nym_config::{NymConfig, OptionalSet, DB_FILE_NAME};
 use nym_sphinx::params::PacketSize;
 use serde::{Deserialize, Serialize};
 use std::marker::PhantomData;
@@ -13,7 +13,6 @@ use url::Url;
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen::prelude::*;

-pub mod old_config_v1_1_13;
 pub mod persistence;

 pub const MISSING_VALUE: &str = "MISSING VALUE";
@@ -211,12 +210,11 @@ impl<T> Config<T> {
    }

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

    pub fn with_disabled_cover_traffic(mut self, disabled: bool) -> Self {
@@ -227,8 +225,8 @@ impl<T> Config<T> {
    }

    pub fn set_no_cover_traffic(&mut self) {
-        self.debug.cover_traffic.disable_loop_cover_traffic_stream = true;
-        self.debug.traffic.disable_main_poisson_packet_distribution = true;
+        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) {
@@ -313,93 +311,87 @@ impl<T> Config<T> {
    }

    pub fn get_average_packet_delay(&self) -> Duration {
-        self.debug.traffic.average_packet_delay
+        self.debug.average_packet_delay
    }

    pub fn get_average_ack_delay(&self) -> Duration {
-        self.debug.acknowledgements.average_ack_delay
+        self.debug.average_ack_delay
    }

    pub fn get_ack_wait_multiplier(&self) -> f64 {
-        self.debug.acknowledgements.ack_wait_multiplier
+        self.debug.ack_wait_multiplier
    }

    pub fn get_ack_wait_addition(&self) -> Duration {
-        self.debug.acknowledgements.ack_wait_addition
+        self.debug.ack_wait_addition
    }

    pub fn get_loop_cover_traffic_average_delay(&self) -> Duration {
-        self.debug.cover_traffic.loop_cover_traffic_average_delay
+        self.debug.loop_cover_traffic_average_delay
    }

    pub fn get_message_sending_average_delay(&self) -> Duration {
-        self.debug.traffic.message_sending_average_delay
+        self.debug.message_sending_average_delay
    }

    pub fn get_gateway_response_timeout(&self) -> Duration {
-        self.debug.gateway_connection.gateway_response_timeout
+        self.debug.gateway_response_timeout
    }

    pub fn get_topology_refresh_rate(&self) -> Duration {
-        self.debug.topology.topology_refresh_rate
+        self.debug.topology_refresh_rate
    }

    pub fn get_topology_resolution_timeout(&self) -> Duration {
-        self.debug.topology.topology_resolution_timeout
+        self.debug.topology_resolution_timeout
    }

    pub fn get_disabled_loop_cover_traffic_stream(&self) -> bool {
-        self.debug.cover_traffic.disable_loop_cover_traffic_stream
+        self.debug.disable_loop_cover_traffic_stream
    }

    pub fn get_disabled_main_poisson_packet_distribution(&self) -> bool {
-        self.debug.traffic.disable_main_poisson_packet_distribution
+        self.debug.disable_main_poisson_packet_distribution
    }

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

    pub fn get_minimum_reply_surb_storage_threshold(&self) -> usize {
-        self.debug.reply_surbs.minimum_reply_surb_storage_threshold
+        self.debug.minimum_reply_surb_storage_threshold
    }

    pub fn get_maximum_reply_surb_storage_threshold(&self) -> usize {
-        self.debug.reply_surbs.maximum_reply_surb_storage_threshold
+        self.debug.maximum_reply_surb_storage_threshold
    }

    pub fn get_minimum_reply_surb_request_size(&self) -> u32 {
-        self.debug.reply_surbs.minimum_reply_surb_request_size
+        self.debug.minimum_reply_surb_request_size
    }

    pub fn get_maximum_reply_surb_request_size(&self) -> u32 {
-        self.debug.reply_surbs.maximum_reply_surb_request_size
+        self.debug.maximum_reply_surb_request_size
    }

    pub fn get_maximum_allowed_reply_surb_request_size(&self) -> u32 {
-        self.debug
-            .reply_surbs
-            .maximum_allowed_reply_surb_request_size
+        self.debug.maximum_allowed_reply_surb_request_size
    }

    pub fn get_maximum_reply_surb_rerequest_waiting_period(&self) -> Duration {
-        self.debug
-            .reply_surbs
-            .maximum_reply_surb_rerequest_waiting_period
+        self.debug.maximum_reply_surb_rerequest_waiting_period
    }

    pub fn get_maximum_reply_surb_drop_waiting_period(&self) -> Duration {
-        self.debug
-            .reply_surbs
-            .maximum_reply_surb_drop_waiting_period
+        self.debug.maximum_reply_surb_drop_waiting_period
    }

    pub fn get_maximum_reply_surb_age(&self) -> Duration {
-        self.debug.reply_surbs.maximum_reply_surb_age
+        self.debug.maximum_reply_surb_age
    }

    pub fn get_maximum_reply_key_age(&self) -> Duration {
-        self.debug.reply_surbs.maximum_reply_key_age
+        self.debug.maximum_reply_key_age
    }
 }

@@ -458,63 +450,63 @@ impl From<nym_topology::gateway::Node> for GatewayEndpointConfig {
 pub struct Client<T> {
    /// Version of the client for which this configuration was created.
    #[serde(default = "missing_string_value")]
-    pub version: String,
+    version: String,

    /// ID specifies the human readable ID of this particular client.
-    pub id: String,
+    id: String,

    /// Indicates whether this client is running in a disabled credentials mode, thus attempting
    /// to claim bandwidth without presenting bandwidth credentials.
    #[serde(default)]
-    pub disabled_credentials_mode: bool,
+    disabled_credentials_mode: bool,

    /// Addresses to nyxd validators via which the client can communicate with the chain.
    #[serde(alias = "validator_urls")]
-    pub nyxd_urls: Vec<Url>,
+    nyxd_urls: Vec<Url>,

    /// Addresses to APIs running on validator from which the client gets the view of the network.
    #[serde(alias = "validator_api_urls")]
-    pub nym_api_urls: Vec<Url>,
+    nym_api_urls: Vec<Url>,

    /// Path to file containing private identity key.
-    pub private_identity_key_file: PathBuf,
+    private_identity_key_file: PathBuf,

    /// Path to file containing public identity key.
-    pub public_identity_key_file: PathBuf,
+    public_identity_key_file: PathBuf,

    /// Path to file containing private encryption key.
-    pub private_encryption_key_file: PathBuf,
+    private_encryption_key_file: PathBuf,

    /// Path to file containing public encryption key.
-    pub public_encryption_key_file: PathBuf,
+    public_encryption_key_file: PathBuf,

    /// Path to file containing shared key derived with the specified gateway that is used
    /// for all communication with it.
-    pub gateway_shared_key_file: PathBuf,
+    gateway_shared_key_file: PathBuf,

    /// Path to file containing key used for encrypting and decrypting the content of an
    /// acknowledgement so that nobody besides the client knows which packet it refers to.
-    pub ack_key_file: PathBuf,
+    ack_key_file: PathBuf,

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

    /// Path to the database containing bandwidth credentials of this client.
-    pub database_path: PathBuf,
+    database_path: PathBuf,

    /// Path to the persistent store for received reply surbs, unused encryption keys and used sender tags.
    // this was set to use #[serde(default)] for the purposes of compatibility for multi-surbs introduced in 1.1.4.
    // if you're reading this message and we have already introduced some breaking changes, feel free
    // to remove that attribute since at this point the client configs should have gotten regenerated
    #[serde(default)]
-    pub reply_surb_database_path: PathBuf,
+    reply_surb_database_path: PathBuf,

    /// nym_home_directory specifies absolute path to the home nym Clients directory.
    /// It is expected to use default value and hence .toml file should not redefine this field.
-    pub nym_root_directory: PathBuf,
+    nym_root_directory: PathBuf,

    #[serde(skip)]
-    pub super_struct: PhantomData<T>,
+    super_struct: PhantomData<T>,
 }

 impl<T: NymConfig> Default for Client<T> {
@@ -587,7 +579,7 @@ impl<T: NymConfig> Client<T> {
    }

    fn default_database_path(id: &str) -> PathBuf {
-        T::default_data_directory(id).join(CRED_DB_FILE_NAME)
+        T::default_data_directory(id).join(DB_FILE_NAME)
    }
 }

@@ -595,9 +587,9 @@ impl<T: NymConfig> Client<T> {
 #[serde(deny_unknown_fields)]
 pub struct Logging {}

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
+#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(default, deny_unknown_fields)]
-pub struct Traffic {
+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
@@ -605,74 +597,6 @@ pub struct Traffic {
    #[serde(with = "humantime_serde")]
    pub average_packet_delay: Duration,

-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take another 'real traffic stream' message to be sent.
-    /// If no real packets are available and cover traffic is enabled,
-    /// a loop cover message is sent instead in order to preserve the rate.
-    #[serde(with = "humantime_serde")]
-    pub message_sending_average_delay: Duration,
-
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    pub disable_main_poisson_packet_distribution: bool,
-
-    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
-    pub use_extended_packet_size: Option<ExtendedPacketSize>,
-}
-
-impl Default for Traffic {
-    fn default() -> Self {
-        Traffic {
-            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
-            disable_main_poisson_packet_distribution: false,
-            use_extended_packet_size: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct CoverTraffic {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take for another loop cover traffic message to be sent.
-    #[serde(with = "humantime_serde")]
-    pub loop_cover_traffic_average_delay: Duration,
-
-    /// Controls whether the dedicated loop cover traffic stream should be enabled.
-    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
-    pub disable_loop_cover_traffic_stream: bool,
-}
-
-impl Default for CoverTraffic {
-    fn default() -> Self {
-        CoverTraffic {
-            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
-            disable_loop_cover_traffic_stream: false,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct GatewayConnection {
-    /// How long we're willing to wait for a response to a message sent to the gateway,
-    /// before giving up on it.
-    #[serde(with = "humantime_serde")]
-    pub gateway_response_timeout: Duration,
-}
-
-impl Default for GatewayConnection {
-    fn default() -> Self {
-        GatewayConnection {
-            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Acknowledgements {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent acknowledgement is going to be delayed at any given mix node.
    /// So for an ack going through three mix nodes, on average, it will take three times this value
@@ -690,21 +614,24 @@ pub struct Acknowledgements {
    /// In an ideal network with 0 latency, this value would have been 0.
    #[serde(with = "humantime_serde")]
    pub ack_wait_addition: Duration,
-}

-impl Default for Acknowledgements {
-    fn default() -> Self {
-        Acknowledgements {
-            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
-            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
-        }
-    }
-}
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take for another loop cover traffic message to be sent.
+    #[serde(with = "humantime_serde")]
+    pub loop_cover_traffic_average_delay: Duration,
+
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take another 'real traffic stream' message to be sent.
+    /// If no real packets are available and cover traffic is enabled,
+    /// a loop cover message is sent instead in order to preserve the rate.
+    #[serde(with = "humantime_serde")]
+    pub message_sending_average_delay: Duration,
+
+    /// How long we're willing to wait for a response to a message sent to the gateway,
+    /// before giving up on it.
+    #[serde(with = "humantime_serde")]
+    pub gateway_response_timeout: Duration,

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct Topology {
    /// The uniform delay every which clients are querying the directory server
    /// to try to obtain a compatible network topology to send sphinx packets through.
    #[serde(with = "humantime_serde")]
@@ -715,20 +642,18 @@ pub struct Topology {
    /// did not reach its destination.
    #[serde(with = "humantime_serde")]
    pub topology_resolution_timeout: Duration,
-}

-impl Default for Topology {
-    fn default() -> Self {
-        Topology {
-            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
-            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-        }
-    }
-}
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
+    pub disable_loop_cover_traffic_stream: bool,
+
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Controls whether the sent sphinx packet use a NON-DEFAULT bigger size.
+    pub use_extended_packet_size: Option<ExtendedPacketSize>,

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct ReplySurbs {
    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
    /// It can only allow to go below that value if its to request additional reply surbs.
    pub minimum_reply_surb_storage_threshold: usize,
@@ -766,9 +691,29 @@ pub struct ReplySurbs {
    pub maximum_reply_key_age: Duration,
 }

-impl Default for ReplySurbs {
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+pub enum ExtendedPacketSize {
+    Extended8,
+    Extended16,
+    Extended32,
+}
+
+impl Default for DebugConfig {
    fn default() -> Self {
-        ReplySurbs {
+        DebugConfig {
+            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
+            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
+            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
+            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
+            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
+            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
+            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
+            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
+            disable_loop_cover_traffic_stream: false,
+            disable_main_poisson_packet_distribution: false,
+            use_extended_packet_size: None,
            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
@@ -783,52 +728,6 @@ impl Default for ReplySurbs {
    }
 }

-#[derive(Debug, Clone, Copy, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct DebugConfig {
-    /// Defines all configuration options related to traffic streams.
-    pub traffic: Traffic,
-
-    /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTraffic,
-
-    /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnection,
-
-    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: Acknowledgements,
-
-    /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: Topology,
-
-    /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbs,
-}
-
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq)]
-#[serde(rename_all = "lowercase")]
-pub enum ExtendedPacketSize {
-    Extended8,
-    Extended16,
-    Extended32,
-}
-
-// it could be derived, sure, but I'd rather have an explicit implementation in case we had to change
-// something manually at some point
-#[allow(clippy::derivable_impls)]
-impl Default for DebugConfig {
-    fn default() -> Self {
-        DebugConfig {
-            traffic: Default::default(),
-            cover_traffic: Default::default(),
-            gateway_connection: Default::default(),
-            acknowledgements: Default::default(),
-            topology: Default::default(),
-            reply_surbs: Default::default(),
-        }
-    }
-}
-
 impl From<ExtendedPacketSize> for PacketSize {
    fn from(size: ExtendedPacketSize) -> PacketSize {
        match size {
@@ -1,198 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::config::{
-    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, ExtendedPacketSize,
-    GatewayConnection, Logging, ReplySurbs, Topology, Traffic, DEFAULT_ACK_WAIT_ADDITION,
-    DEFAULT_ACK_WAIT_MULTIPLIER, DEFAULT_AVERAGE_PACKET_DELAY, DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-    DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY, DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
-    DEFAULT_MAXIMUM_REPLY_KEY_AGE, DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-    DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD, DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
-    DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
-    DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD, DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
-    DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE, DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-    DEFAULT_TOPOLOGY_REFRESH_RATE, DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-};
-use nym_config::NymConfig;
-use serde::{Deserialize, Serialize};
-use std::marker::PhantomData;
-use std::time::Duration;
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct OldConfigV1_1_13<T> {
-    pub client: Client<T>,
-
-    #[serde(default)]
-    logging: Logging,
-    #[serde(default)]
-    debug: OldDebugConfigV1_1_13,
-}
-
-impl<T: NymConfig> Default for OldConfigV1_1_13<T> {
-    fn default() -> Self {
-        OldConfigV1_1_13 {
-            client: Client::<T>::default(),
-            logging: Default::default(),
-            debug: Default::default(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct OldDebugConfigV1_1_13 {
-    #[serde(with = "humantime_serde")]
-    pub average_packet_delay: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub average_ack_delay: Duration,
-
-    pub ack_wait_multiplier: f64,
-    #[serde(with = "humantime_serde")]
-    pub ack_wait_addition: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub loop_cover_traffic_average_delay: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub message_sending_average_delay: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub gateway_response_timeout: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub topology_refresh_rate: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub topology_resolution_timeout: Duration,
-
-    pub disable_loop_cover_traffic_stream: bool,
-
-    pub disable_main_poisson_packet_distribution: bool,
-
-    pub use_extended_packet_size: Option<ExtendedPacketSize>,
-
-    pub minimum_reply_surb_storage_threshold: usize,
-
-    pub maximum_reply_surb_storage_threshold: usize,
-
-    pub minimum_reply_surb_request_size: u32,
-
-    pub maximum_reply_surb_request_size: u32,
-
-    pub maximum_allowed_reply_surb_request_size: u32,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_rerequest_waiting_period: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_drop_waiting_period: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_surb_age: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub maximum_reply_key_age: Duration,
-}
-
-impl From<OldDebugConfigV1_1_13> for DebugConfig {
-    fn from(value: OldDebugConfigV1_1_13) -> Self {
-        DebugConfig {
-            traffic: Traffic {
-                average_packet_delay: value.average_packet_delay,
-                message_sending_average_delay: value.message_sending_average_delay,
-                disable_main_poisson_packet_distribution: value
-                    .disable_main_poisson_packet_distribution,
-                use_extended_packet_size: value.use_extended_packet_size,
-            },
-            cover_traffic: CoverTraffic {
-                loop_cover_traffic_average_delay: value.loop_cover_traffic_average_delay,
-                disable_loop_cover_traffic_stream: value.disable_loop_cover_traffic_stream,
-            },
-            gateway_connection: GatewayConnection {
-                gateway_response_timeout: value.gateway_response_timeout,
-            },
-            acknowledgements: Acknowledgements {
-                average_ack_delay: value.average_ack_delay,
-                ack_wait_multiplier: value.ack_wait_multiplier,
-                ack_wait_addition: value.ack_wait_addition,
-            },
-            topology: Topology {
-                topology_refresh_rate: value.topology_refresh_rate,
-                topology_resolution_timeout: value.topology_resolution_timeout,
-            },
-            reply_surbs: ReplySurbs {
-                minimum_reply_surb_storage_threshold: value.minimum_reply_surb_storage_threshold,
-                maximum_reply_surb_storage_threshold: value.maximum_reply_surb_storage_threshold,
-                minimum_reply_surb_request_size: value.minimum_reply_surb_request_size,
-                maximum_reply_surb_request_size: value.maximum_reply_surb_request_size,
-                maximum_allowed_reply_surb_request_size: value
-                    .maximum_allowed_reply_surb_request_size,
-                maximum_reply_surb_rerequest_waiting_period: value
-                    .maximum_reply_surb_rerequest_waiting_period,
-                maximum_reply_surb_drop_waiting_period: value
-                    .maximum_reply_surb_drop_waiting_period,
-                maximum_reply_surb_age: value.maximum_reply_surb_age,
-                maximum_reply_key_age: value.maximum_reply_key_age,
-            },
-        }
-    }
-}
-
-impl Default for OldDebugConfigV1_1_13 {
-    fn default() -> Self {
-        OldDebugConfigV1_1_13 {
-            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            average_ack_delay: DEFAULT_AVERAGE_PACKET_DELAY,
-            ack_wait_multiplier: DEFAULT_ACK_WAIT_MULTIPLIER,
-            ack_wait_addition: DEFAULT_ACK_WAIT_ADDITION,
-            loop_cover_traffic_average_delay: DEFAULT_LOOP_COVER_STREAM_AVERAGE_DELAY,
-            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
-            gateway_response_timeout: DEFAULT_GATEWAY_RESPONSE_TIMEOUT,
-            topology_refresh_rate: DEFAULT_TOPOLOGY_REFRESH_RATE,
-            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
-            disable_loop_cover_traffic_stream: false,
-            disable_main_poisson_packet_distribution: false,
-            use_extended_packet_size: None,
-            minimum_reply_surb_storage_threshold: DEFAULT_MINIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-            maximum_reply_surb_storage_threshold: DEFAULT_MAXIMUM_REPLY_SURB_STORAGE_THRESHOLD,
-            minimum_reply_surb_request_size: DEFAULT_MINIMUM_REPLY_SURB_REQUEST_SIZE,
-            maximum_reply_surb_request_size: DEFAULT_MAXIMUM_REPLY_SURB_REQUEST_SIZE,
-            maximum_allowed_reply_surb_request_size: DEFAULT_MAXIMUM_ALLOWED_SURB_REQUEST_SIZE,
-            maximum_reply_surb_rerequest_waiting_period:
-                DEFAULT_MAXIMUM_REPLY_SURB_REREQUEST_WAITING_PERIOD,
-            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
-            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
-            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
-        }
-    }
-}
-
-impl<T, U> From<OldConfigV1_1_13<T>> for Config<U> {
-    fn from(value: OldConfigV1_1_13<T>) -> Self {
-        Config {
-            client: Client {
-                version: value.client.version,
-                id: value.client.id,
-                disabled_credentials_mode: value.client.disabled_credentials_mode,
-                nyxd_urls: value.client.nyxd_urls,
-                nym_api_urls: value.client.nym_api_urls,
-                private_identity_key_file: value.client.private_identity_key_file,
-                public_identity_key_file: value.client.public_identity_key_file,
-                private_encryption_key_file: value.client.private_encryption_key_file,
-                public_encryption_key_file: value.client.public_encryption_key_file,
-                gateway_shared_key_file: value.client.gateway_shared_key_file,
-                ack_key_file: value.client.ack_key_file,
-                gateway_endpoint: value.client.gateway_endpoint,
-                database_path: value.client.database_path,
-                reply_surb_database_path: value.client.reply_surb_database_path,
-                nym_root_directory: value.client.nym_root_directory,
-
-                super_struct: PhantomData,
-            },
-            logging: value.logging,
-            debug: value.debug.into(),
-        }
-    }
-}
@@ -3,7 +3,6 @@

 use gateway_client::error::GatewayClientError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
-use nym_topology::gateway::GatewayConversionError;
 use nym_topology::NymTopologyError;
 use validator_client::ValidatorClientError;

@@ -54,32 +53,7 @@ pub enum ClientCoreError {
    GatewayOwnerUnknown,

    #[error("The address of the gateway is unknown - did you run init?")]
-    GatewayAddressUnknown,
-
-    #[error("The gateway is malformed: {source}")]
-    MalformedGateway {
-        #[from]
-        source: GatewayConversionError,
-    },
-
-    #[error("failed to establish connection to gateway: {source}")]
-    GatewayConnectionFailure {
-        #[from]
-        source: tungstenite::Error,
-    },
-
-    #[cfg(target_arch = "wasm32")]
-    #[error("failed to establish gateway connection (wasm)")]
-    GatewayJsConnectionFailure,
-
-    #[error("Gateway connection was abruptly closed")]
-    GatewayConnectionAbruptlyClosed,
-
-    #[error("Timed out while trying to establish gateway connection")]
-    GatewayConnectionTimeout,
-
-    #[error("No ping measurements for the gateway ({identity}) performed")]
-    NoGatewayMeasurements { identity: String },
+    GatwayAddressUnknown,

    #[error("failed to register receiver for reconstructed mixnet messages")]
    FailedToRegisterReceiver,
@@ -6,223 +6,52 @@ use crate::{
    config::{persistence::key_pathfinder::ClientKeyPathfinder, Config},
    error::ClientCoreError,
 };
-use futures::{SinkExt, StreamExt};
+#[cfg(target_arch = "wasm32")]
+use gateway_client::wasm_mockups::SigningNyxdClient;
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
-use log::{debug, info, trace, warn};
 use nym_config::NymConfig;
 use nym_crypto::asymmetric::identity;
 use nym_topology::{filter::VersionFilterable, gateway};
-use rand::{seq::SliceRandom, thread_rng, Rng};
+use rand::{seq::SliceRandom, thread_rng};
 use std::{sync::Arc, time::Duration};
 use tap::TapFallible;
-use tungstenite::Message;
 use url::Url;
-
-#[cfg(not(target_arch = "wasm32"))]
-use tokio::net::TcpStream;
-#[cfg(not(target_arch = "wasm32"))]
-use tokio::time::Instant;
-#[cfg(not(target_arch = "wasm32"))]
-use tokio_tungstenite::connect_async;
-#[cfg(not(target_arch = "wasm32"))]
-use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 #[cfg(not(target_arch = "wasm32"))]
 use validator_client::nyxd::SigningNyxdClient;

-#[cfg(not(target_arch = "wasm32"))]
-type WsConn = WebSocketStream<MaybeTlsStream<TcpStream>>;
-
-#[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::SigningNyxdClient;
-#[cfg(target_arch = "wasm32")]
-use wasm_timer::Instant;
-#[cfg(target_arch = "wasm32")]
-use wasm_utils::websocket::JSWebsocket;
-
-#[cfg(target_arch = "wasm32")]
-type WsConn = JSWebsocket;
-
-const MEASUREMENTS: usize = 3;
-
-#[cfg(not(target_arch = "wasm32"))]
-const CONN_TIMEOUT: Duration = Duration::from_millis(1500);
-const PING_TIMEOUT: Duration = Duration::from_millis(1000);
-
-struct GatewayWithLatency {
-    gateway: gateway::Node,
-    latency: Duration,
-}
-
-impl GatewayWithLatency {
-    fn new(gateway: gateway::Node, latency: Duration) -> Self {
-        GatewayWithLatency { gateway, latency }
-    }
-}
-
-async fn current_gateways<R: Rng>(
-    rng: &mut R,
-    nym_apis: Vec<Url>,
-) -> Result<Vec<gateway::Node>, ClientCoreError> {
-    let nym_api = nym_apis
-        .choose(rng)
+pub(super) async fn query_gateway_details(
+    validator_servers: Vec<Url>,
+    chosen_gateway_id: Option<identity::PublicKey>,
+) -> Result<gateway::Node, ClientCoreError> {
+    let nym_api = validator_servers
+        .choose(&mut thread_rng())
        .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-    let client = validator_client::client::NymApiClient::new(nym_api.clone());
+    let validator_client = validator_client::client::NymApiClient::new(nym_api.clone());

    log::trace!("Fetching list of gateways from: {}", nym_api);
-
-    let gateways = client.get_cached_gateways().await?;
+    let gateways = validator_client.get_cached_gateways().await?;
    let valid_gateways = gateways
        .into_iter()
        .filter_map(|gateway| gateway.try_into().ok())
        .collect::<Vec<gateway::Node>>();

-    // we were always filtering by version so I'm not removing that 'feature'
    let filtered_gateways = valid_gateways.filter_by_version(env!("CARGO_PKG_VERSION"));
-    Ok(filtered_gateways)
-}

-#[cfg(not(target_arch = "wasm32"))]
-async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
-    match tokio::time::timeout(CONN_TIMEOUT, connect_async(endpoint)).await {
-        Err(_elapsed) => Err(ClientCoreError::GatewayConnectionTimeout),
-        Ok(Err(conn_failure)) => Err(conn_failure.into()),
-        Ok(Ok((stream, _))) => Ok(stream),
-    }
-}
-
-#[cfg(target_arch = "wasm32")]
-async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
-    JSWebsocket::new(endpoint).map_err(|_| ClientCoreError::GatewayJsConnectionFailure)
-}
-
-async fn measure_latency(gateway: gateway::Node) -> Result<GatewayWithLatency, ClientCoreError> {
-    let addr = gateway.clients_address();
-    trace!(
-        "establishing connection to {} ({addr})...",
-        gateway.identity_key,
-    );
-    let mut stream = connect(&addr).await?;
-
-    let mut results = Vec::new();
-    for _ in 0..MEASUREMENTS {
-        let measurement_future = async {
-            let ping_content = vec![1, 2, 3];
-            let start = Instant::now();
-            stream.send(Message::Ping(ping_content.clone())).await?;
-
-            match stream.next().await {
-                Some(Ok(Message::Pong(content))) => {
-                    if content == ping_content {
-                        let elapsed = Instant::now().duration_since(start);
-                        trace!("current ping time: {elapsed:?}");
-                        results.push(elapsed);
-                    } else {
-                        warn!("received a pong message with different content? wtf.")
-                    }
-                }
-                Some(Ok(_)) => warn!("received a message that's not a pong!"),
-                Some(Err(err)) => return Err(err.into()),
-                None => return Err(ClientCoreError::GatewayConnectionAbruptlyClosed),
-            }
-
-            Ok::<(), ClientCoreError>(())
-        };
-
-        // thanks to wasm we can't use tokio::time::timeout : (
-        #[cfg(not(target_arch = "wasm32"))]
-        let timeout = tokio::time::sleep(PING_TIMEOUT);
-        #[cfg(not(target_arch = "wasm32"))]
-        tokio::pin!(timeout);
-
-        #[cfg(target_arch = "wasm32")]
-        let mut timeout = wasm_timer::Delay::new(PING_TIMEOUT);
-
-        tokio::select! {
-            _ = &mut timeout => {
-                warn!("timed out while trying to perform measurement...")
-            }
-            res = measurement_future => res?,
-        }
-    }
-
-    let count = results.len() as u64;
-    if count == 0 {
-        return Err(ClientCoreError::NoGatewayMeasurements {
-            identity: gateway.identity_key.to_base58_string(),
-        });
-    }
-
-    let sum: Duration = results.into_iter().sum();
-    let avg = Duration::from_nanos(sum.as_nanos() as u64 / count);
-
-    Ok(GatewayWithLatency::new(gateway, avg))
-}
-
-async fn choose_gateway_by_latency<R: Rng>(
-    rng: &mut R,
-    gateways: Vec<gateway::Node>,
-) -> Result<gateway::Node, ClientCoreError> {
-    info!("choosing gateway by latency...");
-
-    let mut gateways_with_latency = Vec::new();
-    for gateway in gateways {
-        let id = *gateway.identity();
-        trace!("measuring latency to {id}...");
-        let with_latency = match measure_latency(gateway).await {
-            Ok(res) => res,
-            Err(err) => {
-                warn!("failed to measure {id}: {err}");
-                continue;
-            }
-        };
-        debug!(
-            "{id} ({}): {:?}",
-            with_latency.gateway.location, with_latency.latency
-        );
-        gateways_with_latency.push(with_latency)
-    }
-
-    let chosen = gateways_with_latency
-        .choose_weighted(rng, |item| 1. / item.latency.as_secs_f32())
-        .expect("invalid selection weight!");
-
-    info!(
-        "chose gateway {} (located at {}) with average latency of {:?}",
-        chosen.gateway.identity_key, chosen.gateway.location, chosen.latency
-    );
-
-    Ok(chosen.gateway.clone())
-}
-
-fn uniformly_random_gateway<R: Rng>(
-    rng: &mut R,
-    gateways: Vec<gateway::Node>,
-) -> Result<gateway::Node, ClientCoreError> {
-    gateways
-        .choose(rng)
-        .ok_or(ClientCoreError::NoGatewaysOnNetwork)
-        .cloned()
-}
-
-pub(super) async fn query_gateway_details(
-    validator_servers: Vec<Url>,
-    chosen_gateway_id: Option<identity::PublicKey>,
-    by_latency: bool,
-) -> Result<gateway::Node, ClientCoreError> {
-    let mut rng = thread_rng();
-    let gateways = current_gateways(&mut rng, validator_servers).await?;
-
-    // if we set an explicit gateway, use that one and nothing else
-    if let Some(explicitly_chosen) = chosen_gateway_id {
-        gateways
-            .into_iter()
-            .find(|gateway| gateway.identity_key == explicitly_chosen)
-            .ok_or_else(|| ClientCoreError::NoGatewayWithId(explicitly_chosen.to_string()))
-    } else if by_latency {
-        choose_gateway_by_latency(&mut rng, gateways).await
+    // if we have chosen particular gateway - use it, otherwise choose a random one.
+    // (remember that in active topology all gateways have at least 100 reputation so should
+    // be working correctly)
+    if let Some(gateway_id) = chosen_gateway_id {
+        filtered_gateways
+            .iter()
+            .find(|gateway| gateway.identity_key == gateway_id)
+            .ok_or_else(|| ClientCoreError::NoGatewayWithId(gateway_id.to_string()))
+            .cloned()
    } else {
-        uniformly_random_gateway(&mut rng, gateways)
+        filtered_gateways
+            .choose(&mut rand::thread_rng())
+            .ok_or(ClientCoreError::NoGatewaysOnNetwork)
+            .cloned()
    }
 }

@@ -77,11 +77,9 @@ pub async fn register_with_gateway(
    key_manager: &mut KeyManager,
    nym_api_endpoints: Vec<Url>,
    chosen_gateway_id: Option<identity::PublicKey>,
-    by_latency: bool,
 ) -> Result<GatewayEndpointConfig, ClientCoreError> {
    // Get the gateway details of the gateway we will use
-    let gateway =
-        helpers::query_gateway_details(nym_api_endpoints, chosen_gateway_id, by_latency).await?;
+    let gateway = helpers::query_gateway_details(nym_api_endpoints, chosen_gateway_id).await?;
    log::debug!("Querying gateway gives: {}", gateway);

    let our_identity = key_manager.identity_keypair();
@@ -104,7 +102,6 @@ pub async fn setup_gateway_from_config<C, T>(
    register_gateway: bool,
    user_chosen_gateway_id: Option<identity::PublicKey>,
    config: &Config<T>,
-    by_latency: bool,
 ) -> Result<GatewayEndpointConfig, ClientCoreError>
 where
    C: NymConfig + ClientCoreConfigTrait,
@@ -112,20 +109,17 @@ where
 {
    let id = config.get_id();

-    // If we are not going to register gateway, and an explicitly chosen gateway is not passed in,
+    // If we are not going to register gateway, and an explicitly chosed gateway is not passed in,
    // load the existing configuration file
    if !register_gateway && user_chosen_gateway_id.is_none() {
        println!("Not registering gateway, will reuse existing config and keys");
        return load_existing_gateway_config::<C>(&id);
    }

-    // Else, we proceed by querying the nym-api
-    let gateway = helpers::query_gateway_details(
-        config.get_nym_api_endpoints(),
-        user_chosen_gateway_id,
-        by_latency,
-    )
-    .await?;
+    // Else, we preceed by querying the nym-api
+    let gateway =
+        helpers::query_gateway_details(config.get_nym_api_endpoints(), user_chosen_gateway_id)
+            .await?;
    log::debug!("Querying gateway gives: {}", gateway);

    // If we are not registering, just return this and assume the caller has the keys already and
@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-bip39 = { workspace = true }
+bip39 = "1.0.1"
 clap = { version = "4.0", features = ["cargo", "derive"] }
 log = "0.4"
 rand = "0.7.3"
@@ -15,10 +15,10 @@ thiserror = "1.0"
 url = "2.2"
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime

-nym-coconut-interface = { path = "../../common/coconut-interface" }
+coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
-nym-credentials = { path = "../../common/credentials" }
-nym-credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials" }
+credential-storage = { path = "../../common/credential-storage" }
 nym-crypto = { path = "../../common/crypto", features = ["rand", "asymmetric", "symmetric", "aes", "hashing"] }
 nym-bin-common = { path = "../../common/bin-common"}
 nym-network-defaults = { path = "../../common/network-defaults" }
@@ -7,11 +7,11 @@ use nym_bin_common::completions::ArgShell;
 use rand::rngs::OsRng;
 use std::str::FromStr;

-use nym_coconut_interface::{Base58, Parameters};
-use nym_credential_storage::storage::Storage;
-use nym_credential_storage::PersistentStorage;
-use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
-use nym_credentials::coconut::utils::obtain_aggregate_signature;
+use coconut_interface::{Base58, Parameters};
+use credential_storage::storage::Storage;
+use credential_storage::PersistentStorage;
+use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
+use credentials::coconut::utils::obtain_aggregate_signature;
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_network_defaults::VOUCHER_INFO;
 use validator_client::nyxd::traits::DkgQueryClient;
@@ -4,8 +4,8 @@
 use std::time::SystemTimeError;
 use thiserror::Error;

-use nym_credential_storage::error::StorageError;
-use nym_credentials::error::Error as CredentialError;
+use credential_storage::error::StorageError;
+use credentials::error::Error as CredentialError;
 use nym_crypto::asymmetric::encryption::KeyRecoveryError;
 use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use validator_client::nyxd::error::NyxdError;
@@ -11,7 +11,7 @@ use commands::*;
 use error::Result;
 use log::*;
 use nym_bin_common::completions::fig_generate;
-use nym_config::{CRED_DB_FILE_NAME, DATA_DIR};
+use nym_config::{DATA_DIR, DB_FILE_NAME};
 use nym_network_defaults::{setup_env, NymNetworkDetails};
 use std::process::exit;
 use std::time::{Duration, SystemTime};
@@ -51,11 +51,8 @@ async fn block_until_coconut_is_available<C: Clone + CosmWasmClient + Send + Syn

            break;
        } else {
-            // Use 1 additional second to not start the next iteration immediately and spam get_current_epoch queries
-            let secs_until_final = epoch
-                .final_timestamp_secs()
-                .saturating_sub(current_timestamp_secs)
-                + 1;
+            // Use 20 additional seconds to avoid the exact moment of going into the final epoch state
+            let secs_until_final = epoch.final_timestamp_secs() + 20 - current_timestamp_secs;
            info!("Approximately {} seconds until coconut is available. Sleeping until then. You can safely kill the process at any moment.", secs_until_final);
            std::thread::sleep(Duration::from_secs(secs_until_final));
        }
@@ -73,11 +70,8 @@ async fn main() -> Result<()> {

    match args.command {
        Command::Run(r) => {
-            let db_path = r
-                .client_home_directory
-                .join(DATA_DIR)
-                .join(CRED_DB_FILE_NAME);
-            let shared_storage = nym_credential_storage::initialise_storage(db_path).await;
+            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 recovery_storage = recovery_storage::RecoveryStorage::new(r.recovery_dir)?;

            let network_details = NymNetworkDetails::new_from_env();
@@ -1,7 +1,7 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use credentials::coconut::bandwidth::BandwidthVoucher;
 use std::fs::{create_dir_all, read_dir, File};
 use std::io::{Read, Write};
 use std::path::PathBuf;
@@ -1,8 +1,8 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_coconut_interface::Parameters;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use coconut_interface::Parameters;
+use credentials::coconut::bandwidth::BandwidthVoucher;

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

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.14"
+version = "1.1.10"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -36,10 +36,10 @@ tokio-tungstenite = "0.14" # websocket
 ## internal
 nym-bin-common = { path = "../../common/bin-common" }
 client-core = { path = "../client-core", features = ["fs-surb-storage"] }
-nym-coconut-interface = { path = "../../common/coconut-interface" }
+coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
-nym-credential-storage = { path = "../../common/credential-storage" }
-nym-credentials = { path = "../../common/credentials" }
+credential-storage = { path = "../../common/credential-storage" }
+credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
@@ -15,7 +15,6 @@ pub use client_core::config::Config as BaseConfig;
 pub use client_core::config::MISSING_VALUE;
 pub use client_core::config::{DebugConfig, GatewayEndpointConfig};

-pub mod old_config_v1_1_13;
 mod template;

 #[derive(Debug, Deserialize, PartialEq, Eq, Serialize, Clone, Copy)]
@@ -1,60 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::config::{Config, Socket};
-use client_core::config::old_config_v1_1_13::OldConfigV1_1_13 as OldBaseConfigV1_1_13;
-use nym_config::NymConfig;
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-
-#[derive(Debug, Default, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct OldConfigV1_1_13 {
-    #[serde(flatten)]
-    base: OldBaseConfigV1_1_13<OldConfigV1_1_13>,
-
-    socket: Socket,
-}
-
-impl NymConfig for OldConfigV1_1_13 {
-    fn template() -> &'static str {
-        // not intended to be used
-        unimplemented!()
-    }
-
-    fn default_root_directory() -> PathBuf {
-        dirs::home_dir()
-            .expect("Failed to evaluate $HOME value")
-            .join(".nym")
-            .join("clients")
-    }
-
-    fn try_default_root_directory() -> Option<PathBuf> {
-        dirs::home_dir().map(|path| path.join(".nym").join("clients"))
-    }
-
-    fn root_directory(&self) -> PathBuf {
-        self.base.client.nym_root_directory.clone()
-    }
-
-    fn config_directory(&self) -> PathBuf {
-        self.root_directory()
-            .join(&self.base.client.id)
-            .join("config")
-    }
-
-    fn data_directory(&self) -> PathBuf {
-        self.root_directory()
-            .join(&self.base.client.id)
-            .join("data")
-    }
-}
-
-impl From<OldConfigV1_1_13> for Config {
-    fn from(value: OldConfigV1_1_13) -> Self {
-        Config {
-            base: value.base.into(),
-            socket: value.socket,
-        }
-    }
-}
@@ -110,15 +110,10 @@ host = '{{ socket.host }}'

 [debug]

-[debug.traffic]
-average_packet_delay = '{{ debug.traffic.average_packet_delay }}'
-message_sending_average_delay = '{{ debug.traffic.message_sending_average_delay }}'
-
-[debug.acknowledgements]
-average_ack_delay = '{{ debug.acknowledgements.average_ack_delay }}'
-
-[debug.cover_traffic]
-loop_cover_traffic_average_delay = '{{ debug.cover_traffic.loop_cover_traffic_average_delay }}'
+average_packet_delay = '{{ debug.average_packet_delay }}'
+average_ack_delay = '{{ debug.average_ack_delay }}'
+loop_cover_traffic_average_delay = '{{ debug.loop_cover_traffic_average_delay }}'
+message_sending_average_delay = '{{ debug.message_sending_average_delay }}'

 "#
 }
@@ -74,7 +74,7 @@ impl SocketClient {
        let client = validator_client::Client::new_query(client_config)
            .expect("Could not construct query client");
        BandwidthController::new(
-            nym_credential_storage::initialise_storage(config.get_base().get_database_path()).await,
+            credential_storage::initialise_storage(config.get_base().get_database_path()).await,
            client,
        )
    }
@@ -101,7 +101,6 @@ impl SocketClient {
        let ClientState {
            shared_lane_queue_lengths,
            reply_controller_sender,
-            ..
        } = client_state;

        let websocket_handler = websocket::HandlerBuilder::new(
@@ -1,7 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
    client::config::Config,
    commands::{override_config, OverrideConfig},
@@ -26,11 +25,6 @@ pub(crate) struct Init {
    #[clap(long)]
    gateway: Option<identity::PublicKey>,

-    /// Specifies whether the new gateway should be determined based by latency as opposed to being chosen
-    /// uniformly.
-    #[clap(long, conflicts_with = "gateway")]
-    latency_based_selection: bool,
-
    /// Force register gateway. WARNING: this will overwrite any existing keys for the given id,
    /// potentially causing loss of access.
    #[clap(long)]
@@ -122,9 +116,6 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {

    let already_init = Config::default_config_file_path(id).exists();
    if already_init {
-        // in case we're using old config, try to upgrade it
-        // (if we're using the current version, it's a no-op)
-        try_upgrade_v1_1_13_config(id)?;
        println!("Client \"{id}\" was already initialised before");
    }

@@ -152,7 +143,6 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
        register_gateway,
        user_chosen_gateway_id,
        config.get_base(),
-        args.latency_based_selection,
    )
    .await
    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?;
@@ -1,15 +1,13 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::config::old_config_v1_1_13::OldConfigV1_1_13;
 use crate::client::config::{BaseConfig, Config};
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use lazy_static::lazy_static;
-use log::info;
 use nym_bin_common::build_information::BinaryBuildInformation;
 use nym_bin_common::completions::{fig_generate, ArgShell};
-use nym_config::{NymConfig, OptionalSet};
+use nym_config::OptionalSet;
 use std::error::Error;
 use std::net::IpAddr;

@@ -104,20 +102,6 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
        )
 }

-fn try_upgrade_v1_1_13_config(id: &str) -> std::io::Result<()> {
-    // explicitly load it as v1.1.13 (which is incompatible with the current, i.e. 1.1.14+)
-    let Ok(old_config) = OldConfigV1_1_13::load_from_file(id) else {
-        // if we failed to load it, there might have been nothing to upgrade
-        // or maybe it was an even older file. in either way. just ignore it and carry on with our day
-        return Ok(());
-    };
-    info!("It seems the client is using <= v1.1.13 config template.");
-    info!("It is going to get updated to the current specification.");
-
-    let updated: Config = old_config.into();
-    updated.save_to_file(None)
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -4,12 +4,12 @@
 use std::error::Error;
 use std::net::IpAddr;

-use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
    client::{config::Config, SocketClient},
    commands::{override_config, OverrideConfig},
    error::ClientError,
 };
+
 use clap::Args;
 use log::*;
 use nym_bin_common::version_checker::is_minor_version_compatible;
@@ -100,10 +100,6 @@ fn version_check(cfg: &Config) -> bool {
 pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn Error + Send + Sync>> {
    let id = &args.id;

-    // in case we're using old config, try to upgrade it
-    // (if we're using the current version, it's a no-op)
-    try_upgrade_v1_1_13_config(id)?;
-
    let mut config = match Config::load_from_file(id) {
        Ok(cfg) => cfg,
        Err(err) => {
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.14"
+version = "1.1.10"
 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"
@@ -29,26 +29,26 @@ url = "2.2"
 # internal
 nym-bin-common = { path = "../../common/bin-common" }
 client-core = { path = "../client-core", features = ["fs-surb-storage"] }
-nym-coconut-interface = { path = "../../common/coconut-interface" }
+coconut-interface = { path = "../../common/coconut-interface" }
 nym-config = { path = "../../common/config" }
-nym-credential-storage = { path = "../../common/credential-storage", optional = true }
+credential-storage = { path = "../../common/credential-storage", optional = true }
 mobile-storage = { path = "../../common/mobile-storage", optional = true }
-nym-credentials = { path = "../../common/credentials" }
+credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 nym-network-defaults = { path = "../../common/network-defaults" }
 nym-sphinx = { path = "../../common/nymsphinx" }
-nym-ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
+ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
 nym-pemstore = { path = "../../common/pemstore" }
-nym-socks5-proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
-nym-service-providers-common = { path = "../../service-providers/common" }
-nym-socks5-requests = { path = "../../common/socks5/requests" }
+proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
+service-providers-common = { path = "../../service-providers/common" }
+socks5-requests = { path = "../../common/socks5/requests" }
 nym-task = { path = "../../common/task" }
 nym-topology = { path = "../../common/topology" }
 validator-client = { path = "../../common/client-libs/validator-client", features = ["nyxd-client"] }

 [features]
-default = ["nym-credential-storage"]
+default = ["credential-storage"]
 eth = []
 mobile = ["mobile-storage", "gateway-client/mobile"]
@@ -7,15 +7,14 @@ pub use client_core::config::MISSING_VALUE;
 use client_core::config::{ClientCoreConfigTrait, DebugConfig};
 use nym_config::defaults::DEFAULT_SOCKS5_LISTENING_PORT;
 use nym_config::{NymConfig, OptionalSet};
-use nym_service_providers_common::interface::ProviderInterfaceVersion;
-use nym_socks5_requests::Socks5ProtocolVersion;
 use nym_sphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};
+use service_providers_common::interface::ProviderInterfaceVersion;
+use socks5_requests::Socks5ProtocolVersion;
 use std::fmt::Debug;
 use std::path::PathBuf;
 use std::str::FromStr;

-pub mod old_config_v1_1_13;
 mod template;

 const DEFAULT_CONNECTION_START_SURBS: u32 = 20;
@@ -1,66 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::config::{Config, Socks5, Socks5Debug};
-use client_core::config::old_config_v1_1_13::OldConfigV1_1_13 as OldBaseConfigV1_1_13;
-use nym_config::NymConfig;
-use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
-
-#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct OldConfigV1_1_13 {
-    #[serde(flatten)]
-    base: OldBaseConfigV1_1_13<OldConfigV1_1_13>,
-
-    socks5: Socks5,
-
-    #[serde(default)]
-    socks5_debug: Socks5Debug,
-}
-
-impl NymConfig for OldConfigV1_1_13 {
-    fn template() -> &'static str {
-        // not intended to be used
-        unimplemented!()
-    }
-
-    fn default_root_directory() -> PathBuf {
-        #[cfg(not(feature = "mobile"))]
-        let base_dir = dirs::home_dir().expect("Failed to evaluate $HOME value");
-        #[cfg(feature = "mobile")]
-        let base_dir = PathBuf::from("/tmp");
-
-        base_dir.join(".nym").join("socks5-clients")
-    }
-
-    fn try_default_root_directory() -> Option<PathBuf> {
-        dirs::home_dir().map(|path| path.join(".nym").join("socks5-clients"))
-    }
-
-    fn root_directory(&self) -> PathBuf {
-        self.base.client.nym_root_directory.clone()
-    }
-
-    fn config_directory(&self) -> PathBuf {
-        self.root_directory()
-            .join(&self.base.client.id)
-            .join("config")
-    }
-
-    fn data_directory(&self) -> PathBuf {
-        self.root_directory()
-            .join(&self.base.client.id)
-            .join("data")
-    }
-}
-
-impl From<OldConfigV1_1_13> for Config {
-    fn from(value: OldConfigV1_1_13) -> Self {
-        Config {
-            base: value.base.into(),
-            socks5: value.socks5,
-            socks5_debug: value.socks5_debug,
-        }
-    }
-}
@@ -114,15 +114,10 @@ send_anonymously = {{ socks5.send_anonymously }}

 [debug]

-[debug.traffic]
-average_packet_delay = '{{ debug.traffic.average_packet_delay }}'
-message_sending_average_delay = '{{ debug.traffic.message_sending_average_delay }}'
-
-[debug.acknowledgements]
-average_ack_delay = '{{ debug.acknowledgements.average_ack_delay }}'
-
-[debug.cover_traffic]
-loop_cover_traffic_average_delay = '{{ debug.cover_traffic.loop_cover_traffic_average_delay }}'
+average_packet_delay = '{{ debug.average_packet_delay }}'
+average_ack_delay = '{{ debug.average_ack_delay }}'
+loop_cover_traffic_average_delay = '{{ debug.loop_cover_traffic_average_delay }}'
+message_sending_average_delay = '{{ debug.message_sending_average_delay }}'

 "#
 }
@@ -92,7 +92,7 @@ impl NymClient {

        #[cfg(not(feature = "mobile"))]
        let storage =
-            nym_credential_storage::initialise_storage(config.get_base().get_database_path()).await;
+            credential_storage::initialise_storage(config.get_base().get_database_path()).await;

        #[cfg(feature = "mobile")]
        let storage = mobile_storage::PersistentStorage {};
@@ -123,7 +123,7 @@ impl NymClient {

        let ClientState {
            shared_lane_queue_lengths,
-            ..
+            reply_controller_sender: _,
        } = client_status;

        let authenticator = Authenticator::new(auth_methods, allowed_users);
@@ -1,7 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
    client::config::Config,
    commands::{override_config, OverrideConfig},
@@ -38,11 +37,6 @@ pub(crate) struct Init {
    #[clap(long)]
    gateway: Option<identity::PublicKey>,

-    /// Specifies whether the new gateway should be determined based by latency as opposed to being chosen
-    /// uniformly.
-    #[clap(long, conflicts_with = "gateway")]
-    latency_based_selection: bool,
-
    /// Force register gateway. WARNING: this will overwrite any existing keys for the given id,
    /// potentially causing loss of access.
    #[clap(long)]
@@ -125,9 +119,6 @@ pub(crate) async fn execute(args: &Init) -> Result<(), Socks5ClientError> {

    let already_init = Config::default_config_file_path(id).exists();
    if already_init {
-        // in case we're using old config, try to upgrade it
-        // (if we're using the current version, it's a no-op)
-        try_upgrade_v1_1_13_config(id)?;
        println!("SOCKS5 client \"{id}\" was already initialised before");
    }

@@ -158,7 +149,6 @@ pub(crate) async fn execute(args: &Init) -> Result<(), Socks5ClientError> {
        register_gateway,
        user_chosen_gateway_id,
        config.get_base(),
-        args.latency_based_selection,
    )
    .await
    .tap_err(|err| eprintln!("Failed to setup gateway\nError: {err}"))?;
@@ -1,15 +1,13 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::config::old_config_v1_1_13::OldConfigV1_1_13;
 use crate::client::config::{BaseConfig, Config};
 use clap::CommandFactory;
 use clap::{Parser, Subcommand};
 use lazy_static::lazy_static;
-use log::info;
 use nym_bin_common::build_information::BinaryBuildInformation;
 use nym_bin_common::completions::{fig_generate, ArgShell};
-use nym_config::{NymConfig, OptionalSet};
+use nym_config::OptionalSet;
 use std::error::Error;

 pub mod init;
@@ -103,20 +101,6 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
        )
 }

-fn try_upgrade_v1_1_13_config(id: &str) -> std::io::Result<()> {
-    // explicitly load it as v1.1.13 (which is incompatible with the current, i.e. 1.1.14+)
-    let Ok(old_config) = OldConfigV1_1_13::load_from_file(id) else {
-        // if we failed to load it, there might have been nothing to upgrade
-        // or maybe it was an even older file. in either way. just ignore it and carry on with our day
-        return Ok(());
-    };
-    info!("It seems the client is using <= v1.1.13 config template.");
-    info!("It is going to get updated to the current specification.");
-
-    let updated: Config = old_config.into();
-    updated.save_to_file(None)
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -1,12 +1,12 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::commands::try_upgrade_v1_1_13_config;
 use crate::{
    client::{config::Config, NymClient},
    commands::{override_config, OverrideConfig},
    error::Socks5ClientError,
 };
+
 use clap::Args;
 use log::*;
 use nym_bin_common::version_checker::is_minor_version_compatible;
@@ -108,10 +108,6 @@ fn version_check(cfg: &Config) -> bool {
 pub(crate) async fn execute(args: &Run) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let id = &args.id;

-    // in case we're using old config, try to upgrade it
-    // (if we're using the current version, it's a no-op)
-    try_upgrade_v1_1_13_config(id)?;
-
    let mut config = match Config::load_from_file(id) {
        Ok(cfg) => cfg,
        Err(err) => {
@@ -1,6 +1,6 @@
 use crate::socks::types::SocksProxyError;
 use client_core::error::ClientCoreError;
-use nym_socks5_requests::{ConnectionError, ConnectionId};
+use socks5_requests::{ConnectionError, ConnectionId};

 #[derive(thiserror::Error, Debug)]
 pub enum Socks5ClientError {
@@ -8,19 +8,19 @@ use client_core::client::inbound_messages::{InputMessage, InputMessageSender};
 use futures::channel::mpsc;
 use futures::task::{Context, Poll};
 use log::*;
-use nym_service_providers_common::interface::{ProviderInterfaceVersion, RequestVersion};
-use nym_socks5_proxy_helpers::connection_controller::{
-    ConnectionReceiver, ControllerCommand, ControllerSender,
-};
-use nym_socks5_proxy_helpers::proxy_runner::ProxyRunner;
-use nym_socks5_requests::{
-    ConnectionId, RemoteAddress, Socks5ProtocolVersion, Socks5ProviderRequest, Socks5Request,
-};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_task::connections::{LaneQueueLengths, TransmissionLane};
 use nym_task::TaskClient;
 use pin_project::pin_project;
+use proxy_helpers::connection_controller::{
+    ConnectionReceiver, ControllerCommand, ControllerSender,
+};
+use proxy_helpers::proxy_runner::ProxyRunner;
 use rand::RngCore;
+use service_providers_common::interface::{ProviderInterfaceVersion, RequestVersion};
+use socks5_requests::{
+    ConnectionId, RemoteAddress, Socks5ProtocolVersion, Socks5ProviderRequest, Socks5Request,
+};
 use std::io;
 use std::net::SocketAddr;
 use std::pin::Pin;
@@ -4,11 +4,11 @@ use log::*;

 use client_core::client::received_buffer::ReconstructedMessagesReceiver;
 use client_core::client::received_buffer::{ReceivedBufferMessage, ReceivedBufferRequestSender};
-use nym_service_providers_common::interface::{ControlResponse, ResponseContent};
-use nym_socks5_proxy_helpers::connection_controller::ControllerSender;
-use nym_socks5_requests::{Socks5ProviderResponse, Socks5Response, Socks5ResponseContent};
 use nym_sphinx::receiver::ReconstructedMessage;
 use nym_task::TaskClient;
+use proxy_helpers::connection_controller::ControllerSender;
+use service_providers_common::interface::{ControlResponse, ResponseContent};
+use socks5_requests::{Socks5ProviderResponse, Socks5Response, Socks5ResponseContent};

 use crate::error::Socks5ClientError;

@@ -8,10 +8,10 @@ use client_core::client::{
    inbound_messages::InputMessageSender, received_buffer::ReceivedBufferRequestSender,
 };
 use log::*;
-use nym_socks5_proxy_helpers::connection_controller::Controller;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_task::connections::{ConnectionCommandSender, LaneQueueLengths};
 use nym_task::TaskClient;
+use proxy_helpers::connection_controller::Controller;
 use std::net::SocketAddr;
 use tap::TapFallible;
 use tokio::net::TcpListener;
@@ -1,4 +1,4 @@
-use nym_socks5_requests::Socks5RequestError;
+use socks5_requests::Socks5RequestError;
 use std::string::FromUtf8Error;
 use thiserror::Error;

@@ -1,71 +1,83 @@
 {
-  "root": true,
-  "env": {
-    "browser": true,
-    "es6": true,
-    "node": true
-  },
-  "parserOptions": {
-    "ecmaVersion": 2019,
-    "sourceType": "module"
-  },
-  "globals": {
-    "Atomics": "readonly",
-    "SharedArrayBuffer": "readonly"
-  },
-  "plugins": ["prettier", "mocha"],
-  "extends": ["airbnb-base", "airbnb-typescript/base", "prettier"],
-  "rules": {
-    "prettier/prettier": "error",
-    "import/prefer-default-export": "off",
-    "import/no-extraneous-dependencies": [
-      "error",
-      {
-        "devDependencies": ["**/*.test.[jt]s", "**/*.spec.[jt]s"]
-      }
-    ],
-    "import/extensions": [
-      "error",
-      "ignorePackages",
-      {
-        "ts": "never",
-        "js": "never"
-      }
-    ]
-  },
-  "overrides": [
-    {
-      "files": "**/*.ts",
-      "parser": "@typescript-eslint/parser",
-      "parserOptions": {
-        "project": "./tsconfig.json"
-      },
-      "plugins": ["@typescript-eslint/eslint-plugin"],
-      "extends": ["plugin:@typescript-eslint/eslint-recommended", "plugin:@typescript-eslint/recommended", "prettier"],
-      "rules": {
-        "@typescript-eslint/explicit-function-return-type": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "@typescript-eslint/no-var-requires": "off",
-        "no-use-before-define": [0],
-        "@typescript-eslint/no-use-before-define": [1],
-        "import/no-unresolved": 0,
+    "root": true,
+    "env": {
+        "browser": true,
+        "es6": true,
+        "node": true
+    },
+    "parserOptions": {
+        "ecmaVersion": 2019,
+        "sourceType": "module"
+    },
+    "globals": {
+        "Atomics": "readonly",
+        "SharedArrayBuffer": "readonly"
+    },
+    "plugins": ["prettier", "mocha"],
+    "extends": [
+        "airbnb-base",
+        "airbnb-typescript/base",
+        "prettier"],
+    "rules": {
+        "prettier/prettier": "error",
+        "import/prefer-default-export": "off",
        "import/no-extraneous-dependencies": [
-          "error",
-          {
-            "devDependencies": ["**/*.test.ts", "**/*.spec.ts"]
-          }
+            "error",
+            {
+                "devDependencies": [
+                    "**/*.test.[jt]s",
+                    "**/*.spec.[jt]s"
+                ]
+            }
        ],
-        "quotes": "off",
-        "@typescript-eslint/quotes": [
-          2,
-          "single",
-          {
-            "avoidEscape": true
-          }
-        ],
-        "@typescript-eslint/no-unused-vars": [2, { "argsIgnorePattern": "^_" }]
-      }
-    }
-  ],
-  "ignorePatterns": ["tsconfig.json", "*.d.ts", "dist/**/*", "dist", "node_modules"]
+        "import/extensions": [
+            "error",
+            "ignorePackages",
+            {
+                "ts": "never",
+                "js": "never"
+            }
+        ]
+    },
+    "overrides": [
+        {
+            "files": "**/*.ts",
+            "parser": "@typescript-eslint/parser",
+            "parserOptions": {
+                "project": "./tsconfig.json"
+            },
+            "plugins": ["@typescript-eslint/eslint-plugin"],
+            "extends": [
+                "plugin:@typescript-eslint/eslint-recommended",
+                "plugin:@typescript-eslint/recommended",
+                "prettier"
+            ],
+            "rules": {
+                "@typescript-eslint/explicit-function-return-type": "off",
+                "@typescript-eslint/no-explicit-any": "off",
+                "@typescript-eslint/no-var-requires": "off",
+                "no-use-before-define": [0],
+                "@typescript-eslint/no-use-before-define": [1],
+                "import/no-unresolved": 0,
+                "import/no-extraneous-dependencies": [
+                    "error",
+                    {
+                        "devDependencies": [
+                            "**/*.test.ts",
+                            "**/*.spec.ts"
+                        ]
+                    }
+                ],
+                "quotes": "off",
+                "@typescript-eslint/quotes": [
+                    2,
+                    "single",
+                    {
+                        "avoidEscape": true
+                    }
+                ],
+                "@typescript-eslint/no-unused-vars": [2, { "argsIgnorePattern": "^_" }]
+            }
+        }
+    ]
 }
@@ -4,5 +4,4 @@ coverage
 dist
 docs
 examples/accounts
-node_modules
-.env
+node_modules
@@ -1,5 +1,3 @@
 coverage
 node_modules
-tests
-src
-type
+tests
@@ -1,39 +1,40 @@
-# Nym Validator Client (Typescript)
+Nym Validator Client
+====================

-A TypeScript client for interacting with CosmWasm smart contracts in Nym validators.
+A TypeScript client for interacting with CosmWasm smart contracts in Nym validators. 

-Include the Nym Validator in your project:
+Running examples
+-----------------
+
+With the code checked out, `cd examples`. This folder contains runnable example code that will set up a blockchain and allow you to interact with it through the client. 
+
+Running tests
+-------------

 ```
-yarn add @nymproject/nym-validator-client
+npm test
 ```

-Connect to validator and make queries
+You can also trigger test execution with a test watcher. I don't have the centuries of life left to me that are needed to fight through the arcana of wiring up a working TypeScript mocha triggered execution setup, so for now my Cargo-based hack is:
+

 ```
-import Validator from '@nymproject/nym-validator-client'
-
-const main = async () => {
-
- const client = await Validator.connectForQuery(rpcAddress, validatorAddress, prefix, mixnetContractAddress, vestingContractAddress, denom)
-
- client.getBalance(address)
-
-}
-
+cargo watch -s "cd clients/validator && npm test"
 ```

-Connect to validator for performing actions
+It's ugly but works fine if you have Cargo installed. TypeScript setup help happily accepted here. 

-```
-import Validator from '@nymproject/nym-validator-client'
+Generating Documentation
+------------------------

-const main = async () => {
+You can generate docs by running `npm run docs`. Generated output will appear in the `docs` directory. 

- const client = await Validator.connect(mnemonic, rpcAddress, validatorAddress, prefix, mixnetContractAddress, vestingContractAddress, denom)
+Packaging
+------------------------

- const res = await client.send(address, [{ amount: '10000000', denom: 'unym' }]);
+If you're a Nym platform developer who's made changes to the client and wants to re-publish the package to NPM, here's how you do it: 

-}
-
-```
+1. Bump the version number (use SemVer)
+1. `npm run build`
+1. `npm login` (if you haven't already)
+1. `npm publish`
@@ -4,23 +4,15 @@
  "description": "A TypeScript client for interacting with smart contracts in Nym validators",
  "repository": "https://github.com/nymtech/nym",
  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "types": "dist/index.d.ts",
  "scripts": {
-    "build": "rollup -c ./rollup.config.mjs",
-    "build:types": "rollup-type-bundler --dist ./dist/nym-validator-client",
-    "build:prod": "sh ./scripts/build-prod.sh",
-    "test": "ts-mocha -p ./tsconfig.test.json ./src/tests/**/*.test.ts",
-    "testmock": "ts-mocha -p ./tsconfig.test.json ./src/tests/mock/*.test.ts",
+    "build": "tsc",
+    "test": "ts-mocha tests/**/*.test.ts",
    "coverage": "nyc npm test",
-    "clean": "rm -rf ./dist",
-    "lint": "eslint",
-    "lint:fix": "eslint --fix",
-    "lint:tsc": "tsc --noEmit",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
    "docs": "typedoc --out docs src/index.ts"
  },
-  "files": [
-    "./dist/*"
-  ],
  "keywords": [],
  "author": "Nym Technologies SA (https://nymtech.net)",
  "contributors": [
@@ -29,14 +21,6 @@
  ],
  "license": "Apache-2.0",
  "devDependencies": {
-    "@favware/rollup-type-bundler": "^2.0.0",
-    "@nymproject/types": "^1.0.0",
-    "@rollup/plugin-commonjs": "^24.0.1",
-    "@rollup/plugin-json": "^6.0.0",
-    "@rollup/plugin-typescript": "^11.0.0",
-    "@rollup/plugin-node-resolve": "^15.0.1",
-    "rollup": "^3.17.2",
-    "rollup-plugin-dts": "^5.2.0",
    "@typescript-eslint/eslint-plugin": "^5.7.0",
    "@typescript-eslint/parser": "^5.7.0",
    "eslint": "^7.18.0",
@@ -47,21 +31,21 @@
    "eslint-plugin-import": "^2.25.4",
    "eslint-plugin-mocha": "^10.0.3",
    "eslint-plugin-prettier": "^4.0.0",
+    "expect": "^28.1.3",
    "mocha": "^10.0.0",
    "prettier": "^2.5.1",
-    "ts-mocha": "^10.0.0",
    "typedoc": "^0.22.13",
-    "typescript": "^4.6.2",
-    "cosmjs-types": "^0.4.1",
-    "dotenv": "^16.0.3",
-    "expect": "^28.1.3",
-    "moq.ts": "^7.3.4",
-    "@cosmjs/cosmwasm-stargate": "^0.29.5",
-    "@cosmjs/crypto": "^0.29.5",
-    "@cosmjs/math": "^0.29.5",
-    "@cosmjs/proto-signing": "^0.29.5",
-    "@cosmjs/stargate": "^0.29.5",
-    "@cosmjs/tendermint-rpc": "^0.29.5",
-    "axios": "^1.3.3"
+    "ts-mocha": "^10.0.0",
+    "typescript": "^4.6.2"
+  },
+  "dependencies": {
+    "@cosmjs/cosmwasm-stargate": "^0.28.0",
+    "@cosmjs/crypto": "^0.28.0",
+    "@cosmjs/math": "^0.28.0",
+    "@cosmjs/proto-signing": "^0.28.0",
+    "@cosmjs/stargate": "^0.28.0",
+    "@cosmjs/tendermint-rpc": "^0.28.0",
+    "axios": "^0.26.1",
+    "cosmjs-types": "^0.4.1"
  }
 }
@@ -1,15 +0,0 @@
-import typescript from '@rollup/plugin-typescript';
-import resolve from '@rollup/plugin-node-resolve';
-import json from '@rollup/plugin-json';
-import commonjs from '@rollup/plugin-commonjs';
-
-export default [
-  {
-    input: './src/index.ts',
-    output: {
-      dir: 'dist/nym-validator-client',
-      format: 'cjs',
-    },
-    plugins: [resolve(), typescript(), commonjs(), json()],
-  },
-];
@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-
-set -o errexit
-set -o nounset
-
-rm -rf ./dist || true
-rm -rf ../../dist || true
-
-
-# Bundle application
-
-yarn build
-
-# Bundle types
-
-yarn build:types
-
-# Build package.json for bundle
-
-node ./scripts/buildPackageJson.mjs
-
-# Copy README
-
-cp README.md dist/nym-validator-client
-
-# move the output outside of the yarn/npm workspaces
-
-mv ./dist ../../
-
-echo "Output can be found in:"
-realpath ../../dist
@@ -1,20 +0,0 @@
-import * as fs from 'fs';
-
-// parse the package.json from the SDK, so we can keep fields like the name and version
-const json = JSON.parse(fs.readFileSync('./package.json').toString());
-
-// defaults (NB: these are in the output file locations)
-const main = 'index.js';
-const types = 'index.d.ts';
-
-// make a package.json for the bundle
-const packageJson = {
-  name: json.name,
-  version: json.version,
-  license: json.license,
-  author: json.author,
-  main,
-  types,
-};
-
-fs.writeFileSync('./dist/nym-validator-client/package.json', JSON.stringify(packageJson, null, 2));
@@ -1,6 +1,5 @@
 import { Decimal } from '@cosmjs/math';
 import { Coin } from '@cosmjs/stargate';
-import { CoinMap } from './types/shared';

 // NARROW NO-BREAK SPACE (U+202F)
 const thinSpace = '\u202F';
@@ -35,6 +34,15 @@ export function nativeToPrintable(nativeValue: string): string {
  return Decimal.fromAtomics(nativeValue, 6).toString();
 }

+export interface MappedCoin {
+  readonly denom: string;
+  readonly fractionalDigits: number;
+}
+
+export interface CoinMap {
+  readonly [key: string]: MappedCoin;
+}
+
 export function nativeCoinToDisplay(coin: Coin, coinMap: CoinMap): Coin {
  if (!coinMap) return coin;

@@ -1,3 +1,6 @@
+import { Bip39, Random } from '@cosmjs/crypto';
+import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing';
+import { coin as cosmosCoin, Coin, DeliverTxResponse, isDeliverTxFailure, StdFee } from '@cosmjs/stargate';
 import {
  ExecuteResult,
  InstantiateOptions,
@@ -5,37 +8,45 @@ import {
  MigrateResult,
  UploadResult,
 } from '@cosmjs/cosmwasm-stargate';
-import { Bip39, Random } from '@cosmjs/crypto';
-import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing';
-import { Coin, coin as cosmosCoin, DeliverTxResponse, isDeliverTxFailure, StdFee } from '@cosmjs/stargate';
+import SigningClient, { ISigningClient } from './signing-client';
 import {
  ContractStateParams,
  Delegation,
  Gateway,
  GatewayBond,
-  GatewayOwnershipResponse,
-  LayerDistribution,
  MixnetContractVersion,
  MixNode,
  MixNodeBond,
-  MixNodeCostParams,
-  MixNodeDetails,
-  MixNodeRewarding,
-  MixOwnershipResponse,
  PagedAllDelegationsResponse,
  PagedDelegatorDelegationsResponse,
  PagedGatewayResponse,
  PagedMixDelegationsResponse,
-  PagedMixNodeBondResponse,
-  PagedMixNodeDetailsResponse,
-  PagedUnbondedMixnodesResponse,
-  RewardingParams,
-  StakeSaturationResponse,
-  UnbondedMixnodeResponse,
-} from '@nymproject/types';
+  PagedMixnodeResponse,
+} from './types';
+import {
+  CoinMap,
+  displayAmountToNative,
+  MappedCoin,
+  nativeCoinToDisplay,
+  nativeToPrintable,
+  printableBalance,
+  printableCoin,
+} from './currency';
 import QueryClient from './query-client';
-import SigningClient, { ISigningClient } from './signing-client';
-import { ContractState } from './types/shared';
+import { nymGasPrice } from './stargate-helper';
+
+export { coins, coin } from '@cosmjs/stargate';
+export { Coin };
+export {
+  displayAmountToNative,
+  nativeCoinToDisplay,
+  printableCoin,
+  printableBalance,
+  nativeToPrintable,
+  MappedCoin,
+  CoinMap,
+};
+export { nymGasPrice };

 export interface INymClient {
  readonly mixnetContract: string;
@@ -136,7 +147,7 @@ export default class ValidatorClient implements INymClient {
    return DirectSecp256k1HdWallet.fromMnemonic(mnemonic, signerOptions);
  }

-  async getBalance(address: string): Promise<Coin> {
+  getBalance(address: string): Promise<Coin> {
    return this.client.getBalance(address, this.denom);
  }

@@ -148,39 +159,15 @@ export default class ValidatorClient implements INymClient {
    return this.client.getCachedMixnodes();
  }

-  async getStakeSaturation(mixId: number): Promise<StakeSaturationResponse> {
-    return this.client.getStakeSaturation(this.mixnetContract, mixId);
-  }
-
-  async getActiveMixnodes(): Promise<MixNodeDetails[]> {
+  async getActiveMixnodes(): Promise<MixNodeBond[]> {
    return this.client.getActiveMixnodes();
  }

-  async getUnbondedMixNodeInformation(mixId: number): Promise<UnbondedMixnodeResponse> {
-    return this.client.getUnbondedMixNodeInformation(this.mixnetContract, mixId);
-  }
-
  async getRewardedMixnodes(): Promise<MixNodeBond[]> {
    return this.client.getRewardedMixnodes();
  }

-  async getMixnodeRewardingDetails(mixId: number): Promise<MixNodeRewarding> {
-    return this.client.getMixnodeRewardingDetails(this.mixnetContract, mixId);
-  }
-
-  async getOwnedMixnode(address: string): Promise<MixOwnershipResponse> {
-    return this.client.getOwnedMixnode(this.mixnetContract, address);
-  }
-
-  async ownsGateway(address: string): Promise<GatewayOwnershipResponse> {
-    return this.client.ownsGateway(this.mixnetContract, address);
-  }
-
-  async getLayerDistribution(): Promise<LayerDistribution> {
-    return this.client.getLayerDistribution(this.mixnetContract);
-  }
-
-  public async getMixnetContractSettings(): Promise<ContractState> {
+  public async getMixnetContractSettings(): Promise<ContractStateParams> {
    return this.client.getStateParams(this.mixnetContract);
  }

@@ -188,74 +175,29 @@ export default class ValidatorClient implements INymClient {
    return this.client.getContractVersion(this.mixnetContract);
  }

-  public async getVestingContractVersion(): Promise<MixnetContractVersion> {
-    return this.client.getContractVersion(this.vestingContract);
+  public async getRewardPool(): Promise<string> {
+    return this.client.getRewardPool(this.mixnetContract);
  }

-  public async getSpendableCoins(vestingAccountAddress: string): Promise<MixnetContractVersion> {
-    return this.client.getSpendableCoins(this.vestingContract, vestingAccountAddress);
+  public async getCirculatingSupply(): Promise<string> {
+    return this.client.getCirculatingSupply(this.mixnetContract);
  }

-  public async getRewardParams(): Promise<RewardingParams> {
-    return this.client.getRewardParams(this.mixnetContract);
+  public async getSybilResistancePercent(): Promise<number> {
+    return this.client.getSybilResistancePercent(this.mixnetContract);
  }

-  async getUnbondedMixNodes(): Promise<UnbondedMixnodeResponse[]> {
-    let mixNodes: UnbondedMixnodeResponse[] = [];
-    const limit = 50;
-    let startAfter;
-    for (;;) {
-      // eslint-disable-next-line no-await-in-loop
-      const pagedResponse: PagedUnbondedMixnodesResponse = await this.client.getUnbondedMixNodes(
-        this.mixnetContract,
-        limit,
-        startAfter,
-      );
-
-      mixNodes = mixNodes.concat(pagedResponse.nodes);
-      startAfter = pagedResponse.start_next_after;
-      // if `start_next_after` is not set, we're done
-      if (!startAfter) {
-        break;
-      }
-    }
-
-    return mixNodes;
+  public async getIntervalRewardPercent(): Promise<number> {
+    return this.client.getIntervalRewardPercent(this.mixnetContract);
  }

-  public async getMixNodeBonds(): Promise<MixNodeBond[]> {
+  public async getAllNyxdMixnodes(): Promise<MixNodeBond[]> {
    let mixNodes: MixNodeBond[] = [];
    const limit = 50;
    let startAfter;
-    for (;;) {
+    for (; ;) {
      // eslint-disable-next-line no-await-in-loop
-      const pagedResponse: PagedMixNodeBondResponse = await this.client.getMixNodeBonds(
-        this.mixnetContract,
-        limit,
-        startAfter,
-      );
-      mixNodes = mixNodes.concat(pagedResponse.nodes);
-      startAfter = pagedResponse.start_next_after;
-      // if `start_next_after` is not set, we're done
-      if (!startAfter) {
-        break;
-      }
-    }
-
-    return mixNodes;
-  }
-
-  public async getMixNodesDetailed(): Promise<MixNodeDetails[]> {
-    let mixNodes: MixNodeDetails[] = [];
-    const limit = 50;
-    let startAfter;
-    for (;;) {
-      // eslint-disable-next-line no-await-in-loop
-      const pagedResponse: PagedMixNodeDetailsResponse = await this.client.getMixNodesDetailed(
-        this.mixnetContract,
-        limit,
-        startAfter,
-      );
+      const pagedResponse: PagedMixnodeResponse = await this.client.getMixNodesPaged(this.mixnetContract, limit);
      mixNodes = mixNodes.concat(pagedResponse.nodes);
      startAfter = pagedResponse.start_next_after;
      // if `start_next_after` is not set, we're done
@@ -268,24 +210,37 @@ export default class ValidatorClient implements INymClient {
  }

  public async getAllNyxdGateways(): Promise<GatewayBond[]> {
-    const pagedResponse: PagedGatewayResponse = await this.client.getGatewaysPaged(this.mixnetContract);
-    return pagedResponse.nodes;
+    let gateways: GatewayBond[] = [];
+    const limit = 50;
+    let startAfter;
+    for (; ;) {
+      // eslint-disable-next-line no-await-in-loop
+      const pagedResponse: PagedGatewayResponse = await this.client.getGatewaysPaged(this.mixnetContract, limit);
+      gateways = gateways.concat(pagedResponse.nodes);
+      startAfter = pagedResponse.start_next_after;
+      // if `start_next_after` is not set, we're done
+      if (!startAfter) {
+        break;
+      }
+    }
+
+    return gateways;
  }

  /**
   * Gets list of all delegations towards particular mixnode.
   *
-   * @param mix_id identity of the node to which the delegation was sent
+   * @param mixIdentity identity of the node to which the delegation was sent
   */
-  public async getAllNyxdSingleMixnodeDelegations(mix_id: number): Promise<Delegation[]> {
+  public async getAllNyxdSingleMixnodeDelegations(mixIdentity: string): Promise<Delegation[]> {
    let delegations: Delegation[] = [];
    const limit = 250;
    let startAfter;
-    for (;;) {
+    for (; ;) {
      // eslint-disable-next-line no-await-in-loop
      const pagedResponse: PagedMixDelegationsResponse = await this.client.getMixNodeDelegationsPaged(
        this.mixnetContract,
-        mix_id,
+        mixIdentity,
        limit,
        startAfter,
      );
@@ -304,7 +259,7 @@ export default class ValidatorClient implements INymClient {
    let delegations: Delegation[] = [];
    const limit = 250;
    let startAfter;
-    for (;;) {
+    for (; ;) {
      // eslint-disable-next-line no-await-in-loop
      const pagedResponse: PagedDelegatorDelegationsResponse = await this.client.getDelegatorDelegationsPaged(
        this.mixnetContract,
@@ -323,13 +278,13 @@ export default class ValidatorClient implements INymClient {
    return delegations;
  }

-  public async getAllNyxdDelegations(): Promise<Delegation[]> {
+  public async getAllNyxdNetworkDelegations(): Promise<Delegation[]> {
    let delegations: Delegation[] = [];
    const limit = 250;
    let startAfter;
-    for (;;) {
+    for (; ;) {
      // eslint-disable-next-line no-await-in-loop
-      const pagedResponse: PagedAllDelegationsResponse = await this.client.getAllDelegationsPaged(
+      const pagedResponse: PagedAllDelegationsResponse = await this.client.getAllNetworkDelegationsPaged(
        this.mixnetContract,
        limit,
        startAfter,
@@ -345,10 +300,6 @@ export default class ValidatorClient implements INymClient {
    return delegations;
  }

-  public async getDelegationDetails(mix_id: number, delegator: string): Promise<Delegation> {
-    return this.client.getDelegationDetails(this.mixnetContract, mix_id, delegator);
-  }
-
  /**
   * Generate a minimum gateway bond required to create a fresh mixnode.
   *
@@ -357,7 +308,7 @@ export default class ValidatorClient implements INymClient {
  public async minimumMixnodePledge(): Promise<Coin> {
    const stateParams = await this.getMixnetContractSettings();
    // we trust the contract to return a valid number
-    return cosmosCoin(stateParams.params.minimum_mixnode_pledge, this.prefix);
+    return cosmosCoin(stateParams.minimum_mixnode_pledge, this.prefix);
  }

  /**
@@ -368,7 +319,7 @@ export default class ValidatorClient implements INymClient {
  public async minimumGatewayPledge(): Promise<Coin> {
    const stateParams = await this.getMixnetContractSettings();
    // we trust the contract to return a valid number
-    return cosmosCoin(stateParams.params.minimum_gateway_pledge, this.prefix);
+    return cosmosCoin(stateParams.minimum_gateway_pledge, this.prefix);
  }

  public async send(
@@ -442,21 +393,12 @@ export default class ValidatorClient implements INymClient {
  public async bondMixNode(
    mixNode: MixNode,
    ownerSignature: string,
-    costParams: MixNodeCostParams,
    pledge: Coin,
    fee?: StdFee | 'auto' | number,
    memo?: string,
  ): Promise<ExecuteResult> {
    this.assertSigning();
-    return (this.client as ISigningClient).bondMixNode(
-      this.mixnetContract,
-      mixNode,
-      costParams,
-      ownerSignature,
-      pledge,
-      fee,
-      memo,
-    );
+    return (this.client as ISigningClient).bondMixNode(this.mixnetContract, mixNode, ownerSignature, pledge, fee, memo);
  }

  public async unbondMixNode(fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult> {
@@ -481,29 +423,29 @@ export default class ValidatorClient implements INymClient {
  }

  public async delegateToMixNode(
-    mixId: number,
+    mixIdentity: string,
    amount: Coin,
    fee?: StdFee | 'auto' | number,
    memo?: string,
  ): Promise<ExecuteResult> {
    this.assertSigning();
-    return (this.client as ISigningClient).delegateToMixNode(this.mixnetContract, mixId, amount, fee, memo);
+    return (this.client as ISigningClient).delegateToMixNode(this.mixnetContract, mixIdentity, amount, fee, memo);
  }

  public async undelegateFromMixNode(
-    mixId: number,
+    mixIdentity: string,
    fee?: StdFee | 'auto' | number,
    memo?: string,
  ): Promise<ExecuteResult> {
-    return (this.client as ISigningClient).undelegateFromMixNode(this.mixnetContract, mixId, fee, memo);
+    return (this.client as ISigningClient).undelegateFromMixNode(this.mixnetContract, mixIdentity, fee, memo);
  }

  public async updateMixnodeConfig(
-    mixId: number,
+    mixIdentity: string,
    fee: StdFee | 'auto' | number,
    profitPercentage: number,
  ): Promise<ExecuteResult> {
-    return (this.client as ISigningClient).updateMixnodeConfig(this.mixnetContract, mixId, profitPercentage, fee);
+    return (this.client as ISigningClient).updateMixnodeConfig(this.mixnetContract, mixIdentity, profitPercentage, fee);
  }

  public async updateContractStateParams(
@@ -2,8 +2,9 @@
 * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 * SPDX-License-Identifier: Apache-2.0
 */
+
 import axios from 'axios';
-import { GatewayBond, MixNodeBond, MixNodeDetails } from '@nymproject/types';
+import { GatewayBond, MixNodeBond } from './types';

 export const NYM_API_VERSION = '/v1';
 export const NYM_API_GATEWAYS_PATH = `${NYM_API_VERSION}/gateways`;
@@ -16,7 +17,7 @@ export interface INymApiQuery {

  getCachedGateways(): Promise<GatewayBond[]>;

-  getActiveMixnodes(): Promise<MixNodeDetails[]>;
+  getActiveMixnodes(): Promise<MixNodeBond[]>;

  getRewardedMixnodes(): Promise<MixNodeBond[]>;
 }
@@ -50,7 +51,7 @@ export default class NymApiQuerier implements INymApiQuery {
    throw new Error('None of the provided validator APIs seem to be alive');
  }

-  async getActiveMixnodes(): Promise<MixNodeDetails[]> {
+  async getActiveMixnodes(): Promise<MixNodeBond[]> {
    const url = new URL(this.nymApiUrl);
    url.pathname += NYM_API_ACTIVE_MIXNODES_PATH;

@@ -2,24 +2,28 @@
 * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 * SPDX-License-Identifier: Apache-2.0
 */
+
+import { JsonObject } from '@cosmjs/cosmwasm-stargate';
 // eslint-disable-next-line import/no-cycle
 import { INyxdQuery } from './query-client';
-import { Delegation, RewardingParams, StakeSaturationResponse } from '@nymproject/types';
 import {
-  UnbondedMixnodeResponse,
+  ContractStateParams,
+  Delegation,
  GatewayOwnershipResponse,
+  LayerDistribution,
  MixnetContractVersion,
  MixOwnershipResponse,
  PagedAllDelegationsResponse,
  PagedDelegatorDelegationsResponse,
  PagedGatewayResponse,
  PagedMixDelegationsResponse,
-  PagedMixNodeBondResponse,
-  PagedMixNodeDetailsResponse,
-  PagedUnbondedMixnodesResponse,
-  LayerDistribution,
-} from '@nymproject/types';
-import { ContractState, SmartContractQuery } from './types/shared';
+  PagedMixnodeResponse,
+  RewardingStatus,
+} from './types';
+
+interface SmartContractQuery {
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
+}

 export default class NyxdQuerier implements INyxdQuery {
  client: SmartContractQuery;
@@ -34,44 +38,15 @@ export default class NyxdQuerier implements INyxdQuery {
    });
  }

-  getMixNodeBonds(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeBondResponse> {
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_mix_node_bonds: {
+      get_mix_nodes: {
        limit,
        start_after: startAfter,
      },
    });
  }

-  getMixNodesDetailed(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeDetailsResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_mix_nodes_detailed: {
-        limit,
-        start_after: startAfter,
-      },
-    });
-  }
-
-  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_stake_saturation: { mix_id: mixId },
-    });
-  }
-
-  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<any> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_mixnode_rewarding_details: { mix_id: mixId },
-    });
-  }
-
  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
    return this.client.queryContractSmart(mixnetContractAddress, {
      get_gateways: {
@@ -81,51 +56,35 @@ export default class NyxdQuerier implements INyxdQuery {
    });
  }

-  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_owned_mixnode: {
+      owns_mixnode: {
        address,
      },
    });
  }

-  getUnbondedMixNodes(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedUnbondedMixnodesResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_unbonded_mix_nodes: { limit, start_after: startAfter },
-    });
-  }
-
-  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_unbonded_mix_node_information: { mix_id: mixId },
-    });
-  }
-
  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_owned_gateway: {
+      owns_gateway: {
        address,
      },
    });
  }

-  getStateParams(mixnetContractAddress: string): Promise<ContractState> {
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_state: {},
+      state_params: {},
    });
  }

-  getAllDelegationsPaged(
+  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
    limit?: number,
    startAfter?: [string, string],
  ): Promise<PagedAllDelegationsResponse> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_all_delegations: {
+      get_all_network_delegations: {
        start_after: startAfter,
        limit,
      },
@@ -134,13 +93,13 @@ export default class NyxdQuerier implements INyxdQuery {

  getMixNodeDelegationsPaged(
    mixnetContractAddress: string,
-    mix_id: number,
+    mixIdentity: string,
    limit?: number,
    startAfter?: string,
  ): Promise<PagedMixDelegationsResponse> {
    return this.client.queryContractSmart(mixnetContractAddress, {
      get_mixnode_delegations: {
-        mix_id: mix_id,
+        mix_identity: mixIdentity,
        start_after: startAfter,
        limit,
      },
@@ -162,10 +121,10 @@ export default class NyxdQuerier implements INyxdQuery {
    });
  }

-  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation> {
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
    return this.client.queryContractSmart(mixnetContractAddress, {
      get_delegation_details: {
-        mix_id: mix_id,
+        mix_identity: mixIdentity,
        delegator,
      },
    });
@@ -173,19 +132,44 @@ export default class NyxdQuerier implements INyxdQuery {

  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_layer_distribution: {},
+      layer_distribution: {},
    });
  }

-  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams> {
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_rewarding_params: {},
+      get_reward_pool: {},
    });
  }

-  getSpendableCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<any> {
-    return this.client.queryContractSmart(vestingContractAddress, {
-      vesting_account_address: vestingAccountAddress,
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_circulating_supply: {},
+    });
+  }
+
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_interval_reward_percent: {},
+    });
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_sybil_resistance_percent: {},
+    });
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.client.queryContractSmart(mixnetContractAddress, {
+      get_rewarding_status: {
+        mix_identity: mixIdentity,
+        rewarding_interval_nonce: rewardingIntervalNonce,
+      },
    });
  }
 }
@@ -1,56 +1,75 @@
-import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import { CosmWasmClient, JsonObject } from '@cosmjs/cosmwasm-stargate';
+import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+import {
+  Account,
+  Block,
+  Coin,
+  DeliverTxResponse,
+  IndexedTx,
+  SearchTxFilter,
+  SearchTxQuery,
+  SequenceResponse,
+} from '@cosmjs/stargate';
+import { Code, CodeDetails, Contract, ContractCodeHistoryEntry } from '@cosmjs/cosmwasm-stargate/build/cosmwasmclient';
 // eslint-disable-next-line import/no-cycle
 import NyxdQuerier from './nyxd-querier';
 import {
+  ContractStateParams,
  Delegation,
  GatewayBond,
  GatewayOwnershipResponse,
  LayerDistribution,
  MixnetContractVersion,
-  MixNodeDetails,
+  MixNodeBond,
  MixOwnershipResponse,
  PagedAllDelegationsResponse,
  PagedDelegatorDelegationsResponse,
  PagedGatewayResponse,
  PagedMixDelegationsResponse,
-  PagedMixNodeBondResponse,
-  PagedMixNodeDetailsResponse,
-  PagedUnbondedMixnodesResponse,
-  StakeSaturationResponse,
-  UnbondedMixnodeResponse,
-  MixNodeBond,
-  MixNodeRewarding,
-} from '@nymproject/types';
-import NymApiQuerier, { INymApiQuery } from './nym-api-querier';
-import { ContractState, ICosmWasmQuery } from './types/shared';
-import { RewardingParams } from '@nymproject/types';
-import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+  PagedMixnodeResponse,
+  RewardingStatus,
+} from './types';
+import NymApiQuerier, { INymApiQuery as INymApiQuery } from './nym-api-querier';
+
+export interface ICosmWasmQuery {
+  // methods exposed by `CosmWasmClient`
+  getChainId(): Promise<string>;
+  getHeight(): Promise<number>;
+  getAccount(searchAddress: string): Promise<Account | null>;
+  getSequence(address: string): Promise<SequenceResponse>;
+  getBlock(height?: number): Promise<Block>;
+  getBalance(address: string, searchDenom: string): Promise<Coin>;
+  getTx(id: string): Promise<IndexedTx | null>;
+  searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise<readonly IndexedTx[]>;
+  disconnect(): void;
+  broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
+  getCodes(): Promise<readonly Code[]>;
+  getCodeDetails(codeId: number): Promise<CodeDetails>;
+  getContracts(codeId: number): Promise<readonly string[]>;
+  getContract(address: string): Promise<Contract>;
+  getContractCodeHistory(address: string): Promise<readonly ContractCodeHistoryEntry[]>;
+  queryContractRaw(address: string, key: Uint8Array): Promise<Uint8Array | null>;
+  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
+}

 export interface INyxdQuery {
  // nym-specific implemented inside NymQuerier
  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
-  getMixNodeBonds(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeBondResponse>;
-  getMixNodesDetailed(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeDetailsResponse>;
+
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse>;
  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse>;
-  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-  getStateParams(mixnetContractAddress: string): Promise<ContractState>;
-  getAllDelegationsPaged(
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams>;
+
+  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
    limit?: number,
    startAfter?: [string, string],
  ): Promise<PagedAllDelegationsResponse>;
  getMixNodeDelegationsPaged(
    mixnetContractAddress: string,
-    mix_id: number,
+    mixIdentity: string,
    limit?: number,
    startAfter?: string,
  ): Promise<PagedMixDelegationsResponse>;
@@ -60,15 +79,21 @@ export interface INyxdQuery {
    limit?: number,
    startAfter?: string,
  ): Promise<PagedDelegatorDelegationsResponse>;
-  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation>;
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation>;
+
  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
-  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams>;
-  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse>;
-  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse>;
-  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding>;
+  getRewardPool(mixnetContractAddress: string): Promise<string>;
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string>;
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number>;
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number>;
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus>;
 }

-export interface IQueryClient extends ICosmWasmQuery, INyxdQuery, INymApiQuery {}
+export interface IQueryClient extends ICosmWasmQuery, INyxdQuery, INymApiQuery { }

 export default class QueryClient extends CosmWasmClient implements IQueryClient {
  private nyxdQuerier: NyxdQuerier;
@@ -90,73 +115,41 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
    return this.nyxdQuerier.getContractVersion(mixnetContractAddress);
  }

-  getMixNodeBonds(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeBondResponse> {
-    return this.nyxdQuerier.getMixNodeBonds(mixnetContractAddress, limit, startAfter);
-  }
-
-  getMixNodesDetailed(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeDetailsResponse> {
-    return this.nyxdQuerier.getMixNodesDetailed(mixnetContractAddress, limit, startAfter);
-  }
-
-  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse> {
-    return this.nyxdQuerier.getStakeSaturation(mixnetContractAddress, mixId);
-  }
-
-  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding> {
-    return this.nyxdQuerier.getMixnodeRewardingDetails(mixnetContractAddress, mixId);
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.nyxdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
  }

  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
    return this.nyxdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
  }

-  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
-    return this.nyxdQuerier.getOwnedMixnode(mixnetContractAddress, address);
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nyxdQuerier.ownsMixNode(mixnetContractAddress, address);
  }

  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
    return this.nyxdQuerier.ownsGateway(mixnetContractAddress, address);
  }

-  getUnbondedMixNodes(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedUnbondedMixnodesResponse> {
-    return this.nyxdQuerier.getUnbondedMixNodes(mixnetContractAddress, limit, startAfter);
-  }
-
-  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse> {
-    return this.nyxdQuerier.getUnbondedMixNodeInformation(mixnetContractAddress, mixId);
-  }
-
-  getStateParams(mixnetContractAddress: string): Promise<ContractState> {
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
    return this.nyxdQuerier.getStateParams(mixnetContractAddress);
  }

-  getAllDelegationsPaged(
+  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
    limit?: number,
    startAfter?: [string, string],
  ): Promise<PagedAllDelegationsResponse> {
-    return this.nyxdQuerier.getAllDelegationsPaged(mixnetContractAddress, limit, startAfter);
+    return this.nyxdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
  }

  getMixNodeDelegationsPaged(
    mixnetContractAddress: string,
-    mix_id: number,
+    mixIdentity: string,
    limit?: number,
    startAfter?: string,
  ): Promise<PagedMixDelegationsResponse> {
-    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mix_id, limit, startAfter);
+    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
  }

  getDelegatorDelegationsPaged(
@@ -168,16 +161,36 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
    return this.nyxdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
  }

-  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation> {
-    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mix_id, delegator);
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
  }

  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
    return this.nyxdQuerier.getLayerDistribution(mixnetContractAddress);
  }

-  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams> {
-    return this.nyxdQuerier.getRewardParams(mixnetContractAddress);
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.nyxdQuerier.getRewardPool(mixnetContractAddress);
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.nyxdQuerier.getCirculatingSupply(mixnetContractAddress);
+  }
+
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nyxdQuerier.getIntervalRewardPercent(mixnetContractAddress);
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.nyxdQuerier.getSybilResistancePercent(mixnetContractAddress);
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.nyxdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
  }

  getCachedGateways(): Promise<GatewayBond[]> {
@@ -188,15 +201,11 @@ export default class QueryClient extends CosmWasmClient implements IQueryClient
    return this.nymApiQuerier.getCachedMixnodes();
  }

-  getActiveMixnodes(): Promise<MixNodeDetails[]> {
+  getActiveMixnodes(): Promise<MixNodeBond[]> {
    return this.nymApiQuerier.getActiveMixnodes();
  }

  getRewardedMixnodes(): Promise<MixNodeBond[]> {
    return this.nymApiQuerier.getRewardedMixnodes();
  }
-
-  getSpendableCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<any> {
-    return this.nyxdQuerier.getSpendableCoins(vestingContractAddress, vestingAccountAddress);
-  }
 }
@@ -25,22 +25,15 @@ import {
  MixnetContractVersion,
  MixNode,
  MixNodeBond,
-  MixNodeCostParams,
-  MixNodeDetails,
-  MixNodeRewarding,
  MixOwnershipResponse,
  PagedAllDelegationsResponse,
  PagedDelegatorDelegationsResponse,
  PagedGatewayResponse,
  PagedMixDelegationsResponse,
-  PagedMixNodeBondResponse,
-  PagedMixNodeDetailsResponse,
-  PagedUnbondedMixnodesResponse,
-  RewardingParams,
-  UnbondedMixnodeResponse,
-} from '@nymproject/types';
+  PagedMixnodeResponse,
+  RewardingStatus,
+} from './types';
 import NymApiQuerier from './nym-api-querier';
-import { ContractState } from './types/shared';

 // methods exposed by `SigningCosmWasmClient`
 export interface ICosmWasmSigning {
@@ -150,7 +143,6 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign
  bondMixNode(
    mixnetContractAddress: string,
    mixNode: MixNode,
-    costParams: MixNodeCostParams,
    ownerSignature: string,
    pledge: Coin,
    fee?: StdFee | 'auto' | number,
@@ -172,7 +164,7 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign

  delegateToMixNode(
    mixnetContractAddress: string,
-    mixId: number,
+    mixIdentity: string,
    amount: Coin,
    fee?: StdFee | 'auto' | number,
    memo?: string,
@@ -180,14 +172,14 @@ export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSign

  undelegateFromMixNode(
    mixnetContractAddress: string,
-    mixId: number,
+    mixIdentity: string,
    fee?: StdFee | 'auto' | number,
    memo?: string,
  ): Promise<ExecuteResult>;

  updateMixnodeConfig(
    mixnetContractAddress: string,
-    mixId: number,
+    mixIdentity: string,
    profitMarginPercent: number,
    fee: StdFee | 'auto' | number,
  ): Promise<ExecuteResult>;
@@ -243,76 +235,44 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
  // query related:

  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
-    return this.getContractVersion(mixnetContractAddress);
+    return this.nyxdQuerier.getContractVersion(mixnetContractAddress);
  }

-  getMixNodeBonds(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeBondResponse> {
-    return this.nyxdQuerier.getMixNodeBonds(mixnetContractAddress, limit, startAfter);
-  }
-
-  getMixNodesDetailed(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeDetailsResponse> {
-    return this.nyxdQuerier.getMixNodesDetailed(mixnetContractAddress, limit, startAfter);
-  }
-
-  getStakeSaturation(mixnetContractAddress: string, mixId: number) {
-    return this.nyxdQuerier.getStakeSaturation(mixnetContractAddress, mixId);
-  }
-
-  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse> {
-    return this.nyxdQuerier.getUnbondedMixNodeInformation(mixnetContractAddress, mixId);
-  }
-
-  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding> {
-    return this.nyxdQuerier.getMixnodeRewardingDetails(mixnetContractAddress, mixId);
+  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
+    return this.nyxdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
  }

  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
    return this.nyxdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
  }

-  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
-    return this.nyxdQuerier.getOwnedMixnode(mixnetContractAddress, address);
+  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
+    return this.nyxdQuerier.ownsMixNode(mixnetContractAddress, address);
  }

  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
    return this.nyxdQuerier.ownsGateway(mixnetContractAddress, address);
  }

-  getStateParams(mixnetContractAddress: string): Promise<ContractState> {
+  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
    return this.nyxdQuerier.getStateParams(mixnetContractAddress);
  }

-  getAllDelegationsPaged(
+  getAllNetworkDelegationsPaged(
    mixnetContractAddress: string,
    limit?: number,
    startAfter?: [string, string],
  ): Promise<PagedAllDelegationsResponse> {
-    return this.getAllDelegationsPaged(mixnetContractAddress, limit, startAfter);
-  }
-
-  getUnbondedMixNodes(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedUnbondedMixnodesResponse> {
-    return this.nyxdQuerier.getUnbondedMixNodes(mixnetContractAddress, limit, startAfter);
+    return this.nyxdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
  }

  getMixNodeDelegationsPaged(
    mixnetContractAddress: string,
-    mix_id: number,
+    mixIdentity: string,
    limit?: number,
    startAfter?: string,
  ): Promise<PagedMixDelegationsResponse> {
-    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mix_id, limit, startAfter);
+    return this.nyxdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
  }

  getDelegatorDelegationsPaged(
@@ -324,16 +284,36 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
    return this.nyxdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
  }

-  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation> {
-    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mix_id, delegator);
+  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
+    return this.nyxdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
  }

  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
    return this.nyxdQuerier.getLayerDistribution(mixnetContractAddress);
  }

-  getRewardParams(mixnetContractAddress: string): Promise<RewardingParams> {
-    return this.nyxdQuerier.getRewardParams(mixnetContractAddress);
+  getRewardPool(mixnetContractAddress: string): Promise<string> {
+    return this.nyxdQuerier.getRewardPool(mixnetContractAddress);
+  }
+
+  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
+    return this.nyxdQuerier.getCirculatingSupply(mixnetContractAddress);
+  }
+
+  getIntervalRewardPercent(mixnetContractAddress: string): Promise<number> {
+    return this.nyxdQuerier.getIntervalRewardPercent(mixnetContractAddress);
+  }
+
+  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
+    return this.nyxdQuerier.getSybilResistancePercent(mixnetContractAddress);
+  }
+
+  getRewardingStatus(
+    mixnetContractAddress: string,
+    mixIdentity: string,
+    rewardingIntervalNonce: number,
+  ): Promise<RewardingStatus> {
+    return this.nyxdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
  }

  getCachedGateways(): Promise<GatewayBond[]> {
@@ -344,7 +324,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
    return this.nymApiQuerier.getCachedMixnodes();
  }

-  getActiveMixnodes(): Promise<MixNodeDetails[]> {
+  getActiveMixnodes(): Promise<MixNodeBond[]> {
    return this.nymApiQuerier.getActiveMixnodes();
  }

@@ -352,16 +332,11 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
    return this.nymApiQuerier.getRewardedMixnodes();
  }

-  getSpendableCoins(vestingContractAddress: string, vestingAccountAddress: string): Promise<any> {
-    return this.nyxdQuerier.getSpendableCoins(vestingContractAddress, vestingAccountAddress);
-  }
-
  // signing related:

  bondMixNode(
    mixnetContractAddress: string,
    mixNode: MixNode,
-    costParams: MixNodeCostParams,
    ownerSignature: string,
    pledge: Coin,
    fee: StdFee | 'auto' | number = 'auto',
@@ -373,7 +348,6 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
      {
        bond_mixnode: {
          mix_node: mixNode,
-          cost_params: costParams,
          owner_signature: ownerSignature,
        },
      },
@@ -440,7 +414,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig

  delegateToMixNode(
    mixnetContractAddress: string,
-    mixId: number,
+    mixIdentity: string,
    amount: Coin,
    fee: StdFee | 'auto' | number = 'auto',
    memo = 'Default MixNode Delegation from Typescript',
@@ -450,7 +424,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
      mixnetContractAddress,
      {
        delegate_to_mixnode: {
-          mix_id: mixId,
+          mix_identity: mixIdentity,
        },
      },
      fee,
@@ -461,7 +435,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig

  undelegateFromMixNode(
    mixnetContractAddress: string,
-    mixId: number,
+    mixIdentity: string,
    fee: StdFee | 'auto' | number = 'auto',
    memo = 'Default MixNode Undelegation from Typescript',
  ): Promise<ExecuteResult> {
@@ -470,7 +444,7 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig
      mixnetContractAddress,
      {
        undelegate_from_mixnode: {
-          mix_id: mixId,
+          mix_identity: mixIdentity,
        },
      },
      fee,
@@ -480,14 +454,14 @@ export default class SigningClient extends SigningCosmWasmClient implements ISig

  updateMixnodeConfig(
    mixnetContractAddress: string,
-    mixId: number,
+    mixIdentity: string,
    profitMarginPercent: number,
    fee: StdFee | 'auto' | number,
  ): Promise<ExecuteResult> {
    return this.execute(
      this.clientAddress,
      mixnetContractAddress,
-      { update_mixnode_config: { profit_margin_percent: profitMarginPercent, mix_id: mixId } },
+      { update_mixnode_config: { profit_margin_percent: profitMarginPercent, mix_identity: mixIdentity } },
      fee,
    );
  }
@@ -1,178 +0,0 @@
-import expect from 'expect';
-
-export const amountDemon = {
-    amount: expect.any(String),
-    denom: expect.any(String)
-}
-
-export const delegation = {
-    owner: expect.any(String),
-    mix_id: expect.any(Number),
-    cumulative_reward_ratio: expect.any(String),
-    amount: amountDemon,
-    height: expect.any(Number || BigInt),
-    proxy: expect.any(String || null)
-}
-
-export const detailedDelegation = {
-    delegation: delegation,
-    mixnode_still_bonded: expect.any(Boolean)
-}
-
-export const gateway = {
-    pledge_amount: amountDemon,
-    owner: expect.any(String),
-    block_height: expect.any(Number || BigInt),
-    gateway: {
-        host: expect.any(String),
-        mix_port: expect.any(Number),
-        clients_port: expect.any(Number),
-        location: expect.any(String),
-        sphinx_key: expect.any(String),
-        identity_key: expect.any(String),
-        version: expect.any(String),
-    },
-    proxy: expect.any(String || null)
-}
-
-export const pagedGateway = {
-    nodes: gateway,
-    per_page: expect.any(Number),
-    start_next_after: expect.any(Number)
-}
-
-export const ownGateway = {
-    address: expect.any(String),
-    gateway: gateway
-}
-
-export const rewardingdetails = {
-    cost_params: {
-        profit_margin_percent: expect.any(String),
-        interval_operating_cost: {
-            denom: expect.any(String),
-            amount: expect.any(String)
-        }
-    },
-    operator: expect.any(String),
-    delegates: expect.any(String),
-    total_unit_reward: expect.any(String),
-    unit_delegation: expect.any(String),
-    last_rewarded_epoch: expect.any(Number),
-    unique_delegations: expect.any(Number)
-}
-
-export const mix_node = {
-    host: expect.any(String),
-    mix_port: expect.any(Number),
-    verloc_port: expect.any(Number),
-    http_api_port: expect.any(Number),
-    sphinx_key: expect.any(String),
-    identity_key: expect.any(String),
-    version: expect.any(String)
-}
-
-export const mixnodebond = {
-    mix_id: expect.any(Number),
-    owner: expect.any(String),
-    original_pledge: {
-        denom: expect.any(String),
-        amount: expect.any(String)
-    },
-    layer: expect.any(String),
-    mix_node: mix_node,
-    proxy: expect.any(String) || null,
-    bonding_height: expect.any(Number || BigInt),
-    is_unbonding: expect.any(Boolean)
-}
-
-export const mixnode = {
-    bond_information: mixnodebond,
-    rewarding_details: rewardingdetails
-}
-
-export const ownedNode = {
-    address: expect.any(String),
-    mixnode_details: {
-        bond_information: mixnodebond,
-        rewarding_details: rewardingdetails
-    }
-}
-
-export const saturation = {
-    mix_id: expect.any(Number),
-    current_saturation: expect.any(String),
-    uncapped_saturation: expect.any(String)
-}
-
-export const contractVersion = {
-    build_timestamp: expect.any(String),
-    build_version: expect.any(String),
-    commit_sha: expect.any(String),
-    commit_timestamp: expect.any(String),
-    commit_branch: expect.any(String),
-    rustc_version: expect.any(String)
-};
-
-export const stateParams = {
-    minimum_gateway_pledge: amountDemon,
-    minimum_mixnode_pledge: expect.any(String),
-    mixnode_rewarded_set_size: expect.any(Number),
-    mixnode_active_set_size: expect.any(Number)
-}
-
-export const contract = {
-    owner: expect.any(Number),
-    rewarding_validator_address: expect.any(Number),
-    vesting_contract_address: expect.any(Number),
-    rewarding_denom: expect.any(String),
-    params: stateParams
-}
-
-export const rewardingnode = {
-    mix_id: expect.any(Number),
-    rewarding_details: rewardingdetails
-}
-
-export const unbondednode = {
-    mix_id: expect.any(Number),
-    unbonded_info: {
-        identity_key: expect.any(String),
-        owner: expect.any(String),
-        proxy: expect.any(String) || null,
-        unbonding_height: expect.any(Number)
-    }
-}
-
-export const allunbondednodes = [
-    expect.any(Number), {
-        identity_key: expect.any(String),
-        owner: expect.any(String),
-        proxy: expect.any(String) || null,
-        unbonding_height: expect.any(Number)
-    }
-]
-
-export const layerDistribution = {
-    layer1: expect.any(Number),
-    layer2: expect.any(Number),
-    layer3: expect.any(Number)
-}
-
-
-export const intervalRewardParams = {
-    reward_pool: expect.any(Number),
-    staking_supply: expect.any(Number),
-    staking_supply_scale_factor: expect.any(Number),
-    epoch_reward_budget: expect.any(Number),
-    stake_saturation_point: expect.any(Number),
-    sybil_resistance: expect.any(Number),
-    active_set_work_factor: expect.any(Number),
-    interval_pool_emission: expect.any(Number)
-}
-
-export const rewardingParams = {
-    interval: intervalRewardParams,
-    rewarded_set_size: expect.any(Number),
-    active_set_size: expect.any(Number)
-}
@@ -1,19 +0,0 @@
-import { Mock, Times } from 'moq.ts';
-import expect from 'expect';
-import { INyxdQuery } from '../../query-client';
-
-export class TestHelper {
-  buildMethod = async <T>(methodName: string, args: any[], expectedResult: any): Promise<T> => {
-    const client = new Mock<INyxdQuery>()
-      .setup((nym) => nym[methodName](...args))
-      .returns(Promise.resolve(expectedResult));
-    const obj = client.object();
-    const actualDetails = await obj[methodName](...args);
-
-    client.verify((nym) => nym[methodName](...args), Times.Exactly(1));
-    expect(Object.keys([actualDetails])).toEqual(Object.keys(expectedResult));
-    expect(actualDetails).toBeDefined();
-
-    return actualDetails;
-  };
-}
@@ -1,40 +0,0 @@
-import expect from 'expect';
-import { Delegation } from '@nymproject/types';
-import { PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse } from '../../types/shared-types';
-import { TestHelper } from './client';
-import { mixnet, mixnodeowneraddress, mix_id } from './testData';
-
-describe('Delegation mock tests', () => {
-  const testHelper = new TestHelper();
-
-  it('get Delegation Details', () => {
-    const execute = testHelper.buildMethod('getDelegationDetails', [mixnet, mix_id, mixnodeowneraddress], <Delegation>{
-      owner: mixnodeowneraddress,
-      mix_id: 0,
-      cumulative_reward_ratio: '',
-      amount: {
-        denom: 'nym',
-        amount: '10',
-      },
-      height: 1314134144132n,
-      proxy: 'null',
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get All Delegations Paged', () => {
-    const execute = testHelper.buildMethod('getAllDelegationsPaged', [mixnet], <PagedAllDelegationsResponse>{
-      delegations: [],
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Delegator Delegations Paged', () => {
-    const execute = testHelper.buildMethod('getDelegatorDelegationsPaged', [mixnet, mixnodeowneraddress], <
-      PagedDelegatorDelegationsResponse
-    >{
-      delegations: [],
-    });
-    expect(execute).toBeTruthy();
-  });
-});
@@ -1,24 +0,0 @@
-import expect from 'expect';
-import { GatewayOwnershipResponse, PagedGatewayResponse } from '../../types/shared-types';
-import { TestHelper } from './client';
-import { gatewayowneraddress, mixnet } from './testData';
-
-describe('Gateway mock tests', () => {
-  const testHelper = new TestHelper();
-
-  it('get Gateways Paged', () => {
-    const execute = testHelper.buildMethod('getGatewaysPaged', [mixnet], <PagedGatewayResponse>{
-      nodes: [],
-      per_page: 25,
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('owns Gateway', () => {
-    const execute = testHelper.buildMethod('ownsGateway', [mixnet, gatewayowneraddress], <GatewayOwnershipResponse>{
-      address: gatewayowneraddress,
-      gateway: {},
-    });
-    expect(execute).toBeTruthy();
-  });
-});
@@ -1,65 +0,0 @@
-import expect from 'expect';
-import { LayerDistribution, MixnetContractVersion, StakeSaturationResponse } from '@nymproject/types';
-import { TestHelper } from './client';
-import { mixnet, mix_id } from './testData';
-import { RewardingParams } from '@nymproject/types';
-import { ContractState } from '../../types/shared';
-
-describe('Mixnet mock tests', () => {
-  const testHelper = new TestHelper();
-
-  it('get Layer Distribution', () => {
-    const execute = testHelper.buildMethod('getLayerDistribution', [mixnet], <LayerDistribution>{
-      layer1: 2,
-      layer2: 2,
-      layer3: 5,
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Reward Params', () => {
-    const execute = testHelper.buildMethod('getRewardParams', [mixnet], <RewardingParams>{
-      interval: {},
-      rewarded_set_size: 0,
-      active_set_size: 0,
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Stake Saturation', () => {
-    const execute = testHelper.buildMethod('getStakeSaturation', [mixnet, mix_id], <StakeSaturationResponse>{
-      mix_id: 0,
-      current_saturation: '',
-      uncapped_saturation: '',
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get State Params', () => {
-    const execute = testHelper.buildMethod('getStateParams', [mixnet], <ContractState>{
-      owner: '',
-      rewarding_validator_address: '',
-      vesting_contract_address: '',
-      rewarding_denom: 'unym',
-      params: {
-        minimum_mixnode_pledge: '',
-        minimum_gateway_pledge: '',
-        mixnode_rewarded_set_size: 240,
-        mixnode_active_set_size: 240,
-      },
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Contract Version', () => {
-    const execute = testHelper.buildMethod('getContractVersion', [mixnet], <MixnetContractVersion>{
-      build_timestamp: 'test',
-      commit_branch: 'test',
-      build_version: 'test',
-      rustc_version: 'test',
-      commit_sha: 'test',
-      commit_timestamp: 'test',
-    });
-    expect(execute).toBeTruthy();
-  });
-});
@@ -1,71 +0,0 @@
-import expect from 'expect';
-import {
-  MixNodeRewarding,
-  MixOwnershipResponse,
-  PagedMixDelegationsResponse,
-  PagedMixNodeBondResponse,
-  PagedMixNodeDetailsResponse,
-  UnbondedMixnodeResponse,
-} from '@nymproject/types';
-import { TestHelper } from './client';
-import { mixnet, mixnodeowneraddress, mix_id } from './testData';
-
-describe('Mixnode mock tests', () => {
-  const testHelper = new TestHelper();
-
-  it('get Mixnode Bonds', () => {
-    const execute = testHelper.buildMethod('getMixNodeBonds', [mixnet], <PagedMixNodeBondResponse>{
-      nodes: [],
-      per_page: 25,
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Mixnode Delegations Paged', () => {
-    const execute = testHelper.buildMethod('getMixNodeDelegationsPaged', [mixnet, mix_id], <
-      PagedMixDelegationsResponse
-    >{
-      delegations: [],
-      per_page: 25,
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Mixnodes Detailed', () => {
-    const execute = testHelper.buildMethod('getMixNodesDetailed', [mixnet], <PagedMixNodeDetailsResponse>{
-      nodes: [],
-      per_page: 25,
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Mixnode Rewarding Details', () => {
-    const execute = testHelper.buildMethod('getMixnodeRewardingDetails', [mixnet, mix_id], <MixNodeRewarding>{
-      cost_params: {},
-      operator: '',
-      delegates: '',
-      total_unit_reward: '',
-      unit_delegation: '',
-      last_rewarded_epoch: 1,
-      unique_delegations: 1,
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Owned Mixnode', () => {
-    const execute = testHelper.buildMethod('getOwnedMixnode', [mixnet, mixnodeowneraddress], <MixOwnershipResponse>{
-      address: '',
-      mixnode: {},
-    });
-    expect(execute).toBeTruthy();
-  });
-
-  it('get Unbonded Mixnode Information', () => {
-    const execute = testHelper.buildMethod(
-      'getUnbondedMixNodeInformation',
-      [mixnet, mix_id],
-      <UnbondedMixnodeResponse>{},
-    );
-    expect(execute).toBeTruthy();
-  });
-});
@@ -1,8 +0,0 @@
-export const mixnet = 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g';
-export const gatewayowneraddress = 'n16evnn8glr0sham3matj8rg2s24m6x56ayk87ts';
-// export const mixId = 436207616;
-export const mix_id = 26;
-export const nodeIdentityKey = 'ATmVJknZarDF6Yj53M7h8NS9LLCUvWuToXpk3pDvYUH1';
-export const mixnodeowneraddress = 'n1fzv4jc7fanl9s0qj02ge2ezk3kts545kjtek47';
-export const delegatorAddress = 'n1lemst75va9700tsrxq58adzujrh6h9s5x60h9h';
-export const rewardingIntervalNonce = 1;
@@ -1,180 +0,0 @@
-import expect from 'expect';
-import ValidatorClient from '../../index';
-
-import {
-  allunbondednodes,
-  contract,
-  delegation,
-  gateway,
-  layerDistribution,
-  mixnode,
-  mixnodebond,
-  ownedNode,
-  ownGateway,
-  rewardingnode,
-  saturation,
-  unbondednode,
-} from '../expectedResponses';
-import { delegatorAddress, gatewayowneraddress } from '../mock/testData';
-
-const dotenv = require('dotenv');
-
-dotenv.config();
-
-describe('Mixnet queries', () => {
-  let client: ValidatorClient;
-
-  beforeEach(async () => {
-    client = await ValidatorClient.connectForQuery(
-      process.env.rpcAddress || '',
-      process.env.validatorAddress || '',
-      process.env.prefix || '',
-      process.env.mixnetContractAddress || '',
-      process.env.vestingContractAddress || '',
-      process.env.denom || '',
-    );
-  });
-
-  //
-  // CONTRACT
-  //
-
-  it('can query for an account balance', async () => {
-    const balance = await client.getBalance('n1ptg680vnmef2cd8l0s9uyc4f0hgf3x8sed6w77');
-    expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
-  });
-
-  it('can query for stake saturation', async () => {
-    const stakeSaturation = await client.getStakeSaturation(7);
-    expect(Object.keys(stakeSaturation)).toEqual(Object.keys(saturation));
-    expect(stakeSaturation).toBeTruthy();
-    expect(stakeSaturation?.current_saturation).toBeTruthy();
-  });
-
-  it('can query for contract version', async () => {
-    const contractV = await client.getMixnetContractVersion();
-    expect(contractV).toBeTruthy();
-  });
-
-  it('can query for mixnet contract settings', async () => {
-    const settings = await client.getMixnetContractSettings();
-    expect(Object.keys(settings)).toEqual(Object.keys(contract));
-    expect(settings).toBeTruthy();
-  });
-
-  it('can query for reward pool', async () => {
-    const rewardPool = await client.getRewardParams();
-    // TODO add velidation here
-    expect(rewardPool).toBeTruthy();
-  });
-
-  it('can query for layer distribution', async () => {
-    const layer = await client.getLayerDistribution();
-    expect(Object.keys(layer)).toEqual(Object.keys(layerDistribution));
-    expect(layer).toBeTruthy();
-  });
-
-  //
-  // MIXNODES
-  //
-
-  it('can query for unbonded mixnodes', async () => {
-    const unbondedNodes = await client.getUnbondedMixNodes();
-    for (let i = 0; i < unbondedNodes.length; i++) {
-      expect(Object.keys(unbondedNodes[0])).toEqual(Object.keys(allunbondednodes));
-      expect(unbondedNodes).toBeTruthy();
-    }
-  });
-
-  it('can query for unbonded mixnode information', async () => {
-    const unbondedMixnodeInfo = await client.getUnbondedMixNodeInformation(1);
-    expect(Object.keys(unbondedMixnodeInfo)).toEqual(Object.keys(unbondednode));
-    expect(unbondedMixnodeInfo).toBeTruthy();
-  });
-
-  it('can query for mixnode rewarding details', async () => {
-    const rewardingDetails = await client.getMixnodeRewardingDetails(1);
-    expect(Object.keys(rewardingDetails)).toEqual(Object.keys(rewardingnode));
-    expect(rewardingDetails).toBeTruthy();
-  });
-
-  it('can query for owned mixnode', async () => {
-    const ownedMixnode = await client.getOwnedMixnode('n1ptg680vnmef2cd8l0s9uyc4f0hgf3x8sed6w77');
-    expect(Object.keys(ownedMixnode)).toEqual(Object.keys(ownedNode));
-    expect(ownedMixnode).toBeTruthy();
-  });
-
-  it('can query for all mixnode bonds', async () => {
-    const mixnodeBonds = await client.getMixNodeBonds();
-    expect(Object.keys(mixnodeBonds[0])).toEqual(Object.keys(mixnodebond));
-    expect(mixnodeBonds).toBeTruthy();
-    expect(Array.isArray(mixnodeBonds)).toBeTruthy();
-  });
-
-  it('can query for all mixnode details', async () => {
-    const mixnodeDetails = await client.getMixNodesDetailed();
-    expect(Object.keys(mixnodeDetails[0])).toEqual(Object.keys(mixnode));
-    expect(mixnodeDetails).toBeTruthy();
-    expect(Array.isArray(mixnodeDetails)).toBeTruthy();
-  });
-
-  it('can query for all active mixnodes', async () => {
-    const activeNodes = await client.getActiveMixnodes();
-    expect(Object.keys(activeNodes[0])).toEqual(Object.keys(mixnode));
-    expect(activeNodes).toBeTruthy();
-    expect(Array.isArray(activeNodes)).toBeTruthy();
-  });
-
-  it('can query for rewarded mixnodes', async () => {
-    const rewardNodes = await client.getRewardedMixnodes();
-    expect(Object.keys(rewardNodes[0])).toEqual(Object.keys(mixnode));
-    expect(rewardNodes).toBeTruthy();
-  });
-
-  //
-  // DELEGATIONS
-  //
-
-  it('can query for account delegations', async () => {
-    const delegations = await client.getAllNyxdDelegatorDelegations('n1fzv4jc7fanl9s0qj02ge2ezk3kts545kjtek47');
-    expect(Object.keys(delegations[0])).toEqual(Object.keys(delegation));
-    expect(delegations).toBeTruthy();
-    expect(Array.isArray(delegations)).toBeTruthy();
-  });
-
-  it('can query for all delegations', async () => {
-    const allDelegations = await client.getAllNyxdDelegations();
-    expect(Object.keys(allDelegations[0])).toEqual(Object.keys(delegation));
-    expect(allDelegations).toBeTruthy();
-    expect(Array.isArray(allDelegations)).toBeTruthy();
-  });
-
-  it('can query for all delegations on a node', async () => {
-    const mixnodeDelegations = await client.getAllNyxdSingleMixnodeDelegations(1);
-    expect(Object.keys(mixnodeDelegations[0])).toEqual(Object.keys(delegation));
-    expect(mixnodeDelegations).toBeTruthy();
-  });
-
-  it('can query for detailed delegations', async () => {
-    const detailedDelegation = await client.getDelegationDetails(7, delegatorAddress);
-    expect(Object.keys(detailedDelegation)).toEqual(Object.keys(detailedDelegation));
-    expect(detailedDelegation).toBeTruthy();
-  });
-
-  //
-  // GATEWAYS
-  //
-
-  it('can query for all gateways', async () => {
-    const gateways = await client.getAllNyxdGateways();
-    expect(Object.keys(gateways[0])).toEqual(Object.keys(gateway));
-    expect(gateways).toBeTruthy();
-    expect(Array.isArray(gateways)).toBeTruthy();
-  }).timeout(10000);
-
-  it('can query for owned gateway', async () => {
-    const gateway = await client.ownsGateway(gatewayowneraddress);
-    expect(Object.keys(gateway)).toEqual(Object.keys(ownGateway));
-    expect(gateway).toBeTruthy();
-  }).timeout(10000);
-});
@@ -1,28 +0,0 @@
-import expect from 'expect';
-import ValidatorClient from '../../index';
-
-const dotenv = require('dotenv');
-
-dotenv.config();
-
-describe('Vesting queries', () => {
-  let client: ValidatorClient;
-
-  beforeEach(async () => {
-    client = await ValidatorClient.connectForQuery(
-      process.env.rpcAddress || '',
-      process.env.validatorAddress || '',
-      process.env.prefix || '',
-      process.env.mixnetContractAddress || '',
-      process.env.vestingContractAddress || '',
-      process.env.denom || '',
-    );
-  });
-
-  it('can query for contract version', async () => {
-    const contract = await client.getVestingContractVersion();
-    expect(contract).toBeTruthy();
-  });
-
-  it('can get the balance on the account', () => {});
-});
@@ -1,107 +0,0 @@
-import expect from 'expect';
-import ValidatorClient from '../../';
-
-const dotenv = require('dotenv');
-
-dotenv.config();
-
-// TODO: implement for QA with .env for mnemonics
-describe('Mixnet actions', () => {
-  let client: ValidatorClient;
-
-  beforeEach(async () => {
-    client = await ValidatorClient.connect(
-      process.env.mnemonic || '',
-      process.env.rpcAddress || '',
-      process.env.validatorAddress || '',
-      process.env.prefix || '',
-      process.env.mixnetContractAddress || '',
-      process.env.vestingContractAddress || '',
-      process.env.denom || '',
-    );
-  });
-
-  it('can send tokens', async () => {
-    const res = await client.send(client.address, [{ amount: '10000000', denom: 'unym' }]);
-    expect(res.transactionHash).toBeDefined();
-  }).timeout(10000);
-
-  it.skip('can delegate tokens', async () => {
-    const [_, secondMixnode] = await client.getActiveMixnodes();
-
-    if (secondMixnode) {
-      const res = await client.delegateToMixNode(
-        secondMixnode.bond_information.mix_id,
-        {
-          amount: '15000000',
-          denom: 'unym',
-        },
-        { gas: '1000000', amount: [{ amount: '100000', denom: 'unym' }] },
-      );
-      expect(res.transactionHash).toBeDefined();
-    }
-  }).timeout(10000);
-
-  // Need to provide a mix id that can be undelegated from
-  it.skip('can undelegate from a mixnode', async () => {
-    const mixId = 8;
-    const res = await client.undelegateFromMixNode(mixId);
-    expect(res.transactionHash).toBeDefined();
-  });
-
-  it.skip('Can unbond a mixnode', async () => {
-    const res = await client.unbondMixNode();
-    expect(res.transactionHash).toBeDefined();
-  }).timeout(10000);
-
-  it.skip('Can bond a mixnode', async () => {
-    const res = await client.bondMixNode(
-      {
-        identity_key: '3P6pAcF2p3pYMqWdpHqhbavu3ifyaBs5Qw5UmmCGwimx',
-        sphinx_key: 'GQMQKwUThaggatA6oZteSWTsCQoUfmLtamJ7o9YkP9aE',
-        host: '109.74.195.67',
-        mix_port: 1789,
-        verloc_port: 1790,
-        http_api_port: 8000,
-        version: '1.1.4',
-      },
-      '3rXWCQBUj5JQB3UBUkZcXhCk9Zh3cjduMF8aFHPTG7KTkkhZzDJTNmE2p2Ph1g6iQW5vRGTpQzjXF33WDwvhzHk6',
-      { profit_margin_percent: '0.1', interval_operating_cost: { amount: '40', denom: 'nym' } },
-      { amount: '100_000_000', denom: 'unym' },
-      { gas: '1000000', amount: [{ amount: '100000', denom: 'unym' }] },
-    );
-    expect(res.transactionHash).toBeDefined();
-  }).timeout(10000);
-
-  it.skip('can unbond a gateway', async () => {
-    const res = await client.unbondGateway();
-    expect(res.transactionHash).toBeDefined();
-  });
-
-  it.skip('can bond a gateway', async () => {
-    const res = await client.bondGateway(
-      {
-        identity_key: '36vfvEyBzo5cWEFbnP7fqgY39kFw9PQhvwzbispeNaxL',
-        sphinx_key: 'G65Fwc2JNAotuHQFqmDKhQNQL5rn3r9pupUdmxMygNUZ',
-        host: '151.236.220.82',
-        version: '1.1.4',
-        mix_port: 1789,
-        clients_port: 9000,
-        location: 'Cuba',
-      },
-      '3ipSJksWHehZm1YfuH5Ahtg7b22NnrP9hEs6iEDXfUS5uiUhpWmCjGR3b3NDHuxeGjpZYJNYJ52D8WCPK5ZR7Szj',
-      { amount: '100_000_000', denom: 'unym' },
-    );
-    expect(res.transactionHash).toBeDefined();
-  });
-
-  it.skip('can update contract state params', async () => {
-    const res = await client.updateContractStateParams({
-      minimum_mixnode_pledge: '',
-      minimum_gateway_pledge: '',
-      mixnode_rewarded_set_size: 2,
-      mixnode_active_set_size: 2,
-    });
-    expect(res.transactionHash).toBeDefined();
-  });
-});
@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "es6",
+        "module": "commonjs",
+        "esModuleInterop": true,
+        "strict": true,
+        "declaration": true,
+        "outDir": "./dist"
+    },
+    "exclude": [
+        "tests",
+        "dist",
+        "node_modules"
+    ]
+}
@@ -0,0 +1,157 @@
+import { Coin } from '@cosmjs/stargate';
+
+// TODO: ideally we'd have re-exported those using that fancy crate that builds ts types from rust
+
+export type MixnetContractVersion = {
+  build_timestamp: string;
+  build_version: string;
+  commit_sha: string;
+  commit_timestamp: string;
+  commit_branch: string;
+  rustc_version: string;
+};
+
+export type PagedMixnodeResponse = {
+  nodes: MixNodeBond[];
+  per_page: number;
+  start_next_after?: string;
+};
+
+export type PagedGatewayResponse = {
+  nodes: GatewayBond[];
+  per_page: number;
+  start_next_after?: string;
+};
+
+export type MixOwnershipResponse = {
+  address: string;
+  mixnode?: MixNodeBond;
+};
+
+export type GatewayOwnershipResponse = {
+  address: string;
+  gateway?: GatewayBond;
+};
+
+export type ContractStateParams = {
+  // ideally I'd want to define those as `number` rather than `string`, but
+  // rust-side they are defined as Uint128 and that don't have
+  // native javascript representations and therefore are interpreted as strings after deserialization
+  minimum_mixnode_pledge: string;
+  minimum_gateway_pledge: string;
+  mixnode_rewarded_set_size: number;
+  mixnode_active_set_size: number;
+};
+
+export type LayerDistribution = {
+  gateways: number;
+  layer1: number;
+  layer2: number;
+  layer3: number;
+};
+
+export type Delegation = {
+  owner: string;
+  node_identity: string;
+  amount: Coin;
+  block_height: number;
+  proxy?: string;
+};
+
+export type PagedMixDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: string;
+};
+
+export type PagedDelegatorDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: string;
+};
+
+export type PagedAllDelegationsResponse = {
+  delegations: Delegation[];
+  start_next_after?: [string, string];
+};
+
+export type RewardingResult = {
+  operator_reward: string;
+  total_delegator_reward: string;
+};
+
+export type NodeRewardParams = {
+  period_reward_pool: string;
+  k: string;
+  reward_blockstamp: number;
+  circulating_supply: string;
+  uptime: string;
+  sybil_resistance_percent: number;
+};
+
+export type DelegatorRewardParams = {
+  node_reward_params: NodeRewardParams;
+  sigma: number;
+  profit_margin: number;
+  node_profit: number;
+};
+
+export type PendingDelegatorRewarding = {
+  running_results: RewardingResult;
+  next_start: string;
+  rewarding_params: DelegatorRewardParams;
+};
+
+export type RewardingStatus = { Complete: RewardingResult } | { PendingNextDelegatorPage: PendingDelegatorRewarding };
+
+export type MixnodeRewardingStatusResponse = {
+  status?: RewardingStatus;
+};
+
+export enum Layer {
+  Gateway,
+  One,
+  Two,
+  Three,
+}
+
+export type MixNodeBond = {
+  owner: string;
+  mix_node: MixNode;
+  layer: Layer;
+  bond_amount: Coin;
+  total_delegation: Coin;
+};
+
+export type MixNode = {
+  host: string;
+  mix_port: number;
+  verloc_port: number;
+  http_api_port: number;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+  profit_margin_percent: number;
+};
+
+export type GatewayBond = {
+  owner: string;
+  gateway: Gateway;
+
+  bond_amount: Coin;
+  total_delegation: Coin;
+};
+
+export type Gateway = {
+  host: string;
+  mix_port: number;
+  clients_port: number;
+  location: string;
+  sphinx_key: string;
+  identity_key: string;
+  version: string;
+};
+
+export type SendRequest = {
+  senderAddress: string;
+  recipientAddress: string;
+  transferAmount: readonly Coin[];
+};
@@ -1,11 +0,0 @@
-declare namespace NodeJS {
-  interface ProcessEnv {
-    rpcAddress: string;
-    validatorAddress: string;
-    prefix: string;
-    mixnetContractAddress: string;
-    vestingContractAddress: string;
-    denom: string;
-    mnemonic: string;
-  }
-}
@@ -1,259 +0,0 @@
-import { JsonObject } from '@cosmjs/cosmwasm-stargate';
-import { Code, CodeDetails, Contract, ContractCodeHistoryEntry } from '@cosmjs/cosmwasm-stargate/build/cosmwasmclient';
-import {
-  Account,
-  Block,
-  Coin,
-  DeliverTxResponse,
-  IndexedTx,
-  SearchTxFilter,
-  SearchTxQuery,
-  SequenceResponse,
-} from '@cosmjs/stargate';
-import {
-  MixNodeRewarding,
-  PagedMixNodeBondResponse,
-  PagedMixNodeDetailsResponse,
-  StakeSaturationResponse,
-  UnbondedMixnodeResponse,
-} from '@nymproject/types';
-
-export type MixnetContractVersion = {
-  build_timestamp: string;
-  build_version: string;
-  commit_sha: string;
-  commit_timestamp: string;
-  commit_branch: string;
-  rustc_version: string;
-};
-
-export type PagedMixnodeResponse = {
-  nodes: MixNodeBond[];
-  per_page: number;
-  start_next_after?: string;
-};
-
-export type PagedGatewayResponse = {
-  nodes: GatewayBond[];
-  per_page: number;
-  start_next_after?: string;
-};
-
-export type MixOwnershipResponse = {
-  address: string;
-  mixnode?: MixNodeBond;
-};
-
-export type GatewayOwnershipResponse = {
-  address: string;
-  gateway?: GatewayBond;
-};
-
-export type ContractStateParams = {
-  // ideally I'd want to define those as `number` rather than `string`, but
-  // rust-side they are defined as Uint128 and that don't have
-  // native javascript representations and therefore are interpreted as strings after deserialization
-  minimum_mixnode_pledge: string;
-  minimum_gateway_pledge: string;
-  mixnode_rewarded_set_size: number;
-  mixnode_active_set_size: number;
-};
-
-export type LayerDistribution = {
-  gateways: number;
-  layer1: number;
-  layer2: number;
-  layer3: number;
-};
-
-export type Delegation = {
-  owner: string;
-  node_identity: string;
-  amount: Coin;
-  block_height: number;
-  proxy?: string;
-};
-
-export type PagedMixDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: string;
-};
-
-export type PagedDelegatorDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: string;
-};
-
-export type PagedAllDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: [string, string];
-};
-
-export type RewardingResult = {
-  operator_reward: string;
-  total_delegator_reward: string;
-};
-
-export type NodeRewardParams = {
-  period_reward_pool: string;
-  k: string;
-  reward_blockstamp: number;
-  circulating_supply: string;
-  uptime: string;
-  sybil_resistance_percent: number;
-};
-
-export type DelegatorRewardParams = {
-  node_reward_params: NodeRewardParams;
-  sigma: number;
-  profit_margin: number;
-  node_profit: number;
-};
-
-export type PendingDelegatorRewarding = {
-  running_results: RewardingResult;
-  next_start: string;
-  rewarding_params: DelegatorRewardParams;
-};
-
-export type RewardingStatus = { Complete: RewardingResult } | { PendingNextDelegatorPage: PendingDelegatorRewarding };
-
-export type MixnodeRewardingStatusResponse = {
-  status?: RewardingStatus;
-};
-
-export enum Layer {
-  Gateway,
-  One,
-  Two,
-  Three,
-}
-
-export type MixNodeBond = {
-  owner: string;
-  mix_node: MixNode;
-  layer: Layer;
-  bond_amount: Coin;
-  total_delegation: Coin;
-};
-
-export type MixNode = {
-  host: string;
-  mix_port: number;
-  verloc_port: number;
-  http_api_port: number;
-  sphinx_key: string;
-  identity_key: string;
-  version: string;
-  profit_margin_percent: number;
-};
-
-export type GatewayBond = {
-  owner: string;
-  gateway: Gateway;
-
-  bond_amount: Coin;
-  total_delegation: Coin;
-};
-
-export type Gateway = {
-  host: string;
-  mix_port: number;
-  clients_port: number;
-  location: string;
-  sphinx_key: string;
-  identity_key: string;
-  version: string;
-};
-
-export type SendRequest = {
-  senderAddress: string;
-  recipientAddress: string;
-  transferAmount: readonly Coin[];
-};
-
-export interface SmartContractQuery {
-  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
-}
-export interface ICosmWasmQuery {
-  // methods exposed by `CosmWasmClient`
-  getChainId(): Promise<string>;
-  getHeight(): Promise<number>;
-  getAccount(searchAddress: string): Promise<Account | null>;
-  getSequence(address: string): Promise<SequenceResponse>;
-  getBlock(height?: number): Promise<Block>;
-  getBalance(address: string, searchDenom: string): Promise<Coin>;
-  getTx(id: string): Promise<IndexedTx | null>;
-  searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise<readonly IndexedTx[]>;
-  disconnect(): void;
-  broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
-  getCodes(): Promise<readonly Code[]>;
-  getCodeDetails(codeId: number): Promise<CodeDetails>;
-  getContracts(codeId: number): Promise<readonly string[]>;
-  getContract(address: string): Promise<Contract>;
-  getContractCodeHistory(address: string): Promise<readonly ContractCodeHistoryEntry[]>;
-  queryContractRaw(address: string, key: Uint8Array): Promise<Uint8Array | null>;
-  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
-}
-
-export interface INymdQuery {
-  // nym-specific implemented inside NymQuerier
-  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
-  getMixNodeBonds(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeBondResponse>;
-  getMixNodesDetailed(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixNodeDetailsResponse>;
-  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse>;
-  getOwnedMixnode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
-  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-  getStateParams(mixnetContractAddress: string): Promise<ContractState>;
-  getAllNetworkDelegationsPaged(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: [string, string],
-  ): Promise<PagedAllDelegationsResponse>;
-  getMixNodeDelegationsPaged(
-    mixnetContractAddress: string,
-    mix_id: number,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixDelegationsResponse>;
-  getDelegatorDelegationsPaged(
-    mixnetContractAddress: string,
-    delegator: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedDelegatorDelegationsResponse>;
-  getDelegationDetails(mixnetContractAddress: string, mix_id: number, delegator: string): Promise<Delegation>;
-  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
-  getStakeSaturation(mixnetContractAddress: string, mixId: number): Promise<StakeSaturationResponse>;
-  getUnbondedMixNodeInformation(mixnetContractAddress: string, mixId: number): Promise<UnbondedMixnodeResponse>;
-  getMixnodeRewardingDetails(mixnetContractAddress: string, mixId: number): Promise<MixNodeRewarding>;
-}
-
-export interface IVestingQuerier {
-  getVestingContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
-}
-
-export interface MappedCoin {
-  readonly denom: string;
-  readonly fractionalDigits: number;
-}
-
-export interface CoinMap {
-  readonly [key: string]: MappedCoin;
-}
-
-export interface ContractState {
-  owner: string;
-  rewarding_validator_address: string;
-  vesting_contract_address: string;
-  rewarding_denom: string;
-  params: ContractStateParams;
-}
@@ -0,0 +1,11 @@
+import ValidatorClient from '../../validator/index';
+import expect from 'expect';
+
+describe('Query: balances', () => {
+  it('can query for an account balance', async () => {
+    const client = await ValidatorClient.connectForQuery(
+      'https://rpc.nymtech.net/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
+    const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
+    expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
+  }).timeout(5000);
+})
@@ -0,0 +1,14 @@
+import ValidatorClient from '../../dist';
+import expect from 'expect';
+
+// TODO: implement for QA with .env for mnemonics
+// describe('Sign: send', () => {
+//   it('can send tokens', async () => {
+//     const client = await ValidatorClient.connect(
+//       '<ADD MNEMONIC HERE>',
+//       'https://rpc.nyx.nodes.guru/', 'https://validator.nymtech.net/api/', 'n', 'n14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9sjyvg3g', 'n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw', 'nym');
+//     await client.send('<ADD ADDRESS HERE>')
+//     const balance = await client.getBalance('n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy');
+//     expect(Number.parseFloat(balance.amount)).toBeGreaterThan(0);
+//   }).timeout(5000);
+// })
@@ -1,22 +1,23 @@
 {
-  "compilerOptions": {
-    "outDir": "./dist/nym-validator-client",
-    "module": "ES2020",
-    "target": "es2021",
-    "allowJs": false,
-    "strict": true,
-    "lib": ["es2021", "dom", "dom.iterable", "esnext"],
-    "moduleResolution": "node",
-    "skipDefaultLibCheck": true,
-    "esModuleInterop": true,
-    "declaration": true,
-    "skipLibCheck": true,
-    "noImplicitAny": true,
-    "typeRoots": ["./src/types/global.d.ts"]
-  },
-  "typedocOptions": {
-    "entryPoints": ["./src/index.ts"],
-    "out": "docs"
-  },
-  "exclude": ["dist", "./src/tests/**/*", "node_module"]
-}
+    "compilerOptions": {
+        "target": "es6",
+        "module": "commonjs",
+        "esModuleInterop": true,
+        "strict": true,
+        "declaration": true,
+        "outDir": "./dist",
+        "skipLibCheck": true
+    },
+    "typedocOptions": {
+        "entryPoints": [
+            "src/index.ts"
+        ],
+        "out": "docs"
+    },
+    "exclude": [
+        "dist",
+        "examples",
+        "tests",
+        "node_modules"
+    ]
+}
@@ -1,6 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "CommonJS"
-  }
-}
@@ -31,8 +31,8 @@ wasm-bindgen-futures = "0.4"

 # internal
 client-core = { path = "../client-core", default-features = false, features = ["wasm"] }
-nym-coconut-interface = { path = "../../common/coconut-interface" }
-nym-credentials = { path = "../../common/credentials" }
+coconut-interface = { path = "../../common/coconut-interface" }
+credentials = { path = "../../common/credentials" }
 nym-crypto = { path = "../../common/crypto" }
 nym-sphinx = { path = "../../common/nymsphinx" }
 gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm"] }
@@ -3,15 +3,8 @@

 // due to expansion of #[wasm_bindgen] macro on `Debug` Config struct
 #![allow(clippy::drop_non_drop)]
-// another issue due to #[wasm_bindgen] and `Copy` trait
-#![allow(clippy::drop_copy)]

-use client_core::config::{
-    Acknowledgements as ConfigAcknowledgements, CoverTraffic as ConfigCoverTraffic,
-    DebugConfig as ConfigDebug, ExtendedPacketSize, GatewayConnection as ConfigGatewayConnection,
-    GatewayEndpointConfig, ReplySurbs as ConfigReplySurbs, Topology as ConfigTopology,
-    Traffic as ConfigTraffic,
-};
+use client_core::config::{DebugConfig as ConfigDebug, ExtendedPacketSize, GatewayEndpointConfig};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -55,124 +48,15 @@ impl Config {
    }
 }

+// just a helper structure to more easily pass through the JS boundary
 #[wasm_bindgen]
-#[derive(Debug, Copy, Clone)]
-pub struct Traffic {
+pub struct Debug {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent packet is going to be delayed at any given mix node.
    /// So for a packet going through three mix nodes, on average, it will take three times this value
    /// until the packet reaches its destination.
    pub average_packet_delay_ms: u64,

-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take another 'real traffic stream' message to be sent.
-    /// If no real packets are available and cover traffic is enabled,
-    /// a loop cover message is sent instead in order to preserve the rate.
-    pub message_sending_average_delay_ms: u64,
-
-    /// Controls whether the main packet stream constantly produces packets according to the predefined
-    /// poisson distribution.
-    pub disable_main_poisson_packet_distribution: bool,
-
-    /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size.
-    pub use_extended_packet_size: bool,
-}
-
-impl From<Traffic> for ConfigTraffic {
-    fn from(traffic: Traffic) -> Self {
-        let use_extended_packet_size = traffic
-            .use_extended_packet_size
-            .then(|| ExtendedPacketSize::Extended32);
-
-        ConfigTraffic {
-            average_packet_delay: Duration::from_millis(traffic.average_packet_delay_ms),
-            message_sending_average_delay: Duration::from_millis(
-                traffic.message_sending_average_delay_ms,
-            ),
-            disable_main_poisson_packet_distribution: traffic
-                .disable_main_poisson_packet_distribution,
-            use_extended_packet_size,
-        }
-    }
-}
-
-impl From<ConfigTraffic> for Traffic {
-    fn from(traffic: ConfigTraffic) -> Self {
-        Traffic {
-            average_packet_delay_ms: traffic.average_packet_delay.as_millis() as u64,
-            message_sending_average_delay_ms: traffic.message_sending_average_delay.as_millis()
-                as u64,
-            disable_main_poisson_packet_distribution: traffic
-                .disable_main_poisson_packet_distribution,
-            use_extended_packet_size: traffic.use_extended_packet_size.is_some(),
-        }
-    }
-}
-
-#[wasm_bindgen]
-#[derive(Debug, Copy, Clone)]
-pub struct CoverTraffic {
-    /// The parameter of Poisson distribution determining how long, on average,
-    /// it is going to take for another loop cover traffic message to be sent.
-    pub loop_cover_traffic_average_delay_ms: u64,
-
-    /// Controls whether the dedicated loop cover traffic stream should be enabled.
-    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay])
-    pub disable_loop_cover_traffic_stream: bool,
-}
-
-impl From<CoverTraffic> for ConfigCoverTraffic {
-    fn from(cover_traffic: CoverTraffic) -> Self {
-        ConfigCoverTraffic {
-            loop_cover_traffic_average_delay: Duration::from_millis(
-                cover_traffic.loop_cover_traffic_average_delay_ms,
-            ),
-            disable_loop_cover_traffic_stream: cover_traffic.disable_loop_cover_traffic_stream,
-        }
-    }
-}
-
-impl From<ConfigCoverTraffic> for CoverTraffic {
-    fn from(cover_traffic: ConfigCoverTraffic) -> Self {
-        CoverTraffic {
-            loop_cover_traffic_average_delay_ms: cover_traffic
-                .loop_cover_traffic_average_delay
-                .as_millis() as u64,
-            disable_loop_cover_traffic_stream: cover_traffic.disable_loop_cover_traffic_stream,
-        }
-    }
-}
-
-#[wasm_bindgen]
-#[derive(Debug, Copy, Clone)]
-pub struct GatewayConnection {
-    /// How long we're willing to wait for a response to a message sent to the gateway,
-    /// before giving up on it.
-    pub gateway_response_timeout_ms: u64,
-}
-
-impl From<GatewayConnection> for ConfigGatewayConnection {
-    fn from(gateway_connection: GatewayConnection) -> Self {
-        ConfigGatewayConnection {
-            gateway_response_timeout: Duration::from_millis(
-                gateway_connection.gateway_response_timeout_ms,
-            ),
-        }
-    }
-}
-
-impl From<ConfigGatewayConnection> for GatewayConnection {
-    fn from(gateway_connection: ConfigGatewayConnection) -> Self {
-        GatewayConnection {
-            gateway_response_timeout_ms: gateway_connection.gateway_response_timeout.as_millis()
-                as u64,
-        }
-    }
-}
-
-#[wasm_bindgen]
-#[derive(Debug, Copy, Clone)]
-pub struct Acknowledgements {
    /// The parameter of Poisson distribution determining how long, on average,
    /// sent acknowledgement is going to be delayed at any given mix node.
    /// So for an ack going through three mix nodes, on average, it will take three times this value
@@ -188,31 +72,21 @@ pub struct Acknowledgements {
    /// it is assumed it was lost and retransmission of the data packet happens.
    /// In an ideal network with 0 latency, this value would have been 0.
    pub ack_wait_addition_ms: u64,
-}

-impl From<Acknowledgements> for ConfigAcknowledgements {
-    fn from(acknowledgements: Acknowledgements) -> Self {
-        ConfigAcknowledgements {
-            average_ack_delay: Duration::from_millis(acknowledgements.average_ack_delay_ms),
-            ack_wait_multiplier: acknowledgements.ack_wait_multiplier,
-            ack_wait_addition: Duration::from_millis(acknowledgements.ack_wait_addition_ms),
-        }
-    }
-}
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take for another loop cover traffic message to be sent.
+    pub loop_cover_traffic_average_delay_ms: u64,

-impl From<ConfigAcknowledgements> for Acknowledgements {
-    fn from(acknowledgements: ConfigAcknowledgements) -> Self {
-        Acknowledgements {
-            average_ack_delay_ms: acknowledgements.average_ack_delay.as_millis() as u64,
-            ack_wait_multiplier: acknowledgements.ack_wait_multiplier,
-            ack_wait_addition_ms: acknowledgements.ack_wait_addition.as_millis() as u64,
-        }
-    }
-}
+    /// The parameter of Poisson distribution determining how long, on average,
+    /// it is going to take another 'real traffic stream' message to be sent.
+    /// If no real packets are available and cover traffic is enabled,
+    /// a loop cover message is sent instead in order to preserve the rate.
+    pub message_sending_average_delay_ms: u64,
+
+    /// How long we're willing to wait for a response to a message sent to the gateway,
+    /// before giving up on it.
+    pub gateway_response_timeout_ms: u64,

-#[wasm_bindgen]
-#[derive(Debug, Copy, Clone)]
-pub struct Topology {
    /// The uniform delay every which clients are querying the directory server
    /// to try to obtain a compatible network topology to send sphinx packets through.
    pub topology_refresh_rate_ms: u64,
@@ -221,31 +95,18 @@ pub struct Topology {
    /// path. This timeout determines waiting period until it is decided that the packet
    /// did not reach its destination.
    pub topology_resolution_timeout_ms: u64,
-}

-impl From<Topology> for ConfigTopology {
-    fn from(topology: Topology) -> Self {
-        ConfigTopology {
-            topology_refresh_rate: Duration::from_millis(topology.topology_refresh_rate_ms),
-            topology_resolution_timeout: Duration::from_millis(
-                topology.topology_resolution_timeout_ms,
-            ),
-        }
-    }
-}
+    /// Controls whether the dedicated loop cover traffic stream should be enabled.
+    /// (and sending packets, on average, every [Self::loop_cover_traffic_average_delay_ms])
+    pub disable_loop_cover_traffic_stream: bool,

-impl From<ConfigTopology> for Topology {
-    fn from(topology: ConfigTopology) -> Self {
-        Topology {
-            topology_refresh_rate_ms: topology.topology_refresh_rate.as_millis() as u64,
-            topology_resolution_timeout_ms: topology.topology_resolution_timeout.as_millis() as u64,
-        }
-    }
-}
+    /// Controls whether the main packet stream constantly produces packets according to the predefined
+    /// poisson distribution.
+    pub disable_main_poisson_packet_distribution: bool,
+
+    /// Controls whether the sent sphinx packet use the NON-DEFAULT bigger size.
+    pub use_extended_packet_size: bool,

-#[wasm_bindgen]
-#[derive(Debug, Copy, Clone)]
-pub struct ReplySurbs {
    /// Defines the minimum number of reply surbs the client wants to keep in its storage at all times.
    /// It can only allow to go below that value if its to request additional reply surbs.
    pub minimum_reply_surb_storage_threshold: usize,
@@ -279,80 +140,46 @@ pub struct ReplySurbs {
    pub maximum_reply_key_age_ms: u64,
 }

-impl From<ReplySurbs> for ConfigReplySurbs {
-    fn from(reply_surbs: ReplySurbs) -> Self {
-        ConfigReplySurbs {
-            minimum_reply_surb_storage_threshold: reply_surbs.minimum_reply_surb_storage_threshold,
-            maximum_reply_surb_storage_threshold: reply_surbs.maximum_reply_surb_storage_threshold,
-            minimum_reply_surb_request_size: reply_surbs.minimum_reply_surb_request_size,
-            maximum_reply_surb_request_size: reply_surbs.maximum_reply_surb_request_size,
-            maximum_allowed_reply_surb_request_size: reply_surbs
-                .maximum_allowed_reply_surb_request_size,
-            maximum_reply_surb_rerequest_waiting_period: Duration::from_millis(
-                reply_surbs.maximum_reply_surb_rerequest_waiting_period_ms,
-            ),
-            maximum_reply_surb_drop_waiting_period: Duration::from_millis(
-                reply_surbs.maximum_reply_surb_drop_waiting_period_ms,
-            ),
-            maximum_reply_surb_age: Duration::from_millis(reply_surbs.maximum_reply_surb_age_ms),
-            maximum_reply_key_age: Duration::from_millis(reply_surbs.maximum_reply_key_age_ms),
-        }
-    }
-}
-
-impl From<ConfigReplySurbs> for ReplySurbs {
-    fn from(reply_surbs: ConfigReplySurbs) -> Self {
-        ReplySurbs {
-            minimum_reply_surb_storage_threshold: reply_surbs.minimum_reply_surb_storage_threshold,
-            maximum_reply_surb_storage_threshold: reply_surbs.maximum_reply_surb_storage_threshold,
-            minimum_reply_surb_request_size: reply_surbs.minimum_reply_surb_request_size,
-            maximum_reply_surb_request_size: reply_surbs.maximum_reply_surb_request_size,
-            maximum_allowed_reply_surb_request_size: reply_surbs
-                .maximum_allowed_reply_surb_request_size,
-            maximum_reply_surb_rerequest_waiting_period_ms: reply_surbs
-                .maximum_reply_surb_rerequest_waiting_period
-                .as_millis() as u64,
-            maximum_reply_surb_drop_waiting_period_ms: reply_surbs
-                .maximum_reply_surb_drop_waiting_period
-                .as_millis() as u64,
-            maximum_reply_surb_age_ms: reply_surbs.maximum_reply_surb_age.as_millis() as u64,
-            maximum_reply_key_age_ms: reply_surbs.maximum_reply_key_age.as_millis() as u64,
-        }
-    }
-}
-
-// just a helper structure to more easily pass through the JS boundary
-#[wasm_bindgen]
-#[derive(Debug, Copy, Clone)]
-pub struct Debug {
-    /// Defines all configuration options related to traffic streams.
-    pub traffic: Traffic,
-
-    /// Defines all configuration options related to cover traffic stream(s).
-    pub cover_traffic: CoverTraffic,
-
-    /// Defines all configuration options related to the gateway connection.
-    pub gateway_connection: GatewayConnection,
-
-    /// Defines all configuration options related to acknowledgements, such as delays or wait timeouts.
-    pub acknowledgements: Acknowledgements,
-
-    /// Defines all configuration options related topology, such as refresh rates or timeouts.
-    pub topology: Topology,
-
-    /// Defines all configuration options related to reply SURBs.
-    pub reply_surbs: ReplySurbs,
-}
-
 impl From<Debug> for ConfigDebug {
    fn from(debug: Debug) -> Self {
+        // For now we just always use the (older) 32kb extended size
+        let use_extended_packet_size = debug
+            .use_extended_packet_size
+            .then(|| ExtendedPacketSize::Extended32);
+
        ConfigDebug {
-            traffic: debug.traffic.into(),
-            cover_traffic: debug.cover_traffic.into(),
-            gateway_connection: debug.gateway_connection.into(),
-            acknowledgements: debug.acknowledgements.into(),
-            topology: debug.topology.into(),
-            reply_surbs: debug.reply_surbs.into(),
+            average_packet_delay: Duration::from_millis(debug.average_packet_delay_ms),
+            average_ack_delay: Duration::from_millis(debug.average_ack_delay_ms),
+            ack_wait_multiplier: debug.ack_wait_multiplier,
+            ack_wait_addition: Duration::from_millis(debug.ack_wait_addition_ms),
+            loop_cover_traffic_average_delay: Duration::from_millis(
+                debug.loop_cover_traffic_average_delay_ms,
+            ),
+            message_sending_average_delay: Duration::from_millis(
+                debug.message_sending_average_delay_ms,
+            ),
+            gateway_response_timeout: Duration::from_millis(debug.gateway_response_timeout_ms),
+            topology_refresh_rate: Duration::from_millis(debug.topology_refresh_rate_ms),
+            topology_resolution_timeout: Duration::from_millis(
+                debug.topology_resolution_timeout_ms,
+            ),
+            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
+            disable_main_poisson_packet_distribution: debug
+                .disable_main_poisson_packet_distribution,
+            use_extended_packet_size,
+            minimum_reply_surb_storage_threshold: debug.minimum_reply_surb_storage_threshold,
+            maximum_reply_surb_storage_threshold: debug.maximum_reply_surb_storage_threshold,
+            minimum_reply_surb_request_size: debug.minimum_reply_surb_request_size,
+            maximum_reply_surb_request_size: debug.maximum_reply_surb_request_size,
+            maximum_allowed_reply_surb_request_size: debug.maximum_allowed_reply_surb_request_size,
+            maximum_reply_surb_rerequest_waiting_period: Duration::from_millis(
+                debug.maximum_reply_surb_rerequest_waiting_period_ms,
+            ),
+            maximum_reply_surb_drop_waiting_period: Duration::from_millis(
+                debug.maximum_reply_surb_drop_waiting_period_ms,
+            ),
+            maximum_reply_surb_age: Duration::from_millis(debug.maximum_reply_surb_age_ms),
+            maximum_reply_key_age: Duration::from_millis(debug.maximum_reply_key_age_ms),
        }
    }
 }
@@ -360,12 +187,34 @@ impl From<Debug> for ConfigDebug {
 impl From<ConfigDebug> for Debug {
    fn from(debug: ConfigDebug) -> Self {
        Debug {
-            traffic: debug.traffic.into(),
-            cover_traffic: debug.cover_traffic.into(),
-            gateway_connection: debug.gateway_connection.into(),
-            acknowledgements: debug.acknowledgements.into(),
-            topology: debug.topology.into(),
-            reply_surbs: debug.reply_surbs.into(),
+            average_packet_delay_ms: debug.average_packet_delay.as_millis() as u64,
+            average_ack_delay_ms: debug.average_ack_delay.as_millis() as u64,
+            ack_wait_multiplier: debug.ack_wait_multiplier,
+            ack_wait_addition_ms: debug.ack_wait_addition.as_millis() as u64,
+            loop_cover_traffic_average_delay_ms: debug.loop_cover_traffic_average_delay.as_millis()
+                as u64,
+            message_sending_average_delay_ms: debug.message_sending_average_delay.as_millis()
+                as u64,
+            gateway_response_timeout_ms: debug.gateway_response_timeout.as_millis() as u64,
+            topology_refresh_rate_ms: debug.topology_refresh_rate.as_millis() as u64,
+            topology_resolution_timeout_ms: debug.topology_resolution_timeout.as_millis() as u64,
+            disable_loop_cover_traffic_stream: debug.disable_loop_cover_traffic_stream,
+            disable_main_poisson_packet_distribution: debug
+                .disable_main_poisson_packet_distribution,
+            use_extended_packet_size: debug.use_extended_packet_size.is_some(),
+            minimum_reply_surb_storage_threshold: debug.minimum_reply_surb_storage_threshold,
+            maximum_reply_surb_storage_threshold: debug.maximum_reply_surb_storage_threshold,
+            minimum_reply_surb_request_size: debug.minimum_reply_surb_request_size,
+            maximum_reply_surb_request_size: debug.maximum_reply_surb_request_size,
+            maximum_allowed_reply_surb_request_size: debug.maximum_allowed_reply_surb_request_size,
+            maximum_reply_surb_rerequest_waiting_period_ms: debug
+                .maximum_reply_surb_rerequest_waiting_period
+                .as_millis() as u64,
+            maximum_reply_surb_drop_waiting_period_ms: debug
+                .maximum_reply_surb_drop_waiting_period
+                .as_millis() as u64,
+            maximum_reply_surb_age_ms: debug.maximum_reply_surb_age.as_millis() as u64,
+            maximum_reply_key_age_ms: debug.maximum_reply_key_age.as_millis() as u64,
        }
    }
 }
@@ -82,14 +82,8 @@ impl NymClientBuilder {
    // with no persistence
    fn setup_reply_surb_storage_backend(config: &Config) -> browser_backend::Backend {
        browser_backend::Backend::new(
-            config
-                .debug
-                .reply_surbs
-                .minimum_reply_surb_storage_threshold,
-            config
-                .debug
-                .reply_surbs
-                .maximum_reply_surb_storage_threshold,
+            config.debug.minimum_reply_surb_storage_threshold,
+            config.debug.maximum_reply_surb_storage_threshold,
        )
    }

@@ -0,0 +1,10 @@
+[package]
+name = "bandwidth-claim-contract"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+schemars = "0.8"
+serde = { version = "1.0.103", default-features = false, features = ["derive"] }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
farbanas	fbc8fa24c4	add yarn install	2023-02-27 13:10:09 +01:00
farbanas	bafefbf8a6	trying to fix workflow on our custom mac runner	2023-02-27 13:04:58 +01:00
farbanas	09c0a74107	chore: changed mac runner to our new custom one	2023-02-27 11:31:58 +01:00