auto commit generated command files

clippy
tweak works
2024-12-09 15:00:18 +01:00 · 2024-12-09 14:54:15 +01:00 · 2024-12-09 13:19:52 +01:00 · 2024-12-09 13:10:20 +01:00 · 2024-12-09 13:07:03 +01:00 · 2024-12-09 13:02:28 +01:00
472 changed files with 10877 additions and 12203 deletions
@@ -34,6 +34,7 @@ jobs:
    runs-on: ${{ matrix.os }}
    env:
      CARGO_TERM_COLOR: always
+      IPINFO_API_TOKEN: ${{ secrets.IPINFO_API_TOKEN }}
    steps:
      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
@@ -8,7 +8,7 @@ on:
        description: Which gateway probe git ref to build the image with

 env:
-  WORKING_DIRECTORY: "nym-node-status-agent"
+  WORKING_DIRECTORY: "nym-node-status-api/nym-node-status-agent"
  CONTAINER_NAME: "node-status-agent"

 jobs:
@@ -58,4 +58,4 @@ jobs:
      - name: BuildAndPushImageOnHarbor
        run: |
          docker build --build-arg GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }} -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
-          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
@@ -3,7 +3,7 @@ on:
  workflow_dispatch:

 env:
-  WORKING_DIRECTORY: "nym-node-status-api"
+  WORKING_DIRECTORY: "nym-node-status-api/nym-node-status-api"
  CONTAINER_NAME: "node-status-api"

 jobs:
@@ -0,0 +1,55 @@
+name: Build and upload Nyx Chain Watcher container to harbor.nymte.ch
+on:
+  workflow_dispatch:
+
+env:
+  WORKING_DIRECTORY: "nyx-chain-watcher"
+  CONTAINER_NAME: "nyx-chain-watcher"
+
+jobs:
+  build-container:
+    runs-on: arc-ubuntu-22.04-dind
+    steps:
+      - name: Login to Harbor
+        uses: docker/login-action@v3
+        with:
+          registry: harbor.nymte.ch
+          username: ${{ secrets.HARBOR_ROBOT_USERNAME }}
+          password: ${{ secrets.HARBOR_ROBOT_SECRET }}
+
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Configure git identity
+        run: |
+          git config --global user.email "lawrence@nymtech.net"
+          git config --global user.name "Lawrence Stalder"
+
+      - name: Get version from cargo.toml
+        uses: mikefarah/yq@v4.44.5
+        id: get_version
+        with:
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
+
+      - name: Check if tag exists
+        run: |
+          if git rev-parse ${{ steps.get_version.outputs.value }} >/dev/null 2>&1; then
+            echo "Tag ${{ steps.get_version.outputs.value }} already exists"
+          fi
+
+      - name: Remove existing tag if exists
+        run: |
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
+            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+          fi
+
+      - name: Create tag
+        run: |
+          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
+          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+
+      - name: BuildAndPushImageOnHarbor
+        run: |
+          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
@@ -29,7 +29,7 @@ jobs:
        uses: mikefarah/yq@v4.44.5
        id: get_version
        with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/nym-credential-proxy/Cargo.toml
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

      - name: Remove existing tag if exists
        run: |
@@ -4,6 +4,16 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

+## [2024.13-magura-drift] (2024-11-29)
+
+- Optimised syncing bandwidth information to storage
+
+## [2024.13-magura-patched] (2024-11-22)
+
+- [experimental] allow clients to change between deterministic route selection based on packet headers and a pseudorandom distribution
+- Introduced a configurable limit on retransmission frequency of packets if ACKs are not received
+- Filtered out invalid IP addresses on nym-api
+
 ## [2024.13-magura] (2024-11-18)

 - Limit race probability ([#5145])
@@ -61,7 +61,6 @@ members = [
    "common/ip-packet-requests",
    "common/ledger",
    "common/mixnode-common",
-    "common/models",
    "common/network-defaults",
    "common/node-tester-utils",
    "common/nonexhaustive-delayqueue",
@@ -99,13 +98,12 @@ members = [
    "common/wasm/utils",
    "common/wireguard",
    "common/wireguard-types",
-    # "documentation/autodoc",
+    "documentation/autodoc",
    "explorer-api",
    "explorer-api/explorer-api-requests",
    "explorer-api/explorer-client",
    "gateway",
    "integrations/bity",
-    "mixnode",
    "sdk/ffi/cpp",
    "sdk/ffi/go",
    "sdk/ffi/shared",
@@ -124,10 +122,11 @@ members = [
    "nym-data-observatory",
    "nym-network-monitor",
    "nym-node",
-    "nym-node/nym-node-http-api",
    "nym-node/nym-node-requests",
-    "nym-node-status-api",
-    "nym-node-status-agent",
+    "nym-node/nym-node-metrics",
+    "nym-node-status-api/nym-node-status-agent",
+    "nym-node-status-api/nym-node-status-api",
+    "nym-node-status-api/nym-node-status-client",
    "nym-outfox",
    "nym-validator-rewarder",
    "tools/echo-server",
@@ -149,23 +148,22 @@ members = [
    "tools/internal/contract-state-importer/importer-cli",
    "tools/internal/contract-state-importer/importer-contract",
    "tools/internal/testnet-manager",
-    "tools/internal/testnet-manager/dkg-bypass-contract", "common/nym-tui-common",
+    "tools/internal/testnet-manager/dkg-bypass-contract",
+    "common/verloc",
+    "tools/internal/mixnet-connectivity-check",
 ]

 default-members = [
    "clients/native",
    "clients/socks5",
-    "common/models",
    "explorer-api",
-    "gateway",
-    "mixnode",
    "nym-api",
    "nym-credential-proxy/nym-credential-proxy",
    "nym-data-observatory",
    "nym-node",
-    "nym-node-status-api",
+    "nym-node-status-api/nym-node-status-agent",
+    "nym-node-status-api/nym-node-status-api",
    "nym-validator-rewarder",
-    "nym-node-status-api",
    "service-providers/authenticator",
    "service-providers/ip-packet-router",
    "service-providers/network-requester",
@@ -264,6 +262,7 @@ http-body-util = "0.1"
 httpcodec = "0.2.3"
 humantime = "2.1.0"
 humantime-serde = "1.1.1"
+human-repr = "1.1.0"
 hyper = "1.4.1"
 hyper-util = "0.1"
 indicatif = "0.17.8"
@@ -412,15 +411,6 @@ wasm-bindgen-futures = "0.4.45"
 wasmtimer = "0.2.0"
 web-sys = "0.3.72"

-# tui related
-better-panic = "0.3.0"
-color-eyre = "0.6.3"
-crossterm = "0.28.1"
-strip-ansi-escapes = "0.2.0"
-ratatui = "0.29.0"
-tui-logger = "0.14.0"
-
-
 # Profile settings for individual crates

 # Compile-time verified queries do quite a bit of work at compile time. Incremental
@@ -3,37 +3,23 @@ Critical bug or security issue 💥
 If you're here because you're trying to figure out how to notify us of a security issue, send us a PGP encrypted email to:

 ```
-security@nymte.ch
+security@nym.com
 ```

 Encrypted with our public key which is available below in plain text and also on keyservers:

 ```
-pub   rsa4096 2023-10-30 [SC] [expire : 2026-10-29]
+sec   rsa4096/7C3C727F05090550 2023-10-30 [SC] [expire : 2026-10-29]
      24B2592E801A5AAA8666C8BA7C3C727F05090550
-uid          [  ultime ] Security Nym Technologies <security@nymte.ch>
-sub   rsa4096 2023-10-30 [E] [expire : 2026-10-29]
+uid                [  ultime ] Security Nym Technologies <security@nym.com>
+ssb   rsa4096/ACD0FBD79DC70ACC 2023-10-30 [E] [expire : 2026-10-29]

 ```

 The fingerprint of the key is on the second line above.

-If you need to chat __urgently__ to our team for a __critical__ security issue:
-
-go to Matrix, and alert the core engineers with a private direct message:
-
-    Jedrzej Stuczynski @jstuczyn:nymtech.chat
-    Mark Sinclair @mark:nymtech.chat
-    Raphaël Walther @raphael:nymtech.chat
-
 Please avoid opening public issues on GitHub that contain information about a potential security vulnerability as this makes it difficult to reduce the impact and harm of valid security issues.

-If you don't know what Matrix is, you can follow this documentation to create an account on this federation of instant messaging servers:
-
-[Matrix for Instant Messaging](https://matrix.org/docs/chat_basics/matrix-for-im/)
-
-
-
 ```
 -----BEGIN PGP PUBLIC KEY BLOCK-----

@@ -48,43 +34,69 @@ vMFUIzBMHOPXH16036zGyFMC1esRd2qqil4b9KtLgCOkrD1VgpjcveoA0VyMJCN6
 LmKTrVjwjjDMxby+d49BolRWGnCofXozXwvNQx+CYv8M2WPErTpyYoofYFtpqr7A
 fIufc/e0+um3zoGIbHejrhsbuH9Qf+MKsI+Ng93bdDtjeHz6MEgAlsTm0qeizYpj
 IyKZIObPmfvrAm08hFZ8JnGk+XuooF36XWbJYjCCy0bOyMw1r7ZG99TcSwARAQAB
-tC1TZWN1cml0eSBOeW0gVGVjaG5vbG9naWVzIDxzZWN1cml0eUBueW10ZS5jaD6J
-AlQEEwEKAD4WIQQkslkugBpaqoZmyLp8PHJ/BQkFUAUCZT9elwIbAwUJBaOagAUL
-CQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRB8PHJ/BQkFUL7dD/9zO73uI5VR+SWx
-PFmJW+9QsPiQbVRvGwNZurctmQ2s2Pe0vHRELFeqD5oYvSx2Lequ3Ir+zn/C3kDM
-kNs40obSL6jCBiLPkxEY0JqzPM9jZr7EjvlibWV3f6DxooRIqEyfN57I3OBGlqZE
-0Mx7sQuCcgau8C70DF952QhKUwXC2cmpmDKHVEEoio1xGSD4dQhGapCB32RQGtna
-OGfAO9celNMvSq0Lp+aJxeACmWFY5T4/y79JPcT5vSs/yEIRmaH/fn2piwaFBsIq
-gHJJMxO3740P1hF8j7KWUoUofuFaEALHBpEpjWTOj8ej1wmFlu+5F+jSVoc781Wb
-ZZXu04cOBXnGTogzSxMpBe9TtLb28zd6WzFotC25KTI3pngMzXsQGLJLOwvoZKiS
-LFjPRjg1rwobmB3Q3J2W5GYSveia0CDsZGP+g87GVVf/oD2Djpa68xyVYwIYeA6T
-3DNdS77qHiRuGiS4kWXyVjDqOICboR4uCvt09zlkBuLDdTWqWYARUvZjtjs4w/Ol
-rdrBI3A88ti8fRldYaNpu17ME1ilpN44yKoJtqiWc3Tisk8eYLfx6c7FQF3PrRva
-mr7FZvhFsYML5CeNFHTEzN6Y3jjKN/60DvCfodWnWFK47Txkl8UAXGY2W9B0fWqQ
-wUVr8uLuMyyMiKbeoufi7rGOj6AMErkCDQRlP16XARAA8FGmD5J3tM1BOM1niJxZ
-JTdCauzEtxEoBL0RuqGBkR8U29sRM6DwuzjU7PwscFnBaGyU+eU73GwGkH3ozFfF
-tllYhQrhP/kkN+0rEO5Xi+nR+4JCFRqrf3nJXAAPfiksURMp8er1dUOY2/e1ZSoL
-tS+nzUivV8CfE+pgj/5YtGwPC+KYHLATkKkMELCrbW4UO06VWOqQsvr6kivXuJQQ
-LdEAMpBlADmXFG45DmPKQzsBWUgvTwyGy3LX0nys8cgpex9BH8hhr01QmGyP469s
-N3cNrtFuu8U6RAsiCD/8mlBuD3EQEU5SF0lc7kCICAZk+wElmXnimEi0TOYsbz6k
-90lteicX70rA9GNeyI76H+VSOYvWpkRwaJAgUdzrAM1o9SHASq+cZ6nD85OZioQk
-DWM6+Q+sf2oen0qJnnGmUr93kJIC0PIdgrXRrtiNfeRa1Z/H0LmREyyEMoFiVivn
-z1vVk85Oq6Sf3ltUwvmDzuuJOtsp2Qp6+x6Snn/yKauI4uf4Cf/wKUch4r6Bwgg5
-Dw49ky7lwlnALio4GIVoGLpLef93wWoDmp4Klyh3ZPf2nB0U91u3bHRUo7m+D7QJ
-98cyKtqLLzjg7szGf60pIWNWRsadYQT3bSncynqknAjOV3BCvx6/ivsnpj//QjYR
-HtviUAcQ1DBB6UC6q23FIs0AEQEAAYkCPAQYAQoAJhYhBCSyWS6AGlqqhmbIunw8
-cn8FCQVQBQJlP16XAhsMBQkFo5qAAAoJEHw8cn8FCQVQzukP/iLxjOxT+UpPR//c
-prDVSLkP4pF5bmw36U07jvqpS+/KTXsxiiQleffRabOpNLcd+K1ueavyt9nnIwHH
-tHS9kM9A7DBw3LnpEbXki46QDCCI6niGijlLOEeAWqnocwMNTT05wVVgCtO3DQP2
-MoSCcqHpXDChvOyr5d5xjYLVJhlctIMSomcVzGryjknPu0Yj/TkC/4c+m86ZWQUD
-HqMHQIuiEenvb62/F4c5OJIRZPEn70wdddkgJuJU3eHdHrnuhCkjCC93GQGbGj03
-Zqos6699y6hmPeD3U5IUv8ujwZYVCCuDm8gJfrp3R6WLfeZeK9WmTVBpCzsDg3fV
-hSwmOk6pp8DAq1/Dev3yRkFggCEyGK6c9b+a0CRBncl8e5Q0QQIzNiS/uExQP3h+
-ELJs3P0MLP+6FWhNUry09n3lnWkr1hY+v1M0GAxbfdv/tsCN1Pq/VQEz+CTqXqya
-ftWldOHWw6Hh+gtwxcHjG4MBOrO5oICQ3lh2hGwQ58cDgZYSK/OGgJ9BggFl1CcM
-0uGC0/TRCI1zt/4y+7efSZQMZkHo7VC/3MFbp2hcNejpW+BxVuwKTunFvWK3TLhq
-sSlQ5yyhqchooepsFHq9bosKFjLJC01uprBv1rinoNduOy43FbyS7JPRRspANN0R
-iC2pMbWdE0ZTQaFq6tPIg058pjqi
-=nqgX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+=QPTf
 -----END PGP PUBLIC KEY BLOCK-----
+
 ```
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.43"
+version = "1.1.45"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.43"
+version = "1.1.45"
 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"
@@ -46,6 +46,7 @@ nym-sphinx = { path = "../nymsphinx" }
 nym-statistics-common = { path = "../statistics" }
 nym-pemstore = { path = "../pemstore" }
 nym-topology = { path = "../topology", features = ["serializable"] }
+nym-mixnet-client = { path = "../client-libs/mixnet-client", default-features = false }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 nym-task = { path = "../task" }
 nym-credentials-interface = { path = "../credentials-interface" }
@@ -393,13 +393,20 @@ pub struct Traffic {
    /// poisson distribution.
    pub disable_main_poisson_packet_distribution: bool,

+    /// Specify whether route selection should be determined by the packet header.
+    pub deterministic_route_selection: bool,
+
+    /// Specify how many times particular packet can be retransmitted
+    /// None - no limit
+    pub maximum_number_of_retransmissions: Option<u32>,
+
    /// Specifies the packet size used for sent messages.
    /// Do not override it unless you understand the consequences of that change.
    pub primary_packet_size: PacketSize,

    /// Specifies the optional auxiliary packet size for optimizing message streams.
    /// Note that its use decreases overall anonymity.
-    /// Do not set it it unless you understand the consequences of that change.
+    /// Do not set it unless you understand the consequences of that change.
    pub secondary_packet_size: Option<PacketSize>,

    pub packet_type: PacketType,
@@ -424,6 +431,8 @@ impl Default for Traffic {
            average_packet_delay: DEFAULT_AVERAGE_PACKET_DELAY,
            message_sending_average_delay: DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY,
            disable_main_poisson_packet_distribution: false,
+            deterministic_route_selection: false,
+            maximum_number_of_retransmissions: None,
            primary_packet_size: PacketSize::RegularPacket,
            secondary_packet_size: None,
            packet_type: PacketType::Mix,
@@ -111,6 +111,7 @@ impl From<ConfigV5> for Config {
                    primary_packet_size: value.debug.traffic.primary_packet_size,
                    secondary_packet_size: value.debug.traffic.secondary_packet_size,
                    packet_type: value.debug.traffic.packet_type,
+                    ..Default::default()
                },
                cover_traffic: CoverTraffic {
                    loop_cover_traffic_average_delay: value
@@ -14,7 +14,7 @@ use std::os::raw::c_int as RawFd;
 use thiserror::Error;

 #[cfg(not(target_arch = "wasm32"))]
-use futures::channel::{mpsc, oneshot};
+use futures::channel::oneshot;

 // we need to type erase the error type since we can't have dynamic associated types alongside dynamic dispatch
 #[derive(Debug, Error)]
@@ -170,7 +170,7 @@ pub struct LocalGateway {

    // 'sender' part
    /// Channel responsible for taking mix packets and forwarding them further into the further mixnet layers.
-    packet_forwarder: mpsc::UnboundedSender<MixPacket>,
+    packet_forwarder: nym_mixnet_client::forwarder::MixForwardingSender,

    // 'receiver' part
    packet_router_tx: Option<oneshot::Sender<PacketRouter>>,
@@ -180,7 +180,7 @@ pub struct LocalGateway {
 impl LocalGateway {
    pub fn new(
        local_identity: identity::PublicKey,
-        packet_forwarder: mpsc::UnboundedSender<MixPacket>,
+        packet_forwarder: nym_mixnet_client::forwarder::MixForwardingSender,
        packet_router_tx: oneshot::Sender<PacketRouter>,
    ) -> Self {
        LocalGateway {
@@ -208,8 +208,7 @@ mod nonwasm_sealed {
    impl GatewaySender for LocalGateway {
        async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
            self.packet_forwarder
-                .unbounded_send(packet)
-                .map_err(|err| err.into_send_error())
+                .forward_packet(packet)
                .map_err(erase_err)
        }
    }
@@ -30,7 +30,8 @@ pub(crate) enum Action {
    InsertPending(Vec<PendingAcknowledgement>),

    /// Removes given `PendingAcknowledgement` from the 'shared' state. Also cancels the retransmission timer.
-    /// Initiated by `AcknowledgementListener`
+    /// Initiated by `AcknowledgementListener` upon receiving the acknowledgement. Also by `RetransmissionRequestListener`
+    /// upon deciding to abandon the data.
    RemovePending(FragmentIdentifier),

    /// Starts the retransmission timer on given `PendingAcknowledgement` with the `Duration` based on
@@ -41,7 +42,7 @@ pub(crate) enum Action {

    /// Updates the expected delay of given `PendingAcknowledgement` with the new provided `SphinxDelay`.
    /// Initiated by `RetransmissionRequestListener`
-    UpdateDelay(FragmentIdentifier, SphinxDelay),
+    UpdatePendingAck(FragmentIdentifier, SphinxDelay),
 }

 impl Action {
@@ -57,8 +58,8 @@ impl Action {
        Action::StartTimer(frag_id)
    }

-    pub(crate) fn new_update_delay(frag_id: FragmentIdentifier, delay: SphinxDelay) -> Self {
-        Action::UpdateDelay(frag_id, delay)
+    pub(crate) fn new_update_pending_ack(frag_id: FragmentIdentifier, delay: SphinxDelay) -> Self {
+        Action::UpdatePendingAck(frag_id, delay)
    }
 }

@@ -135,7 +136,7 @@ impl ActionController {
    }

    fn handle_start_timer(&mut self, frag_id: FragmentIdentifier) {
-        trace!("{} is starting its timer", frag_id);
+        trace!("{frag_id} is starting its timer");

        if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
            // the fact that this branch is now POSSIBLE is a sign of a need to refactor this whole
@@ -193,7 +194,7 @@ impl ActionController {

    // initiated basically as a first step of retransmission. At first data has its delay updated
    // (as new sphinx packet was created with new expected delivery time)
-    fn handle_update_delay(&mut self, frag_id: FragmentIdentifier, delay: SphinxDelay) {
+    fn handle_update_pending_ack(&mut self, frag_id: FragmentIdentifier, delay: SphinxDelay) {
        trace!("{} is updating its delay", frag_id);
        // TODO: is it possible to solve this without either locking or temporarily removing the value?
        if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.remove(&frag_id) {
@@ -202,7 +203,7 @@ impl ActionController {
            // reference to this Arc. HOWEVER, before the Action was pushed onto the queue, the reference
            // was dropped hence this unwrap is safe.
            let mut inner_data = Arc::try_unwrap(pending_ack_data).unwrap();
-            inner_data.update_delay(delay);
+            inner_data.update_retransmitted(delay);

            self.pending_acks_data
                .insert(frag_id, (Arc::new(inner_data), queue_key));
@@ -225,7 +226,7 @@ impl ActionController {
        // about it. Perhaps just reschedule it at later point?
        let frag_id = expired_ack.into_inner();

-        trace!("{} has expired", frag_id);
+        trace!("{frag_id} has expired");

        if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.get_mut(&frag_id) {
            if queue_key.is_none() {
@@ -258,7 +259,9 @@ impl ActionController {
            Action::InsertPending(pending_acks) => self.handle_insert(pending_acks),
            Action::RemovePending(frag_id) => self.handle_remove(frag_id),
            Action::StartTimer(frag_id) => self.handle_start_timer(frag_id),
-            Action::UpdateDelay(frag_id, delay) => self.handle_update_delay(frag_id, delay),
+            Action::UpdatePendingAck(frag_id, delay) => {
+                self.handle_update_pending_ack(frag_id, delay)
+            }
        }
    }

@@ -71,6 +71,7 @@ pub(crate) struct PendingAcknowledgement {
    delay: SphinxDelay,
    destination: PacketDestination,
    mix_hops: Option<u8>,
+    retransmissions: u32,
 }

 impl PendingAcknowledgement {
@@ -86,6 +87,7 @@ impl PendingAcknowledgement {
            delay,
            destination: PacketDestination::KnownRecipient(recipient.into()),
            mix_hops,
+            retransmissions: 0,
        }
    }

@@ -105,6 +107,7 @@ impl PendingAcknowledgement {
            // Messages sent using SURBs are using the number of mix hops set by the recipient when
            // they provided the SURBs, so it doesn't make sense to include it here.
            mix_hops: None,
+            retransmissions: 0,
        }
    }

@@ -116,8 +119,9 @@ impl PendingAcknowledgement {
        self.message_chunk.clone()
    }

-    fn update_delay(&mut self, new_delay: SphinxDelay) {
+    fn update_retransmitted(&mut self, new_delay: SphinxDelay) {
        self.delay = new_delay;
+        self.retransmissions += 1;
    }
 }

@@ -163,6 +167,9 @@ impl AcknowledgementControllerConnectors {

 /// Configurable parameters of the `AcknowledgementController`
 pub(super) struct Config {
+    /// Specify how many times particular packet can be retransmitted
+    maximum_retransmissions: Option<u32>,
+
    /// Given ack timeout in the form a * BASE_DELAY + b, it specifies the additive part `b`
    ack_wait_addition: Duration,

@@ -174,8 +181,13 @@ pub(super) struct Config {
 }

 impl Config {
-    pub(super) fn new(ack_wait_addition: Duration, ack_wait_multiplier: f64) -> Self {
+    pub(super) fn new(
+        maximum_retransmissions: Option<u32>,
+        ack_wait_addition: Duration,
+        ack_wait_multiplier: f64,
+    ) -> Self {
        Config {
+            maximum_retransmissions,
            ack_wait_addition,
            ack_wait_multiplier,
            packet_size: Default::default(),
@@ -238,6 +250,7 @@ where

        // will listen for any ack timeouts and trigger retransmission
        let retransmission_request_listener = RetransmissionRequestListener::new(
+            config.maximum_retransmissions,
            connectors.ack_action_sender.clone(),
            message_handler,
            retransmission_rx,
@@ -20,6 +20,7 @@ use std::sync::{Arc, Weak};

 // responsible for packet retransmission upon fired timer
 pub(super) struct RetransmissionRequestListener<R> {
+    maximum_retransmissions: Option<u32>,
    action_sender: AckActionSender,
    message_handler: MessageHandler<R>,
    request_receiver: RetransmissionRequestReceiver,
@@ -31,12 +32,14 @@ where
    R: CryptoRng + Rng,
 {
    pub(super) fn new(
+        maximum_retransmissions: Option<u32>,
        action_sender: AckActionSender,
        message_handler: MessageHandler<R>,
        request_receiver: RetransmissionRequestReceiver,
        reply_controller_sender: ReplyControllerSender,
    ) -> Self {
        RetransmissionRequestListener {
+            maximum_retransmissions,
            action_sender,
            message_handler,
            request_receiver,
@@ -77,6 +80,18 @@ where
            }
        };

+        let frag_id = timed_out_ack.message_chunk.fragment_identifier();
+
+        if let Some(limit) = self.maximum_retransmissions {
+            if timed_out_ack.retransmissions >= limit {
+                warn!("reached maximum number of allowed retransmissions for the packet");
+                self.action_sender
+                    .unbounded_send(Action::new_remove(frag_id))
+                    .unwrap();
+                return;
+            }
+        }
+
        let maybe_prepared_fragment = match &timed_out_ack.destination {
            PacketDestination::Anonymous {
                recipient_tag,
@@ -101,8 +116,6 @@ where
            }
        };

-        let frag_id = timed_out_ack.message_chunk.fragment_identifier();
-
        let prepared_fragment = match maybe_prepared_fragment {
            Ok(prepared_fragment) => prepared_fragment,
            Err(err) => {
@@ -136,7 +149,7 @@ where
        // with the additional poisson delay.
        // And since Actions are executed in order `UpdateTimer` will HAVE TO be executed before `StartTimer`
        self.action_sender
-            .unbounded_send(Action::new_update_delay(frag_id, new_delay))
+            .unbounded_send(Action::new_update_pending_ack(frag_id, new_delay))
            .unwrap();

        // send to `OutQueueControl` to eventually send to the mix network
@@ -91,6 +91,9 @@ pub(crate) struct Config {
    /// and surb-based are going to be sent.
    sender_address: Recipient,

+    /// Specify whether route selection should be determined by the packet header.
+    deterministic_route_selection: bool,
+
    /// Average delay a data packet is going to get delay at a single mixnode.
    average_packet_delay: Duration,

@@ -114,10 +117,12 @@ impl Config {
        sender_address: Recipient,
        average_packet_delay: Duration,
        average_ack_delay: Duration,
+        deterministic_route_selection: bool,
    ) -> Self {
        Config {
            ack_key,
            sender_address,
+            deterministic_route_selection,
            average_packet_delay,
            average_ack_delay,
            num_mix_hops: DEFAULT_NUM_MIX_HOPS,
@@ -176,6 +181,7 @@ where
    {
        let message_preparer = MessagePreparer::new(
            rng,
+            config.deterministic_route_selection,
            config.sender_address,
            config.average_packet_delay,
            config.average_ack_delay,
@@ -634,7 +640,7 @@ where

    pub(crate) fn update_ack_delay(&self, id: FragmentIdentifier, new_delay: Delay) {
        self.action_sender
-            .unbounded_send(Action::UpdateDelay(id, new_delay))
+            .unbounded_send(Action::UpdatePendingAck(id, new_delay))
            .expect("action control task has died")
    }

@@ -65,6 +65,7 @@ pub struct Config {
 impl<'a> From<&'a Config> for acknowledgement_control::Config {
    fn from(cfg: &'a Config) -> Self {
        acknowledgement_control::Config::new(
+            cfg.traffic.maximum_number_of_retransmissions,
            cfg.acks.ack_wait_addition,
            cfg.acks.ack_wait_multiplier,
        )
@@ -97,6 +98,7 @@ impl<'a> From<&'a Config> for message_handler::Config {
            cfg.self_recipient,
            cfg.traffic.average_packet_delay,
            cfg.acks.average_ack_delay,
+            cfg.traffic.deterministic_route_selection,
        )
        .with_custom_primary_packet_size(cfg.traffic.primary_packet_size)
        .with_custom_secondary_packet_size(cfg.traffic.secondary_packet_size)
@@ -38,7 +38,7 @@ pub struct TopologyReadPermit<'a> {
    permit: RwLockReadGuard<'a, Option<NymTopology>>,
 }

-impl<'a> Deref for TopologyReadPermit<'a> {
+impl Deref for TopologyReadPermit<'_> {
    type Target = Option<NymTopology>;

    fn deref(&self) -> &Self::Target {
@@ -46,7 +46,8 @@ pub(crate) fn ws_fd(_conn: &WsConn) -> Option<RawFd> {
    #[cfg(unix)]
    match _conn.get_ref() {
        MaybeTlsStream::Plain(stream) => Some(stream.as_raw_fd()),
-        &_ => None,
+        MaybeTlsStream::Rustls(tls_stream) => Some(tls_stream.as_raw_fd()),
+        _ => None,
    }
    #[cfg(not(unix))]
    None
@@ -9,10 +9,14 @@ license.workspace = true

 [dependencies]
 futures = { workspace = true }
-log = { workspace = true }
-tokio = { workspace = true, features = ["time", "net", "rt"] }
-tokio-util = { workspace = true, features = ["codec"] }
+tracing = { workspace = true }
+tokio = { workspace = true, features = ["time"] }
+tokio-util = { workspace = true, features = ["codec"], optional = true }

 # internal
 nym-sphinx = { path = "../../nymsphinx" }
-nym-task = { path = "../../task" }
+nym-task = { path = "../../task", optional = true }
+
+[features]
+default = ["client"]
+client = ["tokio-util", "nym-task", "tokio/net", "tokio/rt"]
@@ -3,7 +3,6 @@

 use futures::channel::mpsc;
 use futures::StreamExt;
-use log::*;
 use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx::framing::codec::NymCodec;
 use nym_sphinx::framing::packet::FramedNymPacket;
@@ -18,13 +17,14 @@ use std::time::Duration;
 use tokio::net::TcpStream;
 use tokio::time::sleep;
 use tokio_util::codec::Framed;
+use tracing::*;

+#[derive(Clone, Copy)]
 pub struct Config {
    initial_reconnection_backoff: Duration,
    maximum_reconnection_backoff: Duration,
    initial_connection_timeout: Duration,
    maximum_connection_buffer_size: usize,
-    use_legacy_version: bool,
 }

 impl Config {
@@ -33,14 +33,12 @@ impl Config {
        maximum_reconnection_backoff: Duration,
        initial_connection_timeout: Duration,
        maximum_connection_buffer_size: usize,
-        use_legacy_version: bool,
    ) -> Self {
        Config {
            initial_reconnection_backoff,
            maximum_reconnection_backoff,
            initial_connection_timeout,
            maximum_connection_buffer_size,
-            use_legacy_version,
        }
    }
 }
@@ -200,9 +198,8 @@ impl SendWithoutResponse for Client {
        packet: NymPacket,
        packet_type: PacketType,
    ) -> io::Result<()> {
-        trace!("Sending packet to {:?}", address);
-        let framed_packet =
-            FramedNymPacket::new(packet, packet_type, self.config.use_legacy_version);
+        trace!("Sending packet to {address:?}");
+        let framed_packet = FramedNymPacket::new(packet, packet_type);

        if let Some(sender) = self.conn_new.get_mut(&address) {
            if let Err(err) = sender.channel.try_send(framed_packet) {
@@ -260,7 +257,6 @@ mod tests {
            maximum_reconnection_backoff: Duration::from_millis(300_000),
            initial_connection_timeout: Duration::from_millis(1_500),
            maximum_connection_buffer_size: 128,
-            use_legacy_version: false,
        })
    }

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

-use crate::client::{Client, Config, SendWithoutResponse};
 use futures::channel::mpsc;
-use futures::StreamExt;
-use log::*;
+use futures::channel::mpsc::SendError;
 use nym_sphinx::forwarding::packet::MixPacket;
-use std::time::Duration;
+use tokio::time::Instant;

-pub type MixForwardingSender = mpsc::UnboundedSender<MixPacket>;
-type MixForwardingReceiver = mpsc::UnboundedReceiver<MixPacket>;
-
-/// A specialisation of client such that it forwards any received packets on the channel into the
-/// mix network immediately, i.e. will not try to listen for any responses.
-pub struct PacketForwarder {
-    mixnet_client: Client,
-    packet_receiver: MixForwardingReceiver,
-    shutdown: nym_task::TaskClient,
+pub fn mix_forwarding_channels() -> (MixForwardingSender, MixForwardingReceiver) {
+    let (tx, rx) = mpsc::unbounded();
+    (tx.into(), rx)
 }

-impl PacketForwarder {
-    pub fn new(
-        initial_reconnection_backoff: Duration,
-        maximum_reconnection_backoff: Duration,
-        initial_connection_timeout: Duration,
-        maximum_connection_buffer_size: usize,
-        use_legacy_version: bool,
-        shutdown: nym_task::TaskClient,
-    ) -> (PacketForwarder, MixForwardingSender) {
-        let client_config = Config::new(
-            initial_reconnection_backoff,
-            maximum_reconnection_backoff,
-            initial_connection_timeout,
-            maximum_connection_buffer_size,
-            use_legacy_version,
-        );
+#[derive(Clone)]
+pub struct MixForwardingSender(mpsc::UnboundedSender<PacketToForward>);

-        let (packet_sender, packet_receiver) = mpsc::unbounded();
+impl From<mpsc::UnboundedSender<PacketToForward>> for MixForwardingSender {
+    fn from(tx: mpsc::UnboundedSender<PacketToForward>) -> Self {
+        MixForwardingSender(tx)
+    }
+}

-        (
-            PacketForwarder {
-                mixnet_client: Client::new(client_config),
-                packet_receiver,
-                shutdown,
-            },
-            packet_sender,
-        )
+impl MixForwardingSender {
+    pub fn forward_packet(&self, packet: impl Into<PacketToForward>) -> Result<(), SendError> {
+        self.0
+            .unbounded_send(packet.into())
+            .map_err(|err| err.into_send_error())
    }

-    pub async fn run(&mut self) {
-        while !self.shutdown.is_shutdown() {
-            tokio::select! {
-                biased;
-                _ = self.shutdown.recv() => {
-                    log::trace!("PacketForwarder: Received shutdown");
-                }
-                Some(mix_packet) = self.packet_receiver.next() => {
-                     trace!("Going to forward packet to {}", mix_packet.next_hop());
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+}

-                    let next_hop = mix_packet.next_hop();
-                    let packet_type = mix_packet.packet_type();
-                    let packet = mix_packet.into_packet();
-                    // we don't care about responses, we just want to fire packets
-                    // as quickly as possible
+pub type MixForwardingReceiver = mpsc::UnboundedReceiver<PacketToForward>;

-                    if let Err(err) =
-                        self.mixnet_client
-                            .send_without_response(next_hop, packet, packet_type)
-                    {
-                        debug!("failed to forward the packet - {err}")
-                    }
-                }
-            }
+pub struct PacketToForward {
+    pub packet: MixPacket,
+    pub forward_delay_target: Option<Instant>,
+}
+
+impl From<MixPacket> for PacketToForward {
+    fn from(packet: MixPacket) -> Self {
+        PacketToForward::new_no_delay(packet)
+    }
+}
+
+impl From<(MixPacket, Option<Instant>)> for PacketToForward {
+    fn from((packet, delay_until): (MixPacket, Option<Instant>)) -> Self {
+        PacketToForward::new(packet, delay_until)
+    }
+}
+
+impl From<(MixPacket, Instant)> for PacketToForward {
+    fn from((packet, delay_until): (MixPacket, Instant)) -> Self {
+        PacketToForward::new(packet, Some(delay_until))
+    }
+}
+
+impl PacketToForward {
+    pub fn new(packet: MixPacket, forward_delay_target: Option<Instant>) -> Self {
+        PacketToForward {
+            packet,
+            forward_delay_target,
        }
    }
+
+    pub fn new_no_delay(packet: MixPacket) -> Self {
+        Self::new(packet, None)
+    }
 }
@@ -1,7 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+#[cfg(feature = "client")]
 pub mod client;
 pub mod forwarder;

+#[cfg(feature = "client")]
 pub use client::{Client, Config, SendWithoutResponse};
@@ -32,7 +32,7 @@ impl Div<GasPrice> for Coin {
    }
 }

-impl<'a> Div<GasPrice> for &'a Coin {
+impl Div<GasPrice> for &Coin {
    type Output = Gas;

    fn div(self, rhs: GasPrice) -> Self::Output {
@@ -22,7 +22,7 @@ pub struct GasPrice {
    pub denom: String,
 }

-impl<'a> Mul<Gas> for &'a GasPrice {
+impl Mul<Gas> for &GasPrice {
    type Output = Coin;

    fn mul(self, gas_limit: Gas) -> Self::Output {
@@ -48,6 +48,7 @@ nym-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-cont
 nym-coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
 nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }
 nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
+nym-ecash-time = { path = "../../common/ecash-time" }
 nym-sphinx = { path = "../../common/nymsphinx" }
 nym-client-core = { path = "../../common/client-core" }
 nym-config = { path = "../../common/config" }
@@ -56,6 +57,7 @@ nym-credentials-interface = { path = "../../common/credentials-interface" }
 nym-credential-storage = { path = "../../common/credential-storage" }
 nym-credential-utils = { path = "../../common/credential-utils" }
 nym-id = { path = "../nym-id" }
+nym-credential-proxy-requests = { path = "../../nym-credential-proxy/nym-credential-proxy-requests" }

 nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
 nym-types = { path = "../../common/types" }
@@ -0,0 +1,41 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::trace;
+use nym_credentials_interface::{generate_keypair_user, generate_keypair_user_from_seed, Base58};
+use serde::{Deserialize, Serialize};
+use std::io::stdout;
+
+#[derive(Serialize, Deserialize)]
+pub struct Bs58EncodedKeys {
+    pub secret_key: String,
+    pub public_key: String,
+}
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Secret value that's used for deriving underlying ecash keypair
+    #[clap(long)]
+    pub(crate) bs58_encoded_client_secret: Option<String>,
+}
+
+pub fn generate_ecash_keypair(args: Args) -> anyhow::Result<()> {
+    trace!("args: {args:?}");
+
+    let keypair = if let Some(secret) = args.bs58_encoded_client_secret {
+        let seed = bs58::decode(&secret).into_vec()?;
+        generate_keypair_user_from_seed(&seed)
+    } else {
+        generate_keypair_user()
+    };
+
+    let encoded = Bs58EncodedKeys {
+        secret_key: keypair.secret_key().to_bs58(),
+        public_key: keypair.public_key().to_bs58(),
+    };
+
+    serde_json::to_writer_pretty(stdout(), &encoded)?;
+
+    Ok(())
+}
@@ -0,0 +1,23 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod generate_keypair;
+pub mod withdrawal_request;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct InternalEcash {
+    #[clap(subcommand)]
+    pub command: InternalEcashCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum InternalEcashCommands {
+    /// Generate a dummy withdrawal request
+    GenerateWithdrawalRequest(withdrawal_request::Args),
+
+    /// Generate dummy ecash keypair
+    GenerateKeypair(generate_keypair::Args),
+}
@@ -0,0 +1,78 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::Parser;
+use log::trace;
+use nym_credential_proxy_requests::api::v1::ticketbook::models::TicketbookRequest;
+use nym_credentials_interface::{
+    generate_keypair_user, withdrawal_request, Base58, SecretKeyUser, TicketType,
+};
+use nym_ecash_time::{ecash_default_expiration_date, EcashTime};
+use serde::{Deserialize, Serialize};
+use std::io::stdout;
+use time::macros::format_description;
+use time::Date;
+use zeroize::Zeroizing;
+
+fn parse_date(raw: &str) -> Result<Date, time::error::Parse> {
+    let format = format_description!("[year]-[month]-[day]");
+    Date::parse(raw, &format)
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Bs58EncodedOutput {
+    pub ecash_proxy_request: TicketbookRequest,
+    pub ecash_secret: String,
+
+    /// Needed to later unblind shares
+    pub ecash_request_info_bs58: String,
+}
+
+#[derive(Debug, Parser)]
+pub struct Args {
+    /// Specify which type of ticketbook
+    #[clap(long, default_value_t = TicketType::V1MixnetEntry)]
+    pub(crate) ticketbook_type: TicketType,
+
+    /// Set expiration date for the ticketbook
+    #[clap(long, value_parser = parse_date, default_value_t = ecash_default_expiration_date())]
+    pub(crate) expiration_date: Date,
+
+    /// Provide ecash secret key (or generate a fresh one)
+    #[clap(long)]
+    pub(crate) ecash_secret_key_bs58: Option<String>,
+}
+
+pub async fn generate_withdrawal_request(args: Args) -> anyhow::Result<()> {
+    trace!("args: {args:?}");
+
+    let ecash_keypair = if let Some(secret_key) = args.ecash_secret_key_bs58 {
+        let secret_key = Zeroizing::new(bs58::decode(Zeroizing::new(secret_key)).into_vec()?);
+        let sk = SecretKeyUser::from_bytes(&secret_key)?;
+        sk.into()
+    } else {
+        generate_keypair_user()
+    };
+
+    let (withdrawal_request, request_info) = withdrawal_request(
+        ecash_keypair.secret_key(),
+        args.expiration_date.ecash_unix_timestamp(),
+        args.ticketbook_type.encode(),
+    )?;
+
+    let encoded = Bs58EncodedOutput {
+        ecash_proxy_request: TicketbookRequest {
+            withdrawal_request: withdrawal_request.into(),
+            ecash_pubkey: ecash_keypair.public_key(),
+            expiration_date: args.expiration_date,
+            ticketbook_type: args.ticketbook_type,
+            is_freepass_request: false,
+        },
+        ecash_secret: ecash_keypair.secret_key().to_bs58(),
+        ecash_request_info_bs58: request_info.to_bs58(),
+    };
+
+    serde_json::to_writer_pretty(stdout(), &encoded)?;
+
+    Ok(())
+}
@@ -0,0 +1,19 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{Args, Subcommand};
+
+pub mod ecash;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct Internal {
+    #[clap(subcommand)]
+    pub command: InternalCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum InternalCommands {
+    /// Ecash related internal commands
+    Ecash(ecash::InternalEcash),
+}
@@ -3,5 +3,6 @@

 pub mod context;
 pub mod ecash;
+pub mod internal;
 pub mod utils;
 pub mod validator;
@@ -32,7 +32,7 @@ pub(crate) mod string_rfc3339_offset_date_time {

    struct Rfc3339OffsetDateTimeVisitor;

-    impl<'de> Visitor<'de> for Rfc3339OffsetDateTimeVisitor {
+    impl Visitor<'_> for Rfc3339OffsetDateTimeVisitor {
        type Value = OffsetDateTime;

        fn expecting(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
@@ -7,7 +7,7 @@ use crate::ClientBandwidth;
 use nym_credentials::ecash::utils::ecash_today;
 use nym_credentials_interface::Bandwidth;
 use nym_gateway_requests::ServerResponse;
-use nym_gateway_storage::Storage;
+use nym_gateway_storage::GatewayStorage;
 use si_scale::helpers::bibytes2;
 use time::OffsetDateTime;
 use tracing::*;
@@ -15,17 +15,17 @@ use tracing::*;
 const FREE_TESTNET_BANDWIDTH_VALUE: Bandwidth = Bandwidth::new_unchecked(64 * 1024 * 1024 * 1024); // 64GB

 #[derive(Clone)]
-pub struct BandwidthStorageManager<S> {
-    pub(crate) storage: S,
+pub struct BandwidthStorageManager {
+    pub(crate) storage: GatewayStorage,
    pub(crate) client_bandwidth: ClientBandwidth,
    pub(crate) client_id: i64,
    pub(crate) bandwidth_cfg: BandwidthFlushingBehaviourConfig,
    pub(crate) only_coconut_credentials: bool,
 }

-impl<S: Storage + Clone + 'static> BandwidthStorageManager<S> {
+impl BandwidthStorageManager {
    pub fn new(
-        storage: S,
+        storage: GatewayStorage,
        client_bandwidth: ClientBandwidth,
        client_id: i64,
        bandwidth_cfg: BandwidthFlushingBehaviourConfig,
@@ -111,7 +111,7 @@ impl<S: Storage + Clone + 'static> BandwidthStorageManager<S> {
    }

    #[instrument(level = "trace", skip_all)]
-    async fn sync_storage_bandwidth(&mut self) -> Result<()> {
+    pub async fn sync_storage_bandwidth(&mut self) -> Result<()> {
        trace!("syncing client bandwidth with the underlying storage");
        let updated = self
            .storage
@@ -8,8 +8,8 @@ use std::time::Duration;
 use time::OffsetDateTime;
 use tokio::sync::RwLock;

-const DEFAULT_CLIENT_BANDWIDTH_MAX_FLUSHING_RATE: Duration = Duration::from_millis(5);
-const DEFAULT_CLIENT_BANDWIDTH_MAX_DELTA_FLUSHING_AMOUNT: i64 = 512 * 1024; // 512kB
+const DEFAULT_CLIENT_BANDWIDTH_MAX_FLUSHING_RATE: Duration = Duration::from_secs(5 * 60); // 5 minutes
+const DEFAULT_CLIENT_BANDWIDTH_MAX_DELTA_FLUSHING_AMOUNT: i64 = 5 * 1024 * 1024; // 5MB

 #[derive(Debug, Clone, Copy)]
 pub struct BandwidthFlushingBehaviourConfig {
@@ -13,7 +13,6 @@ use nym_api_requests::constants::MIN_BATCH_REDEMPTION_DELAY;
 use nym_api_requests::ecash::models::{BatchRedeemTicketsBody, VerifyEcashTicketBody};
 use nym_credentials_interface::Bandwidth;
 use nym_credentials_interface::{ClientTicket, TicketType};
-use nym_gateway_storage::Storage;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
    EcashSigningClient, MultisigQueryClient, MultisigSigningClient, PagedMultisigQueryClient,
@@ -126,21 +125,18 @@ pub struct CredentialHandlerConfig {
    pub maximum_time_between_redemption: Duration,
 }

-pub(crate) struct CredentialHandler<St: Storage> {
+pub(crate) struct CredentialHandler {
    config: CredentialHandlerConfig,
    multisig_threshold: f32,
    ticket_receiver: UnboundedReceiver<ClientTicket>,
-    shared_state: SharedState<St>,
+    shared_state: SharedState,
    pending_tickets: Vec<PendingVerification>,
    pending_redemptions: Vec<PendingRedemptionVote>,
 }

-impl<St> CredentialHandler<St>
-where
-    St: Storage + Clone + 'static,
-{
+impl CredentialHandler {
    async fn rebuild_pending_tickets(
-        shared_state: &SharedState<St>,
+        shared_state: &SharedState,
    ) -> Result<Vec<PendingVerification>, EcashTicketError> {
        // 1. get all tickets that were not fully verified
        let unverified = shared_state.storage.get_all_unverified_tickets().await?;
@@ -188,7 +184,7 @@ where
    }

    async fn rebuild_pending_votes(
-        shared_state: &SharedState<St>,
+        shared_state: &SharedState,
    ) -> Result<Vec<PendingRedemptionVote>, EcashTicketError> {
        // 1. get all tickets that were not fully verified
        let unverified = shared_state.storage.get_all_unresolved_proposals().await?;
@@ -259,7 +255,7 @@ where
    pub(crate) async fn new(
        config: CredentialHandlerConfig,
        ticket_receiver: UnboundedReceiver<ClientTicket>,
-        shared_state: SharedState<St>,
+        shared_state: SharedState,
    ) -> Result<Self, Error> {
        let multisig_threshold = shared_state
            .nyxd_client
@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_gateway_storage::error::StorageError;
+use nym_gateway_storage::error::GatewayStorageError;
 use nym_validator_client::coconut::EcashApiError;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::error::NyxdError;
@@ -37,7 +37,7 @@ pub enum EcashTicketError {
    #[error("could not handle the ecash ticket due to internal storage failure: {source}")]
    InternalStorageFailure {
        #[from]
-        source: StorageError,
+        source: GatewayStorageError,
    },

    #[error("failed to create ticket redemption proposal: {source}")]
@@ -8,7 +8,7 @@ use error::EcashTicketError;
 use futures::channel::mpsc::{self, UnboundedSender};
 use nym_credentials::CredentialSpendingData;
 use nym_credentials_interface::{ClientTicket, CompactEcashError, NymPayInfo, VerificationKeyAuth};
-use nym_gateway_storage::Storage;
+use nym_gateway_storage::GatewayStorage;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::DirectSigningHttpRpcNyxdClient;
 use state::SharedState;
@@ -23,24 +23,21 @@ mod state;

 pub const TIME_RANGE_SEC: i64 = 30;

-pub struct EcashManager<S> {
-    shared_state: SharedState<S>,
+pub struct EcashManager {
+    shared_state: SharedState,

    pk_bytes: [u8; 32], // bytes representation of a pub key representing the verifier
    pay_infos: Mutex<Vec<NymPayInfo>>,
    cred_sender: UnboundedSender<ClientTicket>,
 }

-impl<S> EcashManager<S>
-where
-    S: Storage + Clone + 'static,
-{
+impl EcashManager {
    pub async fn new(
        credential_handler_cfg: CredentialHandlerConfig,
        nyxd_client: DirectSigningHttpRpcNyxdClient,
        pk_bytes: [u8; 32],
        shutdown: nym_task::TaskClient,
-        storage: S,
+        storage: GatewayStorage,
    ) -> Result<Self, Error> {
        let shared_state = SharedState::new(nyxd_client, storage).await?;

@@ -66,7 +63,7 @@ where
        self.shared_state.verification_key(epoch_id).await
    }

-    pub fn storage(&self) -> &S {
+    pub fn storage(&self) -> &GatewayStorage {
        &self.shared_state.storage
    }

@@ -6,7 +6,7 @@ use crate::Error;
 use cosmwasm_std::{from_binary, CosmosMsg, WasmMsg};
 use nym_credentials_interface::VerificationKeyAuth;
 use nym_ecash_contract_common::msg::ExecuteMsg;
-use nym_gateway_storage::Storage;
+use nym_gateway_storage::GatewayStorage;
 use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
@@ -23,20 +23,17 @@ use tracing::{error, trace, warn};

 // state shared by different subtasks dealing with credentials
 #[derive(Clone)]
-pub(crate) struct SharedState<S> {
+pub(crate) struct SharedState {
    pub(crate) nyxd_client: Arc<RwLock<DirectSigningHttpRpcNyxdClient>>,
    pub(crate) address: AccountId,
    pub(crate) epoch_data: Arc<RwLock<BTreeMap<EpochId, EpochState>>>,
-    pub(crate) storage: S,
+    pub(crate) storage: GatewayStorage,
 }

-impl<S> SharedState<S>
-where
-    S: Storage + Clone,
-{
+impl SharedState {
    pub(crate) async fn new(
        nyxd_client: DirectSigningHttpRpcNyxdClient,
-        storage: S,
+        storage: GatewayStorage,
    ) -> Result<Self, Error> {
        let address = nyxd_client.address();

@@ -39,7 +39,7 @@ pub enum Error {
    OutOfBandwidth { required: i64, available: i64 },

    #[error("Internal gateway storage error")]
-    StorageError(#[from] nym_gateway_storage::error::StorageError),
+    StorageError(#[from] nym_gateway_storage::error::GatewayStorageError),

    #[error("{0}")]
    UnknownTicketType(#[from] nym_credentials_interface::UnknownTicketType),
@@ -2,17 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0

 use bandwidth_storage_manager::BandwidthStorageManager;
+use ecash::EcashManager;
+use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
+use nym_credentials_interface::{Bandwidth, ClientTicket, TicketType};
+use nym_gateway_requests::models::CredentialSpendingRequest;
 use std::sync::Arc;
 use time::{Date, OffsetDateTime};
 use tracing::*;

-use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
-use nym_credentials_interface::{Bandwidth, ClientTicket, TicketType};
-use nym_gateway_requests::models::CredentialSpendingRequest;
-use nym_gateway_storage::Storage;
-
 pub use client_bandwidth::*;
-use ecash::EcashManager;
 pub use error::*;

 pub mod bandwidth_storage_manager;
@@ -20,17 +18,17 @@ mod client_bandwidth;
 pub mod ecash;
 pub mod error;

-pub struct CredentialVerifier<S> {
+pub struct CredentialVerifier {
    credential: CredentialSpendingRequest,
-    ecash_verifier: Arc<EcashManager<S>>,
-    bandwidth_storage_manager: BandwidthStorageManager<S>,
+    ecash_verifier: Arc<EcashManager>,
+    bandwidth_storage_manager: BandwidthStorageManager,
 }

-impl<S: Storage + Clone + 'static> CredentialVerifier<S> {
+impl CredentialVerifier {
    pub fn new(
        credential: CredentialSpendingRequest,
-        ecash_verifier: Arc<EcashManager<S>>,
-        bandwidth_storage_manager: BandwidthStorageManager<S>,
+        ecash_verifier: Arc<EcashManager>,
+        bandwidth_storage_manager: BandwidthStorageManager,
    ) -> Self {
        CredentialVerifier {
            credential,
@@ -26,9 +26,8 @@ const PARALLEL_RUNS: usize = 32;
 /// `lambda` ($\lambda$) in the DKG paper
 const SECURITY_PARAMETER: usize = 256;

-// note: ceiling in integer division can be achieved via q = (x + y - 1) / y;
 /// ceil(SECURITY_PARAMETER / PARALLEL_RUNS) in the paper
-const NUM_CHALLENGE_BITS: usize = (SECURITY_PARAMETER + PARALLEL_RUNS - 1) / PARALLEL_RUNS;
+const NUM_CHALLENGE_BITS: usize = SECURITY_PARAMETER.div_ceil(PARALLEL_RUNS);

 // type alias for ease of use
 type FirstChallenge = Vec<Vec<Vec<u64>>>;
@@ -196,7 +196,7 @@ impl<'b> Add<&'b Polynomial> for Polynomial {
    }
 }

-impl<'a> Add<Polynomial> for &'a Polynomial {
+impl Add<Polynomial> for &Polynomial {
    type Output = Polynomial;

    fn add(self, rhs: Polynomial) -> Polynomial {
@@ -212,10 +212,10 @@ impl Add<Polynomial> for Polynomial {
    }
 }

-impl<'a, 'b> Add<&'b Polynomial> for &'a Polynomial {
+impl<'a> Add<&'a Polynomial> for &Polynomial {
    type Output = Polynomial;

-    fn add(self, rhs: &'b Polynomial) -> Self::Output {
+    fn add(self, rhs: &'a Polynomial) -> Self::Output {
        let len = self.coefficients.len();
        let rhs_len = rhs.coefficients.len();

@@ -37,7 +37,7 @@ pub struct GatewayHandshake<'a> {
    handshake_future: BoxFuture<'a, Result<SharedGatewayKey, HandshakeError>>,
 }

-impl<'a> Future for GatewayHandshake<'a> {
+impl Future for GatewayHandshake<'_> {
    type Output = Result<SharedGatewayKey, HandshakeError>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -16,12 +16,15 @@ sqlx = { workspace = true, features = [
    "migrate",
    "time",
 ] }
+strum = { workspace = true }
 time = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }

 nym-sphinx = { path = "../nymsphinx" }
 nym-credentials-interface = { path = "../credentials-interface" }
+nym-node-metrics = { path = "../../nym-node/nym-node-metrics" }
+nym-statistics-common = { path = "../statistics" }


 [build-dependencies]
@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: GPL-3.0-only

 use error::StatsStorageError;
-use models::{ActiveSession, FinishedSession, SessionType, StoredFinishedSession};
+use models::StoredFinishedSession;
+use nym_node_metrics::entry::{ActiveSession, FinishedSession, SessionType};
 use nym_sphinx::DestinationAddressBytes;
 use sessions::SessionManager;
 use sqlx::ConnectOptions;
@@ -70,8 +71,8 @@ impl PersistentStatsStorage {
            .session_manager
            .insert_finished_session(
                date,
-                session.duration.whole_milliseconds() as i64,
-                session.typ.to_string().into(),
+                session.duration.as_millis() as i64,
+                session.typ.to_string(),
            )
            .await?)
    }
@@ -125,7 +126,7 @@ impl PersistentStatsStorage {
            .insert_active_session(
                client_address.as_base58_string(),
                session.start,
-                session.typ.to_string().into(),
+                session.typ.to_string(),
            )
            .await?)
    }
@@ -137,10 +138,7 @@ impl PersistentStatsStorage {
    ) -> Result<(), StatsStorageError> {
        Ok(self
            .session_manager
-            .update_active_session_type(
-                client_address.as_base58_string(),
-                session_type.to_string().into(),
-            )
+            .update_active_session_type(client_address.as_base58_string(), session_type.to_string())
            .await?)
    }

@@ -1,9 +1,11 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only

-use nym_credentials_interface::TicketType;
+use nym_node_metrics::entry::{ActiveSession, FinishedSession, SessionType};
 use sqlx::prelude::FromRow;
-use time::{Duration, OffsetDateTime};
+use time::OffsetDateTime;
+
+pub use nym_credentials_interface::TicketType;

 #[derive(FromRow)]
 pub struct StoredFinishedSession {
@@ -11,52 +13,26 @@ pub struct StoredFinishedSession {
    typ: String,
 }

-impl StoredFinishedSession {
-    pub fn serialize(&self) -> (u64, String) {
-        (
-            self.duration_ms as u64, //we are sure that it fits in a u64, see `fn end_at`
-            self.typ.clone(),
-        )
+impl From<StoredFinishedSession> for FinishedSession {
+    fn from(value: StoredFinishedSession) -> Self {
+        FinishedSession {
+            duration: std::time::Duration::from_millis(value.duration_ms as u64),
+            typ: SessionType::from_string(value.typ),
+        }
    }
 }

-pub struct FinishedSession {
-    pub duration: Duration,
-    pub typ: SessionType,
+pub trait ToSessionType {
+    fn to_session_type(&self) -> SessionType;
 }

-#[derive(PartialEq)]
-pub enum SessionType {
-    Vpn,
-    Mixnet,
-    Unknown,
-}
-
-impl SessionType {
-    pub fn to_string(&self) -> &str {
+impl ToSessionType for TicketType {
+    fn to_session_type(&self) -> SessionType {
        match self {
-            Self::Vpn => "vpn",
-            Self::Mixnet => "mixnet",
-            Self::Unknown => "unknown",
-        }
-    }
-
-    pub fn from_string(s: &str) -> Self {
-        match s {
-            "vpn" => Self::Vpn,
-            "mixnet" => Self::Mixnet,
-            _ => Self::Unknown,
-        }
-    }
-}
-
-impl From<TicketType> for SessionType {
-    fn from(value: TicketType) -> Self {
-        match value {
-            TicketType::V1MixnetEntry => Self::Mixnet,
-            TicketType::V1MixnetExit => Self::Mixnet,
-            TicketType::V1WireguardEntry => Self::Vpn,
-            TicketType::V1WireguardExit => Self::Vpn,
+            TicketType::V1MixnetEntry => SessionType::Mixnet,
+            TicketType::V1MixnetExit => SessionType::Mixnet,
+            TicketType::V1WireguardEntry => SessionType::Vpn,
+            TicketType::V1WireguardExit => SessionType::Vpn,
        }
    }
 }
@@ -67,38 +43,6 @@ pub(crate) struct StoredActiveSession {
    typ: String,
 }

-pub struct ActiveSession {
-    pub start: OffsetDateTime,
-    pub typ: SessionType,
-}
-
-impl ActiveSession {
-    pub fn new(start_time: OffsetDateTime) -> Self {
-        ActiveSession {
-            start: start_time,
-            typ: SessionType::Unknown,
-        }
-    }
-
-    pub fn set_type(&mut self, ticket_type: TicketType) {
-        self.typ = ticket_type.into();
-    }
-
-    pub fn end_at(self, stop_time: OffsetDateTime) -> Option<FinishedSession> {
-        let session_duration = stop_time - self.start;
-        //ensure duration is positive to fit in a u64
-        //u64::max milliseconds is 500k millenia so no overflow issue
-        if session_duration > Duration::ZERO {
-            Some(FinishedSession {
-                duration: session_duration,
-                typ: self.typ,
-            })
-        } else {
-            None
-        }
-    }
-}
-
 impl From<StoredActiveSession> for ActiveSession {
    fn from(value: StoredActiveSession) -> Self {
        ActiveSession {
@@ -9,7 +9,6 @@ edition.workspace = true
 license.workspace = true

 [dependencies]
-async-trait = { workspace = true }
 bincode = { workspace = true }
 defguard_wireguard_rs = { workspace = true }
 log = { workspace = true }
@@ -4,7 +4,7 @@
 use thiserror::Error;

 #[derive(Error, Debug)]
-pub enum StorageError {
+pub enum GatewayStorageError {
    #[error("Database experienced an internal error: {0}")]
    InternalDatabaseError(#[from] sqlx::Error),

@@ -1,10 +1,8 @@
 // Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only

-use async_trait::async_trait;
 use bandwidth::BandwidthManager;
 use clients::{ClientManager, ClientType};
-use error::StorageError;
 use inboxes::InboxManager;
 use models::{
    Client, PersistedBandwidth, PersistedSharedKeys, RedemptionProposal, StoredMessage,
@@ -29,237 +27,11 @@ mod shared_keys;
 mod tickets;
 mod wireguard_peers;

-#[async_trait]
-pub trait Storage: Send + Sync {
-    async fn get_mixnet_client_id(
-        &self,
-        client_address: DestinationAddressBytes,
-    ) -> Result<i64, StorageError>;
-
-    /// Inserts provided derived shared keys into the database.
-    /// If keys previously existed for the provided client, they are overwritten with the new data.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: base58-encoded address of the client
-    /// * `shared_keys`:
-    ///     - legacy: shared encryption (AES128CTR) and mac (hmac-blake3) derived shared keys to store.
-    ///     - current: shared AES256-GCM-SIV keys
-    async fn insert_shared_keys(
-        &self,
-        client_address: DestinationAddressBytes,
-        shared_keys: &SharedGatewayKey,
-    ) -> Result<i64, StorageError>;
-
-    /// Tries to retrieve shared keys stored for the particular client.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    async fn get_shared_keys(
-        &self,
-        client_address: DestinationAddressBytes,
-    ) -> Result<Option<PersistedSharedKeys>, StorageError>;
-
-    /// Removes from the database shared keys derived with the particular client.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    // currently there is no code flow that causes removal (not overwriting)
-    // of the stored keys. However, retain the function for consistency and completion sake
-    #[allow(dead_code)]
-    async fn remove_shared_keys(
-        &self,
-        client_address: DestinationAddressBytes,
-    ) -> Result<(), StorageError>;
-
-    /// Tries to retrieve a particular client.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_id`: id of the client
-    #[allow(dead_code)]
-    async fn get_client(&self, client_id: i64) -> Result<Option<Client>, StorageError>;
-
-    /// Inserts new message to the storage for an offline client for future retrieval.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    /// * `message`: raw message to store.
-    async fn store_message(
-        &self,
-        client_address: DestinationAddressBytes,
-        message: Vec<u8>,
-    ) -> Result<(), StorageError>;
-
-    /// Retrieves messages stored for the particular client specified by the provided address.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    /// * `start_after`: optional starting id of the messages to grab
-    ///
-    /// returns the retrieved messages alongside optional id of the last message retrieved if
-    /// there are more messages to retrieve.
-    async fn retrieve_messages(
-        &self,
-        client_address: DestinationAddressBytes,
-        start_after: Option<i64>,
-    ) -> Result<(Vec<StoredMessage>, Option<i64>), StorageError>;
-
-    /// Removes messages with the specified ids
-    ///
-    /// # Arguments
-    ///
-    /// * `ids`: ids of the messages to remove
-    async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), StorageError>;
-
-    /// Creates a new bandwidth entry for the particular client.
-    async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), StorageError>;
-
-    /// Set the freepass expiration date of the particular client to the provided date.
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    /// * `expiration`: the expiration date of the associated free pass.
-    async fn set_expiration(
-        &self,
-        client_id: i64,
-        expiration: OffsetDateTime,
-    ) -> Result<(), StorageError>;
-
-    /// Reset all the bandwidth
-    ///
-    /// # Arguments
-    ///
-    /// * `client_address`: address of the client
-    async fn reset_bandwidth(&self, client_id: i64) -> Result<(), StorageError>;
-
-    /// Tries to retrieve available bandwidth for the particular client.
-    async fn get_available_bandwidth(
-        &self,
-        client_id: i64,
-    ) -> Result<Option<PersistedBandwidth>, StorageError>;
-
-    /// Increases specified client's bandwidth by the provided amount and returns the current value.
-    async fn increase_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError>;
-
-    async fn revoke_ticket_bandwidth(
-        &self,
-        ticket_id: i64,
-        amount: i64,
-    ) -> Result<(), StorageError>;
-
-    #[allow(dead_code)]
-    /// Decreases specified client's bandwidth by the provided amount and returns the current value.
-    async fn decrease_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError>;
-
-    async fn insert_epoch_signers(
-        &self,
-        epoch_id: i64,
-        signer_ids: Vec<i64>,
-    ) -> Result<(), StorageError>;
-
-    async fn insert_received_ticket(
-        &self,
-        client_id: i64,
-        received_at: OffsetDateTime,
-        serial_number: Vec<u8>,
-        data: Vec<u8>,
-    ) -> Result<i64, StorageError>;
-
-    // note: this only checks very recent tickets that haven't yet been redeemed
-    // (but it's better than nothing)
-    /// Check if the ticket with the provided serial number if already present in the storage.
-    ///
-    /// # Arguments
-    ///
-    /// * `serial_number`: the unique serial number embedded in the ticket
-    async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, StorageError>;
-
-    async fn insert_ticket_verification(
-        &self,
-        ticket_id: i64,
-        signer_id: i64,
-        verified_at: OffsetDateTime,
-        accepted: bool,
-    ) -> Result<(), StorageError>;
-
-    async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), StorageError>;
-
-    async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), StorageError>;
-
-    async fn remove_verified_ticket_binary_data(&self, ticket_id: i64) -> Result<(), StorageError>;
-
-    async fn get_all_verified_tickets_with_sn(&self) -> Result<Vec<VerifiedTicket>, StorageError>;
-    async fn get_all_proposed_tickets_with_sn(
-        &self,
-        proposal_id: u32,
-    ) -> Result<Vec<VerifiedTicket>, StorageError>;
-
-    async fn insert_redemption_proposal(
-        &self,
-        tickets: &[VerifiedTicket],
-        proposal_id: u32,
-        created_at: OffsetDateTime,
-    ) -> Result<(), StorageError>;
-
-    async fn clear_post_proposal_data(
-        &self,
-        proposal_id: u32,
-        resolved_at: OffsetDateTime,
-        rejected: bool,
-    ) -> Result<(), StorageError>;
-
-    async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, StorageError>;
-
-    async fn get_all_unverified_tickets(&self) -> Result<Vec<ClientTicket>, StorageError>;
-    async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, StorageError>;
-    async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, StorageError>;
-
-    async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, StorageError>;
-
-    /// Insert a wireguard peer in the storage.
-    ///
-    /// # Arguments
-    ///
-    /// * `peer`: wireguard peer data to be stored
-    /// * `with_client_id`: if the peer should have a corresponding client_id
-    ///   (created with entry wireguard ticket) or live without one (or with an
-    ///   exiting one), for temporary backwards compatibility.
-    async fn insert_wireguard_peer(
-        &self,
-        peer: &defguard_wireguard_rs::host::Peer,
-        with_client_id: bool,
-    ) -> Result<Option<i64>, StorageError>;
-
-    /// Tries to retrieve available bandwidth for the particular peer.
-    ///
-    /// # Arguments
-    ///
-    /// * `peer_public_key`: wireguard public key of the peer to be retrieved.
-    async fn get_wireguard_peer(
-        &self,
-        peer_public_key: &str,
-    ) -> Result<Option<WireguardPeer>, StorageError>;
-
-    /// Retrieves all wireguard peers.
-    async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, StorageError>;
-
-    /// Remove a wireguard peer from the storage.
-    ///
-    /// # Arguments
-    ///
-    /// * `peer_public_key`: wireguard public key of the peer to be removed.
-    async fn remove_wireguard_peer(&self, peer_public_key: &str) -> Result<(), StorageError>;
-}
+pub use error::GatewayStorageError;

 // note that clone here is fine as upon cloning the same underlying pool will be used
 #[derive(Clone)]
-pub struct PersistentStorage {
+pub struct GatewayStorage {
    client_manager: ClientManager,
    shared_key_manager: SharedKeysManager,
    inbox_manager: InboxManager,
@@ -268,7 +40,7 @@ pub struct PersistentStorage {
    wireguard_peer_manager: wireguard_peers::WgPeerManager,
 }

-impl PersistentStorage {
+impl GatewayStorage {
    /// Initialises `PersistentStorage` using the provided path.
    ///
    /// # Arguments
@@ -278,7 +50,7 @@ impl PersistentStorage {
    pub async fn init<P: AsRef<Path> + Send>(
        database_path: P,
        message_retrieval_limit: i64,
-    ) -> Result<Self, StorageError> {
+    ) -> Result<Self, GatewayStorageError> {
        debug!(
            "Attempting to connect to database {:?}",
            database_path.as_ref().as_os_str()
@@ -307,7 +79,7 @@ impl PersistentStorage {
        }

        // the cloning here are cheap as connection pool is stored behind an Arc
-        Ok(PersistentStorage {
+        Ok(GatewayStorage {
            client_manager: clients::ClientManager::new(connection_pool.clone()),
            wireguard_peer_manager: wireguard_peers::WgPeerManager::new(connection_pool.clone()),
            shared_key_manager: SharedKeysManager::new(connection_pool.clone()),
@@ -318,23 +90,22 @@ impl PersistentStorage {
    }
 }

-#[async_trait]
-impl Storage for PersistentStorage {
-    async fn get_mixnet_client_id(
+impl GatewayStorage {
+    pub async fn get_mixnet_client_id(
        &self,
        client_address: DestinationAddressBytes,
-    ) -> Result<i64, StorageError> {
+    ) -> Result<i64, GatewayStorageError> {
        Ok(self
            .shared_key_manager
            .client_id(&client_address.as_base58_string())
            .await?)
    }

-    async fn insert_shared_keys(
+    pub async fn insert_shared_keys(
        &self,
        client_address: DestinationAddressBytes,
        shared_keys: &SharedGatewayKey,
-    ) -> Result<i64, StorageError> {
+    ) -> Result<i64, GatewayStorageError> {
        let client_address_bs58 = client_address.as_base58_string();
        let client_id = match self
            .shared_key_manager
@@ -359,10 +130,10 @@ impl Storage for PersistentStorage {
        Ok(client_id)
    }

-    async fn get_shared_keys(
+    pub async fn get_shared_keys(
        &self,
        client_address: DestinationAddressBytes,
-    ) -> Result<Option<PersistedSharedKeys>, StorageError> {
+    ) -> Result<Option<PersistedSharedKeys>, GatewayStorageError> {
        let keys = self
            .shared_key_manager
            .get_shared_keys(&client_address.as_base58_string())
@@ -371,37 +142,37 @@ impl Storage for PersistentStorage {
    }

    #[allow(dead_code)]
-    async fn remove_shared_keys(
+    pub async fn remove_shared_keys(
        &self,
        client_address: DestinationAddressBytes,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        self.shared_key_manager
            .remove_shared_keys(&client_address.as_base58_string())
            .await?;
        Ok(())
    }

-    async fn get_client(&self, client_id: i64) -> Result<Option<Client>, StorageError> {
+    pub async fn get_client(&self, client_id: i64) -> Result<Option<Client>, GatewayStorageError> {
        let client = self.client_manager.get_client(client_id).await?;
        Ok(client)
    }

-    async fn store_message(
+    pub async fn store_message(
        &self,
        client_address: DestinationAddressBytes,
        message: Vec<u8>,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        self.inbox_manager
            .insert_message(&client_address.as_base58_string(), message)
            .await?;
        Ok(())
    }

-    async fn retrieve_messages(
+    pub async fn retrieve_messages(
        &self,
        client_address: DestinationAddressBytes,
        start_after: Option<i64>,
-    ) -> Result<(Vec<StoredMessage>, Option<i64>), StorageError> {
+    ) -> Result<(Vec<StoredMessage>, Option<i64>), GatewayStorageError> {
        let messages = self
            .inbox_manager
            .get_messages(&client_address.as_base58_string(), start_after)
@@ -409,87 +180,95 @@ impl Storage for PersistentStorage {
        Ok(messages)
    }

-    async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), StorageError> {
+    pub async fn remove_messages(&self, ids: Vec<i64>) -> Result<(), GatewayStorageError> {
        for id in ids {
            self.inbox_manager.remove_message(id).await?;
        }
        Ok(())
    }

-    async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), StorageError> {
+    pub async fn create_bandwidth_entry(&self, client_id: i64) -> Result<(), GatewayStorageError> {
        self.bandwidth_manager.insert_new_client(client_id).await?;
        Ok(())
    }

-    async fn set_expiration(
+    pub async fn set_expiration(
        &self,
        client_id: i64,
        expiration: OffsetDateTime,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        self.bandwidth_manager
            .set_expiration(client_id, expiration)
            .await?;
        Ok(())
    }

-    async fn reset_bandwidth(&self, client_id: i64) -> Result<(), StorageError> {
+    pub async fn reset_bandwidth(&self, client_id: i64) -> Result<(), GatewayStorageError> {
        self.bandwidth_manager.reset_bandwidth(client_id).await?;
        Ok(())
    }

-    async fn get_available_bandwidth(
+    pub async fn get_available_bandwidth(
        &self,
        client_id: i64,
-    ) -> Result<Option<PersistedBandwidth>, StorageError> {
+    ) -> Result<Option<PersistedBandwidth>, GatewayStorageError> {
        Ok(self
            .bandwidth_manager
            .get_available_bandwidth(client_id)
            .await?)
    }

-    async fn increase_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError> {
+    pub async fn increase_bandwidth(
+        &self,
+        client_id: i64,
+        amount: i64,
+    ) -> Result<i64, GatewayStorageError> {
        Ok(self
            .bandwidth_manager
            .increase_bandwidth(client_id, amount)
            .await?)
    }

-    async fn revoke_ticket_bandwidth(
+    pub async fn revoke_ticket_bandwidth(
        &self,
        ticket_id: i64,
        amount: i64,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        Ok(self
            .bandwidth_manager
            .revoke_ticket_bandwidth(ticket_id, amount)
            .await?)
    }

-    async fn decrease_bandwidth(&self, client_id: i64, amount: i64) -> Result<i64, StorageError> {
+    pub async fn decrease_bandwidth(
+        &self,
+        client_id: i64,
+        amount: i64,
+    ) -> Result<i64, GatewayStorageError> {
        Ok(self
            .bandwidth_manager
            .decrease_bandwidth(client_id, amount)
            .await?)
    }

-    async fn insert_epoch_signers(
+    pub async fn insert_epoch_signers(
        &self,
        epoch_id: i64,
        signer_ids: Vec<i64>,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        self.ticket_manager
            .insert_ecash_signers(epoch_id, signer_ids)
            .await?;
        Ok(())
    }

-    async fn insert_received_ticket(
+    pub async fn insert_received_ticket(
        &self,
        client_id: i64,
        received_at: OffsetDateTime,
        serial_number: Vec<u8>,
        data: Vec<u8>,
-    ) -> Result<i64, StorageError> {
+    ) -> Result<i64, GatewayStorageError> {
        // technically if we crash between those 2 calls we'll have a bit of data inconsistency,
        // but nothing too tragic. we just won't get paid for a single ticket
        let ticket_id = self
@@ -503,24 +282,24 @@ impl Storage for PersistentStorage {
        Ok(ticket_id)
    }

-    async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, StorageError> {
+    pub async fn contains_ticket(&self, serial_number: &[u8]) -> Result<bool, GatewayStorageError> {
        Ok(self.ticket_manager.has_ticket_data(serial_number).await?)
    }

-    async fn insert_ticket_verification(
+    pub async fn insert_ticket_verification(
        &self,
        ticket_id: i64,
        signer_id: i64,
        verified_at: OffsetDateTime,
        accepted: bool,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        self.ticket_manager
            .insert_ticket_verification(ticket_id, signer_id, verified_at, accepted)
            .await?;
        Ok(())
    }

-    async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), StorageError> {
+    pub async fn update_rejected_ticket(&self, ticket_id: i64) -> Result<(), GatewayStorageError> {
        // set the ticket as rejected
        self.ticket_manager.set_rejected_ticket(ticket_id).await?;

@@ -531,7 +310,7 @@ impl Storage for PersistentStorage {
        Ok(())
    }

-    async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), StorageError> {
+    pub async fn update_verified_ticket(&self, ticket_id: i64) -> Result<(), GatewayStorageError> {
        // 1. insert into verified table
        self.ticket_manager
            .insert_verified_ticket(ticket_id)
@@ -545,36 +324,41 @@ impl Storage for PersistentStorage {
        Ok(())
    }

-    async fn remove_verified_ticket_binary_data(&self, ticket_id: i64) -> Result<(), StorageError> {
+    pub async fn remove_verified_ticket_binary_data(
+        &self,
+        ticket_id: i64,
+    ) -> Result<(), GatewayStorageError> {
        self.ticket_manager
            .remove_binary_ticket_data(ticket_id)
            .await?;
        Ok(())
    }

-    async fn get_all_verified_tickets_with_sn(&self) -> Result<Vec<VerifiedTicket>, StorageError> {
+    pub async fn get_all_verified_tickets_with_sn(
+        &self,
+    ) -> Result<Vec<VerifiedTicket>, GatewayStorageError> {
        Ok(self
            .ticket_manager
            .get_all_verified_tickets_with_sn()
            .await?)
    }

-    async fn get_all_proposed_tickets_with_sn(
+    pub async fn get_all_proposed_tickets_with_sn(
        &self,
        proposal_id: u32,
-    ) -> Result<Vec<VerifiedTicket>, StorageError> {
+    ) -> Result<Vec<VerifiedTicket>, GatewayStorageError> {
        Ok(self
            .ticket_manager
            .get_all_proposed_tickets_with_sn(proposal_id as i64)
            .await?)
    }

-    async fn insert_redemption_proposal(
+    pub async fn insert_redemption_proposal(
        &self,
        tickets: &[VerifiedTicket],
        proposal_id: u32,
        created_at: OffsetDateTime,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        // if we crash between those, there might a bit of an issue. we should revisit it later

        // 1. insert the actual proposal
@@ -592,12 +376,12 @@ impl Storage for PersistentStorage {
        Ok(())
    }

-    async fn clear_post_proposal_data(
+    pub async fn clear_post_proposal_data(
        &self,
        proposal_id: u32,
        resolved_at: OffsetDateTime,
        rejected: bool,
-    ) -> Result<(), StorageError> {
+    ) -> Result<(), GatewayStorageError> {
        // 1. update proposal metadata
        self.ticket_manager
            .update_redemption_proposal(proposal_id as i64, resolved_at, rejected)
@@ -616,11 +400,13 @@ impl Storage for PersistentStorage {
        Ok(())
    }

-    async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, StorageError> {
+    pub async fn latest_proposal(&self) -> Result<Option<RedemptionProposal>, GatewayStorageError> {
        Ok(self.ticket_manager.get_latest_redemption_proposal().await?)
    }

-    async fn get_all_unverified_tickets(&self) -> Result<Vec<ClientTicket>, StorageError> {
+    pub async fn get_all_unverified_tickets(
+        &self,
+    ) -> Result<Vec<ClientTicket>, GatewayStorageError> {
        self.ticket_manager
            .get_unverified_tickets()
            .await?
@@ -629,29 +415,37 @@ impl Storage for PersistentStorage {
            .collect()
    }

-    async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, StorageError> {
+    pub async fn get_all_unresolved_proposals(&self) -> Result<Vec<i64>, GatewayStorageError> {
        Ok(self
            .ticket_manager
            .get_all_unresolved_redemption_proposal_ids()
            .await?)
    }

-    async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, StorageError> {
+    pub async fn get_votes(&self, ticket_id: i64) -> Result<Vec<i64>, GatewayStorageError> {
        Ok(self
            .ticket_manager
            .get_verification_votes(ticket_id)
            .await?)
    }

-    async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, StorageError> {
+    pub async fn get_signers(&self, epoch_id: i64) -> Result<Vec<i64>, GatewayStorageError> {
        Ok(self.ticket_manager.get_epoch_signers(epoch_id).await?)
    }

-    async fn insert_wireguard_peer(
+    /// Insert a wireguard peer in the storage.
+    ///
+    /// # Arguments
+    ///
+    /// * `peer`: wireguard peer data to be stored
+    /// * `with_client_id`: if the peer should have a corresponding client_id
+    ///   (created with entry wireguard ticket) or live without one (or with an
+    ///   exiting one), for temporary backwards compatibility.
+    pub async fn insert_wireguard_peer(
        &self,
        peer: &defguard_wireguard_rs::host::Peer,
        with_client_id: bool,
-    ) -> Result<Option<i64>, StorageError> {
+    ) -> Result<Option<i64>, GatewayStorageError> {
        let client_id = match self
            .wireguard_peer_manager
            .retrieve_peer(&peer.public_key.to_string())
@@ -676,10 +470,15 @@ impl Storage for PersistentStorage {
        Ok(client_id)
    }

-    async fn get_wireguard_peer(
+    /// Tries to retrieve available bandwidth for the particular peer.
+    ///
+    /// # Arguments
+    ///
+    /// * `peer_public_key`: wireguard public key of the peer to be retrieved.
+    pub async fn get_wireguard_peer(
        &self,
        peer_public_key: &str,
-    ) -> Result<Option<WireguardPeer>, StorageError> {
+    ) -> Result<Option<WireguardPeer>, GatewayStorageError> {
        let peer = self
            .wireguard_peer_manager
            .retrieve_peer(peer_public_key)
@@ -687,12 +486,21 @@ impl Storage for PersistentStorage {
        Ok(peer)
    }

-    async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, StorageError> {
+    /// Retrieves all wireguard peers.
+    pub async fn get_all_wireguard_peers(&self) -> Result<Vec<WireguardPeer>, GatewayStorageError> {
        let ret = self.wireguard_peer_manager.retrieve_all_peers().await?;
        Ok(ret)
    }

-    async fn remove_wireguard_peer(&self, peer_public_key: &str) -> Result<(), StorageError> {
+    /// Remove a wireguard peer from the storage.
+    ///
+    /// # Arguments
+    ///
+    /// * `peer_public_key`: wireguard public key of the peer to be removed.
+    pub async fn remove_wireguard_peer(
+        &self,
+        peer_public_key: &str,
+    ) -> Result<(), GatewayStorageError> {
        self.wireguard_peer_manager
            .remove_peer(peer_public_key)
            .await?;
@@ -1,7 +1,7 @@
 // Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only

-use crate::error::StorageError;
+use crate::error::GatewayStorageError;
 use nym_credentials_interface::{AvailableBandwidth, ClientTicket, CredentialSpendingData};
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use sqlx::FromRow;
@@ -24,24 +24,24 @@ pub struct PersistedSharedKeys {
 }

 impl TryFrom<PersistedSharedKeys> for SharedGatewayKey {
-    type Error = StorageError;
+    type Error = GatewayStorageError;

    fn try_from(value: PersistedSharedKeys) -> Result<Self, Self::Error> {
        match (
            &value.derived_aes256_gcm_siv_key,
            &value.derived_aes128_ctr_blake3_hmac_keys_bs58,
        ) {
-            (None, None) => Err(StorageError::MissingSharedKey {
+            (None, None) => Err(GatewayStorageError::MissingSharedKey {
                id: value.client_id,
            }),
            (Some(aes256gcm_siv), _) => {
                let current_key = SharedSymmetricKey::try_from_bytes(aes256gcm_siv)
-                    .map_err(|source| StorageError::DataCorruption(source.to_string()))?;
+                    .map_err(|source| GatewayStorageError::DataCorruption(source.to_string()))?;
                Ok(SharedGatewayKey::Current(current_key))
            }
            (None, Some(aes128ctr_hmac)) => {
                let legacy_key = LegacySharedKeys::try_from_base58_string(aes128ctr_hmac)
-                    .map_err(|source| StorageError::DataCorruption(source.to_string()))?;
+                    .map_err(|source| GatewayStorageError::DataCorruption(source.to_string()))?;
                Ok(SharedGatewayKey::Legacy(legacy_key))
            }
        }
@@ -91,12 +91,12 @@ pub struct UnverifiedTicketData {
 }

 impl TryFrom<UnverifiedTicketData> for ClientTicket {
-    type Error = StorageError;
+    type Error = GatewayStorageError;

    fn try_from(value: UnverifiedTicketData) -> Result<Self, Self::Error> {
        Ok(ClientTicket {
            spending_data: CredentialSpendingData::try_from_bytes(&value.data).map_err(|_| {
-                StorageError::MalformedStoredTicketData {
+                GatewayStorageError::MalformedStoredTicketData {
                    ticket_id: value.ticket_id,
                }
            })?,
@@ -152,7 +152,7 @@ impl From<defguard_wireguard_rs::host::Peer> for WireguardPeer {
 }

 impl TryFrom<WireguardPeer> for defguard_wireguard_rs::host::Peer {
-    type Error = crate::error::StorageError;
+    type Error = crate::error::GatewayStorageError;

    fn try_from(value: WireguardPeer) -> Result<Self, Self::Error> {
        Ok(Self {
@@ -5,8 +5,9 @@ use std::fmt;

 use http::HeaderValue;
 use nym_bin_common::build_information::{BinaryBuildInformation, BinaryBuildInformationOwned};
+use serde::{Deserialize, Serialize};

-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct UserAgent {
    pub application: String,
    pub version: String,
@@ -26,7 +26,7 @@ url = { workspace = true }
 time.workspace = true
 thiserror = { workspace = true }

-nym-crypto = { path = "../crypto" }
+nym-crypto = { path = "../crypto", features = ["asymmetric"] }
 nym-network-defaults = { path = "../network-defaults" }
 nym-sphinx-acknowledgements = { path = "../nymsphinx/acknowledgements" }
 nym-sphinx-addressing = { path = "../nymsphinx/addressing" }
@@ -35,7 +35,5 @@ nym-sphinx-framing = { path = "../nymsphinx/framing" }
 nym-sphinx-params = { path = "../nymsphinx/params" }
 nym-sphinx-types = { path = "../nymsphinx/types" }
 nym-task = { path = "../task" }
-nym-validator-client = { path = "../client-libs/validator-client" }
-nym-bin-common = { path = "../bin-common" }
 nym-metrics = { path = "../nym-metrics" }
-nym-node-http-api = { path = "../../nym-node/nym-node-http-api" } 
+
@@ -1,4 +1,4 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
+
 pub mod packet_processor;
-pub mod verloc;
@@ -1,81 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::fmt::{self, Display, Formatter};
-use std::io;
-
-#[derive(Debug)]
-pub enum RttError {
-    UnexpectedEchoPacketSize,
-    UnexpectedReplyPacketSize,
-
-    MalformedSenderIdentity,
-
-    MalformedEchoSignature,
-    MalformedReplySignature,
-
-    InvalidEchoSignature,
-    InvalidReplySignature,
-
-    UnreachableNode(String, io::Error),
-    UnexpectedConnectionFailureWrite(String, io::Error),
-    UnexpectedConnectionFailureRead(String, io::Error),
-    ConnectionReadTimeout(String),
-    ConnectionWriteTimeout(String),
-
-    UnexpectedReplySequence,
-
-    ShutdownReceived,
-}
-
-impl Display for RttError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            RttError::UnexpectedEchoPacketSize => {
-                write!(f, "The received echo packet had unexpected size")
-            }
-            RttError::UnexpectedReplyPacketSize => {
-                write!(f, "The received reply packet had unexpected size")
-            }
-            RttError::MalformedSenderIdentity => {
-                write!(f, "The received echo packet had malformed sender")
-            }
-            RttError::MalformedEchoSignature => {
-                write!(f, "The received echo packet had malformed signature")
-            }
-            RttError::MalformedReplySignature => {
-                write!(f, "The received reply packet had malformed signature")
-            }
-            RttError::InvalidEchoSignature => {
-                write!(f, "The received echo packet had invalid signature")
-            }
-            RttError::InvalidReplySignature => {
-                write!(f, "The received reply packet had invalid signature")
-            }
-            RttError::UnreachableNode(id, err) => {
-                write!(f, "Could not establish connection to {id} - {err}")
-            }
-            RttError::UnexpectedConnectionFailureWrite(id, err) => {
-                write!(f, "Failed to write echo packet to {id} - {err}")
-            }
-            RttError::UnexpectedConnectionFailureRead(id, err) => {
-                write!(f, "Failed to read reply packet from {id} - {err}")
-            }
-            RttError::ConnectionReadTimeout(id) => {
-                write!(f, "Timed out while trying to read reply packet from {id}")
-            }
-            RttError::ConnectionWriteTimeout(id) => {
-                write!(f, "Timed out while trying to write echo packet to {id}")
-            }
-            RttError::UnexpectedReplySequence => write!(
-                f,
-                "The received reply packet had an unexpected sequence number"
-            ),
-            RttError::ShutdownReceived => {
-                write!(f, "Shutdown signal received")
-            }
-        }
-    }
-}
-
-impl std::error::Error for RttError {}
@@ -1,35 +0,0 @@
-// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_node_http_api::state::metrics::{SharedVerlocStats, VerlocNodeResult};
-use std::mem;
-use time::OffsetDateTime;
-
-pub(crate) trait VerlocStatsUpdateExt {
-    async fn start_new_measurements(&self, nodes_to_test: usize);
-
-    async fn append_measurement_results(&self, new_data: Vec<VerlocNodeResult>);
-
-    async fn finish_measurements(&self);
-}
-
-impl VerlocStatsUpdateExt for SharedVerlocStats {
-    async fn start_new_measurements(&self, nodes_to_test: usize) {
-        let mut guard = self.write().await;
-        guard.previous_run_data = mem::take(&mut guard.current_run_data);
-        guard.current_run_data.nodes_tested = nodes_to_test;
-    }
-
-    async fn append_measurement_results(&self, mut new_data: Vec<VerlocNodeResult>) {
-        let mut write_permit = self.write().await;
-        write_permit.current_run_data.results.append(&mut new_data);
-        // make sure the data always stays in order.
-        // TODO: considering the front of the results is guaranteed to be sorted, should perhaps
-        // a non-default sorting algorithm be used?
-        write_permit.current_run_data.results.sort()
-    }
-
-    async fn finish_measurements(&self) {
-        self.write().await.current_run_data.run_finished = Some(OffsetDateTime::now_utc())
-    }
-}
@@ -1,383 +0,0 @@
-// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::verloc::listener::PacketListener;
-use crate::verloc::sender::{PacketSender, TestedNode};
-use futures::stream::FuturesUnordered;
-use futures::StreamExt;
-use log::*;
-use nym_bin_common::version_checker::{self, parse_version};
-use nym_crypto::asymmetric::identity;
-use nym_network_defaults::mainnet::NYM_API;
-use nym_node_http_api::state::metrics::{SharedVerlocStats, VerlocNodeResult};
-use nym_task::TaskClient;
-use rand::seq::SliceRandom;
-use rand::thread_rng;
-use std::net::SocketAddr;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::task::JoinHandle;
-use tokio::time::sleep;
-use url::Url;
-
-use measurement::VerlocStatsUpdateExt;
-
-// pub use crate::verloc::measurement::{AtomicVerlocResult, Verloc, VerlocResult};
-
-pub mod error;
-pub(crate) mod listener;
-pub(crate) mod measurement;
-pub(crate) mod packet;
-pub(crate) mod sender;
-
-// TODO: MUST BE UPDATED BEFORE ACTUAL RELEASE!!
-pub const MINIMUM_NODE_VERSION: &str = "0.10.1";
-
-// by default all of those are overwritten by config data from mixnodes directly
-const DEFAULT_VERLOC_PORT: u16 = 1790;
-const DEFAULT_PACKETS_PER_NODE: usize = 100;
-const DEFAULT_PACKET_TIMEOUT: Duration = Duration::from_millis(1500);
-const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_millis(5000);
-const DEFAULT_DELAY_BETWEEN_PACKETS: Duration = Duration::from_millis(50);
-const DEFAULT_BATCH_SIZE: usize = 50;
-const DEFAULT_TESTING_INTERVAL: Duration = Duration::from_secs(60 * 60 * 12);
-const DEFAULT_RETRY_TIMEOUT: Duration = Duration::from_secs(60 * 30);
-
-#[derive(Clone, Debug)]
-pub struct Config {
-    /// Minimum semver version of a node (gateway or mixnode) that is capable of replying to echo packets.
-    minimum_compatible_node_version: version_checker::Version,
-
-    /// Socket address of this node on which it will be listening for the measurement packets.
-    listening_address: SocketAddr,
-
-    /// Specifies number of echo packets sent to each node during a measurement run.
-    packets_per_node: usize,
-
-    /// Specifies maximum amount of time to wait for the reply packet to arrive before abandoning the test.
-    packet_timeout: Duration,
-
-    /// Specifies maximum amount of time to wait for the connection to get established.
-    connection_timeout: Duration,
-
-    /// Specifies delay between subsequent test packets being sent (after receiving a reply).
-    delay_between_packets: Duration,
-
-    /// Specifies number of nodes being tested at once.
-    tested_nodes_batch_size: usize,
-
-    /// Specifies delay between subsequent test runs.
-    testing_interval: Duration,
-
-    /// Specifies delay between attempting to run the measurement again if the previous run failed
-    /// due to being unable to get the list of nodes.
-    retry_timeout: Duration,
-
-    /// URLs to the nym apis for obtaining network topology.
-    nym_api_urls: Vec<Url>,
-}
-
-impl Config {
-    pub fn build() -> ConfigBuilder {
-        ConfigBuilder::new()
-    }
-}
-
-#[must_use]
-pub struct ConfigBuilder(Config);
-
-impl ConfigBuilder {
-    pub fn new() -> ConfigBuilder {
-        Self::default()
-    }
-
-    pub fn minimum_compatible_node_version(mut self, version: version_checker::Version) -> Self {
-        self.0.minimum_compatible_node_version = version;
-        self
-    }
-
-    pub fn listening_address(mut self, listening_address: SocketAddr) -> Self {
-        self.0.listening_address = listening_address;
-        self
-    }
-
-    pub fn packets_per_node(mut self, packets_per_node: usize) -> Self {
-        self.0.packets_per_node = packets_per_node;
-        self
-    }
-
-    pub fn packet_timeout(mut self, packet_timeout: Duration) -> Self {
-        self.0.packet_timeout = packet_timeout;
-        self
-    }
-
-    pub fn connection_timeout(mut self, connection_timeout: Duration) -> Self {
-        self.0.connection_timeout = connection_timeout;
-        self
-    }
-
-    pub fn delay_between_packets(mut self, delay_between_packets: Duration) -> Self {
-        self.0.delay_between_packets = delay_between_packets;
-        self
-    }
-
-    pub fn tested_nodes_batch_size(mut self, tested_nodes_batch_size: usize) -> Self {
-        self.0.tested_nodes_batch_size = tested_nodes_batch_size;
-        self
-    }
-
-    pub fn testing_interval(mut self, testing_interval: Duration) -> Self {
-        self.0.testing_interval = testing_interval;
-        self
-    }
-
-    pub fn retry_timeout(mut self, retry_timeout: Duration) -> Self {
-        self.0.retry_timeout = retry_timeout;
-        self
-    }
-
-    pub fn nym_api_urls(mut self, nym_api_urls: Vec<Url>) -> Self {
-        self.0.nym_api_urls = nym_api_urls;
-        self
-    }
-
-    pub fn build(self) -> Config {
-        // panics here are fine as those are only ever constructed at the initial setup
-        assert!(
-            !self.0.nym_api_urls.is_empty(),
-            "at least one validator endpoint must be provided",
-        );
-        self.0
-    }
-}
-
-impl Default for ConfigBuilder {
-    fn default() -> Self {
-        ConfigBuilder(Config {
-            minimum_compatible_node_version: parse_version(MINIMUM_NODE_VERSION).unwrap(),
-            listening_address: format!("[::]:{DEFAULT_VERLOC_PORT}").parse().unwrap(),
-            packets_per_node: DEFAULT_PACKETS_PER_NODE,
-            packet_timeout: DEFAULT_PACKET_TIMEOUT,
-            connection_timeout: DEFAULT_CONNECTION_TIMEOUT,
-            delay_between_packets: DEFAULT_DELAY_BETWEEN_PACKETS,
-            tested_nodes_batch_size: DEFAULT_BATCH_SIZE,
-            testing_interval: DEFAULT_TESTING_INTERVAL,
-            retry_timeout: DEFAULT_RETRY_TIMEOUT,
-            nym_api_urls: vec![NYM_API.parse().expect("Invalid default API URL")],
-        })
-    }
-}
-
-pub struct VerlocMeasurer {
-    config: Config,
-    packet_sender: Arc<PacketSender>,
-    packet_listener: Arc<PacketListener>,
-    shutdown_listener: TaskClient,
-
-    currently_used_api: usize,
-
-    // Note: this client is only fine here as it does not maintain constant connection to the validator.
-    // It only does bunch of REST queries. If we update it at some point to a more sophisticated (maybe signing) client,
-    // then it definitely cannot be constructed here and probably will need to be passed from outside,
-    // as mixnodes/gateways would already be using an instance of said client.
-    validator_client: nym_validator_client::NymApiClient,
-    state: SharedVerlocStats,
-}
-
-impl VerlocMeasurer {
-    pub fn new(
-        mut config: Config,
-        identity: Arc<identity::KeyPair>,
-        shutdown_listener: TaskClient,
-    ) -> Self {
-        config.nym_api_urls.shuffle(&mut thread_rng());
-
-        VerlocMeasurer {
-            packet_sender: Arc::new(PacketSender::new(
-                Arc::clone(&identity),
-                config.packets_per_node,
-                config.packet_timeout,
-                config.connection_timeout,
-                config.delay_between_packets,
-                shutdown_listener.clone().named("VerlocPacketSender"),
-            )),
-            packet_listener: Arc::new(PacketListener::new(
-                config.listening_address,
-                Arc::clone(&identity),
-                shutdown_listener.clone().named("VerlocPacketListener"),
-            )),
-            shutdown_listener,
-            currently_used_api: 0,
-            validator_client: nym_validator_client::NymApiClient::new(
-                config.nym_api_urls[0].clone(),
-            ),
-            config,
-            state: SharedVerlocStats::default(),
-        }
-    }
-
-    pub fn set_shared_state(&mut self, state: SharedVerlocStats) {
-        self.state = state;
-    }
-
-    fn use_next_nym_api(&mut self) {
-        if self.config.nym_api_urls.len() == 1 {
-            warn!("There's only a single validator API available - it won't be possible to use a different one");
-            return;
-        }
-
-        self.currently_used_api = (self.currently_used_api + 1) % self.config.nym_api_urls.len();
-        self.validator_client
-            .change_nym_api(self.config.nym_api_urls[self.currently_used_api].clone())
-    }
-
-    fn start_listening(&self) -> JoinHandle<()> {
-        let packet_listener = Arc::clone(&self.packet_listener);
-        tokio::spawn(packet_listener.run())
-    }
-
-    async fn perform_measurement(&self, nodes_to_test: Vec<TestedNode>) -> MeasurementOutcome {
-        log::trace!("Performing measurements");
-        if nodes_to_test.is_empty() {
-            log::debug!("there are no nodes to measure");
-            return MeasurementOutcome::Done;
-        }
-
-        let mut shutdown_listener = self.shutdown_listener.clone().named("VerlocMeasurement");
-        shutdown_listener.disarm();
-
-        for chunk in nodes_to_test.chunks(self.config.tested_nodes_batch_size) {
-            let mut chunk_results = Vec::with_capacity(chunk.len());
-
-            let mut measurement_chunk = chunk
-                .iter()
-                .map(|node| {
-                    let node = *node;
-                    let packet_sender = Arc::clone(&self.packet_sender);
-                    // TODO: there's a potential issue here. if we make the measurement go into separate
-                    // task, we risk biasing results with the bunch of context switches overhead
-                    // but if we don't do it, it will take ages to complete
-
-                    // TODO: check performance difference when it's not spawned as a separate task
-                    tokio::spawn(async move {
-                        (
-                            packet_sender.send_packets_to_node(node).await,
-                            node.identity,
-                        )
-                    })
-                })
-                .collect::<FuturesUnordered<_>>();
-
-            // exhaust the results
-            while !shutdown_listener.is_shutdown() {
-                tokio::select! {
-                    measurement_result = measurement_chunk.next() => {
-                        let Some(result) = measurement_result else {
-                            // if the stream has finished, it means we got everything we could have gotten
-                            break
-                        };
-
-                        // if we receive JoinError it means the task failed to get executed, so either there's a bigger issue with tokio
-                        // or there was a panic inside the task itself. In either case, we should just terminate ourselves.
-                        let execution_result = result.expect("the measurement task panicked!");
-                        let identity = execution_result.1;
-
-                        let measurement_result = match execution_result.0 {
-                            Err(err) => {
-                                debug!("Failed to perform measurement for {identity}: {err}");
-                                None
-                            }
-                            Ok(result) => Some(result),
-                        };
-                        chunk_results.push(VerlocNodeResult::new(identity, measurement_result));
-                    },
-                    _ = shutdown_listener.recv() => {
-                        trace!("Shutdown received while measuring");
-                        return MeasurementOutcome::Shutdown;
-                    }
-                }
-            }
-
-            // update the results vector with chunks as they become available (by default every 50 nodes)
-            self.state.append_measurement_results(chunk_results).await;
-        }
-
-        MeasurementOutcome::Done
-    }
-
-    pub async fn run(&mut self) {
-        self.start_listening();
-
-        while !self.shutdown_listener.is_shutdown() {
-            info!("Starting verloc measurements");
-            // TODO: should we also measure gateways?
-
-            let all_mixes = match self.validator_client.get_all_described_nodes().await {
-                Ok(nodes) => nodes,
-                Err(err) => {
-                    error!(
-                        "failed to obtain list of mixnodes from the validator - {}. Going to attempt to use another validator API in the next run",
-                        err
-                    );
-                    self.use_next_nym_api();
-                    sleep(self.config.retry_timeout).await;
-                    continue;
-                }
-            };
-            if all_mixes.is_empty() {
-                warn!("There does not seem there are any nodes to measure...")
-            }
-
-            // we only care about address and identity
-            let tested_nodes = all_mixes
-                .into_iter()
-                .filter(|n| n.description.declared_role.mixnode)
-                .filter_map(|node| {
-                    // try to parse the identity and host
-                    let node_identity = node.ed25519_identity_key();
-
-                    let ip = node.description.host_information.ip_address.first()?;
-                    let verloc_port = node.description.verloc_port();
-                    let verloc_host = SocketAddr::new(*ip, verloc_port);
-
-                    // TODO: possible problem in the future, this does name resolution and theoretically
-                    // if a lot of nodes maliciously mis-configured themselves, it might take a while to resolve them all
-                    // However, maybe it's not a problem as if they are misconfigured, they will eventually be
-                    // pushed out of the network and on top of that, verloc is done in separate task that runs
-                    // only every few hours.
-                    Some(TestedNode::new(verloc_host, node_identity))
-                })
-                .collect::<Vec<_>>();
-
-            // on start of each run remove old results
-            self.state.start_new_measurements(tested_nodes.len()).await;
-
-            if let MeasurementOutcome::Shutdown = self.perform_measurement(tested_nodes).await {
-                log::trace!("Shutting down after aborting measurements");
-                break;
-            }
-
-            // write current time to "run finished" field
-            self.state.finish_measurements().await;
-
-            info!(
-                "Finished performing verloc measurements. The next one will happen in {:?}",
-                self.config.testing_interval
-            );
-
-            tokio::select! {
-                _ = sleep(self.config.testing_interval) => {},
-                _ = self.shutdown_listener.recv() => {
-                    log::trace!("Shutdown received while sleeping");
-                }
-            }
-        }
-
-        log::trace!("Verloc: Exiting");
-    }
-}
-
-enum MeasurementOutcome {
-    Done,
-    Shutdown,
-}
@@ -1,17 +0,0 @@
-[package]
-name = "nym-common-models"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-readme.workspace = true
-
-[dependencies]
-anyhow = { workspace = true }
-bincode = { workspace = true }
-nym-crypto = { path = "../crypto", features = ["asymmetric", "serde"] }
-serde = { workspace = true, features = ["derive"] }
@@ -1 +0,0 @@
-pub mod ns_api;
@@ -29,6 +29,9 @@ pub struct NodeTester<R> {

    packet_size: PacketSize,

+    /// Specify whether route selection should be determined by the packet header.
+    deterministic_route_selection: bool,
+
    /// Average delay a data packet is going to get delay at a single mixnode.
    average_packet_delay: Duration,

@@ -48,11 +51,13 @@ impl<R> NodeTester<R>
 where
    R: Rng + CryptoRng,
 {
+    #[allow(clippy::too_many_arguments)]
    pub fn new(
        rng: R,
        base_topology: NymTopology,
        self_address: Option<Recipient>,
        packet_size: PacketSize,
+        deterministic_route_selection: bool,
        average_packet_delay: Duration,
        average_ack_delay: Duration,
        ack_key: Arc<AckKey>,
@@ -62,6 +67,7 @@ where
            base_topology,
            self_address,
            packet_size,
+            deterministic_route_selection,
            average_packet_delay,
            average_ack_delay,
            num_mix_hops: DEFAULT_NUM_MIX_HOPS,
@@ -289,10 +295,18 @@ where
 impl<R: CryptoRng + Rng> FragmentPreparer for NodeTester<R> {
    type Rng = R;

+    fn deterministic_route_selection(&self) -> bool {
+        self.deterministic_route_selection
+    }
+
    fn rng(&mut self) -> &mut Self::Rng {
        &mut self.rng
    }

+    fn nonce(&self) -> i32 {
+        1
+    }
+
    fn num_mix_hops(&self) -> u8 {
        self.num_mix_hops
    }
@@ -304,8 +318,4 @@ impl<R: CryptoRng + Rng> FragmentPreparer for NodeTester<R> {
    fn average_ack_delay(&self) -> Duration {
        self.average_ack_delay
    }
-
-    fn nonce(&self) -> i32 {
-        1
-    }
 }
@@ -1,45 +0,0 @@
-[package]
-name = "nym-tui-common"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-readme.workspace = true
-
-[dependencies]
-async-trait = { workspace = true }
-humantime-serde = { workspace = true }
-serde = { workspace = true }
-tokio = { workspace = true, features = ["sync", "rt-multi-thread", "signal", "macros"] }
-tokio-stream = { workspace = true }
-tokio-util = { workspace = true, features = ["rt"] }
-tracing = { workspace = true }
-thiserror = { workspace = true }
-
-# tui
-crossterm = { workspace = true, features = ["event-stream"] }
-ratatui = { workspace = true, features = ["serde", "macros", "crossterm"] }
-tui-logger = { workspace = true, optional = true, features = ["tracing-support"], default-features = false }
-
-# panic handlers
-better-panic = { workspace = true }
-color-eyre = { workspace = true }
-strip-ansi-escapes = { workspace = true }
-
-[dev-dependencies]
-tracing-subscriber = { workspace = true, features = ["env-filter"] }
-tracing = { workspace = true, features = ["log"] }
-
-[[example]]
-name = "hello_world"
-required-features = ["logger"]
-
-
-
-
-[features]
-logger = ["tui-logger"]
@@ -1,175 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use async_trait::async_trait;
-use color_eyre::eyre;
-use crossterm::event::{KeyCode, KeyEvent};
-use nym_tui_common::tui::config::keybindings::{KeyBinding, LoggerKeybindings};
-use nym_tui_common::{
-    run_tui, Action, ActionDispatcher, ActionSender, AppAction, Component, DebugHistory, Logger,
-    LoggerProps, State,
-};
-use ratatui::layout::{Layout, Rect};
-use ratatui::prelude::Constraint;
-use ratatui::widgets::Paragraph;
-use ratatui::Frame;
-use tracing::log::LevelFilter;
-use tracing_subscriber::EnvFilter;
-
-// useful pattern for tabs, etc:
-/*
-fn get_active_page_component_mut(&mut self) -> &mut dyn Component {
-    match self.props.active_tab {
-        ActiveTab::Tab1 => &mut self.tab1,
-        ActiveTab::Tab2 => &mut self.tab2,
-    }
-}
- */
-
-struct Props {
-    custom_quit: KeyBinding,
-}
-
-impl From<&HelloStore> for Props {
-    fn from(store: &HelloStore) -> Self {
-        Props {
-            custom_quit: store.config.custom_quit,
-        }
-    }
-}
-
-pub struct HelloRootApp {
-    props: Props,
-
-    action_sender: ActionSender<HelloActions>,
-    logger: Logger<HelloStore, HelloActions>,
-    debug_history: DebugHistory<HelloStore, HelloActions>,
-}
-
-impl Component for HelloRootApp {
-    type State = HelloStore;
-    type Actions = HelloActions;
-
-    fn new(state: &HelloStore, action_sender: ActionSender<HelloActions>) -> Self
-    where
-        Self: Sized,
-    {
-        HelloRootApp {
-            props: Props::from(state),
-            action_sender: action_sender.clone(),
-            logger: Logger::new(state, action_sender.clone()),
-            debug_history: DebugHistory::new(state, action_sender),
-        }
-    }
-
-    fn update(self, state: &Self::State) -> Self
-    where
-        Self: Sized,
-    {
-        HelloRootApp {
-            logger: self.logger.update(state),
-            debug_history: self.debug_history.update(state),
-            ..self
-        }
-    }
-
-    fn tick(&mut self) -> bool {
-        let logger_tick = self.logger.tick();
-        let debug_history_tick = self.debug_history.tick();
-
-        logger_tick || debug_history_tick
-    }
-
-    fn handle_key(&mut self, key: KeyEvent) -> eyre::Result<()> {
-        let maybe_binding = KeyBinding::from(key);
-        if maybe_binding == self.props.custom_quit {
-            self.action_sender.send(Action::Quit);
-        }
-
-        self.logger.handle_key(key)?;
-        self.debug_history.handle_key(key)?;
-
-        Ok(())
-    }
-
-    fn view(&mut self, frame: &mut Frame, rect: Rect) {
-        let [logs, hello_rect] =
-            Layout::vertical([Constraint::Percentage(50), Constraint::Percentage(50)]).areas(rect);
-
-        self.logger.view(frame, logs);
-
-        frame.render_widget(Paragraph::new("Hello world!").centered(), hello_rect);
-
-        self.debug_history.view(frame, rect);
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum HelloActions {}
-
-impl AppAction for HelloActions {}
-
-#[derive(Clone)]
-pub struct HelloConfig {
-    pub custom_quit: KeyBinding,
-    pub logger_keybindings: LoggerKeybindings,
-}
-
-impl Default for HelloConfig {
-    fn default() -> Self {
-        HelloConfig {
-            custom_quit: KeyBinding::new(KeyCode::Char('x')),
-            logger_keybindings: Default::default(),
-        }
-    }
-}
-
-#[derive(Clone, Default)]
-pub struct HelloStore {
-    config: HelloConfig,
-}
-
-impl<'a> From<&'a HelloStore> for LoggerProps {
-    fn from(store: &'a HelloStore) -> LoggerProps {
-        LoggerProps {
-            keybindings: store.config.logger_keybindings,
-        }
-    }
-}
-
-impl State for HelloStore {}
-
-#[derive(Default)]
-pub struct HelloDispatcher {}
-
-#[async_trait]
-impl ActionDispatcher for HelloDispatcher {
-    type Store = HelloStore;
-    type Actions = HelloActions;
-
-    async fn handle_app_action(
-        &mut self,
-        action: Self::Actions,
-        store: &mut Self::Store,
-    ) -> eyre::Result<()> {
-        let _ = action;
-        let _ = store;
-        Ok(())
-    }
-}
-
-#[tokio::main]
-async fn main() -> eyre::Result<()> {
-    use tracing_subscriber::layer::SubscriberExt;
-    use tracing_subscriber::util::SubscriberInitExt;
-    use tracing_subscriber::Layer;
-
-    let filter: EnvFilter = "trace,mio=warn".parse()?;
-
-    tracing_subscriber::registry()
-        .with(tui_logger::tracing_subscriber_layer().with_filter(filter))
-        .init();
-    tui_logger::init_logger(LevelFilter::Trace)?;
-
-    run_tui::<HelloRootApp, _>(Default::default(), HelloDispatcher {}, Default::default()).await
-}
@@ -1,24 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::char::ParseCharError;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum NymTuiError {
-    #[error("failed to abort tui processing task within specified duration")]
-    TuiTaskAbortFailure,
-
-    #[error("{str} could not be parsed into a character: {source}")]
-    InvalidCharacter {
-        str: String,
-        #[source]
-        source: ParseCharError,
-    },
-
-    #[error("could not process an unknown keybinding: '{value}'")]
-    UnknownKeyBinding { value: String },
-
-    #[error("could not process an unknown key modifier: '{value}'")]
-    UnknownKeyModifier { value: String },
-}
@@ -1,46 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#![warn(clippy::expect_used)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::todo)]
-#![warn(clippy::dbg_macro)]
-#![warn(clippy::panic)]
-
-use crate::tui::manager::TuiManager;
-use color_eyre::eyre;
-
-pub mod error;
-pub mod tui;
-
-pub use crate::tui::config::TuiConfig;
-pub use tui::action::{Action, AppAction};
-pub use tui::dispatcher::store::State;
-pub use tui::dispatcher::{ActionDispatcher, ActionSender};
-pub use tui::initialize_panic_handler;
-pub use tui::ui::components::Component;
-
-// components:
-pub use tui::ui::components::common::DebugHistory;
-#[cfg(feature = "logger")]
-pub use tui::ui::components::common::{Logger, LoggerProps};
-
-pub async fn run_tui<C, D>(
-    config: TuiConfig,
-    action_dispatcher: D,
-    initial_state: D::Store,
-) -> eyre::Result<()>
-where
-    C: Component + Send + Sync + 'static,
-    C::State: Send + Sync + 'static,
-    C::Actions: Send + Sync + Clone + 'static,
-    D: ActionDispatcher<Store = C::State, Actions = C::Actions> + Send + Sync + 'static,
-{
-    initialize_panic_handler()?;
-
-    TuiManager::<C>::build_new(config, action_dispatcher, initial_state)?
-        .wait_for_exit_or_signal()
-        .await;
-
-    Ok(())
-}
@@ -1,13 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::fmt::Debug;
-
-#[derive(Debug)]
-pub enum Action<T: AppAction> {
-    Quit,
-
-    AppDefined(T),
-}
-
-pub trait AppAction: Debug {}
@@ -1,271 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::fmt::{Display, Formatter};
-use std::str::FromStr;
-use std::sync::LazyLock;
-
-use crate::error::NymTuiError;
-#[cfg(feature = "logger")]
-use tui_logger::TuiWidgetEvent;
-
-static KEY_MODIFIERS: LazyLock<HashMap<&'static str, KeyModifiers>> = LazyLock::new(|| {
-    let mut m = HashMap::new();
-    m.insert("shift", KeyModifiers::SHIFT);
-    m.insert("ctrl", KeyModifiers::CONTROL);
-    m.insert("alt", KeyModifiers::ALT);
-    m.insert("super", KeyModifiers::SUPER);
-    m.insert("hyper", KeyModifiers::HYPER);
-    m.insert("meta", KeyModifiers::META);
-    m
-});
-
-static SPECIAL_KEYS: LazyLock<HashMap<&'static str, KeyCode>> = LazyLock::new(|| {
-    let mut m = HashMap::new();
-    m.insert("backspace", KeyCode::Backspace);
-    m.insert("enter", KeyCode::Enter);
-    m.insert("left", KeyCode::Left);
-    m.insert("right", KeyCode::Right);
-    m.insert("up", KeyCode::Up);
-    m.insert("down", KeyCode::Down);
-    m.insert("home", KeyCode::Home);
-    m.insert("end", KeyCode::End);
-    m.insert("pageup", KeyCode::PageUp);
-    m.insert("pagedown", KeyCode::PageDown);
-    m.insert("tab", KeyCode::Tab);
-    m.insert("backtab", KeyCode::BackTab);
-    m.insert("delete", KeyCode::Delete);
-    m.insert("insert", KeyCode::Insert);
-    m.insert("null", KeyCode::Null);
-    m.insert("esc", KeyCode::Esc);
-    m.insert("space", KeyCode::Char(' '));
-    m.insert("f1", KeyCode::F(1));
-    m.insert("f2", KeyCode::F(2));
-    m.insert("f3", KeyCode::F(3));
-    m.insert("f4", KeyCode::F(4));
-    m.insert("f5", KeyCode::F(5));
-    m.insert("f6", KeyCode::F(6));
-    m.insert("f7", KeyCode::F(7));
-    m.insert("f8", KeyCode::F(8));
-    m.insert("f9", KeyCode::F(9));
-    m.insert("f10", KeyCode::F(10));
-    m.insert("f11", KeyCode::F(11));
-    m.insert("f12", KeyCode::F(12));
-    m
-});
-
-#[cfg(feature = "logger")]
-#[derive(Serialize, Deserialize, Clone, Copy, Debug)]
-#[serde(rename_all = "kebab-case", deny_unknown_fields, default)]
-pub struct LoggerKeybindings {
-    // TODO: give them better names
-    tui_logger_space_key: KeyBinding,
-    tui_logger_up_key: KeyBinding,
-    tui_logger_down_key: KeyBinding,
-    tui_logger_left_key: KeyBinding,
-    tui_logger_right_key: KeyBinding,
-    tui_logger_plus_key: KeyBinding,
-    tui_logger_minus_key: KeyBinding,
-    tui_logger_hide_key: KeyBinding,
-    tui_logger_focus_key: KeyBinding,
-    tui_logger_prev_page_key: KeyBinding,
-    tui_logger_next_page_key: KeyBinding,
-    tui_logger_escape_key: KeyBinding,
-}
-
-#[cfg(feature = "logger")]
-impl Default for LoggerKeybindings {
-    fn default() -> Self {
-        LoggerKeybindings {
-            tui_logger_space_key: KeyBinding::new(KeyCode::Char(' ')),
-            tui_logger_up_key: KeyBinding::new(KeyCode::Up),
-            tui_logger_down_key: KeyBinding::new(KeyCode::Down),
-            tui_logger_left_key: KeyBinding::new(KeyCode::Left),
-            tui_logger_right_key: KeyBinding::new(KeyCode::Right),
-            tui_logger_plus_key: KeyBinding::new(KeyCode::Char('+')),
-            tui_logger_minus_key: KeyBinding::new(KeyCode::Char('-')),
-            tui_logger_hide_key: KeyBinding::new(KeyCode::Char('h')),
-            tui_logger_focus_key: KeyBinding::new(KeyCode::Char('f')),
-            tui_logger_prev_page_key: KeyBinding::new(KeyCode::PageUp),
-            tui_logger_next_page_key: KeyBinding::new(KeyCode::PageDown),
-            tui_logger_escape_key: KeyBinding::new(KeyCode::Esc),
-        }
-    }
-}
-
-#[cfg(feature = "logger")]
-impl LoggerKeybindings {
-    pub fn tui_logger_event(&self, key: KeyBinding) -> Option<TuiWidgetEvent> {
-        if key == self.tui_logger_space_key {
-            Some(TuiWidgetEvent::SpaceKey)
-        } else if key == self.tui_logger_up_key {
-            Some(TuiWidgetEvent::UpKey)
-        } else if key == self.tui_logger_down_key {
-            Some(TuiWidgetEvent::DownKey)
-        } else if key == self.tui_logger_left_key {
-            Some(TuiWidgetEvent::LeftKey)
-        } else if key == self.tui_logger_right_key {
-            Some(TuiWidgetEvent::RightKey)
-        } else if key == self.tui_logger_plus_key {
-            Some(TuiWidgetEvent::PlusKey)
-        } else if key == self.tui_logger_minus_key {
-            Some(TuiWidgetEvent::MinusKey)
-        } else if key == self.tui_logger_hide_key {
-            Some(TuiWidgetEvent::HideKey)
-        } else if key == self.tui_logger_focus_key {
-            Some(TuiWidgetEvent::FocusKey)
-        } else if key == self.tui_logger_prev_page_key {
-            Some(TuiWidgetEvent::PrevPageKey)
-        } else if key == self.tui_logger_next_page_key {
-            Some(TuiWidgetEvent::NextPageKey)
-        } else if key == self.tui_logger_escape_key {
-            Some(TuiWidgetEvent::EscapeKey)
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, Copy, Eq, PartialEq, Hash)]
-#[serde(try_from = "String")]
-#[serde(into = "String")]
-pub struct KeyBinding {
-    pub code: KeyCode,
-    pub modifier: KeyModifiers,
-}
-
-impl KeyBinding {
-    pub fn new(code: KeyCode) -> Self {
-        KeyBinding {
-            code,
-            modifier: KeyModifiers::NONE,
-        }
-    }
-
-    pub fn new_with_modifier(code: KeyCode, modifier: KeyModifiers) -> Self {
-        KeyBinding { code, modifier }
-    }
-}
-
-impl From<KeyEvent> for KeyBinding {
-    fn from(value: KeyEvent) -> Self {
-        KeyBinding {
-            code: value.code,
-            modifier: value.modifiers,
-        }
-    }
-}
-
-impl Display for KeyBinding {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        if self.modifier.contains(KeyModifiers::SHIFT) {
-            write!(f, "shift+")?;
-        }
-        if self.modifier.contains(KeyModifiers::CONTROL) {
-            write!(f, "ctrl+")?;
-        }
-        if self.modifier.contains(KeyModifiers::ALT) {
-            write!(f, "alt+")?;
-        }
-        if self.modifier.contains(KeyModifiers::SUPER) {
-            write!(f, "super+")?;
-        }
-        if self.modifier.contains(KeyModifiers::HYPER) {
-            write!(f, "hyper+")?;
-        }
-        if self.modifier.contains(KeyModifiers::META) {
-            write!(f, "meta+")?;
-        }
-        match self.code {
-            KeyCode::Backspace => write!(f, "backspace"),
-            KeyCode::Enter => write!(f, "enter"),
-            KeyCode::Left => write!(f, "left"),
-            KeyCode::Right => write!(f, "right"),
-            KeyCode::Up => write!(f, "up"),
-            KeyCode::Down => write!(f, "down"),
-            KeyCode::Home => write!(f, "home"),
-            KeyCode::End => write!(f, "end"),
-            KeyCode::PageUp => write!(f, "pageup"),
-            KeyCode::PageDown => write!(f, "pagedown"),
-            KeyCode::Tab => write!(f, "tab"),
-            KeyCode::BackTab => write!(f, "backtab"),
-            KeyCode::Delete => write!(f, "delete"),
-            KeyCode::Insert => write!(f, "insert"),
-            KeyCode::Char(c) => write!(f, "{c}"),
-            KeyCode::Null => write!(f, "null"),
-            KeyCode::Esc => write!(f, "esc"),
-            _ => write!(f, "unknown"),
-        }
-    }
-}
-
-impl From<KeyBinding> for String {
-    fn from(value: KeyBinding) -> Self {
-        value.to_string()
-    }
-}
-
-impl TryFrom<String> for KeyBinding {
-    type Error = NymTuiError;
-
-    fn try_from(value: String) -> Result<Self, Self::Error> {
-        value.parse()
-    }
-}
-
-impl FromStr for KeyBinding {
-    type Err = NymTuiError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.rsplit_once('+') {
-            Some((modifiers, value)) => Ok(Self {
-                code: parse_keycode(value)?,
-                modifier: parse_modifiers(modifiers)?,
-            }),
-            None => Ok(Self {
-                code: parse_keycode(s)?,
-                modifier: KeyModifiers::NONE,
-            }),
-        }
-    }
-}
-
-fn parse_keycode(value: &str) -> Result<KeyCode, NymTuiError> {
-    Ok(if value.len() == 1 {
-        KeyCode::Char(
-            char::from_str(value)
-                .map_err(|source| NymTuiError::InvalidCharacter {
-                    str: value.to_string(),
-                    source,
-                })?
-                .to_ascii_lowercase(),
-        )
-    } else {
-        SPECIAL_KEYS
-            .get(value)
-            .cloned()
-            .ok_or_else(|| NymTuiError::UnknownKeyBinding {
-                value: value.to_string(),
-            })?
-    })
-}
-
-fn parse_modifiers(modifiers: &str) -> Result<KeyModifiers, NymTuiError> {
-    modifiers
-        .split('+')
-        .try_fold(KeyModifiers::NONE, |modifiers, token| {
-            KEY_MODIFIERS
-                .get(token)
-                .map(|modifier| modifiers | *modifier)
-                .ok_or_else(|| NymTuiError::UnknownKeyModifier {
-                    value: token.to_string(),
-                })
-        })
-}
-
-pub fn key_event_to_string(key_event: &KeyEvent) -> String {
-    KeyBinding::from(*key_event).to_string()
-}
@@ -1,69 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-
-pub mod keybindings;
-
-pub const DEFAULT_TICK_RATE: Duration = Duration::from_millis(200);
-
-const DEFAULT_SHUTDOWN_GRACE: Duration = Duration::from_millis(500);
-const DEFAULT_CANCEL_GRACE: Duration = Duration::from_millis(500);
-const DEFAULT_ABORT_GRACE: Duration = Duration::from_millis(200);
-
-#[derive(Default, Debug, Serialize, Deserialize, Clone)]
-pub struct TuiConfig {
-    pub tui: Tui,
-
-    // #[serde(default)]
-    // pub key_bindings: KeyBindings,
-    #[serde(default)]
-    pub debug: Debug,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
-pub struct Debug {
-    pub debug_mode_enabled: bool,
-
-    #[serde(with = "humantime_serde")]
-    pub shutdown_grace: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub cancel_grace: Duration,
-
-    #[serde(with = "humantime_serde")]
-    pub abort_grace: Duration,
-}
-
-impl Default for Debug {
-    fn default() -> Self {
-        Debug {
-            debug_mode_enabled: true,
-            shutdown_grace: DEFAULT_SHUTDOWN_GRACE,
-            cancel_grace: DEFAULT_CANCEL_GRACE,
-            abort_grace: DEFAULT_ABORT_GRACE,
-        }
-    }
-}
-
-#[derive(Default, Debug, Serialize, Deserialize, Clone, Copy)]
-pub struct Tui {
-    #[serde(default, flatten)]
-    pub debug: TuiDebug,
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
-pub struct TuiDebug {
-    #[serde(with = "humantime_serde")]
-    pub tick_rate: Duration,
-}
-
-impl Default for TuiDebug {
-    fn default() -> Self {
-        TuiDebug {
-            tick_rate: DEFAULT_TICK_RATE,
-            // frame_rate: DEFAULT_FRAME_RATE,
-        }
-    }
-}
@@ -1,139 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::tui::action::Action;
-use crate::tui::dispatcher::store::State;
-use crate::AppAction;
-use async_trait::async_trait;
-use color_eyre::eyre;
-use tokio::sync::mpsc::UnboundedSender;
-use tokio_stream::wrappers::UnboundedReceiverStream;
-use tokio_stream::StreamExt;
-use tokio_util::sync::CancellationToken;
-use tracing::{debug, error, info, warn};
-
-pub mod store;
-
-#[derive(Clone)]
-pub struct ActionSender<T: AppAction>(UnboundedSender<Action<T>>);
-
-impl<T> From<UnboundedSender<Action<T>>> for ActionSender<T>
-where
-    T: AppAction,
-{
-    fn from(value: UnboundedSender<Action<T>>) -> Self {
-        ActionSender(value)
-    }
-}
-
-impl<T> ActionSender<T>
-where
-    T: AppAction,
-{
-    pub fn send(&self, action: impl Into<Action<T>>) {
-        if let Err(unsent) = self.0.send(action.into()) {
-            error!("failed to send {:?} action to the dispatcher", unsent.0)
-        }
-    }
-}
-
-pub type ActionReceiver<T> = UnboundedReceiverStream<Action<T>>;
-
-pub type StateUpdateSender<S> = UnboundedSender<S>;
-pub type StateUpdateReceiver<S> = UnboundedReceiverStream<S>;
-
-#[async_trait]
-pub trait ActionDispatcher {
-    type Store: State;
-    type Actions: AppAction;
-
-    async fn handle_app_action(
-        &mut self,
-        action: Self::Actions,
-        store: &mut Self::Store,
-    ) -> eyre::Result<()>;
-}
-
-pub struct DispatcherLoop<D: ActionDispatcher> {
-    dispatcher: D,
-    store: D::Store,
-
-    // to be used with async actions
-    #[allow(dead_code)]
-    action_sender: ActionSender<D::Actions>,
-    action_receiver: ActionReceiver<D::Actions>,
-    state_update_sender: StateUpdateSender<D::Store>,
-    cancellation_token: CancellationToken,
-}
-
-impl<D> DispatcherLoop<D>
-where
-    D: ActionDispatcher + Send + Sync + 'static,
-    D::Store: Send + Sync + 'static,
-{
-    pub(crate) fn new(
-        dispatcher: D,
-        store: D::Store,
-        action_sender: impl Into<ActionSender<D::Actions>>,
-        action_receiver: impl Into<ActionReceiver<D::Actions>>,
-        state_update_sender: StateUpdateSender<D::Store>,
-        cancellation_token: CancellationToken,
-    ) -> DispatcherLoop<D> {
-        DispatcherLoop {
-            dispatcher,
-            store,
-            action_sender: action_sender.into(),
-            action_receiver: action_receiver.into(),
-            state_update_sender,
-            cancellation_token,
-        }
-    }
-
-    async fn handle_action(&mut self, action: Option<Action<D::Actions>>) -> eyre::Result<()> {
-        let Some(action) = action else {
-            warn!("the dispatcher channel has closed! we're probably already in shutdown!");
-            // but if we're not, make sure to kick it off...
-            self.cancellation_token.cancel();
-            return Ok(());
-        };
-
-        match action {
-            Action::Quit => {
-                debug!("attempting to handle the QUIT action");
-                self.cancellation_token.cancel();
-                // no need to send any state updates here
-                return Ok(());
-            }
-            Action::AppDefined(action) => {
-                debug!("attempting to handle the following action: {:?}", action);
-                self.dispatcher
-                    .handle_app_action(action, &mut self.store)
-                    .await?;
-            }
-        }
-
-        self.state_update_sender.send(self.store.clone())?;
-        Ok(())
-    }
-
-    pub async fn run(&mut self) -> eyre::Result<()> {
-        info!("starting the dispatcher loop");
-
-        // issue initial state
-        self.state_update_sender.send(self.store.clone())?;
-
-        loop {
-            tokio::select! {
-                biased;
-                _ = self.cancellation_token.cancelled() => {
-                    info!("received cancellation token");
-                    break;
-                }
-                maybe_action = self.action_receiver.next() => {
-                    self.handle_action(maybe_action).await?
-                }
-            }
-        }
-        Ok(())
-    }
-}
@@ -1,80 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use color_eyre::eyre;
-use crossterm::event::EventStream;
-use ratatui::backend::CrosstermBackend as Backend;
-use ratatui::crossterm::{
-    self, cursor,
-    terminal::{EnterAlternateScreen, LeaveAlternateScreen},
-};
-use std::ops::{Deref, DerefMut};
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use tokio_stream::Stream;
-
-pub struct TuiHandle {
-    pub terminal: ratatui::Terminal<Backend<std::io::Stderr>>,
-    pub crossterm_events: EventStream,
-}
-
-impl TuiHandle {
-    pub fn new() -> Result<TuiHandle, eyre::Error> {
-        let terminal = ratatui::Terminal::new(Backend::new(std::io::stderr()))?;
-        let crossterm_events = EventStream::new();
-
-        Ok(TuiHandle {
-            terminal,
-            crossterm_events,
-        })
-    }
-
-    pub fn enter(&self) -> Result<(), eyre::Error> {
-        crossterm::terminal::enable_raw_mode()?;
-        crossterm::execute!(std::io::stderr(), EnterAlternateScreen, cursor::Hide)?;
-        Ok(())
-    }
-
-    pub fn exit(&mut self) -> eyre::Result<()> {
-        if crossterm::terminal::is_raw_mode_enabled()? {
-            self.terminal.flush()?;
-            crossterm::execute!(std::io::stderr(), LeaveAlternateScreen, cursor::Show)?;
-            crossterm::terminal::disable_raw_mode()?;
-        }
-        Ok(())
-    }
-}
-
-impl Stream for TuiHandle {
-    type Item = <EventStream as Stream>::Item;
-
-    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Pin::new(&mut self.crossterm_events).poll_next(cx)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.crossterm_events.size_hint()
-    }
-}
-
-impl Deref for TuiHandle {
-    type Target = ratatui::Terminal<Backend<std::io::Stderr>>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.terminal
-    }
-}
-
-impl DerefMut for TuiHandle {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.terminal
-    }
-}
-
-impl Drop for TuiHandle {
-    fn drop(&mut self) {
-        // well. at this point we can't do much, we'll just go straight into the panic handler
-        #[allow(clippy::expect_used)]
-        self.exit().expect("failed to teardown the terminal")
-    }
-}
@@ -1,158 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::tui::action::Action;
-use crate::tui::config::TuiConfig;
-use crate::tui::dispatcher::{ActionDispatcher, ActionSender, DispatcherLoop};
-use crate::tui::ui::UiEventLoop;
-use crate::Component;
-use color_eyre::eyre;
-use std::time::Duration;
-use tokio::sync::mpsc;
-use tokio::task::JoinHandle;
-use tokio::time::timeout;
-use tokio_util::sync::CancellationToken;
-use tokio_util::task::TaskTracker;
-use tracing::{error, info};
-
-pub struct TuiManager<C: Component> {
-    shutdown_grace: Duration,
-    cancel_grace: Duration,
-    abort_grace: Duration,
-
-    task_tracker: TaskTracker,
-    cancellation_token: CancellationToken,
-
-    dispatcher_handle: JoinHandle<eyre::Result<()>>,
-    ui_event_loop_handle: JoinHandle<eyre::Result<()>>,
-
-    action_sender: ActionSender<C::Actions>,
-}
-
-impl<C> TuiManager<C>
-where
-    C: Component + Send + Sync + 'static,
-    C::State: Send + Sync + 'static,
-    C::Actions: Send + Sync + Clone + 'static,
-{
-    pub(crate) fn build_new<D>(
-        config: TuiConfig,
-        action_dispatcher: D,
-        initial_state: D::Store,
-    ) -> eyre::Result<TuiManager<C>>
-    where
-        D: ActionDispatcher<Store = C::State, Actions = C::Actions> + Send + Sync + 'static,
-    {
-        let task_tracker = TaskTracker::new();
-        let cancellation_token = CancellationToken::new();
-
-        let (action_tx, action_rx) = mpsc::unbounded_channel();
-        let (state_tx, state_rx) = mpsc::unbounded_channel();
-
-        let mut dispatcher_loop = DispatcherLoop::new(
-            action_dispatcher,
-            initial_state,
-            action_tx.clone(),
-            action_rx,
-            state_tx,
-            cancellation_token.clone(),
-        );
-        let mut ui_event_loop = UiEventLoop::<C>::new(
-            config.tui.debug.tick_rate,
-            cancellation_token.clone(),
-            state_rx,
-            action_tx.clone(),
-        )?;
-
-        let dispatcher_handle = task_tracker.spawn(async move { dispatcher_loop.run().await });
-        let ui_event_loop_handle = task_tracker.spawn(async move { ui_event_loop.run().await });
-
-        task_tracker.close();
-
-        Ok(TuiManager {
-            shutdown_grace: config.debug.shutdown_grace,
-            cancel_grace: config.debug.cancel_grace,
-            abort_grace: config.debug.abort_grace,
-            task_tracker,
-            cancellation_token,
-            dispatcher_handle,
-            ui_event_loop_handle,
-            action_sender: action_tx.into(),
-        })
-    }
-
-    async fn graceful_shutdown(&self) {
-        // 1. try to send quit action to handle it the most gracefully
-        self.action_sender.send(Action::Quit);
-        if timeout(self.shutdown_grace, self.task_tracker.wait())
-            .await
-            .is_ok()
-        {
-            return;
-        }
-        error!("timed out while waiting for graceful shutdown");
-
-        // 2. if that doesn't work, issue cancellation token
-        self.cancellation_token.cancel();
-        if timeout(self.cancel_grace, self.task_tracker.wait())
-            .await
-            .is_ok()
-        {
-            return;
-        }
-        error!("timed out while attempting to resolve cancellation token shutdown");
-
-        // 3. finally go with nuclear option and just abort the tasks
-        self.dispatcher_handle.abort();
-        self.ui_event_loop_handle.abort();
-
-        if timeout(self.abort_grace, self.task_tracker.wait())
-            .await
-            .is_ok()
-        {
-            return;
-        }
-
-        error!("somehow we still failed to shutdown our tasks! we might end up in a dirty state... oh well")
-    }
-
-    pub(crate) async fn wait_for_exit_or_signal(&self) {
-        tokio::select! {
-            _ = self.task_tracker.wait() => {
-                // user decided to quit with 'normal' action
-            }
-            _ = wait_for_signal() => {
-                self.graceful_shutdown().await
-            }
-        }
-    }
-}
-
-#[cfg(unix)]
-#[allow(clippy::expect_used)]
-pub async fn wait_for_signal() {
-    use tokio::signal::unix::{signal, SignalKind};
-    let mut sigterm = signal(SignalKind::terminate()).expect("failed to setup SIGTERM channel");
-    let mut sigquit = signal(SignalKind::quit()).expect("failed to setup SIGQUIT channel");
-
-    tokio::select! {
-        _ = tokio::signal::ctrl_c() => {
-            info!("Received SIGINT");
-        },
-        _ = sigterm.recv() => {
-            info!("Received SIGTERM");
-        }
-        _ = sigquit.recv() => {
-            info!("Received SIGQUIT");
-        }
-    }
-}
-
-#[cfg(not(unix))]
-pub async fn wait_for_signal() {
-    tokio::select! {
-        _ = tokio::signal::ctrl_c() => {
-            info!("Received SIGINT");
-        },
-    }
-}
@@ -1,46 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::tui::handle::TuiHandle;
-use color_eyre::eyre;
-use tracing::error;
-
-pub mod action;
-pub mod config;
-pub(crate) mod dispatcher;
-pub mod handle;
-pub(crate) mod manager;
-pub(crate) mod ui;
-
-pub fn initialize_panic_handler() -> eyre::Result<()> {
-    let (panic_hook, eyre_hook) = color_eyre::config::HookBuilder::default()
-        .display_location_section(true)
-        .display_env_section(true)
-        .into_hooks();
-    eyre_hook.install()?;
-    std::panic::set_hook(Box::new(move |panic_info| {
-        if let Err(r) = TuiHandle::new().and_then(|mut h| h.exit()) {
-            error!("Unable to exit Terminal: {:?}", r);
-        }
-
-        let msg = format!("{}", panic_hook.panic_report(panic_info));
-        #[cfg(not(debug_assertions))]
-        {
-            eprintln!("{}", msg); // prints color-eyre stack trace to stderr
-        }
-        error!("error: {}", strip_ansi_escapes::strip_str(msg));
-
-        #[cfg(debug_assertions)]
-        {
-            // Better Panic stacktrace that is only enabled when debugging.
-            better_panic::Settings::auto()
-                .most_recent_first(false)
-                .lineno_suffix(true)
-                .verbosity(better_panic::Verbosity::Full)
-                .create_panic_handler()(panic_info);
-        }
-
-        std::process::exit(1);
-    }));
-    Ok(())
-}
@@ -1,70 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::tui::config::keybindings::key_event_to_string;
-use crate::tui::dispatcher::ActionSender;
-use crate::{AppAction, Component, State};
-use crossterm::event::KeyEvent;
-use ratatui::layout::{Alignment, Rect};
-use ratatui::prelude::{Line, Style, Stylize};
-use ratatui::widgets::Block;
-use ratatui::Frame;
-use std::marker::PhantomData;
-
-pub struct DebugHistory<S, A> {
-    last_tick_key_events: Vec<KeyEvent>,
-
-    phantom_state: PhantomData<S>,
-    phantom_action: PhantomData<A>,
-}
-
-impl<S, A> Component for DebugHistory<S, A>
-where
-    S: State,
-    A: AppAction,
-{
-    type State = S;
-    type Actions = A;
-
-    fn new(_state: &Self::State, _action_sender: ActionSender<Self::Actions>) -> Self
-    where
-        Self: Sized,
-    {
-        DebugHistory {
-            last_tick_key_events: vec![],
-            phantom_state: PhantomData,
-            phantom_action: PhantomData,
-        }
-    }
-
-    fn tick(&mut self) -> bool {
-        let was_empty = self.last_tick_key_events.is_empty();
-        self.last_tick_key_events.drain(..);
-
-        !was_empty
-    }
-
-    fn handle_key(&mut self, key: KeyEvent) -> color_eyre::Result<()> {
-        self.last_tick_key_events.push(key);
-        Ok(())
-    }
-
-    fn view(&mut self, frame: &mut Frame, rect: Rect) {
-        frame.render_widget(
-            Block::default()
-                .title_top(
-                    Line::from(format!(
-                        "{:?}",
-                        &self
-                            .last_tick_key_events
-                            .iter()
-                            .map(key_event_to_string)
-                            .collect::<Vec<_>>()
-                    ))
-                    .alignment(Alignment::Right),
-                )
-                .title_style(Style::default().bold()),
-            rect,
-        );
-    }
-}
@@ -1,81 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::tui::config::keybindings::LoggerKeybindings;
-use crate::tui::dispatcher::store::State;
-use crate::tui::dispatcher::ActionSender;
-use crate::tui::ui::components::Component;
-use crate::AppAction;
-use crossterm::event::KeyEvent;
-use ratatui::layout::Rect;
-use ratatui::prelude::*;
-use ratatui::widgets::Block;
-use ratatui::Frame;
-use std::marker::PhantomData;
-use tui_logger::{TuiLoggerLevelOutput, TuiLoggerSmartWidget, TuiWidgetState};
-
-pub struct Props {
-    pub keybindings: LoggerKeybindings,
-}
-
-pub struct Logger<S, A> {
-    props: Props,
-    widget_state: TuiWidgetState,
-
-    phantom_state: PhantomData<S>,
-    phantom_action: PhantomData<A>,
-}
-
-impl<S, A> Component for Logger<S, A>
-where
-    S: State,
-    for<'a> Props: From<&'a S>,
-    A: AppAction,
-{
-    type State = S;
-    type Actions = A;
-
-    fn new(state: &Self::State, _action_sender: ActionSender<Self::Actions>) -> Self
-    where
-        Self: Sized,
-    {
-        Logger {
-            props: Props::from(state),
-            widget_state: TuiWidgetState::new(),
-            phantom_state: PhantomData,
-            phantom_action: PhantomData,
-        }
-    }
-
-    fn tick(&mut self) -> bool {
-        true
-    }
-
-    fn handle_key(&mut self, key: KeyEvent) -> color_eyre::Result<()> {
-        if let Some(tui_event) = self.props.keybindings.tui_logger_event(key.into()) {
-            self.widget_state.transition(tui_event)
-        }
-        Ok(())
-    }
-
-    fn view(&mut self, frame: &mut Frame, rect: Rect) {
-        let border = Block::bordered();
-        let inner_area = border.inner(rect);
-        frame.render_widget(border, rect);
-
-        let tui_sm = TuiLoggerSmartWidget::default()
-            .style_error(Style::default().fg(Color::Red))
-            .style_warn(Style::default().fg(Color::Yellow))
-            .style_info(Style::default().fg(Color::Green))
-            .style_debug(Style::default().fg(Color::Cyan))
-            .style_trace(Style::default().fg(Color::Magenta))
-            .output_separator(':')
-            .output_timestamp(Some("%F %H:%M:%S%.3f".to_string()))
-            .output_level(Some(TuiLoggerLevelOutput::Long))
-            .output_target(true)
-            .output_file(true)
-            .output_line(true)
-            .state(&self.widget_state);
-        frame.render_widget(tui_sm, inner_area);
-    }
-}
@@ -1,12 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod debug_history;
-
-#[cfg(feature = "logger")]
-pub mod logger;
-
-pub use debug_history::DebugHistory;
-
-#[cfg(feature = "logger")]
-pub use logger::{Logger, Props as LoggerProps};
@@ -1,45 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::tui::dispatcher::ActionSender;
-use crate::{AppAction, State};
-use color_eyre::eyre;
-use crossterm::event::KeyEvent;
-use ratatui::prelude::Rect;
-use ratatui::Frame;
-
-pub mod common;
-
-// pub trait Props<'a>: From<&'a Self::State> {
-//     type State: State;
-// }
-
-pub trait Component {
-    type State: State;
-    type Actions: AppAction;
-
-    fn new(state: &Self::State, action_sender: ActionSender<Self::Actions>) -> Self
-    where
-        Self: Sized;
-
-    fn update(self, state: &Self::State) -> Self
-    where
-        Self: Sized,
-    {
-        let _ = state;
-        self
-    }
-
-    // returns boolean indicating whether a rerender is needed
-    // fn tick(&mut self) -> bool;
-    fn tick(&mut self) -> bool {
-        false
-    }
-
-    fn handle_key(&mut self, key: KeyEvent) -> eyre::Result<()> {
-        let _ = key;
-        Ok(())
-    }
-
-    fn view(&mut self, frame: &mut Frame, rect: Rect);
-}
@@ -1,154 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::tui::dispatcher::{ActionSender, StateUpdateReceiver};
-use crate::tui::handle::TuiHandle;
-use crate::tui::ui::components::Component;
-use color_eyre::eyre;
-use color_eyre::eyre::eyre;
-use crossterm::event::Event;
-use humantime_serde::re::humantime;
-use std::io;
-use std::marker::PhantomData;
-use std::time::Duration;
-use tokio::time::{timeout, Instant};
-use tokio_stream::StreamExt;
-use tokio_util::sync::CancellationToken;
-use tracing::{info, trace, warn};
-
-pub mod components;
-
-pub struct UiEventLoop<C: Component> {
-    tick_rate: Duration,
-    cancellation_token: CancellationToken,
-    state_receiver: StateUpdateReceiver<C::State>,
-
-    // only to be used to construct root 'App' instance
-    action_sender: ActionSender<C::Actions>,
-    tui_handle: TuiHandle,
-
-    root_component: PhantomData<C>,
-}
-
-impl<C> UiEventLoop<C>
-where
-    C: Component,
-{
-    pub fn new(
-        tick_rate: Duration,
-        cancellation_token: CancellationToken,
-        state_receiver: impl Into<StateUpdateReceiver<C::State>>,
-        action_sender: impl Into<ActionSender<C::Actions>>,
-    ) -> eyre::Result<Self> {
-        Ok(UiEventLoop {
-            tick_rate,
-            cancellation_token,
-            state_receiver: state_receiver.into(),
-            action_sender: action_sender.into(),
-            tui_handle: TuiHandle::new()?,
-            root_component: PhantomData,
-        })
-    }
-
-    async fn handle_ui_event(
-        &mut self,
-        event: Option<io::Result<Event>>,
-        root_app: &mut C,
-    ) -> eyre::Result<()> {
-        let Some(event) = event else {
-            warn!("the crossterm event channel has closed! we're probably already in shutdown!");
-            // but if we're not, make sure to kick it off...
-            self.cancellation_token.cancel();
-            return Ok(());
-        };
-
-        match event? {
-            Event::FocusGained => {}
-            Event::FocusLost => {}
-            Event::Key(key_event) => root_app.handle_key(key_event)?,
-            Event::Mouse(_) => {}
-            Event::Paste(_) => {}
-            Event::Resize(_, _) => {}
-        }
-
-        Ok(())
-    }
-
-    async fn handle_updated_state(&mut self, state: Option<C::State>, root_app: C) -> C
-    where
-        C: Component,
-    {
-        let Some(updated_state) = state else {
-            warn!("the state update channel has closed! we're probably already in shutdown!");
-            // but if we're not, make sure to kick it off...
-            self.cancellation_token.cancel();
-            return root_app;
-        };
-
-        root_app.update(&updated_state)
-    }
-
-    pub async fn run(&mut self) -> eyre::Result<()>
-    where
-        // this clone shouldn't really be needed...
-        C::Actions: Clone,
-    {
-        info!("starting the ui loop");
-
-        // wait for initial state...
-        let initial_state = timeout(Duration::from_secs(1), self.state_receiver.next())
-            .await?
-            .ok_or_else(|| eyre!("did not receive initial state!"))?;
-
-        let mut root_app = C::new(&initial_state, self.action_sender.clone());
-
-        let mut tick_rate = self.tick_rate;
-        let mut tick_interval = tokio::time::interval(tick_rate);
-        self.tui_handle.enter()?;
-
-        let mut draw = true;
-
-        loop {
-            if draw {
-                let draw_start = Instant::now();
-
-                trace!("redrawing the UI");
-                self.tui_handle
-                    .draw(|frame| root_app.view(frame, frame.area()))?;
-
-                let taken = humantime::format_duration(draw_start.elapsed()).to_string();
-                trace!(time_taken = taken, "UI drawing");
-            }
-
-            tokio::select! {
-                biased;
-                _ = self.cancellation_token.cancelled() => {
-                    info!("received cancellation token");
-                    break;
-                }
-                maybe_ui_event = self.tui_handle.next() => {
-                    self.handle_ui_event(maybe_ui_event, &mut root_app).await?;
-                    draw = true;
-                }
-                state_update = self.state_receiver.next() => {
-                    root_app = self.handle_updated_state(state_update, root_app).await;
-                    // the tick rate has changed
-                    if self.tick_rate != tick_rate {
-                        tick_rate = self.tick_rate;
-                        tick_interval = tokio::time::interval(tick_rate);
-                    }
-                    draw = true;
-                }
-                _ = tick_interval.tick() => {
-                    let tick_start = Instant::now();
-                    draw = root_app.tick();
-
-                    let taken = humantime::format_duration(tick_start.elapsed()).to_string();
-                    trace!(time_taken = taken, will_redraw = draw, "app tick");
-                },
-            }
-        }
-
-        Ok(())
-    }
-}
@@ -324,18 +324,6 @@ pub fn unchecked_aggregate_indices_signatures(
    _aggregate_indices_signatures(params, vk, signatures_shares, false)
 }

-/// Generates parameters for the scheme setup.
-///
-/// # Arguments
-///
-/// * `total_coins` - it is the number of coins in a freshly generated wallet. It is the public parameter of the scheme.
-///
-/// # Returns
-///
-/// A `Parameters` struct containing group parameters, public key, the number of signatures (`total_coins`),
-/// and a map of signatures for each index `l`.
-///
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -264,7 +264,7 @@ impl<'b> Add<&'b VerificationKeyAuth> for VerificationKeyAuth {
    }
 }

-impl<'a> Mul<Scalar> for &'a VerificationKeyAuth {
+impl Mul<Scalar> for &VerificationKeyAuth {
    type Output = VerificationKeyAuth;

    #[inline]
@@ -530,6 +530,15 @@ impl From<KeyPairUser> for SecretKeyUser {
    }
 }

+impl From<SecretKeyUser> for KeyPairUser {
+    fn from(value: SecretKeyUser) -> Self {
+        KeyPairUser {
+            public_key: value.public_key(),
+            secret_key: value,
+        }
+    }
+}
+
 impl KeyPairUser {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Self {
@@ -984,7 +984,7 @@ pub struct SerialNumberRef<'a> {
    pub(crate) inner: &'a [G1Projective],
 }

-impl<'a> SerialNumberRef<'a> {
+impl SerialNumberRef<'_> {
    pub fn to_bytes(&self) -> Vec<u8> {
        let ss_len = self.inner.len();
        let mut bytes: Vec<u8> = Vec::with_capacity(ss_len * 48);
@@ -206,10 +206,10 @@ impl Deref for PublicKey {
    }
 }

-impl<'a, 'b> Mul<&'b Scalar> for &'a PublicKey {
+impl<'a> Mul<&'a Scalar> for &PublicKey {
    type Output = G1Projective;

-    fn mul(self, rhs: &'b Scalar) -> Self::Output {
+    fn mul(self, rhs: &'a Scalar) -> Self::Output {
        self.0 * rhs
    }
 }
@@ -305,7 +305,7 @@ impl<'b> Add<&'b VerificationKey> for VerificationKey {
    }
 }

-impl<'a> Mul<Scalar> for &'a VerificationKey {
+impl Mul<Scalar> for &VerificationKey {
    type Output = VerificationKey;

    #[inline]
@@ -64,7 +64,7 @@ impl<'de> Deserialize<'de> for Recipient {
    {
        struct RecipientVisitor;

-        impl<'de> Visitor<'de> for RecipientVisitor {
+        impl Visitor<'_> for RecipientVisitor {
            type Value = Recipient;

            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
@@ -1,6 +1,13 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+//! Encoding and decoding node routing information.
+//!
+//! This module is responsible for encoding and decoding node routing information, so that
+//! they could be later put into an appropriate field in a sphinx header.
+//! Currently, that routing information is an IP address, but in principle it can be anything
+//!  for as long as it's going to fit in the field.
+
 use nym_crypto::asymmetric::identity;
 use nym_sphinx_types::{NodeAddressBytes, NODE_ADDRESS_LENGTH};

@@ -12,13 +19,6 @@ use thiserror::Error;
 pub type NodeIdentity = identity::PublicKey;
 pub const NODE_IDENTITY_SIZE: usize = identity::PUBLIC_KEY_LENGTH;

-/// Encodoing and decoding node routing information.
-///
-/// This module is responsible for encoding and decoding node routing information, so that
-/// they could be later put into an appropriate field in a sphinx header.
-/// Currently, that routing information is an IP address, but in principle it can be anything
-/// for as long as it's going to fit in the field.
-
 /// MAX_UNPADDED_LEN represents maximum length an unpadded address could have.
 /// In this case it's an ipv6 socket address (with version prefix)
 pub const MAX_NODE_ADDRESS_UNPADDED_LEN: usize = 19;
@@ -56,7 +56,7 @@ impl<'de> Deserialize<'de> for ReplySurb {
    {
        struct ReplySurbVisitor;

-        impl<'de> Visitor<'de> for ReplySurbVisitor {
+        impl Visitor<'_> for ReplySurbVisitor {
            type Value = ReplySurb;

            fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
@@ -18,19 +18,13 @@ pub struct FramedNymPacket {
 }

 impl FramedNymPacket {
-    pub fn new(packet: NymPacket, packet_type: PacketType, use_legacy_version: bool) -> Self {
+    pub fn new(packet: NymPacket, packet_type: PacketType) -> Self {
        // If this fails somebody is using the library in a super incorrect way, because they
        // already managed to somehow create a sphinx packet
        let packet_size = PacketSize::get_type(packet.len()).unwrap();

-        let use_legacy = if packet_type == PacketType::Outfox {
-            false
-        } else {
-            use_legacy_version
-        };
-
        let header = Header {
-            packet_version: PacketVersion::new(use_legacy),
+            packet_version: PacketVersion::new(),
            packet_size,
            packet_type,
        };
@@ -13,12 +13,8 @@ pub enum PacketVersion {
 }

 impl PacketVersion {
-    pub fn new(use_legacy: bool) -> Self {
-        if use_legacy {
-            Self::new_legacy()
-        } else {
-            Self::new_versioned(CURRENT_PACKET_VERSION_NUMBER)
-        }
+    pub fn new() -> Self {
+        Self::new_versioned(CURRENT_PACKET_VERSION_NUMBER)
    }

    pub fn new_legacy() -> Self {
@@ -18,7 +18,7 @@ use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX
 use nym_sphinx_types::{Delay, NymPacket};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, Rng, SeedableRng};
-use rand_chacha::ChaCha20Rng;
+use rand_chacha::ChaCha8Rng;

 use nym_sphinx_chunking::monitoring;
 use std::time::Duration;
@@ -51,6 +51,7 @@ impl From<PreparedFragment> for MixPacket {
 pub trait FragmentPreparer {
    type Rng: CryptoRng + Rng;

+    fn deterministic_route_selection(&self) -> bool;
    fn rng(&mut self) -> &mut Self::Rng;
    fn nonce(&self) -> i32;
    fn num_mix_hops(&self) -> u8;
@@ -201,9 +202,7 @@ pub trait FragmentPreparer {
        // could perform diffie-hellman with its own keys followed by a kdf to re-derive
        // the packet encryption key

-        let seed = fragment.seed().wrapping_mul(self.nonce());
-        let mut rng = ChaCha20Rng::seed_from_u64(seed as u64);
-
+        let fragment_header = fragment.header();
        let destination = packet_recipient.gateway();
        let hops = mix_hops.unwrap_or(self.num_mix_hops());
        monitoring::fragment_sent(&fragment, self.nonce(), *destination, hops);
@@ -241,8 +240,18 @@ pub trait FragmentPreparer {
        };

        // generate pseudorandom route for the packet
-        log::trace!("Preparing chunk for sending with {} mix hops", hops);
-        let route = topology.random_route_to_gateway(&mut rng, hops, destination)?;
+        log::trace!("Preparing chunk for sending with {hops} mix hops");
+        let route = if self.deterministic_route_selection() {
+            log::trace!("using deterministic route selection");
+            let seed = fragment_header.seed().wrapping_mul(self.nonce());
+            let mut rng = ChaCha8Rng::seed_from_u64(seed as u64);
+            topology.random_route_to_gateway(&mut rng, hops, destination)?
+        } else {
+            log::trace!("using pseudorandom route selection");
+            let mut rng = self.rng();
+            topology.random_route_to_gateway(&mut rng, hops, destination)?
+        };
+
        let destination = packet_recipient.as_sphinx_destination();

        // including set of delays
@@ -313,6 +322,9 @@ pub struct MessagePreparer<R> {
    /// Instance of a cryptographically secure random number generator.
    rng: R,

+    /// Specify whether route selection should be determined by the packet header.
+    deterministic_route_selection: bool,
+
    /// Address of this client which also represent an address to which all acknowledgements
    /// and surb-based are going to be sent.
    sender_address: Recipient,
@@ -336,6 +348,7 @@ where
 {
    pub fn new(
        rng: R,
+        deterministic_route_selection: bool,
        sender_address: Recipient,
        average_packet_delay: Duration,
        average_ack_delay: Duration,
@@ -344,6 +357,7 @@ where
        let nonce = rng.gen();
        MessagePreparer {
            rng,
+            deterministic_route_selection,
            sender_address,
            average_packet_delay,
            average_ack_delay,
@@ -457,10 +471,18 @@ where
 impl<R: CryptoRng + Rng> FragmentPreparer for MessagePreparer<R> {
    type Rng = R;

+    fn deterministic_route_selection(&self) -> bool {
+        self.deterministic_route_selection
+    }
+
    fn rng(&mut self) -> &mut Self::Rng {
        &mut self.rng
    }

+    fn nonce(&self) -> i32 {
+        self.nonce
+    }
+
    fn num_mix_hops(&self) -> u8 {
        self.num_mix_hops
    }
@@ -472,10 +494,6 @@ impl<R: CryptoRng + Rng> FragmentPreparer for MessagePreparer<R> {
    fn average_ack_delay(&self) -> Duration {
        self.average_ack_delay
    }
-
-    fn nonce(&self) -> i32 {
-        self.nonce
-    }
 }

 /*
@@ -253,25 +253,15 @@ impl Socks5RequestContent {
    /// Deserialize the request type, connection id, destination address and port,
    /// and the request body from bytes.
    ///
-    // TODO: this was already inaccurate
-    // /// Serialized bytes looks like this:
-    // ///
-    // /// --------------------------------------------------------------------------------------
-    // ///  request_flag | connection_id | address_length | remote_address_bytes | request_data |
-    // ///        1      |       8       |      2         |    address_length    |    ...       |
-    // /// --------------------------------------------------------------------------------------
-    ///
    /// The request_flag tells us whether this is a new connection request (`new_connect`),
    /// an already-established connection we should send up (`new_send`), or
    /// a request to close an established connection (`new_close`).
-
    // connect:
    // RequestFlag::Connect || CONN_ID || ADDR_LEN || ADDR || <RETURN_ADDR>
    //
    // send:
    // RequestFlag::Send || CONN_ID || LOCAL_CLOSED || DATA
    // where DATA: SEQ || TRUE_DATA
-
    pub fn try_from_bytes(b: &[u8]) -> Result<Socks5RequestContent, RequestDeserializationError> {
        // each request needs to at least contain flag and ConnectionId
        if b.is_empty() {
@@ -26,3 +26,4 @@ nym-sphinx = { path = "../nymsphinx" }
 nym-credentials-interface = { path = "../credentials-interface" }
 nym-metrics = { path = "../nym-metrics" }
 nym-task = { path = "../task" }
+
@@ -31,40 +31,12 @@ impl GatewayStatsReporter {
 /// Gateway Statistics events
 pub enum GatewayStatsEvent {
    /// Events in the lifecycle of an established client tunnel
-    SessionStatsEvent(SessionEvent),
-}
-
-impl GatewayStatsEvent {
-    /// A new session between this gateway and the client remote has successfully opened
-    pub fn new_session_start(client: DestinationAddressBytes) -> GatewayStatsEvent {
-        GatewayStatsEvent::SessionStatsEvent(SessionEvent::SessionStart {
-            start_time: OffsetDateTime::now_utc(),
-            client,
-        })
-    }
-
-    /// An existing session with the client remote has ended
-    pub fn new_session_stop(client: DestinationAddressBytes) -> GatewayStatsEvent {
-        GatewayStatsEvent::SessionStatsEvent(SessionEvent::SessionStop {
-            stop_time: OffsetDateTime::now_utc(),
-            client,
-        })
-    }
-
-    /// A new ecash ticket has been added / requested
-    pub fn new_ecash_ticket(
-        client: DestinationAddressBytes,
-        ticket_type: TicketType,
-    ) -> GatewayStatsEvent {
-        GatewayStatsEvent::SessionStatsEvent(SessionEvent::EcashTicket {
-            ticket_type,
-            client,
-        })
-    }
+    SessionStatsEvent(GatewaySessionEvent),
 }

 /// Events in the lifecycle of an established client tunnel
-pub enum SessionEvent {
+#[derive(Debug, Clone, Copy)]
+pub enum GatewaySessionEvent {
    /// A new session between this gateway and the client remote has successfully opened
    SessionStart {
        /// The timestamp of the session open event
@@ -87,3 +59,32 @@ pub enum SessionEvent {
        client: DestinationAddressBytes,
    },
 }
+
+impl GatewaySessionEvent {
+    /// A new session between this gateway and the client remote has successfully opened
+    pub fn new_session_start(client: DestinationAddressBytes) -> GatewaySessionEvent {
+        GatewaySessionEvent::SessionStart {
+            start_time: OffsetDateTime::now_utc(),
+            client,
+        }
+    }
+
+    /// An existing session with the client remote has ended
+    pub fn new_session_stop(client: DestinationAddressBytes) -> GatewaySessionEvent {
+        GatewaySessionEvent::SessionStop {
+            stop_time: OffsetDateTime::now_utc(),
+            client,
+        }
+    }
+
+    /// A new ecash ticket has been added / requested
+    pub fn new_ecash_ticket(
+        client: DestinationAddressBytes,
+        ticket_type: TicketType,
+    ) -> GatewaySessionEvent {
+        GatewaySessionEvent::EcashTicket {
+            ticket_type,
+            client,
+        }
+    }
+}
@@ -12,7 +12,7 @@
 #![warn(clippy::dbg_macro)]

 use nym_crypto::asymmetric::ed25519;
-use sha2::Digest;
+use sha2::{Digest, Sha256};

 /// Client specific statistics interfaces and events.
 pub mod clients;
@@ -36,3 +36,7 @@ fn generate_stats_id<M: AsRef<[u8]>>(prefix: &str, id_seed: M) -> String {
    let output = hasher.finalize();
    format!("{:x}", output)
 }
+
+pub fn hash_identifier<M: AsRef<[u8]>>(identifier: M) -> String {
+    format!("{:x}", Sha256::digest(identifier))
+}
@@ -455,6 +455,10 @@ impl TaskClient {
        self.mode.set_should_not_signal_on_drop();
    }

+    pub fn rearm(&mut self) {
+        self.mode.set_should_signal_on_drop();
+    }
+
    pub fn send_we_stopped(&mut self, err: SentError) {
        if self.mode.is_dummy() {
            return;
@@ -482,7 +486,7 @@ impl Drop for TaskClient {
        if !self.mode.should_signal_on_drop() {
            self.log(
                Level::Trace,
-                "the task client is getting dropped but inststructed to not signal: this is expected during client shutdown",
+                "the task client is getting dropped but instructed to not signal: this is expected during client shutdown",
            );
            return;
        } else {
@@ -527,6 +531,14 @@ impl ClientOperatingMode {
        }
    }

+    fn set_should_signal_on_drop(&mut self) {
+        use ClientOperatingMode::{Dummy, Listening, ListeningButDontReportHalt};
+        *self = match &self {
+            ListeningButDontReportHalt | Listening => Listening,
+            Dummy => Dummy,
+        };
+    }
+
    fn set_should_not_signal_on_drop(&mut self) {
        use ClientOperatingMode::{Dummy, Listening, ListeningButDontReportHalt};
        *self = match &self {
@@ -0,0 +1,27 @@
+[package]
+name = "nym-verloc"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+readme.workspace = true
+
+[dependencies]
+bytes = { workspace = true }
+futures = { workspace = true }
+humantime = { workspace = true }
+tracing = { workspace = true }
+time = { workspace = true }
+tokio = { workspace = true, features = ["sync", "net", "rt-multi-thread", "io-util"] }
+tokio-util = { workspace = true, features = ["codec"] }
+thiserror = { workspace = true }
+rand = { workspace = true }
+url = { workspace = true }
+
+nym-crypto = { path = "../crypto", features = ["asymmetric"] }
+nym-task = { path = "../task" }
+nym-validator-client = { path = "../client-libs/validator-client" }
@@ -0,0 +1,72 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::io;
+use std::net::SocketAddr;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum VerlocError {
+    #[error("the received echo packet had unexpected size")]
+    UnexpectedEchoPacketSize,
+
+    #[error("the received reply packet had unexpected size")]
+    UnexpectedReplyPacketSize,
+
+    #[error("the received echo packet had malformed sender")]
+    MalformedSenderIdentity,
+
+    #[error("the received echo packet had malformed signature")]
+    MalformedEchoSignature,
+
+    #[error("the received reply packet had malformed signature")]
+    MalformedReplySignature,
+
+    #[error("the received echo packet had invalid signature")]
+    InvalidEchoSignature,
+
+    #[error("the received reply packet had invalid signature")]
+    InvalidReplySignature,
+
+    #[error("could not establish connection to {identity} on {address}: {err}")]
+    UnreachableNode {
+        identity: String,
+        address: SocketAddr,
+        #[source]
+        err: io::Error,
+    },
+
+    #[error("failed to write echo packet to {identity} on {address}: {err}")]
+    UnexpectedConnectionFailureWrite {
+        identity: String,
+        address: SocketAddr,
+        #[source]
+        err: io::Error,
+    },
+
+    #[error("failed to read reply packet from {identity} on {address}: {err}")]
+    UnexpectedConnectionFailureRead {
+        identity: String,
+        address: SocketAddr,
+        #[source]
+        err: io::Error,
+    },
+
+    #[error("timed out while trying to read reply packet from {identity} on {address}")]
+    ConnectionReadTimeout {
+        identity: String,
+        address: SocketAddr,
+    },
+
+    #[error("timed out while trying to write echo packet to {identity} on {address}")]
+    ConnectionWriteTimeout {
+        identity: String,
+        address: SocketAddr,
+    },
+
+    #[error("the received reply packet had an unexpected sequence number")]
+    UnexpectedReplySequence,
+
+    #[error("shutdown signal received")]
+    ShutdownReceived,
+}
@@ -0,0 +1,11 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+#![warn(clippy::expect_used)]
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::todo)]
+#![warn(clippy::dbg_macro)]
+
+pub mod error;
+pub mod measurements;
+pub mod models;
@@ -0,0 +1,135 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_validator_client::UserAgent;
+use std::net::{IpAddr, Ipv6Addr, SocketAddr};
+use std::time::Duration;
+use url::Url;
+
+// by default all of those are overwritten by config data from nym-node directly
+const DEFAULT_VERLOC_PORT: u16 = 1790;
+const DEFAULT_PACKETS_PER_NODE: usize = 100;
+const DEFAULT_PACKET_TIMEOUT: Duration = Duration::from_millis(1500);
+const DEFAULT_CONNECTION_TIMEOUT: Duration = Duration::from_millis(5000);
+const DEFAULT_DELAY_BETWEEN_PACKETS: Duration = Duration::from_millis(50);
+const DEFAULT_BATCH_SIZE: usize = 50;
+const DEFAULT_TESTING_INTERVAL: Duration = Duration::from_secs(60 * 60 * 12);
+const DEFAULT_RETRY_TIMEOUT: Duration = Duration::from_secs(60 * 30);
+
+#[derive(Clone, Debug)]
+pub struct Config {
+    /// Socket address of this node on which it will be listening for the measurement packets.
+    pub listening_address: SocketAddr,
+
+    /// Specifies number of echo packets sent to each node during a measurement run.
+    pub packets_per_node: usize,
+
+    /// Specifies maximum amount of time to wait for the reply packet to arrive before abandoning the test.
+    pub packet_timeout: Duration,
+
+    /// Specifies maximum amount of time to wait for the connection to get established.
+    pub connection_timeout: Duration,
+
+    /// Specifies delay between subsequent test packets being sent (after receiving a reply).
+    pub delay_between_packets: Duration,
+
+    /// Specifies number of nodes being tested at once.
+    pub tested_nodes_batch_size: usize,
+
+    /// Specifies delay between subsequent test runs.
+    pub testing_interval: Duration,
+
+    /// Specifies delay between attempting to run the measurement again if the previous run failed
+    /// due to being unable to get the list of nodes.
+    pub retry_timeout: Duration,
+
+    /// URLs to the nym apis for obtaining network topology.
+    pub nym_api_urls: Vec<Url>,
+
+    /// User agent used for querying the nym-api
+    pub user_agent: UserAgent,
+}
+
+impl Config {
+    pub fn build(nym_api_urls: Vec<Url>, user_agent: impl Into<UserAgent>) -> ConfigBuilder {
+        ConfigBuilder::new(nym_api_urls, user_agent)
+    }
+}
+
+#[must_use]
+pub struct ConfigBuilder(Config);
+
+impl ConfigBuilder {
+    pub fn new(nym_api_urls: Vec<Url>, user_agent: impl Into<UserAgent>) -> ConfigBuilder {
+        ConfigBuilder(Config {
+            // '[::]:port'
+            listening_address: SocketAddr::new(
+                IpAddr::V6(Ipv6Addr::UNSPECIFIED),
+                DEFAULT_VERLOC_PORT,
+            ),
+            packets_per_node: DEFAULT_PACKETS_PER_NODE,
+            packet_timeout: DEFAULT_PACKET_TIMEOUT,
+            connection_timeout: DEFAULT_CONNECTION_TIMEOUT,
+            delay_between_packets: DEFAULT_DELAY_BETWEEN_PACKETS,
+            tested_nodes_batch_size: DEFAULT_BATCH_SIZE,
+            testing_interval: DEFAULT_TESTING_INTERVAL,
+            retry_timeout: DEFAULT_RETRY_TIMEOUT,
+            nym_api_urls,
+            user_agent: user_agent.into(),
+        })
+    }
+
+    pub fn listening_address(mut self, listening_address: SocketAddr) -> Self {
+        self.0.listening_address = listening_address;
+        self
+    }
+
+    pub fn packets_per_node(mut self, packets_per_node: usize) -> Self {
+        self.0.packets_per_node = packets_per_node;
+        self
+    }
+
+    pub fn packet_timeout(mut self, packet_timeout: Duration) -> Self {
+        self.0.packet_timeout = packet_timeout;
+        self
+    }
+
+    pub fn connection_timeout(mut self, connection_timeout: Duration) -> Self {
+        self.0.connection_timeout = connection_timeout;
+        self
+    }
+
+    pub fn delay_between_packets(mut self, delay_between_packets: Duration) -> Self {
+        self.0.delay_between_packets = delay_between_packets;
+        self
+    }
+
+    pub fn tested_nodes_batch_size(mut self, tested_nodes_batch_size: usize) -> Self {
+        self.0.tested_nodes_batch_size = tested_nodes_batch_size;
+        self
+    }
+
+    pub fn testing_interval(mut self, testing_interval: Duration) -> Self {
+        self.0.testing_interval = testing_interval;
+        self
+    }
+
+    pub fn retry_timeout(mut self, retry_timeout: Duration) -> Self {
+        self.0.retry_timeout = retry_timeout;
+        self
+    }
+
+    pub fn nym_api_urls(mut self, nym_api_urls: Vec<Url>) -> Self {
+        self.0.nym_api_urls = nym_api_urls;
+        self
+    }
+
+    pub fn build(self) -> Config {
+        // panics here are fine as those are only ever constructed at the initial setup
+        assert!(
+            !self.0.nym_api_urls.is_empty(),
+            "at least one validator endpoint must be provided",
+        );
+        self.0
+    }
+}
@@ -1,29 +1,29 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::verloc::error::RttError;
-use crate::verloc::packet::{EchoPacket, ReplyPacket};
+use crate::error::VerlocError;
+use crate::measurements::packet::{EchoPacket, ReplyPacket};
 use bytes::{BufMut, BytesMut};
 use futures::StreamExt;
-use log::*;
 use nym_crypto::asymmetric::identity;
 use nym_task::TaskClient;
-use std::fmt::{Display, Formatter};
 use std::net::SocketAddr;
 use std::sync::Arc;
-use std::{fmt, io, process};
+use std::{io, process};
+use thiserror::Error;
 use tokio::io::AsyncWriteExt;
 use tokio::net::{TcpListener, TcpStream};
 use tokio_util::codec::{Decoder, Encoder, Framed};
+use tracing::{debug, error, info, trace, warn};

-pub(crate) struct PacketListener {
+pub struct PacketListener {
    address: SocketAddr,
    connection_handler: Arc<ConnectionHandler>,
    shutdown: TaskClient,
 }

 impl PacketListener {
-    pub(crate) fn new(
+    pub fn new(
        address: SocketAddr,
        identity: Arc<identity::KeyPair>,
        shutdown: TaskClient,
@@ -37,13 +37,13 @@ impl PacketListener {
 }

 impl PacketListener {
-    pub(super) async fn run(self: Arc<Self>) {
+    pub async fn run(self: Arc<Self>) {
        let listener = match TcpListener::bind(self.address).await {
            Ok(listener) => listener,
            Err(err) => {
                error!(
-                    "Failed to bind to {} - {}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?",
-                    self.address, err
+                    "Failed to bind to {}: {err}. Are you sure nothing else is running on the specified port and your user has sufficient permission to bind to the requested address?",
+                    self.address
                );
                process::exit(1);
            }
@@ -71,7 +71,7 @@ impl PacketListener {
                    }
                },
                _ = shutdown_listener.recv() => {
-                    log::trace!("PacketListener: Received shutdown");
+                    trace!("PacketListener: Received shutdown");
                }
            }
        }
@@ -137,28 +137,18 @@ impl ConnectionHandler {
    }
 }

-#[derive(Debug)]
+#[derive(Debug, Error)]
 enum EchoPacketCodecError {
-    IoError(io::Error),
-    PacketRecoveryError(RttError),
+    #[error("encountered io error {0}")]
+    IoError(#[from] io::Error),
+
+    #[error("failed to correctly decode an echo packet: {0}")]
+    PacketRecoveryError(Box<VerlocError>),
 }

-impl Display for EchoPacketCodecError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            EchoPacketCodecError::IoError(err) => write!(f, "encountered io error - {err}"),
-            EchoPacketCodecError::PacketRecoveryError(err) => {
-                write!(f, "failed to correctly decode an echo packet - {err}")
-            }
-        }
-    }
-}
-
-impl std::error::Error for EchoPacketCodecError {}
-
-impl From<io::Error> for EchoPacketCodecError {
-    fn from(err: io::Error) -> Self {
-        EchoPacketCodecError::IoError(err)
+impl From<VerlocError> for EchoPacketCodecError {
+    fn from(value: VerlocError) -> Self {
+        EchoPacketCodecError::PacketRecoveryError(Box::new(value))
    }
 }

@@ -188,10 +178,7 @@ impl Decoder for EchoPacketCodec {

        let packet_bytes = src.split_to(EchoPacket::SIZE);

-        let echo_packet = match EchoPacket::try_from_bytes(&packet_bytes) {
-            Ok(packet) => packet,
-            Err(err) => return Err(EchoPacketCodecError::PacketRecoveryError(err)),
-        };
+        let echo_packet = EchoPacket::try_from_bytes(&packet_bytes)?;

        // reserve enough bytes for the next frame
        src.reserve(EchoPacket::SIZE);
@@ -0,0 +1,225 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::measurements::metrics::SharedVerlocStats;
+use crate::measurements::sender::TestedNode;
+use crate::measurements::{Config, PacketListener, PacketSender};
+use crate::models::VerlocNodeResult;
+use futures::stream::FuturesUnordered;
+use futures::StreamExt;
+use nym_crypto::asymmetric::identity;
+use nym_task::TaskClient;
+use nym_validator_client::models::NymNodeDescription;
+use nym_validator_client::NymApiClient;
+use rand::prelude::SliceRandom;
+use rand::thread_rng;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::task::JoinHandle;
+use tokio::time::sleep;
+use tracing::{debug, error, info, trace, warn};
+
+pub struct VerlocMeasurer {
+    config: Config,
+    packet_sender: Arc<PacketSender>,
+    packet_listener: Arc<PacketListener>,
+    shutdown_listener: TaskClient,
+    state: SharedVerlocStats,
+}
+
+impl VerlocMeasurer {
+    pub fn new(
+        config: Config,
+        identity: Arc<identity::KeyPair>,
+        shutdown_listener: TaskClient,
+    ) -> Self {
+        VerlocMeasurer {
+            packet_sender: Arc::new(PacketSender::new(
+                Arc::clone(&identity),
+                config.packets_per_node,
+                config.packet_timeout,
+                config.connection_timeout,
+                config.delay_between_packets,
+                shutdown_listener.clone().named("VerlocPacketSender"),
+            )),
+            packet_listener: Arc::new(PacketListener::new(
+                config.listening_address,
+                Arc::clone(&identity),
+                shutdown_listener.clone().named("VerlocPacketListener"),
+            )),
+            shutdown_listener,
+            config,
+            state: SharedVerlocStats::default(),
+        }
+    }
+
+    pub fn set_shared_state(&mut self, state: SharedVerlocStats) {
+        self.state = state;
+    }
+
+    fn start_listening(&self) -> JoinHandle<()> {
+        let packet_listener = Arc::clone(&self.packet_listener);
+        tokio::spawn(packet_listener.run())
+    }
+
+    async fn perform_measurement(&self, nodes_to_test: Vec<TestedNode>) -> MeasurementOutcome {
+        trace!("Performing measurements");
+        if nodes_to_test.is_empty() {
+            debug!("there are no nodes to measure");
+            return MeasurementOutcome::Done;
+        }
+
+        let mut shutdown_listener = self.shutdown_listener.clone().named("VerlocMeasurement");
+        shutdown_listener.disarm();
+
+        for chunk in nodes_to_test.chunks(self.config.tested_nodes_batch_size) {
+            let mut chunk_results = Vec::with_capacity(chunk.len());
+
+            let mut measurement_chunk = chunk
+                .iter()
+                .map(|node| {
+                    let node = *node;
+                    let packet_sender = Arc::clone(&self.packet_sender);
+                    // TODO: there's a potential issue here. if we make the measurement go into separate
+                    // task, we risk biasing results with the bunch of context switches overhead
+                    // but if we don't do it, it will take ages to complete
+
+                    // TODO: check performance difference when it's not spawned as a separate task
+                    tokio::spawn(async move {
+                        (
+                            packet_sender.send_packets_to_node(node).await,
+                            node.identity,
+                        )
+                    })
+                })
+                .collect::<FuturesUnordered<_>>();
+
+            // exhaust the results
+            while !shutdown_listener.is_shutdown() {
+                tokio::select! {
+                    measurement_result = measurement_chunk.next() => {
+                        let Some(result) = measurement_result else {
+                            // if the stream has finished, it means we got everything we could have gotten
+                            break
+                        };
+
+                        // if we receive JoinError it means the task failed to get executed, so either there's a bigger issue with tokio
+                        // or there was a panic inside the task itself. In either case, we should just terminate ourselves.
+                        let Ok(execution_result) = result else {
+                            error!("the verloc measurer has panicked!");
+                            continue
+                        };
+                        let identity = execution_result.1;
+
+                        let measurement_result = match execution_result.0 {
+                            Err(err) => {
+                                debug!("Failed to perform measurement for {identity}: {err}");
+                                None
+                            }
+                            Ok(result) => Some(result),
+                        };
+                        chunk_results.push(VerlocNodeResult::new(identity, measurement_result));
+                    },
+                    _ = shutdown_listener.recv() => {
+                        trace!("Shutdown received while measuring");
+                        return MeasurementOutcome::Shutdown;
+                    }
+                }
+            }
+
+            // update the results vector with chunks as they become available (by default every 50 nodes)
+            self.state.append_measurement_results(chunk_results).await;
+        }
+
+        MeasurementOutcome::Done
+    }
+
+    async fn get_list_of_nodes(&self) -> Option<Vec<NymNodeDescription>> {
+        let mut api_endpoints = self.config.nym_api_urls.clone();
+        api_endpoints.shuffle(&mut thread_rng());
+        for api_endpoint in api_endpoints {
+            let client = NymApiClient::new_with_user_agent(
+                api_endpoint.clone(),
+                self.config.user_agent.clone(),
+            );
+            match client.get_all_described_nodes().await {
+                Ok(res) => return Some(res),
+                Err(err) => {
+                    warn!("failed to get described nodes from {api_endpoint}: {err}")
+                }
+            }
+        }
+        None
+    }
+
+    pub async fn run(&mut self) {
+        self.start_listening();
+
+        while !self.shutdown_listener.is_shutdown() {
+            info!("Starting verloc measurements");
+            // TODO: should we also measure gateways?
+
+            let Some(all_nodes) = self.get_list_of_nodes().await else {
+                error!("failed to obtain list of all nodes from any available api endpoint");
+                sleep(self.config.retry_timeout).await;
+                continue;
+            };
+
+            if all_nodes.is_empty() {
+                warn!("it does not seem there are any nodes to measure...");
+                sleep(self.config.retry_timeout).await;
+                continue;
+            }
+
+            // we only care about address and identity
+            let tested_nodes = all_nodes
+                .into_iter()
+                .filter_map(|node| {
+                    // try to parse the identity and host
+                    let node_identity = node.ed25519_identity_key();
+
+                    let ip = node.description.host_information.ip_address.first()?;
+                    let verloc_port = node.description.verloc_port();
+                    let verloc_host = SocketAddr::new(*ip, verloc_port);
+
+                    // TODO: possible problem in the future, this does name resolution and theoretically
+                    // if a lot of nodes maliciously mis-configured themselves, it might take a while to resolve them all
+                    // However, maybe it's not a problem as if they are misconfigured, they will eventually be
+                    // pushed out of the network and on top of that, verloc is done in separate task that runs
+                    // only every few hours.
+                    Some(TestedNode::new(verloc_host, node_identity))
+                })
+                .collect::<Vec<_>>();
+
+            // on start of each run remove old results
+            self.state.start_new_measurements(tested_nodes.len()).await;
+
+            if let MeasurementOutcome::Shutdown = self.perform_measurement(tested_nodes).await {
+                trace!("Shutting down after aborting measurements");
+                break;
+            }
+
+            // write current time to "run finished" field
+            self.state.finish_measurements().await;
+
+            info!(
+                "Finished performing verloc measurements. The next one will happen in {:?}",
+                self.config.testing_interval
+            );
+
+            tokio::select! {
+                _ = sleep(self.config.testing_interval) => {},
+                _ = self.shutdown_listener.recv() => {
+                    trace!("Shutdown received while sleeping");
+                }
+            }
+        }
+
+        trace!("Verloc: Exiting");
+    }
+}
+
+enum MeasurementOutcome {
+    Done,
+    Shutdown,
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
mfahampshire	0cf93d2b9d	auto commit generated command files	2024-12-09 15:00:18 +01:00
mfahampshire	5d3a5a022f	clippy	2024-12-09 14:54:15 +01:00
mfahampshire	93a995f011	tweak works	2024-12-09 13:19:52 +01:00
mfahampshire	7bc6268b40	auto commit generated command files	2024-12-09 13:10:20 +01:00
mfahampshire	2ace2926d2	clean autodoc-generated-markdown in script	2024-12-09 13:07:03 +01:00
mfahampshire	bb6d7769ca	auto commit generated command files	2024-12-09 13:02:28 +01:00
mfahampshire	616b52604a	add autodoc to workspace	2024-12-09 12:58:55 +01:00
mfahampshire	298c52d650	add autodoc to workspace	2024-12-09 12:58:45 +01:00
mfahampshire	97f64f2687	tweak script to build from master	2024-12-09 12:44:37 +01:00
mfahampshire	dc098dfe15	Merge branch 'develop' of github.com:nymtech/nym into develop	2024-12-09 12:31:29 +01:00
Drazen Urch	1b8a929ff5	Nmv2 add debug config (#5212 ) * Add debug config to clients * Add deterministic traffic selection flag	2024-12-09 09:03:04 +01:00
Jon Häggblad	72a4624ace	Add NYXD_WS to qa.env (#5226 )	2024-12-09 09:00:39 +01:00
mfahampshire	12cd1d26a4	Merge branch 'develop' of github.com:nymtech/nym into develop	2024-12-07 12:48:33 +01:00
Mark Sinclair	e5e7ddb0b6	Create push-nyx-chain-watcher.yaml	2024-12-06 20:30:19 +00:00
mfahampshire	98165966ad	Merge branch 'develop' of github.com:nymtech/nym into develop	2024-12-06 16:31:13 +01:00
Jędrzej Stuczyński	5a07b73375	feature: hopefully final steps of the smoosh™️ (#5201 ) * removed mnemonic from gateway config struct scaffolding for common mixnet listener running verloc unconditionally in a nym-node remove filtering by mixnode extracted verloc to separate crate integrated nym-node-http-server more tightly with the binary most logic for handling forward packets running all mixnode-related tasks natively inside nymnode removed gateway storage trait in favour of the only concrete implementation most logic for handling final hop packets using nym-node owned socket listener for gateways utility for sending plain message through mixnet + gateway fix using common packet forwarding in both modes nifying nym-node metrics reproduce behaviour of the console logger cleaned up cli args redesigned gateway tasks startup procedure removing dead code scaffolding for old config v6 config migration implemented MixnetMetricsCleaner * clippy * require entry/exit for wireguard * removed dead code in migration code * updated config template * use custom user agent for verloc queries * fixed premature shutdown of gateway tasks * hidden nym-api flag to allow illegal node ips * experiment: final hop handing with wireguard * added additional startup logs * typo * fixed legacy stats endpoint data * additional logs * apply review comments * fixed local testnet manager	2024-12-05 17:21:36 +00:00
Bogdan-Ștefan Neacşu	d1f702c4aa	Extend raw ws fd for gateway client (#5218 )	2024-12-05 14:48:33 +02:00
Tommy Verrall	c20c7147f8	Merge pull request #4813 from nymtech/dependabot/npm_and_yarn/testnet-faucet/micromatch-4.0.8 build(deps): bump micromatch from 4.0.4 to 4.0.8 in /testnet-faucet	2024-12-05 10:51:34 +00:00
Tommy Verrall	06956226ad	Merge pull request #5195 from nymtech/raphael/update-security Update Security disclosure email, public key and policy	2024-12-05 10:49:48 +00:00
Jon Häggblad	b06091e548	Derive serialize for UserAgent (#5210 )	2024-12-05 11:21:33 +01:00
Simon Wicky	f3bf5d080b	better date serilization (#5207 )	2024-12-04 11:11:51 +01:00
dynco-nym	e06d442e95	Restore Location fields (#5208 ) * Add latitude/longitude fields to Location * Add regression test * Bump package version * Load secret during workflow	2024-12-03 18:35:56 +01:00
mfahampshire	fef9e4ad78	Merge branch 'develop' of github.com:nymtech/nym into develop	2024-12-03 13:32:08 +01:00
dynco-nym	fc79f739d4	Fix overflow (#5204 )	2024-12-03 10:20:28 +01:00
benedetta davico	6ee8ccbeaa	Merge pull request #5199 from nymtech/merge/release/2024.14-crunch merge crunch into develop	2024-12-02 13:21:04 +01:00
Jędrzej Stuczyński	cfebd14655	Merge branch 'release/2024.14-crunch' into merge/release/2024.14-crunch	2024-12-02 11:21:09 +00:00
Simon Wicky	4851614375	NS API - Gateway stats scraping (#5180 ) * squashed commit before rebasing * removed blank lines	2024-12-02 12:15:30 +01:00
benedetta davico	ec502f46f0	Merge pull request #5196 from nymtech/release/2024.13-magura-patched-v2 Merging magura drift into crunch	2024-12-02 12:13:12 +01:00
Raphaël Walther	841fb81d24	Update Security disclosure email, public key and policy	2024-11-29 16:54:17 +01:00
dynco-nym	a9e62889c3	Remove explorer dependency (#5190 ) * Move monitor code to a struct - to store state in a struct * explorer deprecation wip * Replace explorer with ipinfo calls * PR feedback * Fix clippy * Bump package version * Remove ipinfo crate due to openssl dep * Add remaining bandwidth log	2024-11-29 16:45:55 +01:00
import this	074d705448	[DOCs/operators]: Magura-drift - second patch (#5194 ) * syntax edits * new version harsh * changelog info - ready to review	2024-11-29 13:34:58 +00:00
benedettadavico	4a9a5579c4	update changelog	2024-11-29 14:06:32 +01:00
benedetta davico	96180275f8	Update Cargo.toml	2024-11-29 13:57:57 +01:00
Bogdan-Ștefan Neacşu	ab20260a2f	Guard storage access with cache (#5193 ) * Guard storage access with cache * Do the sync way less freq * Change sync behaviour for bandwidth too * Use bigger delta	2024-11-29 14:56:39 +02:00
Tommy Verrall	ec1c564c2b	Merge pull request #5150 from nymtech/dependabot/npm_and_yarn/testnet-faucet/cross-spawn-7.0.6 build(deps): bump cross-spawn from 7.0.3 to 7.0.6 in /testnet-faucet	2024-11-29 12:27:29 +00:00
Tommy Verrall	bdf97bcbd6	Merge pull request #5151 from nymtech/fix/validator-rewarder-push-docker fix: validator-rewarder GH job	2024-11-29 12:26:55 +00:00
Jędrzej Stuczyński	889d464e98	improvement: make internal gateway clients use the same topology cache (#5191 )	2024-11-29 09:45:12 +00:00
Jędrzej Stuczyński	56206433e6	chore: apply 1.84 linter suggestions (#5192 )	2024-11-29 09:20:45 +00:00
Tommy Verrall	8e9d01c47b	Merge pull request #5189 from nymtech/fix/network-tunnel-script Fix/network tunnel script	2024-11-28 15:47:56 +00:00
mfahampshire	842158124d	Merge branch 'develop' of github.com:nymtech/nym into develop	2024-11-28 15:02:01 +01:00
Tommy Verrall	f95f01959c	fix multiple forwarding calls also add more logging around joke section	2024-11-28 12:29:29 +01:00
Tommy Verrall	42de620951	typo	2024-11-28 12:06:03 +01:00
Tommy Verrall	af9f7b1c0f	formatting	2024-11-28 12:02:45 +01:00
Tommy Verrall	7c1ad7d20c	add more output on joke commands this should help the end users debug their machines further	2024-11-28 12:02:13 +01:00
Tommy Verrall	9ac0595a35	remove duplicate iptable rules	2024-11-28 11:49:29 +01:00
Tommy Verrall	c6c138167d	Merge pull request #5186 from nymtech/fix/network-tunnel-script fix for the network tunnel manager script	2024-11-28 09:39:50 +00:00
Tommy Verrall	09633dead1	add the enable ip forwarding method	2024-11-28 10:38:13 +01:00
dynco-nym	cd2ad0adbb	Update dir in workflow (#5185 )	2024-11-27 17:50:55 +01:00
benedetta davico	0b52224917	Update network_tunnel_manager.sh	2024-11-27 17:26:37 +01:00
dynco-nym	96ebe3fc4f	Fix overflow (#5184 )	2024-11-27 17:07:01 +01:00
Drazen Urch	8e713d43e1	Add monitor_run and testing_route indexes (#5182 )	2024-11-27 11:07:39 +01:00
dynco-nym	e7f806219c	Move NS client to separate package under NS API (#5171 ) * Move client code to NS API * Move client to separate package * Move things around * Adjust run scripts * rustfmt * Add client to workspace	2024-11-26 15:59:42 +01:00
benedettadavico	35aa7e338d	bump binary versions	2024-11-26 15:01:06 +01:00
Jędrzej Stuczyński	2a60b2f057	bugfix: fixed nym-node config migrations (again) (#5179 )	2024-11-26 09:41:18 +00:00
import this	edd3f9108a	[DOCs/operators]: Guide to change wg private address (#5178 )	2024-11-26 09:32:09 +00:00
Jędrzej Stuczyński	dcde4c8df1	bugfix: use default value for verloc config when deserialising missing values (#5177 )	2024-11-25 17:54:32 +00:00
Tommy Verrall	fcaa32284b	Merge pull request #5175 from nymtech/fix/empty_allowed Remove peers with no allowed ip from storage	2024-11-25 17:36:33 +00:00
Tommy Verrall	3c56977fb5	Merge pull request #5176 from nymtech/script-update Script update	2024-11-25 17:35:41 +00:00
Tommy Verrall	5f3bb5db82	remove command features	2024-11-25 17:52:49 +01:00
Tommy Verrall	1b84639c34	re-add the configure icmp command	2024-11-25 17:48:03 +01:00
Tommy Verrall	546a486f9f	script overhaul - improved iptables management: apply_iptables_rules and apply_iptables_rules_wg now automatically remove duplicate rules before reapplying them, ensuring a clean setup without disrupting iptables - consolidated joke feature: unified the "joke through the mixnet" logic into a generic function, allowing it to work seamlessly across any specified interface - enhanced tunnel checks: added check_nym_wg_tun alongside check_nymtun_iptables, making it easier to verify the state of both tunnels - reduced error-prone behavior: simplified workflows to avoid issues caused by running commands multiple times how to use: 1. download the script and make it executable: curl -L -o network_tunnel_manager.sh https://raw.download.github.of.this.file && chmod u+x network_tunnel_manager.sh 2. run the following commands as needed: - apply_iptables_rules: apply and clean iptables rules for nymtun0 - apply_iptables_rules_wg: apply and clean iptables rules for nymwg - check_ipv6_ipv4_forwarding: verify if ipv4 and ipv6 forwarding are enabled - check_ip_routing: display the current ipv4 and ipv6 routing tables tldr: - improved iptables handling to avoid duplicates - unified functionality for better maintainability - reduced potential errors when rerunning commands	2024-11-25 17:45:10 +01:00
Bogdan-Ștefan Neacşu	fa72f90bfa	Remove peers with no allowed ip from storage	2024-11-25 16:44:23 +00:00
Jędrzej Stuczyński	5668e123d9	introduced initial internal commands for nym-cli: ecash key and request generation (#5174 ) * introduced initial internal commands for nym-cli: ecash key and request generation * reduced args logging level	2024-11-25 15:41:49 +00:00
import this	27637ae6b4	[DOCs/operators]: Routine guides update with release changes (#5173 ) * finish doc updates - ready for review * info to warning change * add non root guide and a new error * syntax fix * syntax edit	2024-11-25 14:27:52 +00:00
Jędrzej Stuczyński	12b9aefa99	bugfix: correctly expose ecash-related data on nym-api (#5155 ) * fixed signer related endpoints * fixed aggregation of partial data if the api is not a signer * fixes to swagger docs for global ecash endpoints * remove unused axum_macros * fixed test traits	2024-11-25 08:39:55 +00:00
benedetta davico	0041937ed3	Merge pull request #5170 from nymtech/merge/release/2024.13-magura-patched merge patched magura into develop	2024-11-25 09:06:32 +01:00
Jędrzej Stuczyński	0e5bd966dd	Merge branch 'release/2024.13-magura-patched' into develop	2024-11-22 15:53:59 +00:00
Jędrzej Stuczyński	6acd936368	bugfix: additional improvements to nym-api db performance (#5168 ) * added statement logging to nym-api db * adding additional pool options * dont blow up upon failing to submit network monitor results * store in-memory cache of node database ids	2024-11-22 15:52:26 +00:00
benedettadavico	01c7b2819e	update changelog	2024-11-22 10:50:59 +01:00
Simon Wicky	042a8a58aa	start session collection for exit gateways (#5148 ) (#5161 )	2024-11-22 09:12:01 +01:00
benedettadavico	d8ab2a8f15	update version for clients and nym-node	2024-11-22 07:25:54 +01:00
mfahampshire	c75e0fdb83	patch curl command for network_tunnel_man.sh	2024-11-21 21:22:11 +01:00
Jędrzej Stuczyński	d6d2239685	implement optional cap for number of ack retransmissions (#5158 ) * implement optional cap for number of ack retransmissions * Wasm	2024-11-21 18:57:24 +00:00
Jędrzej Stuczyński	3d704fbbf1	change: make nym-api optionally ignore nodes with illegal ip addresses, like loopback (#5159 )	2024-11-21 18:54:14 +00:00
Jędrzej Stuczyński	119c36b0bb	added 'deterministic_route_selection' for sphinx packet route selection (#5157 ) * added 'deterministic_route_selection' for sphinx packet route selection * clippy + wasm * Switch to ChaCha8Rng for deterministic route generation --------- Co-authored-by: durch <durch@users.noreply.github.com>	2024-11-21 18:21:01 +00:00
Jędrzej Stuczyński	6b5b97199b	fix: tracing logger to output to stderr	2024-11-19 17:47:13 +00:00
dependabot[bot]	d2e85f2bfe	build(deps): bump cross-spawn from 7.0.3 to 7.0.6 in /testnet-faucet Bumps [cross-spawn](https://github.com/moxystudio/node-cross-spawn) from 7.0.3 to 7.0.6. - [Changelog](https://github.com/moxystudio/node-cross-spawn/blob/master/CHANGELOG.md) - [Commits](https://github.com/moxystudio/node-cross-spawn/compare/v7.0.3...v7.0.6) --- updated-dependencies: - dependency-name: cross-spawn dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com>	2024-11-19 10:32:10 +00:00
Fran Arbanas	b28e953a2b	fix: validator-rewarder GH job	2024-11-12 17:16:59 +01:00
dependabot[bot]	b4ca959800	build(deps): bump micromatch from 4.0.4 to 4.0.8 in /testnet-faucet Bumps [micromatch](https://github.com/micromatch/micromatch) from 4.0.4 to 4.0.8. - [Release notes](https://github.com/micromatch/micromatch/releases) - [Changelog](https://github.com/micromatch/micromatch/blob/master/CHANGELOG.md) - [Commits](https://github.com/micromatch/micromatch/compare/4.0.4...4.0.8) --- updated-dependencies: - dependency-name: micromatch dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com>	2024-08-27 15:46:12 +00:00