Rename vpn-api-lib-wasm to nym-credential-proxy-lib-wasm, and:

- change from yarn to npm - fix license so Apache-2.0 (like the rest of the SDK)
build(deps): bump lazy_static from 1.4.0 to 1.5.0 (#4913 )
2024-10-30 12:39:20 +00:00 · 2024-10-30 07:07:39 +01:00 · 2024-10-29 23:27:10 +01:00 · 2024-10-29 20:47:07 +01:00 · 2024-10-29 17:46:35 +01:00 · 2024-10-29 17:46:35 +01:00
209 changed files with 13070 additions and 8984 deletions
@@ -57,6 +57,12 @@ jobs:
          command: fmt
          args: --all -- --check

+      - name: Clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --workspace --all-targets -- -D warnings
+
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
@@ -82,9 +88,3 @@ jobs:
        with:
          command: test
          args: --workspace -- --ignored
-
-      - name: Clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: --workspace --all-targets -- -D warnings
@@ -1,45 +0,0 @@
-name: ci-nym-credential-proxy
-
-on:
-  pull_request:
-    paths:
-      - 'common/**'
-      - 'nym-credential-proxy/**'
-      - '.github/workspace/ci-nym-credential-proxy.yml'
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: arc-ubuntu-22.04
-    env:
-      CARGO_TERM_COLOR: always
-      MANIFEST_PATH: "--manifest-path nym-credential-proxy/Cargo.toml"
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
-
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-          components: rustfmt, clippy
-
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: ${{ env.MANIFEST_PATH }} --all -- --check
-
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: ${{ env.MANIFEST_PATH }} --workspace --all-targets
-
-      - name: Clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: ${{ env.MANIFEST_PATH }} --workspace --all-targets -- -D warnings
@@ -29,7 +29,7 @@ jobs:
        uses: mikefarah/yq@v4.44.3
        id: get_version
        with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/nym-credential-proxy/Cargo.toml

      - name: Check if tag exists
        run: |
@@ -51,5 +51,5 @@ jobs:

      - 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 build -f ${{ env.WORKING_DIRECTORY }}/nym-credential-proxy/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
@@ -0,0 +1,55 @@
+name: Build and upload Data observatory container to harbor.nymte.ch
+on:
+  workflow_dispatch:
+
+env:
+  WORKING_DIRECTORY: "nym-data-observatory"
+  CONTAINER_NAME: "data-observatory"
+
+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.3
+        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
@@ -0,0 +1,56 @@
+name: Build and upload Node Status agent container to harbor.nymte.ch
+
+on:
+  workflow_dispatch:
+
+env:
+  WORKING_DIRECTORY: "nym-node-status-agent"
+  CONTAINER_NAME: "node-status-agent"
+
+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.3
+        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
@@ -1,11 +1,55 @@
 name: Build and upload Node Status API container to harbor.nymte.ch
-
 on:
  workflow_dispatch:

+env:
+  WORKING_DIRECTORY: "nym-node-status-api"
+  CONTAINER_NAME: "node-status-api"
+
 jobs:
-  my-job:
-    runs-on: arc-ubuntu-22.04
+  build-container:
+    runs-on: arc-ubuntu-22.04-dind
    steps:
-      - name: my-step
-        run: echo "Hello World!"
+      - 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.3
+        id: get_version
+        with:
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
+
+      - name: Check if tag exists
+        run: |
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
+            echo "Tag ${{ steps.get_version.outputs.result }} 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
@@ -4,6 +4,80 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

+## [2024.12-aero] (2024-10-17)
+
+- nym-node: don't use bloomfilters for double spending checks ([#4960])
+- bugfix: replace unreachable macro with an error return ([#4958])
+- [DOCs:/operators]: Update FAQ sphinx size ([#4946])
+- [DOCs/operators]: Release notes v2024.11-wedel ([#4939])
+- Fix handle drop ([#4934])
+- Assume offline mode ([#4926])
+- Make ip-packet-request VERSION pub ([#4925])
+- Expose error type ([#4924])
+- Fix argument to cargo-deny action ([#4922])
+- Fix nymvpn.com url in mainnet defaults ([#4920])
+- Check both version and type in message header ([#4918])
+- Bump http-api-client default timeout to 30 sec ([#4917])
+- Max/proxy ffi ([#4906])
+- Data Observatory stub ([#4905])
+- Fix missing duplication of modified tables ([#4904])
+- Update cargo deny ([#4901])
+- docs: add hostname instructions for wss ([#4900])
+- build(deps): bump the patch-updates group across 1 directory with 9 updates ([#4898])
+- Fix clippy for beta toolchain ([#4897])
+- Remove clippy github PR annotations ([#4896])
+- Fix apt install in ci-build-upload-binaries.yml ([#4894])
+- Update network monitor entrypoint ([#4893])
+- Update nym-vpn metapackage and replace nymvpn-x with nym-vpn-app ([#4889])
+- Entry wireguard tickets ([#4888])
+- Build and Push CI ([#4887])
+- Feature/updated gateway registration ([#4885])
+- Few fixes to NNM pre deploy ([#4883])
+- Fix sql serde with enum ([#4875])
+- allow clients to send stateless gateway requests without prior registration ([#4873])
+- chore: remove queued migration for adding explicit admin ([#4871])
+- Gateway database modifications for different modes ([#4868])
+- build(deps): bump strum from 0.25.0 to 0.26.3 ([#4848])
+- Use serde from workspace ([#4833])
+- build(deps): bump toml from 0.5.11 to 0.8.14 ([#4805])
+- Max/rust sdk stream abstraction ([#4743])
+
+[#4960]: https://github.com/nymtech/nym/pull/4960
+[#4958]: https://github.com/nymtech/nym/pull/4958
+[#4946]: https://github.com/nymtech/nym/pull/4946
+[#4939]: https://github.com/nymtech/nym/pull/4939
+[#4934]: https://github.com/nymtech/nym/pull/4934
+[#4926]: https://github.com/nymtech/nym/pull/4926
+[#4925]: https://github.com/nymtech/nym/pull/4925
+[#4924]: https://github.com/nymtech/nym/pull/4924
+[#4922]: https://github.com/nymtech/nym/pull/4922
+[#4920]: https://github.com/nymtech/nym/pull/4920
+[#4918]: https://github.com/nymtech/nym/pull/4918
+[#4917]: https://github.com/nymtech/nym/pull/4917
+[#4906]: https://github.com/nymtech/nym/pull/4906
+[#4905]: https://github.com/nymtech/nym/pull/4905
+[#4904]: https://github.com/nymtech/nym/pull/4904
+[#4901]: https://github.com/nymtech/nym/pull/4901
+[#4900]: https://github.com/nymtech/nym/pull/4900
+[#4898]: https://github.com/nymtech/nym/pull/4898
+[#4897]: https://github.com/nymtech/nym/pull/4897
+[#4896]: https://github.com/nymtech/nym/pull/4896
+[#4894]: https://github.com/nymtech/nym/pull/4894
+[#4893]: https://github.com/nymtech/nym/pull/4893
+[#4889]: https://github.com/nymtech/nym/pull/4889
+[#4888]: https://github.com/nymtech/nym/pull/4888
+[#4887]: https://github.com/nymtech/nym/pull/4887
+[#4885]: https://github.com/nymtech/nym/pull/4885
+[#4883]: https://github.com/nymtech/nym/pull/4883
+[#4875]: https://github.com/nymtech/nym/pull/4875
+[#4873]: https://github.com/nymtech/nym/pull/4873
+[#4871]: https://github.com/nymtech/nym/pull/4871
+[#4868]: https://github.com/nymtech/nym/pull/4868
+[#4848]: https://github.com/nymtech/nym/pull/4848
+[#4833]: https://github.com/nymtech/nym/pull/4833
+[#4805]: https://github.com/nymtech/nym/pull/4805
+[#4743]: https://github.com/nymtech/nym/pull/4743
+
 ## [2024.11-wedel] (2024-09-23)

 - Backport #4894 to fix ci ([#4899])
@@ -19,33 +19,33 @@ members = [
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
-    "common/authenticator-requests",
    "common/async-file-watcher",
+    "common/authenticator-requests",
    "common/bandwidth-controller",
    "common/bin-common",
    "common/client-core",
    "common/client-core/config-types",
-    "common/client-core/surb-storage",
    "common/client-core/gateways-storage",
+    "common/client-core/surb-storage",
    "common/client-libs/gateway-client",
    "common/client-libs/mixnet-client",
    "common/client-libs/validator-client",
    "common/commands",
    "common/config",
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
-    "common/cosmwasm-smart-contracts/ecash-contract",
    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
+    "common/cosmwasm-smart-contracts/ecash-contract",
    "common/cosmwasm-smart-contracts/group-contract",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
    "common/cosmwasm-smart-contracts/vesting-contract",
    "common/country-group",
    "common/credential-storage",
-    "common/credentials",
    "common/credential-utils",
-    "common/credentials-interface",
    "common/credential-verification",
+    "common/credentials",
+    "common/credentials-interface",
    "common/crypto",
    "common/dkg",
    "common/ecash-double-spending",
@@ -54,19 +54,21 @@ members = [
    "common/exit-policy",
    "common/gateway-requests",
    "common/gateway-storage",
+    "common/gateway-stats-storage",
    "common/http-api-client",
    "common/http-api-common",
    "common/inclusion-probability",
    "common/ip-packet-requests",
    "common/ledger",
    "common/mixnode-common",
+    "common/models",
    "common/network-defaults",
    "common/node-tester-utils",
    "common/nonexhaustive-delayqueue",
-    "common/nymcoconut",
-    "common/nym_offline_compact_ecash",
    "common/nym-id",
    "common/nym-metrics",
+    "common/nym_offline_compact_ecash",
+    "common/nymcoconut",
    "common/nymsphinx",
    "common/nymsphinx/acknowledgements",
    "common/nymsphinx/addressing",
@@ -102,23 +104,28 @@ members = [
    "gateway",
    "integrations/bity",
    "mixnode",
+    "sdk/ffi/cpp",
+    "sdk/ffi/go",
+    "sdk/ffi/shared",
    "sdk/lib/socks5-listener",
    "sdk/rust/nym-sdk",
-    "sdk/ffi/shared",
-    "sdk/ffi/go",
-    "sdk/ffi/cpp",
    "service-providers/authenticator",
    "service-providers/common",
    "service-providers/ip-packet-router",
    "service-providers/network-requester",
-    "nym-network-monitor",
    "nym-api",
-    "nym-browser-extension/storage",
    "nym-api/nym-api-requests",
+    "nym-browser-extension/storage",
+    "nym-credential-proxy/nym-credential-proxy",
+    "nym-credential-proxy/nym-credential-proxy-requests",
+    "nym-credential-proxy/nym-credential-proxy-lib-wasm",
    "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-outfox",
    "nym-validator-rewarder",
    "tools/echo-server",
@@ -136,23 +143,27 @@ members = [
    "wasm/mix-fetch",
    "wasm/node-tester",
    "wasm/zknym-lib",
-    "tools/internal/testnet-manager",
-    "tools/internal/testnet-manager/dkg-bypass-contract",
    "tools/echo-server",
    "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",
 ]

 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-validator-rewarder",
+    "nym-node-status-api",
    "service-providers/authenticator",
    "service-providers/ip-packet-router",
    "service-providers/network-requester",
@@ -183,19 +194,17 @@ aes = "0.8.1"
 aes-gcm = "0.10.1"
 aes-gcm-siv = "0.11.1"
 aead = "0.5.2"
-anyhow = "1.0.89"
+anyhow = "1.0.90"
 argon2 = "0.5.0"
 async-trait = "0.1.83"
+axum-client-ip = "0.6.1"
 axum = "0.7.5"
 axum-extra = "0.9.4"
 base64 = "0.22.1"
 bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
-
-# can we unify those?
-bit-vec = "0.7.0"
+bit-vec = "0.7.0" # can we unify those?
 bitvec = "1.0.0"
-
 blake3 = "1.5.4"
 bloomfilter = "1.0.14"
 bs58 = "0.5.1"
@@ -208,7 +217,7 @@ chacha20 = "0.9.0"
 chacha20poly1305 = "0.10.1"
 chrono = "0.4.31"
 cipher = "0.4.3"
-clap = "4.5.18"
+clap = "4.5.20"
 clap_complete = "4.5"
 clap_complete_fig = "4.5"
 colored = "2.0"
@@ -233,10 +242,12 @@ dotenvy = "0.15.6"
 ecdsa = "0.16"
 ed25519-dalek = "2.1"
 etherparse = "0.13.0"
+envy = "0.4"
 eyre = "0.6.9"
 fastrand = "2.1.1"
 flate2 = "1.0.34"
 futures = "0.3.28"
+futures-util = "0.3"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
 getset = "0.1.3"
@@ -260,22 +271,23 @@ ipnetwork = "0.20"
 isocountry = "0.3.2"
 itertools = "0.13.0"
 k256 = "0.13"
-lazy_static = "1.4.0"
+lazy_static = "1.5.0"
 ledger-transport = "0.10.0"
 ledger-transport-hid = "0.10.0"
 log = "0.4"
 maxminddb = "0.23.0"
 mime = "0.3.17"
+moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
 okapi = "0.7.0"
-once_cell = "1.7.2"
+once_cell = "1.20.2"
 opentelemetry = "0.19.0"
 opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.3"
 pem = "0.8"
 petgraph = "0.6.5"
-pin-project = "1.0"
+pin-project = "1.1"
 pin-project-lite = "0.2.14"
 pretty_env_logger = "0.4.0"
 publicsuffix = "2.2.3"
@@ -295,10 +307,11 @@ rocket_okapi = "0.8.0"
 safer-ffi = "0.1.13"
 schemars = "0.8.21"
 semver = "1.0.23"
-serde = "1.0.210"
+serde = "1.0.211"
 serde_bytes = "0.11.15"
 serde_derive = "1.0"
-serde_json = "1.0.128"
+serde_json = "1.0.132"
+serde_json_path = "0.6.7"
 serde_repr = "0.1"
 serde_with = "3.9.0"
 serde_yaml = "0.9.25"
@@ -307,6 +320,7 @@ si-scale = "0.2.3"
 sphinx-packet = "0.1.1"
 sqlx = "0.7.4"
 strum = "0.26"
+strum_macros = "0.26"
 subtle-encoding = "0.5"
 syn = "1"
 sysinfo = "0.30.13"
@@ -328,6 +342,7 @@ tracing = "0.1.37"
 tracing-opentelemetry = "0.19.0"
 tracing-subscriber = "0.3.16"
 tracing-tree = "0.2.2"
+tracing-log = "0.2"
 ts-rs = "10.0.0"
 tungstenite = { version = "0.20.1", default-features = false }
 url = "2.5"
@@ -389,11 +404,10 @@ indexed_db_futures = { git = "https://github.com/TiemenSch/rust-indexed-db", bra
 js-sys = "0.3.70"
 serde-wasm-bindgen = "0.6.5"
 tsify = "0.4.5"
-wasm-bindgen = "0.2.93"
-wasm-bindgen-futures = "0.4.43"
+wasm-bindgen = "0.2.95"
+wasm-bindgen-futures = "0.4.45"
 wasmtimer = "0.2.0"
-web-sys = "0.3.70"
-
+web-sys = "0.3.72"

 # Profile settings for individual crates

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.41"
+version = "1.1.42"
 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.41"
+version = "1.1.42"
 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"
@@ -45,3 +45,4 @@ tracing = [
    "opentelemetry",
 ]
 clap = [ "dep:clap", "dep:clap_complete", "dep:clap_complete_fig" ]
+models = []
@@ -6,7 +6,6 @@ pub(crate) use accessor::{TopologyAccessor, TopologyReadPermit};
 use futures::StreamExt;
 use log::*;
 use nym_sphinx::addressing::nodes::NodeIdentity;
-use nym_topology::provider_trait::TopologyProvider;
 use nym_topology::NymTopologyError;
 use std::time::Duration;

@@ -18,7 +17,11 @@ use wasmtimer::tokio::sleep;

 mod accessor;
 pub mod geo_aware_provider;
-pub(crate) mod nym_api_provider;
+pub mod nym_api_provider;
+
+pub use geo_aware_provider::GeoAwareTopologyProvider;
+pub use nym_api_provider::{Config as NymApiTopologyProviderConfig, NymApiTopologyProvider};
+pub use nym_topology::provider_trait::TopologyProvider;

 // TODO: move it to config later
 const MAX_FAILURE_COUNT: usize = 10;
@@ -14,9 +14,10 @@ use url::Url;
 pub const DEFAULT_MIN_MIXNODE_PERFORMANCE: u8 = 50;
 pub const DEFAULT_MIN_GATEWAY_PERFORMANCE: u8 = 50;

-pub(crate) struct Config {
-    pub(crate) min_mixnode_performance: u8,
-    pub(crate) min_gateway_performance: u8,
+#[derive(Debug)]
+pub struct Config {
+    pub min_mixnode_performance: u8,
+    pub min_gateway_performance: u8,
 }

 impl Default for Config {
@@ -29,7 +30,7 @@ impl Default for Config {
    }
 }

-pub(crate) struct NymApiTopologyProvider {
+pub struct NymApiTopologyProvider {
    config: Config,

    validator_client: nym_validator_client::client::NymApiClient,
@@ -40,7 +41,7 @@ pub(crate) struct NymApiTopologyProvider {
 }

 impl NymApiTopologyProvider {
-    pub(crate) fn new(
+    pub fn new(
        config: Config,
        mut nym_api_urls: Vec<Url>,
        client_version: String,
@@ -25,7 +25,7 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 nym-http-api-client = { path = "../../../common/http-api-client" }
 thiserror = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 tokio = { workspace = true, features = ["sync", "time"] }
 time = { workspace = true, features = ["formatting"] }
@@ -19,7 +19,7 @@ use nym_api_requests::ecash::{
 };
 use nym_api_requests::models::{
    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
-    RewardEstimationResponse, StakeSaturationResponse,
+    NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::nym_nodes::SkimmedNode;
@@ -30,10 +30,10 @@ use time::Date;
 use url::Url;

 pub use crate::nym_api::NymApiClientExt;
+use nym_mixnet_contract_common::NymNodeDetails;
 pub use nym_mixnet_contract_common::{
    mixnode::MixNodeDetails, GatewayBond, IdentityKey, IdentityKeyRef, NodeId,
 };
-
 // re-export the type to not break existing imports
 pub use crate::coconut::EcashApiClient;

@@ -106,7 +106,9 @@ impl Config {

 pub struct Client<C, S = NoSigner> {
    // ideally they would have been read-only, but unfortunately rust doesn't have such features
+    // #[deprecated(note = "please use `nym_api_client` instead")]
    pub nym_api: nym_api::Client,
+    // pub nym_api_client: NymApiClient,
    pub nyxd: NyxdClient<C, S>,
 }

@@ -243,6 +245,50 @@ impl<C, S> Client<C, S> {
        Ok(self.nym_api.get_gateways().await?)
    }

+    // TODO: combine with NymApiClient...
+    pub async fn get_all_cached_described_nodes(
+        &self,
+    ) -> Result<Vec<NymNodeDescription>, ValidatorClientError> {
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
+        let mut page = 0;
+        let mut descriptions = Vec::new();
+
+        loop {
+            let mut res = self.nym_api.get_nodes_described(Some(page), None).await?;
+
+            descriptions.append(&mut res.data);
+            if descriptions.len() < res.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(descriptions)
+    }
+
+    // TODO: combine with NymApiClient...
+    pub async fn get_all_cached_bonded_nym_nodes(
+        &self,
+    ) -> Result<Vec<NymNodeDetails>, ValidatorClientError> {
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
+        let mut page = 0;
+        let mut bonds = Vec::new();
+
+        loop {
+            let mut res = self.nym_api.get_nym_nodes(Some(page), None).await?;
+
+            bonds.append(&mut res.data);
+            if bonds.len() < res.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(bonds)
+    }
+
    pub async fn blind_sign(
        &self,
        request_body: &BlindSignRequestBody,
@@ -265,6 +311,13 @@ impl NymApiClient {
        NymApiClient { nym_api }
    }

+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn new_with_timeout(api_url: Url, timeout: std::time::Duration) -> Self {
+        let nym_api = nym_api::Client::new(api_url, Some(timeout));
+
+        NymApiClient { nym_api }
+    }
+
    pub fn new_with_user_agent(api_url: Url, user_agent: UserAgent) -> Self {
        let nym_api = nym_api::Client::builder::<_, ValidatorClientError>(api_url)
            .expect("invalid api url")
@@ -320,7 +373,7 @@ impl NymApiClient {
        loop {
            let mut res = self
                .nym_api
-                .get_all_basic_entry_assigned_nodes(
+                .get_basic_entry_assigned_nodes(
                    semver_compatibility.clone(),
                    false,
                    Some(page),
@@ -397,6 +450,48 @@ impl NymApiClient {
        Ok(self.nym_api.get_gateways_described().await?)
    }

+    pub async fn get_all_described_nodes(
+        &self,
+    ) -> Result<Vec<NymNodeDescription>, ValidatorClientError> {
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
+        let mut page = 0;
+        let mut descriptions = Vec::new();
+
+        loop {
+            let mut res = self.nym_api.get_nodes_described(Some(page), None).await?;
+
+            descriptions.append(&mut res.data);
+            if descriptions.len() < res.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(descriptions)
+    }
+
+    pub async fn get_all_bonded_nym_nodes(
+        &self,
+    ) -> Result<Vec<NymNodeDetails>, ValidatorClientError> {
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
+        let mut page = 0;
+        let mut bonds = Vec::new();
+
+        loop {
+            let mut res = self.nym_api.get_nym_nodes(Some(page), None).await?;
+
+            bonds.append(&mut res.data);
+            if bonds.len() < res.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(bonds)
+    }
+
    pub async fn get_gateway_core_status_count(
        &self,
        identity: IdentityKeyRef<'_>,
@@ -121,36 +121,36 @@ async fn test_nyxd_connection(
    {
        Ok(Err(NyxdError::TendermintErrorRpc(e))) => {
            // If we get a tendermint-rpc error, we classify the node as not contactable
-            log::warn!("Checking: nyxd url: {url}: {}: {}", "failed".red(), e);
+            tracing::warn!("Checking: nyxd url: {url}: {}: {}", "failed".red(), e);
            false
        }
        Ok(Err(NyxdError::AbciError { code, log, .. })) => {
            // We accept the mixnet contract not found as ok from a connection standpoint. This happens
            // for example on a pre-launch network.
-            log::debug!(
+            tracing::debug!(
                "Checking: nyxd url: {url}: {}, but with abci error: {code}: {log}",
                "success".green()
            );
            code == 18
        }
        Ok(Err(error @ NyxdError::NoContractAddressAvailable(_))) => {
-            log::warn!("Checking: nyxd url: {url}: {}: {error}", "failed".red());
+            tracing::warn!("Checking: nyxd url: {url}: {}: {error}", "failed".red());
            false
        }
        Ok(Err(e)) => {
            // For any other error, we're optimistic and just try anyway.
-            log::warn!(
+            tracing::warn!(
                "Checking: nyxd_url: {url}: {}, but with error: {e}",
                "success".green()
            );
            true
        }
        Ok(Ok(_)) => {
-            log::debug!("Checking: nyxd_url: {url}: {}", "success".green());
+            tracing::debug!("Checking: nyxd_url: {url}: {}", "success".green());
            true
        }
        Err(e) => {
-            log::warn!("Checking: nyxd_url: {url}: {}: {e}", "failed".red());
+            tracing::warn!("Checking: nyxd_url: {url}: {}: {e}", "failed".red());
            false
        }
    };
@@ -169,15 +169,15 @@ async fn test_nym_api_connection(
    .await
    {
        Ok(Ok(_)) => {
-            log::debug!("Checking: api_url: {url}: {}", "success".green());
+            tracing::debug!("Checking: api_url: {url}: {}", "success".green());
            true
        }
        Ok(Err(e)) => {
-            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
+            tracing::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
            false
        }
        Err(e) => {
-            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
+            tracing::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
            false
        }
    };
@@ -11,9 +11,10 @@ use nym_api_requests::ecash::models::{
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
-    AnnotationResponse, LegacyDescribedMixNode, NodePerformanceResponse,
+    AnnotationResponse, LegacyDescribedMixNode, NodePerformanceResponse, NymNodeDescription,
 };
 use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
+use nym_api_requests::pagination::PaginatedResponse;
 pub use nym_api_requests::{
    ecash::{
        models::{
@@ -38,9 +39,10 @@ use nym_contracts_common::IdentityKey;
 pub use nym_http_api_client::Client;
 use nym_http_api_client::{ApiClient, NO_PARAMS};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
-use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, NodeId};
+use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, NodeId, NymNodeDetails};
 use time::format_description::BorrowedFormatItem;
 use time::Date;
+use tracing::instrument;

 pub mod error;
 pub mod routes;
@@ -52,11 +54,13 @@ pub fn rfc_3339_date() -> Vec<BorrowedFormatItem<'static>> {
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait NymApiClientExt: ApiClient {
+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
        self.get_json(&[routes::API_VERSION, routes::MIXNODES], NO_PARAMS)
            .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes_detailed(&self) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
        self.get_json(
            &[
@@ -70,6 +74,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_gateways_detailed(&self) -> Result<Vec<GatewayBondAnnotated>, NymAPIError> {
        self.get_json(
            &[
@@ -83,6 +88,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes_detailed_unfiltered(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
@@ -98,11 +104,13 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_gateways(&self) -> Result<Vec<GatewayBond>, NymAPIError> {
        self.get_json(&[routes::API_VERSION, routes::GATEWAYS], NO_PARAMS)
            .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_gateways_described(&self) -> Result<Vec<LegacyDescribedGateway>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::GATEWAYS, routes::DESCRIBED],
@@ -111,6 +119,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes_described(&self) -> Result<Vec<LegacyDescribedMixNode>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::MIXNODES, routes::DESCRIBED],
@@ -119,6 +128,45 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    async fn get_nodes_described(
+        &self,
+        page: Option<u32>,
+        per_page: Option<u32>,
+    ) -> Result<PaginatedResponse<NymNodeDescription>, NymAPIError> {
+        let mut params = Vec::new();
+
+        if let Some(page) = page {
+            params.push(("page", page.to_string()))
+        }
+
+        if let Some(per_page) = per_page {
+            params.push(("per_page", per_page.to_string()))
+        }
+
+        self.get_json(&[routes::API_VERSION, "nym-nodes", "described"], &params)
+            .await
+    }
+
+    async fn get_nym_nodes(
+        &self,
+        page: Option<u32>,
+        per_page: Option<u32>,
+    ) -> Result<PaginatedResponse<NymNodeDetails>, NymAPIError> {
+        let mut params = Vec::new();
+
+        if let Some(page) = page {
+            params.push(("page", page.to_string()))
+        }
+
+        if let Some(per_page) = per_page {
+            params.push(("per_page", per_page.to_string()))
+        }
+
+        self.get_json(&[routes::API_VERSION, "nym-nodes", "bonded"], &params)
+            .await
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
    async fn get_basic_mixnodes(
        &self,
        semver_compatibility: Option<String>,
@@ -142,6 +190,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_basic_gateways(
        &self,
        semver_compatibility: Option<String>,
@@ -167,7 +216,8 @@ pub trait NymApiClientExt: ApiClient {

    /// retrieve basic information for nodes are capable of operating as an entry gateway
    /// this includes legacy gateways and nym-nodes
-    async fn get_all_basic_entry_assigned_nodes(
+    #[instrument(level = "debug", skip(self))]
+    async fn get_basic_entry_assigned_nodes(
        &self,
        semver_compatibility: Option<String>,
        no_legacy: bool,
@@ -208,6 +258,7 @@ pub trait NymApiClientExt: ApiClient {

    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
    /// this includes legacy mixnodes and nym-nodes
+    #[instrument(level = "debug", skip(self))]
    async fn get_basic_active_mixing_assigned_nodes(
        &self,
        semver_compatibility: Option<String>,
@@ -247,6 +298,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
@@ -255,6 +307,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_active_mixnodes_detailed(&self) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
        self.get_json(
            &[
@@ -269,6 +322,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::MIXNODES, routes::REWARDED],
@@ -277,6 +331,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_report(
        &self,
        mix_id: NodeId,
@@ -294,6 +349,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_gateway_report(
        &self,
        identity: IdentityKeyRef<'_>,
@@ -311,6 +367,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_history(
        &self,
        mix_id: NodeId,
@@ -328,6 +385,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_gateway_history(
        &self,
        identity: IdentityKeyRef<'_>,
@@ -345,6 +403,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_rewarded_mixnodes_detailed(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
@@ -361,6 +420,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_gateway_core_status_count(
        &self,
        identity: IdentityKeyRef<'_>,
@@ -392,6 +452,7 @@ pub trait NymApiClientExt: ApiClient {
        }
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_core_status_count(
        &self,
        mix_id: NodeId,
@@ -424,6 +485,7 @@ pub trait NymApiClientExt: ApiClient {
        }
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_status(
        &self,
        mix_id: NodeId,
@@ -441,6 +503,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_reward_estimation(
        &self,
        mix_id: NodeId,
@@ -458,6 +521,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn compute_mixnode_reward_estimation(
        &self,
        mix_id: NodeId,
@@ -477,6 +541,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_stake_saturation(
        &self,
        mix_id: NodeId,
@@ -494,6 +559,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_inclusion_probability(
        &self,
        mix_id: NodeId,
@@ -511,6 +577,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_current_node_performance(
        &self,
        node_id: NodeId,
@@ -541,6 +608,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes_blacklisted(&self) -> Result<Vec<NodeId>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::MIXNODES, routes::BLACKLISTED],
@@ -549,6 +617,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_gateways_blacklisted(&self) -> Result<Vec<IdentityKey>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::GATEWAYS, routes::BLACKLISTED],
@@ -557,6 +626,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self, request_body))]
    async fn blind_sign(
        &self,
        request_body: &BlindSignRequestBody,
@@ -573,6 +643,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self, request_body))]
    async fn verify_ecash_ticket(
        &self,
        request_body: &VerifyEcashTicketBody,
@@ -589,6 +660,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self, request_body))]
    async fn batch_redeem_ecash_tickets(
        &self,
        request_body: &BatchRedeemTicketsBody,
@@ -605,6 +677,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn double_spending_filter_v1(&self) -> Result<SpentCredentialsResponse, NymAPIError> {
        self.get_json(
            &[
@@ -617,6 +690,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn partial_expiration_date_signatures(
        &self,
        expiration_date: Option<Date>,
@@ -640,6 +714,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn partial_coin_indices_signatures(
        &self,
        epoch_id: Option<EpochId>,
@@ -660,6 +735,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn global_expiration_date_signatures(
        &self,
        expiration_date: Option<Date>,
@@ -683,6 +759,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn global_coin_indices_signatures(
        &self,
        epoch_id: Option<EpochId>,
@@ -703,6 +780,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn master_verification_key(
        &self,
        epoch_id: Option<EpochId>,
@@ -722,6 +800,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn epoch_credentials(
        &self,
        dkg_epoch: EpochId,
@@ -738,6 +817,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn issued_credential(
        &self,
        credential_id: i64,
@@ -754,6 +834,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn issued_credentials(
        &self,
        credential_ids: Vec<i64>,
@@ -8,9 +8,9 @@ use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
 use cosmwasm_std::Addr;
-use log::trace;
 use nym_coconut_dkg_common::types::{ChunkIndex, NodeIndex, StateAdvanceResponse};
 use serde::Deserialize;
+use tracing::trace;

 use nym_coconut_dkg_common::dealer::RegisteredDealerDetails;
 pub use nym_coconut_dkg_common::{
@@ -29,7 +29,6 @@ use cosmrs::proto::cosmwasm::wasm::v1::{
 };
 use cosmrs::tendermint::{block, chain, Hash};
 use cosmrs::{AccountId, Coin as CosmosCoin, Tx};
-use log::trace;
 use prost::Message;
 use serde::{Deserialize, Serialize};

@@ -68,7 +67,7 @@ pub trait CosmWasmClient: TendermintRpcClient {
        Res: Message + Default,
    {
        if let Some(ref abci_path) = path {
-            trace!("performing query on abci path {abci_path}")
+            tracing::trace!("performing query on abci path {abci_path}")
        }
        let mut buf = Vec::with_capacity(req.encoded_len());
        req.encode(&mut buf)?;
@@ -297,7 +296,7 @@ pub trait CosmWasmClient: TendermintRpcClient {

        let start = Instant::now();
        loop {
-            log::debug!(
+            tracing::debug!(
                "Polling for result of including {} in a block...",
                broadcasted.hash
            );
@@ -522,7 +521,7 @@ pub trait CosmWasmClient: TendermintRpcClient {
            .make_abci_query::<_, QuerySmartContractStateResponse>(path, req)
            .await?;

-        trace!("raw query response: {}", String::from_utf8_lossy(&res.data));
+        tracing::trace!("raw query response: {}", String::from_utf8_lossy(&res.data));
        Ok(serde_json::from_slice(&res.data)?)
    }

@@ -25,12 +25,12 @@ use cosmrs::proto::cosmos::tx::signing::v1beta1::SignMode;
 use cosmrs::staking::{MsgDelegate, MsgUndelegate};
 use cosmrs::tx::{self, Msg};
 use cosmrs::{cosmwasm, AccountId, Any, Tx};
-use log::debug;
 use serde::Serialize;
 use sha2::Digest;
 use sha2::Sha256;
 use std::time::SystemTime;
 use tendermint_rpc::endpoint::broadcast;
+use tracing::debug;

 fn empty_fee() -> tx::Fee {
    tx::Fee {
@@ -7,9 +7,9 @@ use base64::Engine;
 use cosmrs::abci::TxMsgData;
 use cosmrs::cosmwasm::MsgExecuteContractResponse;
 use cosmrs::proto::cosmos::base::query::v1beta1::{PageRequest, PageResponse};
-use log::error;
 use prost::bytes::Bytes;
 use tendermint_rpc::endpoint::broadcast;
+use tracing::error;

 pub use cosmrs::abci::MsgResponse;

@@ -17,6 +17,7 @@ use crate::{
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::{Addr, Coin, Decimal, StdResult, Uint128};
 use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};

 /// Full details associated with given mixnode.
@@ -647,14 +648,39 @@ impl From<LegacyMixLayer> for u8 {
        export_to = "ts-packages/types/src/types/rust/PendingMixnodeChanges.ts"
    )
 )]
-#[cw_serde]
-#[derive(Default, Copy)]
+// note: we had to remove `#[cw_serde]` as it enforces `#[serde(deny_unknown_fields)]` which we do not want
+// with the addition of  .cost_params_change field
+#[derive(
+    ::cosmwasm_schema::serde::Serialize,
+    ::cosmwasm_schema::serde::Deserialize,
+    ::std::clone::Clone,
+    ::std::fmt::Debug,
+    ::std::cmp::PartialEq,
+    ::cosmwasm_schema::schemars::JsonSchema,
+    Default,
+    Copy,
+)]
+#[schemars(crate = "::cosmwasm_schema::schemars")]
 pub struct PendingMixNodeChanges {
    pub pledge_change: Option<EpochEventId>,
+
    #[serde(default)]
    pub cost_params_change: Option<IntervalEventId>,
 }

+#[derive(Default, Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct LegacyPendingMixNodeChanges {
+    pub pledge_change: Option<EpochEventId>,
+}
+
+impl From<PendingMixNodeChanges> for LegacyPendingMixNodeChanges {
+    fn from(value: PendingMixNodeChanges) -> Self {
+        LegacyPendingMixNodeChanges {
+            pledge_change: value.pledge_change,
+        }
+    }
+}
+
 impl PendingMixNodeChanges {
    pub fn new_empty() -> PendingMixNodeChanges {
        PendingMixNodeChanges {
@@ -1,100 +0,0 @@
-// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: GPL-3.0-only
-
-use crate::ecash::error::EcashTicketError;
-use crate::ecash::state::SharedState;
-use nym_ecash_double_spending::DoubleSpendingFilter;
-use nym_gateway_storage::Storage;
-use nym_task::TaskClient;
-use nym_validator_client::client::NymApiClientExt;
-use nym_validator_client::EcashApiClient;
-use rand::prelude::SliceRandom;
-use rand::thread_rng;
-use std::sync::Arc;
-use tokio::sync::{RwLock, RwLockReadGuard};
-use tokio::time::{interval, Duration};
-use tracing::{info, trace, warn};
-
-#[derive(Clone)]
-pub(crate) struct DoubleSpendingDetector<S> {
-    spent_serial_numbers: Arc<RwLock<DoubleSpendingFilter>>,
-    shared_state: SharedState<S>,
-}
-
-impl<S> DoubleSpendingDetector<S>
-where
-    S: Storage + Clone + Send + Sync + 'static,
-{
-    pub(crate) fn new(shared_state: SharedState<S>) -> Self {
-        DoubleSpendingDetector {
-            spent_serial_numbers: Arc::new(RwLock::new(DoubleSpendingFilter::new_empty_ecash())),
-            shared_state,
-        }
-    }
-
-    pub(crate) async fn check(&self, serial_number: &Vec<u8>) -> bool {
-        self.spent_serial_numbers.read().await.check(serial_number)
-    }
-
-    async fn latest_api_endpoints(
-        &self,
-    ) -> Result<RwLockReadGuard<Vec<EcashApiClient>>, EcashTicketError> {
-        let epoch_id = self.shared_state.current_epoch_id().await?;
-        self.shared_state.api_clients(epoch_id).await
-    }
-
-    async fn refresh_bloomfilter(&self) {
-        let mut filter_builder = self.spent_serial_numbers.read().await.rebuild();
-
-        let api_clients = match self.latest_api_endpoints().await {
-            Ok(clients) => clients,
-            Err(err) => {
-                warn!("failed to obtain current api clients: {err}");
-                return;
-            }
-        };
-
-        let mut clients = api_clients
-            .iter()
-            .map(|c| c.api_client.clone())
-            .collect::<Vec<_>>();
-        clients.shuffle(&mut thread_rng());
-
-        for client in clients {
-            match client.nym_api.double_spending_filter_v1().await {
-                Ok(response) => {
-                    // due to relative big size of the filter, query only one api since all of them should contain
-                    // roughly the same data anyway.
-                    filter_builder.add_bytes(&response.bitmap);
-                    *self.spent_serial_numbers.write().await = filter_builder.build();
-                    return;
-                }
-                Err(err) => {
-                    warn!("Validator @ {} could not be reached. There might be a problem with the ecash endpoint: {err}", client.api_url());
-                }
-            }
-        }
-
-        warn!("none of the validators could be reached. the bloomfilter will remain unchanged.");
-    }
-
-    async fn run(&self, mut shutdown: TaskClient) {
-        info!("Starting Ecash DoubleSpendingDetector");
-        let mut interval = interval(Duration::from_secs(600));
-
-        while !shutdown.is_shutdown() {
-            tokio::select! {
-                biased;
-                _ = shutdown.recv() => {
-                    trace!("ecash_verifier::DoubleSpendingDetector : received shutdown");
-                },
-                _ = interval.tick() => self.refresh_bloomfilter().await,
-
-            }
-        }
-    }
-
-    pub(crate) fn start(self, shutdown: nym_task::TaskClient) {
-        tokio::spawn(async move { self.run(shutdown).await });
-    }
-}
@@ -4,7 +4,6 @@
 use crate::Error;
 use credential_sender::CredentialHandler;
 use credential_sender::CredentialHandlerConfig;
-use double_spending::DoubleSpendingDetector;
 use error::EcashTicketError;
 use futures::channel::mpsc::{self, UnboundedSender};
 use nym_credentials::CredentialSpendingData;
@@ -18,7 +17,6 @@ use tokio::sync::{Mutex, RwLockReadGuard};
 use tracing::error;

 pub mod credential_sender;
-pub(crate) mod double_spending;
 pub mod error;
 mod helpers;
 mod state;
@@ -31,7 +29,6 @@ pub struct EcashManager<S> {
    pk_bytes: [u8; 32], // bytes representation of a pub key representing the verifier
    pay_infos: Mutex<Vec<NymPayInfo>>,
    cred_sender: UnboundedSender<ClientTicket>,
-    double_spend_detector: DoubleSpendingDetector<S>,
 }

 impl<S> EcashManager<S>
@@ -47,9 +44,6 @@ where
    ) -> Result<Self, Error> {
        let shared_state = SharedState::new(nyxd_client, storage).await?;

-        let double_spend_detector = DoubleSpendingDetector::new(shared_state.clone());
-        double_spend_detector.clone().start(shutdown.clone());
-
        let (cred_sender, cred_receiver) = mpsc::unbounded();

        let cs =
@@ -62,7 +56,6 @@ where
            pk_bytes,
            pay_infos: Default::default(),
            cred_sender,
-            double_spend_detector,
        })
    }

@@ -163,10 +156,6 @@ where
        Ok(())
    }

-    pub async fn check_double_spend(&self, serial_number: &Vec<u8>) -> bool {
-        self.double_spend_detector.check(serial_number).await
-    }
-
    pub fn async_verify(&self, ticket: ClientTicket) {
        // TODO: I guess do something for shutdowns
        let _ = self
@@ -53,18 +53,6 @@ impl<S: Storage + Clone + 'static> CredentialVerifier<S> {
        Ok(())
    }

-    async fn check_bloomfilter(&self, serial_number: &Vec<u8>) -> Result<()> {
-        trace!("checking the bloomfilter...");
-
-        let spent = self.ecash_verifier.check_double_spend(serial_number).await;
-
-        if spent {
-            trace!("the credential has already been spent before at some gateway before (bloomfilter failure)");
-            return Err(Error::BandwidthCredentialAlreadySpent);
-        }
-        Ok(())
-    }
-
    async fn check_local_db_for_double_spending(&self, serial_number: &[u8]) -> Result<()> {
        trace!("checking local db for double spending...");

@@ -128,7 +116,6 @@ impl<S: Storage + Clone + 'static> CredentialVerifier<S> {
        }

        self.check_credential_spending_date(spend_date.ecash_date())?;
-        self.check_bloomfilter(&serial_number).await?;
        self.check_local_db_for_double_spending(&serial_number)
            .await?;

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

 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
-use std::fmt::{self, Display, Formatter};
+use std::fmt::{self, Debug, Display, Formatter};
 use std::str::FromStr;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};
@@ -112,12 +112,18 @@ impl PemStorableKeyPair for KeyPair {
    }
 }

-#[derive(PartialEq, Eq, Hash, Copy, Clone, Debug)]
+#[derive(PartialEq, Eq, Hash, Copy, Clone)]
 pub struct PublicKey(x25519_dalek::PublicKey);

 impl Display for PublicKey {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.to_base58_string())
+        Display::fmt(&self.to_base58_string(), f)
+    }
+}
+
+impl Debug for PublicKey {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Debug::fmt(&self.to_base58_string(), f)
    }
 }

@@ -31,8 +31,16 @@ pub mod option_bs58_x25519_pubkey {
    pub fn deserialize<'de, D: Deserializer<'de>>(
        deserializer: D,
    ) -> Result<Option<PublicKey>, D::Error> {
-        let s = Option::<String>::deserialize(deserializer)?;
-        s.map(|s| PublicKey::from_base58_string(&s).map_err(serde::de::Error::custom))
-            .transpose()
+        match Option::<String>::deserialize(deserializer)? {
+            None => Ok(None),
+            Some(s) => {
+                if s.is_empty() {
+                    Ok(None)
+                } else {
+                    Some(PublicKey::from_base58_string(&s).map_err(serde::de::Error::custom))
+                        .transpose()
+                }
+            }
+        }
    }
 }
@@ -5,7 +5,7 @@ pub use ed25519_dalek::SignatureError;
 use ed25519_dalek::{Signer, SigningKey};
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
-use std::fmt::{self, Display, Formatter};
+use std::fmt::{self, Debug, Display, Formatter};
 use std::str::FromStr;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};
@@ -119,12 +119,18 @@ impl PemStorableKeyPair for KeyPair {
 }

 /// ed25519 EdDSA Public Key
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Eq, PartialEq)]
 pub struct PublicKey(ed25519_dalek::VerifyingKey);

 impl Display for PublicKey {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.to_base58_string())
+        Display::fmt(&self.to_base58_string(), f)
+    }
+}
+
+impl Debug for PublicKey {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Debug::fmt(&self.to_base58_string(), f)
    }
 }

@@ -0,0 +1,34 @@
+[package]
+name = "nym-gateway-stats-storage"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+sqlx = { workspace = true, features = [
+    "runtime-tokio-rustls",
+    "sqlite",
+    "macros",
+    "migrate",
+    "time",
+] }
+time = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+nym-sphinx = { path = "../nymsphinx" }
+nym-credentials-interface = { path = "../credentials-interface" }
+
+
+[build-dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+sqlx = { workspace = true, features = [
+    "runtime-tokio-rustls",
+    "sqlite",
+    "macros",
+    "migrate",
+] }
@@ -0,0 +1,28 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use sqlx::{Connection, SqliteConnection};
+use std::env;
+
+#[tokio::main]
+async fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let database_path = format!("{}/gateway-stats-example.sqlite", out_dir);
+
+    let mut conn = SqliteConnection::connect(&format!("sqlite://{}?mode=rwc", database_path))
+        .await
+        .expect("Failed to create SQLx database connection");
+
+    sqlx::migrate!("./migrations")
+        .run(&mut conn)
+        .await
+        .expect("Failed to perform SQLx migrations");
+
+    #[cfg(target_family = "unix")]
+    println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
+
+    #[cfg(target_family = "windows")]
+    // for some strange reason we need to add a leading `/` to the windows path even though it's
+    // not a valid windows path... but hey, it works...
+    println!("cargo:rustc-env=DATABASE_URL=sqlite:///{}", &database_path);
+}
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+CREATE TABLE sessions_active
+(
+    client_address  TEXT                        NOT NULL PRIMARY KEY UNIQUE,
+    start_time      TIMESTAMP WITHOUT TIME ZONE NOT NULL,
+    typ             TEXT                        NOT NULL
+);
+
+CREATE TABLE sessions_finished
+(
+    id          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    day         DATE    NOT NULL,
+    duration_ms INTEGER NOT NULL,
+    typ         TEXT    NOT NULL
+);
+
+CREATE TABLE sessions_unique_users
+(
+    day             DATE    NOT NULL,
+    client_address  TEXT    NOT NULL,
+    PRIMARY KEY (day, client_address)
+);
@@ -0,0 +1,13 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum StatsStorageError {
+    #[error("Database experienced an internal error: {0}")]
+    InternalDatabaseError(#[from] sqlx::Error),
+
+    #[error("Failed to perform database migration: {0}")]
+    MigrationError(#[from] sqlx::migrate::MigrateError),
+}
@@ -0,0 +1,195 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use error::StatsStorageError;
+use models::{ActiveSession, FinishedSession, SessionType, StoredFinishedSession};
+use nym_sphinx::DestinationAddressBytes;
+use sessions::SessionManager;
+use sqlx::ConnectOptions;
+use std::path::Path;
+use time::Date;
+use tracing::{debug, error};
+
+pub mod error;
+pub mod models;
+mod sessions;
+
+// note that clone here is fine as upon cloning the same underlying pool will be used
+#[derive(Clone)]
+pub struct PersistentStatsStorage {
+    session_manager: SessionManager,
+}
+
+impl PersistentStatsStorage {
+    /// Initialises `PersistentStatsStorage` using the provided path.
+    ///
+    /// # Arguments
+    ///
+    /// * `database_path`: path to the database.
+    pub async fn init<P: AsRef<Path> + Send>(database_path: P) -> Result<Self, StatsStorageError> {
+        debug!(
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
+        );
+
+        // TODO: we can inject here more stuff based on our gateway global config
+        // struct. Maybe different pool size or timeout intervals?
+        let opts = sqlx::sqlite::SqliteConnectOptions::new()
+            .filename(database_path)
+            .create_if_missing(true)
+            .disable_statement_logging();
+
+        // TODO: do we want auto_vacuum ?
+
+        let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
+            Ok(db) => db,
+            Err(err) => {
+                error!("Failed to connect to SQLx database: {err}");
+                return Err(err.into());
+            }
+        };
+
+        if let Err(err) = sqlx::migrate!("./migrations").run(&connection_pool).await {
+            error!("Failed to perform migration on the SQLx database: {err}");
+            return Err(err.into());
+        }
+
+        // the cloning here are cheap as connection pool is stored behind an Arc
+        Ok(PersistentStatsStorage {
+            session_manager: sessions::SessionManager::new(connection_pool),
+        })
+    }
+
+    //Sessions fn
+    pub async fn insert_finished_session(
+        &self,
+        date: Date,
+        session: FinishedSession,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .insert_finished_session(
+                date,
+                session.duration.whole_milliseconds() as i64,
+                session.typ.to_string().into(),
+            )
+            .await?)
+    }
+
+    pub async fn get_finished_sessions(
+        &self,
+        date: Date,
+    ) -> Result<Vec<StoredFinishedSession>, StatsStorageError> {
+        Ok(self.session_manager.get_finished_sessions(date).await?)
+    }
+
+    pub async fn delete_finished_sessions(
+        &self,
+        before_date: Date,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .delete_finished_sessions(before_date)
+            .await?)
+    }
+
+    pub async fn insert_unique_user(
+        &self,
+        date: Date,
+        client_address_bs58: String,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .insert_unique_user(date, client_address_bs58)
+            .await?)
+    }
+
+    pub async fn get_unique_users_count(&self, date: Date) -> Result<i32, StatsStorageError> {
+        Ok(self.session_manager.get_unique_users_count(date).await?)
+    }
+
+    pub async fn delete_unique_users(&self, before_date: Date) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .delete_unique_users(before_date)
+            .await?)
+    }
+
+    pub async fn insert_active_session(
+        &self,
+        client_address: DestinationAddressBytes,
+        session: ActiveSession,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .insert_active_session(
+                client_address.as_base58_string(),
+                session.start,
+                session.typ.to_string().into(),
+            )
+            .await?)
+    }
+
+    pub async fn update_active_session_type(
+        &self,
+        client_address: DestinationAddressBytes,
+        session_type: SessionType,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .update_active_session_type(
+                client_address.as_base58_string(),
+                session_type.to_string().into(),
+            )
+            .await?)
+    }
+
+    pub async fn get_active_session(
+        &self,
+        client_address: DestinationAddressBytes,
+    ) -> Result<Option<ActiveSession>, StatsStorageError> {
+        Ok(self
+            .session_manager
+            .get_active_session(client_address.as_base58_string())
+            .await?
+            .map(Into::into))
+    }
+
+    pub async fn get_all_active_sessions(&self) -> Result<Vec<ActiveSession>, StatsStorageError> {
+        Ok(self
+            .session_manager
+            .get_all_active_sessions()
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect())
+    }
+
+    pub async fn get_started_sessions_count(
+        &self,
+        start_date: Date,
+    ) -> Result<i32, StatsStorageError> {
+        Ok(self
+            .session_manager
+            .get_started_sessions_count(start_date)
+            .await?)
+    }
+
+    pub async fn get_active_users(&self) -> Result<Vec<String>, StatsStorageError> {
+        Ok(self.session_manager.get_active_users().await?)
+    }
+
+    pub async fn delete_active_session(
+        &self,
+        client_address: DestinationAddressBytes,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .delete_active_session(client_address.as_base58_string())
+            .await?)
+    }
+
+    pub async fn cleanup_active_sessions(&self) -> Result<(), StatsStorageError> {
+        Ok(self.session_manager.cleanup_active_sessions().await?)
+    }
+}
@@ -0,0 +1,109 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use nym_credentials_interface::TicketType;
+use sqlx::prelude::FromRow;
+use time::{Duration, OffsetDateTime};
+
+#[derive(FromRow)]
+pub struct StoredFinishedSession {
+    duration_ms: i64,
+    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(),
+        )
+    }
+}
+
+pub struct FinishedSession {
+    pub duration: Duration,
+    pub typ: SessionType,
+}
+
+#[derive(PartialEq)]
+pub enum SessionType {
+    Vpn,
+    Mixnet,
+    Unknown,
+}
+
+impl SessionType {
+    pub fn to_string(&self) -> &str {
+        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,
+        }
+    }
+}
+
+#[derive(FromRow)]
+pub(crate) struct StoredActiveSession {
+    start_time: OffsetDateTime,
+    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 {
+            start: value.start_time,
+            typ: SessionType::from_string(&value.typ),
+        }
+    }
+}
@@ -0,0 +1,177 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use time::{Date, OffsetDateTime};
+
+use crate::models::{StoredActiveSession, StoredFinishedSession};
+
+pub(crate) type Result<T> = std::result::Result<T, sqlx::Error>;
+
+#[derive(Clone)]
+pub(crate) struct SessionManager {
+    connection_pool: sqlx::SqlitePool,
+}
+
+impl SessionManager {
+    /// Creates new instance of the `SessionsManager` with the provided sqlite connection pool.
+    ///
+    /// # Arguments
+    ///
+    /// * `connection_pool`: database connection pool to use.
+    pub(crate) fn new(connection_pool: sqlx::SqlitePool) -> Self {
+        SessionManager { connection_pool }
+    }
+
+    pub(crate) async fn insert_finished_session(
+        &self,
+        date: Date,
+        duration_ms: i64,
+        typ: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "INSERT INTO sessions_finished (day, duration_ms, typ) VALUES (?, ?, ?)",
+            date,
+            duration_ms,
+            typ
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn get_finished_sessions(
+        &self,
+        date: Date,
+    ) -> Result<Vec<StoredFinishedSession>> {
+        sqlx::query_as("SELECT duration_ms, typ FROM sessions_finished WHERE day = ?")
+            .bind(date)
+            .fetch_all(&self.connection_pool)
+            .await
+    }
+
+    pub(crate) async fn delete_finished_sessions(&self, before_date: Date) -> Result<()> {
+        sqlx::query!("DELETE FROM sessions_finished WHERE day <= ? ", before_date)
+            .execute(&self.connection_pool)
+            .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn insert_unique_user(
+        &self,
+        date: Date,
+        client_address_b58: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "INSERT OR IGNORE INTO sessions_unique_users (day, client_address) VALUES (?, ?)",
+            date,
+            client_address_b58,
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn get_unique_users_count(&self, date: Date) -> Result<i32> {
+        Ok(sqlx::query!(
+            "SELECT COUNT(*) as count FROM sessions_unique_users WHERE day = ?",
+            date
+        )
+        .fetch_one(&self.connection_pool)
+        .await?
+        .count)
+    }
+
+    pub(crate) async fn delete_unique_users(&self, before_date: Date) -> Result<()> {
+        sqlx::query!(
+            "DELETE FROM sessions_unique_users WHERE day <= ? ",
+            before_date
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn insert_active_session(
+        &self,
+        client_address_b58: String,
+        start_time: OffsetDateTime,
+        typ: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "INSERT INTO sessions_active (client_address, start_time, typ) VALUES (?, ?, ?)",
+            client_address_b58,
+            start_time,
+            typ
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn update_active_session_type(
+        &self,
+        client_address_b58: String,
+        typ: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "UPDATE sessions_active SET typ = ? WHERE client_address = ?",
+            typ,
+            client_address_b58,
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn get_active_session(
+        &self,
+        client_address_b58: String,
+    ) -> Result<Option<StoredActiveSession>> {
+        sqlx::query_as("SELECT start_time, typ FROM sessions_active WHERE client_address = ?")
+            .bind(client_address_b58)
+            .fetch_optional(&self.connection_pool)
+            .await
+    }
+
+    pub(crate) async fn get_all_active_sessions(&self) -> Result<Vec<StoredActiveSession>> {
+        sqlx::query_as("SELECT start_time, typ FROM sessions_active")
+            .fetch_all(&self.connection_pool)
+            .await
+    }
+
+    pub(crate) async fn get_started_sessions_count(&self, start_date: Date) -> Result<i32> {
+        Ok(sqlx::query!(
+            "SELECT COUNT(*) as count FROM sessions_active WHERE date(start_time) = ?",
+            start_date
+        )
+        .fetch_one(&self.connection_pool)
+        .await?
+        .count)
+    }
+
+    pub(crate) async fn get_active_users(&self) -> Result<Vec<String>> {
+        Ok(sqlx::query!("SELECT client_address from sessions_active")
+            .fetch_all(&self.connection_pool)
+            .await?
+            .into_iter()
+            .map(|record| record.client_address)
+            .collect())
+    }
+
+    pub(crate) async fn delete_active_session(&self, client_address_b58: String) -> Result<()> {
+        sqlx::query!(
+            "DELETE FROM sessions_active WHERE client_address = ?",
+            client_address_b58
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn cleanup_active_sessions(&self) -> Result<()> {
+        sqlx::query!("DELETE FROM sessions_active")
+            .execute(&self.connection_pool)
+            .await?;
+        Ok(())
+    }
+}
@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 use std::time::Duration;
 use thiserror::Error;
-use tracing::warn;
+use tracing::{instrument, warn};
 use url::Url;

 pub use reqwest::IntoUrl;
@@ -35,6 +35,9 @@ pub enum HttpClientError<E: Display = String> {
        source: reqwest::Error,
    },

+    #[error("failed to deserialise received response: {source}")]
+    ResponseDeserialisationFailure { source: serde_json::Error },
+
    #[error("provided url is malformed: {source}")]
    MalformedUrl {
        #[from]
@@ -202,6 +205,7 @@ impl Client {
        self.reqwest_client.get(url)
    }

+    #[instrument(level = "debug", skip_all, fields(path=?path))]
    async fn send_get_request<K, V, E>(
        &self,
        path: PathSegments<'_>,
@@ -212,6 +216,7 @@ impl Client {
        V: AsRef<str>,
        E: Display,
    {
+        tracing::trace!("Sending GET request");
        let url = sanitize_url(&self.base_url, path, params);

        #[cfg(target_arch = "wasm32")]
@@ -277,6 +282,7 @@ impl Client {
        }
    }

+    #[instrument(level = "debug", skip_all)]
    pub async fn get_json<T, K, V, E>(
        &self,
        path: PathSegments<'_>,
@@ -512,12 +518,14 @@ pub fn sanitize_url<K: AsRef<str>, V: AsRef<str>>(
    url
 }

+#[tracing::instrument(level = "debug", skip_all)]
 pub async fn parse_response<T, E>(res: Response, allow_empty: bool) -> Result<T, HttpClientError<E>>
 where
    T: DeserializeOwned,
    E: DeserializeOwned + Display,
 {
    let status = res.status();
+    tracing::debug!("Status: {} (success: {})", &status, status.is_success());

    if !allow_empty {
        if let Some(0) = res.content_length() {
@@ -526,7 +534,17 @@ where
    }

    if res.status().is_success() {
-        Ok(res.json().await?)
+        let text = res.text().await?;
+        match serde_json::from_str(&text) {
+            Ok(res) => Ok(res),
+            Err(source) => {
+                #[cfg(debug_assertions)]
+                {
+                    tracing::trace!("Result:\n{:#?}", text);
+                }
+                Err(HttpClientError::ResponseDeserialisationFailure { source })
+            }
+        }
    } else if res.status() == StatusCode::NOT_FOUND {
        Err(HttpClientError::NotFound)
    } else {
@@ -11,6 +11,7 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
+axum-client-ip.workspace = true
 axum.workspace = true
 bytes = { workspace = true }
 colored.workspace = true
@@ -1,18 +1,18 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only

-use axum::extract::{ConnectInfo, Request};
+use axum::extract::Request;
 use axum::http::header::{HOST, USER_AGENT};
 use axum::http::HeaderValue;
 use axum::middleware::Next;
 use axum::response::IntoResponse;
+use axum_client_ip::InsecureClientIp;
 use colored::Colorize;
-use std::net::SocketAddr;
 use std::time::Instant;
 use tracing::info;

 pub async fn logger(
-    ConnectInfo(addr): ConnectInfo<SocketAddr>,
+    InsecureClientIp(addr): InsecureClientIp,
    request: Request,
    next: Next,
 ) -> impl IntoResponse {
@@ -0,0 +1,14 @@
+[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]
+serde = { workspace = true, features = ["derive"] }
@@ -0,0 +1 @@
+pub mod ns_api;
@@ -0,0 +1,8 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TestrunAssignment {
+    /// has nothing to do with GW identity key. This is PK from `gateways` table
+    pub testrun_id: i64,
+    pub gateway_pk_id: i64,
+}
@@ -19,10 +19,10 @@ pub enum TicketTypeRepr {
 }

 impl TicketTypeRepr {
-    pub const WIREGUARD_ENTRY_TICKET_SIZE: u64 = 512 * 1024 * 1024; // 512 MB
-    pub const WIREGUARD_EXIT_TICKET_SIZE: u64 = 512 * 1024 * 1024; // 512 MB
-    pub const MIXNET_ENTRY_TICKET_SIZE: u64 = 128 * 1024 * 1024; // 128 MB
-    pub const MIXNET_EXIT_TICKET_SIZE: u64 = 128 * 1024 * 1024; // 128 MB
+    pub const WIREGUARD_ENTRY_TICKET_SIZE: u64 = 500 * 1000 * 1000; // 500 MB
+    pub const WIREGUARD_EXIT_TICKET_SIZE: u64 = 500 * 1000 * 1000; // 500 MB
+    pub const MIXNET_ENTRY_TICKET_SIZE: u64 = 200 * 1000 * 1000; // 200 MB
+    pub const MIXNET_EXIT_TICKET_SIZE: u64 = 100 * 1000 * 1000; // 100 MB

    /// How much bandwidth (in bytes) one ticket can grant
    pub const fn bandwidth_value(&self) -> u64 {
@@ -21,7 +21,7 @@ nym-sphinx-types = { path = "../types" }
 nym-topology = { path = "../../topology" }

 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
-version = "0.2.93"
+version = "0.2.95"

 [dev-dependencies]
 rand_chacha = { workspace = true }
@@ -1,11 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::sync::LazyLock;
-
 use crate::fragment::{linked_fragment_payload_max_len, unlinked_fragment_payload_max_len};
-use dashmap::DashMap;
-use fragment::{Fragment, FragmentHeader};
+use fragment::FragmentHeader;
 use nym_crypto::asymmetric::ed25519::PublicKey;
 use serde::Serialize;
 pub use set::split_into_sets;
@@ -29,6 +26,59 @@ pub mod fragment;
 pub mod reconstruction;
 pub mod set;

+pub mod monitoring {
+    use crate::fragment::Fragment;
+    use crate::{ReceivedFragment, SentFragment};
+    use dashmap::DashMap;
+    use nym_crypto::asymmetric::ed25519::PublicKey;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::LazyLock;
+
+    pub static ENABLED: AtomicBool = AtomicBool::new(false);
+
+    pub static FRAGMENTS_RECEIVED: LazyLock<DashMap<i32, Vec<ReceivedFragment>>> =
+        LazyLock::new(DashMap::new);
+
+    pub static FRAGMENTS_SENT: LazyLock<DashMap<i32, Vec<SentFragment>>> =
+        LazyLock::new(DashMap::new);
+
+    pub fn enable() {
+        ENABLED.store(true, Ordering::Relaxed)
+    }
+
+    pub fn enabled() -> bool {
+        ENABLED.load(Ordering::Relaxed)
+    }
+
+    #[macro_export]
+    macro_rules! now {
+        () => {
+            match std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH) {
+                Ok(n) => n.as_secs(),
+                Err(_) => 0,
+            }
+        };
+    }
+
+    pub fn fragment_received(fragment: &Fragment) {
+        if enabled() {
+            let id = fragment.fragment_identifier().set_id();
+            let mut entry = FRAGMENTS_RECEIVED.entry(id).or_default();
+            let r = ReceivedFragment::new(fragment.header(), now!());
+            entry.push(r);
+        }
+    }
+
+    pub fn fragment_sent(fragment: &Fragment, client_nonce: i32, destination: PublicKey, hops: u8) {
+        if enabled() {
+            let id = fragment.fragment_identifier().set_id();
+            let mut entry = FRAGMENTS_SENT.entry(id).or_default();
+            let s = SentFragment::new(fragment.header(), now!(), client_nonce, destination, hops);
+            entry.push(s);
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct FragmentMixParams {
    destination: PublicKey,
@@ -112,35 +162,6 @@ impl ReceivedFragment {
    }
 }

-pub static FRAGMENTS_RECEIVED: LazyLock<DashMap<i32, Vec<ReceivedFragment>>> =
-    LazyLock::new(DashMap::new);
-
-pub static FRAGMENTS_SENT: LazyLock<DashMap<i32, Vec<SentFragment>>> = LazyLock::new(DashMap::new);
-
-#[macro_export]
-macro_rules! now {
-    () => {
-        match std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH) {
-            Ok(n) => n.as_secs(),
-            Err(_) => 0,
-        }
-    };
-}
-
-pub fn fragment_received(fragment: &Fragment) {
-    let id = fragment.fragment_identifier().set_id();
-    let mut entry = FRAGMENTS_RECEIVED.entry(id).or_default();
-    let r = ReceivedFragment::new(fragment.header(), now!());
-    entry.push(r);
-}
-
-pub fn fragment_sent(fragment: &Fragment, client_nonce: i32, destination: PublicKey, hops: u8) {
-    let id = fragment.fragment_identifier().set_id();
-    let mut entry = FRAGMENTS_SENT.entry(id).or_default();
-    let s = SentFragment::new(fragment.header(), now!(), client_nonce, destination, hops);
-    entry.push(s);
-}
-
 /// The idea behind the process of chunking is to incur as little data overhead as possible due
 /// to very computationally costly sphinx encapsulation procedure.
 ///
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 use crate::fragment::Fragment;
-use crate::{fragment_received, ChunkingError};
+use crate::{monitoring, ChunkingError};
 use log::*;
 use std::collections::HashMap;

@@ -110,7 +110,7 @@ impl ReconstructionBuffer {
            }
        });

-        fragment_received(&fragment);
+        monitoring::fragment_received(&fragment);

        let fragment_index = fragment.current_fragment() as usize - 1;
        if self.fragments[fragment_index].is_some() {
@@ -12,7 +12,6 @@ use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx_anonymous_replies::reply_surb::ReplySurb;
 use nym_sphinx_chunking::fragment::{Fragment, FragmentIdentifier};
-use nym_sphinx_chunking::fragment_sent;
 use nym_sphinx_forwarding::packet::MixPacket;
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
@@ -21,6 +20,7 @@ use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, Rng, SeedableRng};
 use rand_chacha::ChaCha20Rng;

+use nym_sphinx_chunking::monitoring;
 use std::time::Duration;

 pub(crate) mod payload;
@@ -206,7 +206,7 @@ pub trait FragmentPreparer {

        let destination = packet_recipient.gateway();
        let hops = mix_hops.unwrap_or(self.num_mix_hops());
-        fragment_sent(&fragment, self.nonce(), *destination, hops);
+        monitoring::fragment_sent(&fragment, self.nonce(), *destination, hops);

        let non_reply_overhead = encryption::PUBLIC_KEY_SIZE;
        let expected_plaintext = match packet_type {
@@ -286,6 +286,10 @@ impl NymTopology {
        self.get_gateway(gateway_identity).is_some()
    }

+    pub fn insert_gateway(&mut self, gateway: gateway::LegacyNode) {
+        self.gateways.push(gateway)
+    }
+
    pub fn set_gateways(&mut self, gateways: Vec<gateway::LegacyNode>) {
        self.gateways = gateways
    }
@@ -116,7 +116,7 @@ impl<'a> TryFrom<&'a SkimmedNode> for LegacyNode {
            });
        }

-        let layer = match value.epoch_role {
+        let layer = match value.role {
            NodeRole::Mixnode { layer } => layer
                .try_into()
                .map_err(|_| MixnodeConversionError::InvalidLayer)?,
@@ -3,9 +3,6 @@

 #[derive(Debug, thiserror::Error)]
 pub enum Error {
-    #[error("peers in wireguard don't match with in-memory ")]
-    PeerMismatch,
-
    #[error("traffic byte data needs to be increasing")]
    InconsistentConsumedBytes,

@@ -20,4 +17,7 @@ pub enum Error {

    #[error("{0}")]
    GatewayStorage(#[from] nym_gateway_storage::error::StorageError),
+
+    #[error("{0}")]
+    SystemTime(#[from] std::time::SystemTimeError),
 }
@@ -226,14 +226,10 @@ impl<St: Storage + Clone + 'static> PeerController<St> {
                .available_bandwidth()
                .await
        } else {
-            let peer = self
-                .host_information
-                .read()
-                .await
-                .peers
-                .get(key)
-                .ok_or(Error::PeerMismatch)?
-                .clone();
+            let Some(peer) = self.host_information.read().await.peers.get(key).cloned() else {
+                // host information not updated yet
+                return Ok(None);
+            };
            BANDWIDTH_CAP_PER_DAY.saturating_sub((peer.rx_bytes + peer.tx_bytes) as i64)
        };

@@ -3,6 +3,7 @@

 use crate::error::Error;
 use crate::peer_controller::PeerControlRequest;
+use defguard_wireguard_rs::host::Peer;
 use defguard_wireguard_rs::{host::Host, key::Key};
 use futures::channel::oneshot;
 use nym_authenticator_requests::v2::registration::BANDWIDTH_CAP_PER_DAY;
@@ -12,10 +13,12 @@ use nym_gateway_storage::Storage;
 use nym_task::TaskClient;
 use nym_wireguard_types::DEFAULT_PEER_TIMEOUT_CHECK;
 use std::sync::Arc;
+use std::time::{Duration, SystemTime};
 use tokio::sync::{mpsc, RwLock};
 use tokio_stream::{wrappers::IntervalStream, StreamExt};

 pub(crate) type SharedBandwidthStorageManager<St> = Arc<RwLock<BandwidthStorageManager<St>>>;
+const AUTO_REMOVE_AFTER: Duration = Duration::from_secs(60 * 60 * 24); // 24 hours

 pub struct PeerHandle<St> {
    storage: St,
@@ -25,6 +28,7 @@ pub struct PeerHandle<St> {
    request_tx: mpsc::Sender<PeerControlRequest>,
    timeout_check_interval: IntervalStream,
    task_client: TaskClient,
+    startup_timestamp: SystemTime,
 }

 impl<St: Storage + Clone + 'static> PeerHandle<St> {
@@ -39,7 +43,8 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
        let timeout_check_interval = tokio_stream::wrappers::IntervalStream::new(
            tokio::time::interval(DEFAULT_PEER_TIMEOUT_CHECK),
        );
-        let task_client = task_client.fork(format!("peer{public_key}"));
+        let mut task_client = task_client.fork(format!("peer-{public_key}"));
+        task_client.disarm();
        PeerHandle {
            storage,
            public_key,
@@ -48,14 +53,11 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
            request_tx,
            timeout_check_interval,
            task_client,
+            startup_timestamp: SystemTime::now(),
        }
    }

-    async fn remove_depleted_peer(&self) -> Result<bool, Error> {
-        log::debug!(
-            "Peer {} doesn't have bandwidth anymore, removing it",
-            self.public_key.to_string()
-        );
+    async fn remove_peer(&self) -> Result<bool, Error> {
        let (response_tx, response_rx) = oneshot::channel();
        self.request_tx
            .send(PeerControlRequest::RemovePeer {
@@ -71,35 +73,44 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
        Ok(success)
    }

-    async fn active_peer(&mut self, storage_peer: WireguardPeer) -> Result<bool, Error> {
-        let kernel_peer = self
-            .host_information
-            .read()
-            .await
-            .peers
-            .get(&self.public_key)
-            .ok_or(Error::PeerMismatch)?
-            .clone();
+    async fn active_peer(
+        &mut self,
+        storage_peer: WireguardPeer,
+        kernel_peer: Peer,
+    ) -> Result<bool, Error> {
        if let Some(bandwidth_manager) = &self.bandwidth_storage_manager {
            let spent_bandwidth = (kernel_peer.rx_bytes + kernel_peer.tx_bytes)
                .checked_sub(storage_peer.rx_bytes as u64 + storage_peer.tx_bytes as u64)
                .ok_or(Error::InconsistentConsumedBytes)?
                .try_into()
                .map_err(|_| Error::InconsistentConsumedBytes)?;
-            if bandwidth_manager
-                .write()
-                .await
-                .try_use_bandwidth(spent_bandwidth)
-                .await
-                .is_err()
+            if spent_bandwidth > 0
+                && bandwidth_manager
+                    .write()
+                    .await
+                    .try_use_bandwidth(spent_bandwidth)
+                    .await
+                    .is_err()
            {
-                let success = self.remove_depleted_peer().await?;
+                let success = self.remove_peer().await?;
                return Ok(!success);
            }
        } else {
+            if SystemTime::now().duration_since(self.startup_timestamp)? >= AUTO_REMOVE_AFTER {
+                log::debug!(
+                    "Peer {} has been present for 24 hours, removing it",
+                    self.public_key.to_string()
+                );
+                let success = self.remove_peer().await?;
+                return Ok(!success);
+            }
            let spent_bandwidth = kernel_peer.rx_bytes + kernel_peer.tx_bytes;
            if spent_bandwidth >= BANDWIDTH_CAP_PER_DAY {
-                let success = self.remove_depleted_peer().await?;
+                log::debug!(
+                    "Peer {} doesn't have bandwidth anymore, removing it",
+                    self.public_key.to_string()
+                );
+                let success = self.remove_peer().await?;
                return Ok(!success);
            }
        }
@@ -111,11 +122,21 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
        while !self.task_client.is_shutdown() {
            tokio::select! {
                _ = self.timeout_check_interval.next() => {
-                    let Some(peer) = self.storage.get_wireguard_peer(&self.public_key.to_string()).await? else {
+                    let Some(kernel_peer) = self
+                        .host_information
+                        .read()
+                        .await
+                        .peers
+                        .get(&self.public_key)
+                        .cloned() else {
+                            // the host information hasn't beed updated yet
+                            continue;
+                        };
+                    let Some(storage_peer) = self.storage.get_wireguard_peer(&self.public_key.to_string()).await? else {
                        log::debug!("Peer {:?} not in storage anymore, shutting down handle", self.public_key);
                        return Ok(());
                    };
-                    if !self.active_peer(peer).await? {
+                    if !self.active_peer(storage_peer, kernel_peer).await? {
                        log::debug!("Peer {:?} doesn't have bandwidth anymore, shutting down handle", self.public_key);
                        return Ok(());
                    }
@@ -433,7 +433,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]

 [[package]]
@@ -1483,9 +1483,9 @@ dependencies = [

 [[package]]
 name = "proc-macro2"
-version = "1.0.81"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
 dependencies = [
 "unicode-ident",
 ]
@@ -1660,7 +1660,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde_derive_internals",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]

 [[package]]
@@ -1702,9 +1702,9 @@ dependencies = [

 [[package]]
 name = "serde"
-version = "1.0.210"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
 dependencies = [
 "serde_derive",
 ]
@@ -1729,13 +1729,13 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.210"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]

 [[package]]
@@ -1746,7 +1746,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]

 [[package]]
@@ -1769,7 +1769,7 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]

 [[package]]
@@ -1928,9 +1928,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.59"
+version = "2.0.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a6531ffc7b071655e4ce2e04bd464c4830bb585a61cabb96cf808f05172615a"
+checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1954,7 +1954,7 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]

 [[package]]
@@ -2120,5 +2120,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]
@@ -3689,8 +3689,7 @@
              "format": "uint32",
              "minimum": 0.0
            }
-          },
-          "additionalProperties": false
+          }
        },
        "Percent": {
          "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -5239,8 +5238,7 @@
              "format": "uint32",
              "minimum": 0.0
            }
-          },
-          "additionalProperties": false
+          }
        },
        "Percent": {
          "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -5575,8 +5573,7 @@
              "format": "uint32",
              "minimum": 0.0
            }
-          },
-          "additionalProperties": false
+          }
        },
        "Percent": {
          "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -7595,8 +7592,7 @@
              "format": "uint32",
              "minimum": 0.0
            }
-          },
-          "additionalProperties": false
+          }
        },
        "Percent": {
          "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -315,8 +315,7 @@
          "format": "uint32",
          "minimum": 0.0
        }
-      },
-      "additionalProperties": false
+      }
    },
    "Percent": {
      "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -323,8 +323,7 @@
          "format": "uint32",
          "minimum": 0.0
        }
-      },
-      "additionalProperties": false
+      }
    },
    "Percent": {
      "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -317,8 +317,7 @@
          "format": "uint32",
          "minimum": 0.0
        }
-      },
-      "additionalProperties": false
+      }
    },
    "Percent": {
      "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -319,8 +319,7 @@
          "format": "uint32",
          "minimum": 0.0
        }
-      },
-      "additionalProperties": false
+      }
    },
    "Percent": {
      "description": "Percent represents a value between 0 and 100% (i.e. between 0.0 and 1.0)",
@@ -52,8 +52,8 @@ pub(crate) fn save_assignment(

    // update metadata
    let mut metadata = ROLES_METADATA.load(storage, inactive)?;
-    let last = assignment.nodes.last().copied().unwrap_or_default();
-    metadata.set_highest_id(last, assignment.role);
+    let highest_id = assignment.nodes.iter().max().copied().unwrap_or_default();
+    metadata.set_highest_id(highest_id, assignment.role);
    metadata.set_role_count(assignment.role, assignment.nodes.len() as u32);
    if assignment.is_final_assignment() {
        metadata.fully_assigned = true
@@ -140,6 +140,7 @@ pub(crate) fn initialise_storage(storage: &mut dyn Storage) -> Result<(), Mixnet
 mod tests {
    use super::*;
    use crate::support::tests::test_helpers;
+    use crate::support::tests::test_helpers::TestSetup;

    #[test]
    fn next_id() {
@@ -149,4 +150,33 @@ mod tests {
            assert_eq!(i, next_nymnode_id_counter(deps.as_mut().storage).unwrap());
        }
    }
+
+    #[test]
+    fn assigning_role_uses_highest_id_even_if_not_sorted() {
+        let mut test = TestSetup::new();
+        let deps = test.deps_mut();
+
+        let sorted = RoleAssignment {
+            role: Role::EntryGateway,
+            nodes: vec![1, 2, 3],
+        };
+
+        let unsorted = RoleAssignment {
+            role: Role::Layer1,
+            nodes: vec![8, 5, 4],
+        };
+
+        save_assignment(deps.storage, sorted).unwrap();
+        save_assignment(deps.storage, unsorted).unwrap();
+
+        let storage = deps.as_ref().storage;
+
+        let active_bucket = ACTIVE_ROLES_BUCKET.load(storage).unwrap();
+        let inactive = active_bucket.other() as u8;
+        let metadata = ROLES_METADATA.load(storage, inactive).unwrap();
+
+        assert_eq!(metadata.entry_gateway_metadata.highest_id, 3);
+        assert_eq!(metadata.layer1_metadata.highest_id, 8);
+        assert_eq!(metadata.highest_rewarded_id(), 8)
+    }
 }
@@ -19,5 +19,5 @@ MULTISIG_CONTRACT_ADDRESS=n1zwv6feuzhy6a9wekh96cd57lsarmqlwxdypdsplw6zhfncqw6ftq
 COCONUT_DKG_CONTRACT_ADDRESS=n1aakfpghcanxtc45gpqlx8j3rq0zcpyf49qmhm9mdjrfx036h4z5sy2vfh9

 EXPLORER_API=https://canary-explorer.performance.nymte.ch/api
-NYXD="https://canary-validator.performance.nymte.ch"
-NYM_API="https://canary-api.performance.nymte.ch/api"
+NYXD=https://canary-validator.performance.nymte.ch
+NYM_API=https://canary-api.performance.nymte.ch/api
@@ -21,8 +21,8 @@ COCONUT_DKG_CONTRACT_ADDRESS=n19604yflqggs9mk2z26mqygq43q2kr3n932egxx630svywd5mp

 REWARDING_VALIDATOR_ADDRESS=n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy
 STATISTICS_SERVICE_DOMAIN_ADDRESS="https://mainnet-stats.nymte.ch:8090"
-NYXD="https://rpc.nymtech.net"
-NYM_API="https://validator.nymtech.net/api/"
+NYXD=https://rpc.nymtech.net
+NYM_API=https://validator.nymtech.net/api/
 NYXD_WS="wss://rpc.nymtech.net/websocket"
-EXPLORER_API="https://explorer.nymtech.net/api/"
+EXPLORER_API=https://explorer.nymtech.net/api/
 NYM_VPN_API="https://nymvpn.com/api"
@@ -19,5 +19,5 @@ VESTING_CONTRACT_ADDRESS=n1jlzdxnyces4hrhqz68dqk28mrw5jgwtcfq0c2funcwrmw0dx9l9s8
 REWARDING_VALIDATOR_ADDRESS=n1rfvpsynktze6wvn6ldskj8xgwfzzk5v6pnff39

 EXPLORER_API=https://qa-network-explorer.qa.nymte.ch/api
-NYXD="https://qa-validator.qa.nymte.ch"
-NYM_API="https://qa-nym-api.qa.nymte.ch/api"
+NYXD=https://qa-validator.qa.nymte.ch
+NYM_API=https://qa-nym-api.qa.nymte.ch/api
@@ -20,6 +20,6 @@ ECASH_CONTRACT_ADDRESS=n1v3vydvs2ued84yv3khqwtgldmgwn0elljsdh08dr5s2j9x4rc5fs9jl

 STATISTICS_SERVICE_DOMAIN_ADDRESS="http://0.0.0.0"
 EXPLORER_API=https://sandbox-explorer.nymtech.net/api
-NYXD="https://rpc.sandbox.nymtech.net"
-NYXD_WS="wss://rpc.sandbox.nymtech.net/websocket"
-NYM_API="https://sandbox-nym-api1.nymtech.net/api"
+NYXD=https://rpc.sandbox.nymtech.net
+NYXD_WS=wss://rpc.sandbox.nymtech.net/websocket
+NYM_API=https://sandbox-nym-api1.nymtech.net/api
@@ -1,6 +1,6 @@
 [package]
 name = "explorer-api"
-version = "1.1.40"
+version = "1.1.41"
 edition = "2021"
 license.workspace = true

@@ -7,12 +7,12 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-log.workspace = true
 nym-explorer-api-requests = { path = "../explorer-api-requests" }
 reqwest = { workspace = true, features = ["json"] }
 serde.workspace = true
 thiserror.workspace = true
 url.workspace = true
+tracing = {workspace = true, features = ["attributes"]}

 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }
@@ -3,6 +3,7 @@ use std::time::Duration;

 use reqwest::StatusCode;
 use thiserror::Error;
+use tracing::instrument;
 use url::Url;

 // Re-export request types
@@ -12,6 +13,8 @@ pub use nym_explorer_api_requests::{

 // Paths
 const API_VERSION: &str = "v1";
+const TMP: &str = "tmp";
+const UNSTABLE: &str = "unstable";
 const MIXNODES: &str = "mix-nodes";
 const GATEWAYS: &str = "gateways";

@@ -47,6 +50,12 @@ impl ExplorerClient {
        Ok(Self { client, url })
    }

+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn new_with_timeout(url: url::Url, timeout: Duration) -> Result<Self, ExplorerApiError> {
+        let client = reqwest::Client::builder().timeout(timeout).build()?;
+        Ok(Self { client, url })
+    }
+
    #[cfg(target_arch = "wasm32")]
    pub fn new(url: url::Url) -> Result<Self, ExplorerApiError> {
        let client = reqwest::Client::builder().build()?;
@@ -58,10 +67,11 @@ impl ExplorerClient {
        paths: &[&str],
    ) -> Result<reqwest::Response, ExplorerApiError> {
        let url = combine_url(self.url.clone(), paths)?;
-        log::trace!("Sending GET request {url:?}");
+        tracing::debug!("Sending GET request");
        Ok(self.client.get(url).send().await?)
    }

+    #[instrument(level = "trace", skip_all, fields(paths=?paths))]
    async fn query_explorer_api<T>(&self, paths: &[&str]) -> Result<T, ExplorerApiError>
    where
        T: std::fmt::Debug,
@@ -70,12 +80,14 @@ impl ExplorerClient {
        let response = self.send_get_request(paths).await?;
        if response.status().is_success() {
            let res = response.json::<T>().await?;
-            log::trace!("Got response: {res:?}");
+            tracing::trace!("Got response: {res:?}");
            Ok(res)
        } else if response.status() == StatusCode::NOT_FOUND {
            Err(ExplorerApiError::NotFound)
        } else {
-            Err(ExplorerApiError::RequestFailure(response.text().await?))
+            let status = response.status();
+            let err_msg = format!("{}: {}", response.text().await?, status);
+            Err(ExplorerApiError::RequestFailure(err_msg))
        }
    }

@@ -86,6 +98,13 @@ impl ExplorerClient {
    pub async fn get_gateways(&self) -> Result<Vec<PrettyDetailedGatewayBond>, ExplorerApiError> {
        self.query_explorer_api(&[API_VERSION, GATEWAYS]).await
    }
+
+    pub async fn unstable_get_gateways(
+        &self,
+    ) -> Result<Vec<PrettyDetailedGatewayBond>, ExplorerApiError> {
+        self.query_explorer_api(&[API_VERSION, TMP, UNSTABLE, GATEWAYS])
+            .await
+    }
 }

 fn combine_url(mut base_url: Url, paths: &[&str]) -> Result<Url, ExplorerApiError> {
@@ -4,6 +4,7 @@
 use crate::state::ExplorerApiStateContext;
 use log::{info, warn};
 use nym_explorer_api_requests::Location;
+use nym_network_defaults::DEFAULT_NYM_NODE_HTTP_PORT;
 use nym_task::TaskClient;

 pub(crate) struct GeoLocateTask {
@@ -25,6 +26,7 @@ impl GeoLocateTask {
                    _ = interval_timer.tick() => {
                        self.locate_mix_nodes().await;
                        self.locate_gateways().await;
+                        self.locate_nym_nodes().await;
                    }
                    _ = self.shutdown.recv() => {
                        trace!("Listener: Received shutdown");
@@ -109,6 +111,83 @@ impl GeoLocateTask {
        trace!("All mix nodes located");
    }

+    async fn locate_nym_nodes(&mut self) {
+        // I'm unwrapping to the default value to get rid of an extra indentation level from the `if let Some(...) = ...`
+        // If the value is None, we'll unwrap to an empty hashmap and the `values()` loop won't do any work anyway
+        let nym_nodes = self.state.inner.nymnodes.get_bonded_nymnodes().await;
+
+        let geo_ip = self.state.inner.geo_ip.0.clone();
+
+        for (i, cache_item) in nym_nodes.values().enumerate() {
+            if self
+                .state
+                .inner
+                .nymnodes
+                .is_location_valid(cache_item.node_id())
+                .await
+            {
+                // when the cached location is valid, don't locate and continue to next mix node
+                continue;
+            }
+
+            let bonded_host = &cache_item.bond_information.node.host;
+
+            match geo_ip.query(
+                bonded_host,
+                Some(
+                    cache_item
+                        .bond_information
+                        .node
+                        .custom_http_port
+                        .unwrap_or(DEFAULT_NYM_NODE_HTTP_PORT),
+                ),
+            ) {
+                Ok(opt) => match opt {
+                    Some(location) => {
+                        let location: Location = location.into();
+
+                        trace!(
+                            "{} mix nodes already located. host {} is located in {:#?}",
+                            i,
+                            bonded_host,
+                            location.three_letter_iso_country_code,
+                        );
+
+                        if i > 0 && (i % 100) == 0 {
+                            info!("Located {} nym-nodes...", i + 1,);
+                        }
+
+                        self.state
+                            .inner
+                            .nymnodes
+                            .set_location(cache_item.node_id(), Some(location))
+                            .await;
+
+                        // one node has been located, so return out of the loop
+                        return;
+                    }
+                    None => {
+                        warn!("❌ Location for {bonded_host} not found.");
+                        self.state
+                            .inner
+                            .nymnodes
+                            .set_location(cache_item.node_id(), None)
+                            .await;
+                    }
+                },
+                Err(_e) => {
+                    // warn!(
+                    //     "❌ Oh no! Location for {} failed. Error: {:#?}",
+                    //     cache_item.mix_node().host,
+                    //     e
+                    // );
+                }
+            };
+        }
+
+        trace!("All nym-nodes nodes located");
+    }
+
    async fn locate_gateways(&mut self) {
        let gateways = self.state.inner.gateways.get_gateways().await;

@@ -10,6 +10,7 @@ use crate::gateways::http::gateways_make_default_routes;
 use crate::http::swagger::get_docs;
 use crate::mix_node::http::mix_node_make_default_routes;
 use crate::mix_nodes::http::mix_nodes_make_default_routes;
+use crate::nym_nodes::http::unstable_temp_nymnodes_make_default_routes;
 use crate::overview::http::overview_make_default_routes;
 use crate::ping::http::ping_make_default_routes;
 use crate::service_providers::http::service_providers_make_default_routes;
@@ -58,6 +59,7 @@ fn configure_rocket(state: ExplorerApiStateContext) -> Rocket<Build> {
        "/ping" => ping_make_default_routes(&openapi_settings),
        "/validators" => validators_make_default_routes(&openapi_settings),
        "/service-providers" => service_providers_make_default_routes(&openapi_settings),
+        "/tmp/unstable" => unstable_temp_nymnodes_make_default_routes(&openapi_settings),
    };

    building_rocket
@@ -22,6 +22,7 @@ mod http;
 mod location;
 mod mix_node;
 pub(crate) mod mix_nodes;
+mod nym_nodes;
 mod overview;
 mod ping;
 pub(crate) mod service_providers;
@@ -0,0 +1,26 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::state::ExplorerApiStateContext;
+use nym_explorer_api_requests::PrettyDetailedGatewayBond;
+use okapi::openapi3::OpenApi;
+use rocket::serde::json::Json;
+use rocket::{Route, State};
+use rocket_okapi::settings::OpenApiSettings;
+
+pub fn unstable_temp_nymnodes_make_default_routes(
+    settings: &OpenApiSettings,
+) -> (Vec<Route>, OpenApi) {
+    openapi_get_routes_spec![settings: all_gateways]
+}
+
+#[openapi(tag = "UNSTABLE")]
+#[get("/gateways")]
+pub(crate) async fn all_gateways(
+    state: &State<ExplorerApiStateContext>,
+) -> Json<Vec<PrettyDetailedGatewayBond>> {
+    let mut gateways = state.inner.gateways.get_detailed_gateways().await;
+    gateways.append(&mut state.inner.nymnodes.pretty_gateways().await);
+
+    Json(gateways)
+}
@@ -0,0 +1,8 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_mixnet_contract_common::NodeId;
+
+use crate::location::LocationCache;
+
+pub(crate) type NymNodeLocationCache = LocationCache<NodeId>;
@@ -0,0 +1,10 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::time::Duration;
+
+pub(crate) mod http;
+pub(crate) mod location;
+pub(crate) mod models;
+
+pub(crate) const CACHE_ENTRY_TTL: Duration = Duration::from_secs(1200);
@@ -0,0 +1,154 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::location::{LocationCache, LocationCacheItem};
+use crate::nym_nodes::location::NymNodeLocationCache;
+use crate::nym_nodes::CACHE_ENTRY_TTL;
+use nym_explorer_api_requests::{Location, PrettyDetailedGatewayBond};
+use nym_mixnet_contract_common::{Gateway, NodeId, NymNodeDetails};
+use nym_validator_client::models::NymNodeDescription;
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime};
+use tokio::sync::{RwLock, RwLockReadGuard};
+
+pub(crate) struct NymNodesCache {
+    pub(crate) valid_until: SystemTime,
+    pub(crate) bonded_nym_nodes: HashMap<NodeId, NymNodeDetails>,
+    pub(crate) described_nodes: HashMap<NodeId, NymNodeDescription>,
+}
+
+impl NymNodesCache {
+    fn new() -> Self {
+        NymNodesCache {
+            valid_until: SystemTime::now() - Duration::from_secs(60), // in the past
+            bonded_nym_nodes: Default::default(),
+            described_nodes: Default::default(),
+        }
+    }
+
+    // fn is_valid(&self) -> bool {
+    //     self.valid_until >= SystemTime::now()
+    // }
+}
+
+#[derive(Clone)]
+pub(crate) struct ThreadSafeNymNodesCache {
+    nymnodes: Arc<RwLock<NymNodesCache>>,
+    locations: Arc<RwLock<LocationCache<NodeId>>>,
+}
+
+impl ThreadSafeNymNodesCache {
+    pub(crate) fn new() -> Self {
+        ThreadSafeNymNodesCache {
+            nymnodes: Arc::new(RwLock::new(NymNodesCache::new())),
+            locations: Arc::new(RwLock::new(NymNodeLocationCache::new())),
+        }
+    }
+
+    pub(crate) fn new_with_location_cache(locations: NymNodeLocationCache) -> Self {
+        ThreadSafeNymNodesCache {
+            nymnodes: Arc::new(RwLock::new(NymNodesCache::new())),
+            locations: Arc::new(RwLock::new(locations)),
+        }
+    }
+
+    pub(crate) async fn is_location_valid(&self, node_id: NodeId) -> bool {
+        self.locations
+            .read()
+            .await
+            .get(&node_id)
+            .map_or(false, |cache_item| {
+                cache_item.valid_until > SystemTime::now()
+            })
+    }
+
+    pub(crate) async fn get_bonded_nymnodes(
+        &self,
+    ) -> RwLockReadGuard<HashMap<NodeId, NymNodeDetails>> {
+        let guard = self.nymnodes.read().await;
+        RwLockReadGuard::map(guard, |n| &n.bonded_nym_nodes)
+    }
+
+    pub(crate) async fn get_locations(&self) -> NymNodeLocationCache {
+        self.locations.read().await.clone()
+    }
+
+    pub(crate) async fn set_location(&self, node_id: NodeId, location: Option<Location>) {
+        // cache the location for this mix node so that it can be used when the mix node list is refreshed
+        self.locations
+            .write()
+            .await
+            .insert(node_id, LocationCacheItem::new_from_location(location));
+    }
+
+    pub(crate) async fn update_cache(
+        &self,
+        all_bonds: Vec<NymNodeDetails>,
+        descriptions: Vec<NymNodeDescription>,
+    ) {
+        let mut guard = self.nymnodes.write().await;
+        guard.bonded_nym_nodes = all_bonds
+            .into_iter()
+            .map(|details| (details.node_id(), details))
+            .collect();
+        guard.described_nodes = descriptions
+            .into_iter()
+            .map(|description| (description.node_id, description))
+            .collect();
+
+        guard.valid_until = SystemTime::now() + CACHE_ENTRY_TTL;
+    }
+
+    pub(crate) async fn pretty_gateways(&self) -> Vec<PrettyDetailedGatewayBond> {
+        let nodes_guard = self.nymnodes.read().await;
+        let location_guard = self.locations.read().await;
+
+        let mut pretty_gateways = vec![];
+
+        for (node_id, native_nymnode) in &nodes_guard.bonded_nym_nodes {
+            let Some(description) = nodes_guard.described_nodes.get(node_id) else {
+                continue;
+            };
+
+            if description.description.declared_role.entry {
+                let location = location_guard.get(node_id);
+                let bond = &native_nymnode.bond_information;
+
+                pretty_gateways.push(PrettyDetailedGatewayBond {
+                    pledge_amount: bond.original_pledge.clone(),
+                    owner: bond.owner.clone(),
+                    block_height: bond.bonding_height,
+                    gateway: Gateway {
+                        host: bond.node.host.clone(),
+                        mix_port: description.description.mix_port(),
+                        clients_port: description.description.mixnet_websockets.ws_port,
+                        location: description
+                            .description
+                            .auxiliary_details
+                            .location
+                            .as_ref()
+                            .map(|l| l.to_string())
+                            .unwrap_or_default(),
+                        sphinx_key: description
+                            .description
+                            .host_information
+                            .keys
+                            .x25519
+                            .to_base58_string(),
+                        identity_key: bond.node.identity_key.clone(),
+                        version: description
+                            .description
+                            .build_information
+                            .build_version
+                            .clone(),
+                    },
+                    proxy: None,
+                    location: location.and_then(|l| l.location.clone()),
+                })
+            }
+        }
+
+        pretty_gateways
+    }
+}
@@ -18,6 +18,8 @@ use crate::gateways::models::ThreadsafeGatewayCache;
 use crate::mix_node::models::ThreadsafeMixNodeCache;
 use crate::mix_nodes::location::MixnodeLocationCache;
 use crate::mix_nodes::models::ThreadsafeMixNodesCache;
+use crate::nym_nodes::location::NymNodeLocationCache;
+use crate::nym_nodes::models::ThreadSafeNymNodesCache;
 use crate::ping::models::ThreadsafePingCache;
 use crate::validators::models::ThreadsafeValidatorCache;

@@ -30,6 +32,7 @@ pub struct ExplorerApiState {
    pub(crate) gateways: ThreadsafeGatewayCache,
    pub(crate) mixnode: ThreadsafeMixNodeCache,
    pub(crate) mixnodes: ThreadsafeMixNodesCache,
+    pub(crate) nymnodes: ThreadSafeNymNodesCache,
    pub(crate) ping: ThreadsafePingCache,
    pub(crate) validators: ThreadsafeValidatorCache,
    pub(crate) geo_ip: ThreadsafeGeoIp,
@@ -49,6 +52,7 @@ pub struct ExplorerApiStateOnDisk {
    pub(crate) country_node_distribution: CountryNodesDistribution,
    pub(crate) mixnode_location_cache: MixnodeLocationCache,
    pub(crate) gateway_location_cache: GatewayLocationCache,
+    pub(crate) nymnode_location_cache: NymNodeLocationCache,
    pub(crate) as_at: DateTime<Utc>,
 }

@@ -85,6 +89,9 @@ impl ExplorerApiStateContext {
                mixnodes: ThreadsafeMixNodesCache::new_with_location_cache(
                    state.mixnode_location_cache,
                ),
+                nymnodes: ThreadSafeNymNodesCache::new_with_location_cache(
+                    state.nymnode_location_cache,
+                ),
                ping: ThreadsafePingCache::new(),
                validators: ThreadsafeValidatorCache::new(),
                validator_client: ThreadsafeValidatorClient::new(),
@@ -101,6 +108,7 @@ impl ExplorerApiStateContext {
                gateways: ThreadsafeGatewayCache::new(),
                mixnode: ThreadsafeMixNodeCache::new(),
                mixnodes: ThreadsafeMixNodesCache::new(),
+                nymnodes: ThreadSafeNymNodesCache::new(),
                ping: ThreadsafePingCache::new(),
                validators: ThreadsafeValidatorCache::new(),
                validator_client: ThreadsafeValidatorClient::new(),
@@ -117,6 +125,7 @@ impl ExplorerApiStateContext {
            country_node_distribution: self.inner.country_node_distribution.get_all().await,
            mixnode_location_cache: self.inner.mixnodes.get_locations().await,
            gateway_location_cache: self.inner.gateways.get_locations().await,
+            nymnode_location_cache: self.inner.nymnodes.get_locations().await,
            as_at: Utc::now(),
        };
        serde_json::to_writer(file, &state).expect("error writing state to disk");
@@ -1,16 +1,16 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_mixnet_contract_common::GatewayBond;
+use crate::mix_nodes::CACHE_REFRESH_RATE;
+use crate::state::ExplorerApiStateContext;
+use nym_mixnet_contract_common::{GatewayBond, NymNodeDetails};
 use nym_task::TaskClient;
-use nym_validator_client::models::MixNodeBondAnnotated;
+use nym_validator_client::models::{MixNodeBondAnnotated, NymNodeDescription};
 use nym_validator_client::nyxd::error::NyxdError;
 use nym_validator_client::nyxd::{Paging, TendermintRpcClient, ValidatorResponse};
 use nym_validator_client::{QueryHttpRpcValidatorClient, ValidatorClientError};
 use std::future::Future;
-
-use crate::mix_nodes::CACHE_REFRESH_RATE;
-use crate::state::ExplorerApiStateContext;
+use tokio::time::MissedTickBehavior;

 pub(crate) struct ExplorerApiTasks {
    state: ExplorerApiStateContext,
@@ -39,6 +39,28 @@ impl ExplorerApiTasks {
        bonds
    }

+    async fn retrieve_bonded_nymnodes(&self) -> Result<Vec<NymNodeDetails>, ValidatorClientError> {
+        info!("About to retrieve all nymnode bonds...");
+        self.state
+            .inner
+            .validator_client
+            .0
+            .get_all_cached_bonded_nym_nodes()
+            .await
+    }
+
+    async fn retrieve_node_descriptions(
+        &self,
+    ) -> Result<Vec<NymNodeDescription>, ValidatorClientError> {
+        info!("About to retrieve node descriptions...");
+        self.state
+            .inner
+            .validator_client
+            .0
+            .get_all_cached_described_nodes()
+            .await
+    }
+
    async fn retrieve_all_mixnodes(&self) -> Vec<MixNodeBondAnnotated> {
        info!("About to retrieve all mixnode bonds...");
        self.retrieve_mixnodes(
@@ -130,10 +152,33 @@ impl ExplorerApiTasks {
        }
    }

+    async fn update_nymnodes_cache(&self) {
+        let nym_node_bonds = self.retrieve_bonded_nymnodes().await.unwrap_or_else(|err| {
+            error!("failed to retrieve nym node bonds: {err}");
+            Vec::new()
+        });
+
+        let all_descriptions = self
+            .retrieve_node_descriptions()
+            .await
+            .unwrap_or_else(|err| {
+                error!("failed to retrieve node descriptions: {err}");
+                Vec::new()
+            });
+
+        self.state
+            .inner
+            .nymnodes
+            .update_cache(nym_node_bonds, all_descriptions)
+            .await
+    }
+
    pub(crate) fn start(mut self) {
        info!("Spawning mix nodes task runner...");
        tokio::spawn(async move {
            let mut interval_timer = tokio::time::interval(CACHE_REFRESH_RATE);
+            interval_timer.set_missed_tick_behavior(MissedTickBehavior::Skip);
+
            while !self.shutdown.is_shutdown() {
                tokio::select! {
                    _ = interval_timer.tick() => {
@@ -147,6 +192,10 @@ impl ExplorerApiTasks {

                        info!("Updating mix node cache...");
                        self.update_mixnode_cache().await;
+
+                        info!("Updating nymnode cache...");
+                        self.update_nymnodes_cache().await;
+                        info!("Done");
                    }
                    _ = self.shutdown.recv() => {
                        trace!("Listener: Received shutdown");
@@ -69,6 +69,7 @@ nym-credentials-interface = { path = "../common/credentials-interface" }
 nym-credential-verification = { path = "../common/credential-verification" }
 nym-crypto = { path = "../common/crypto" }
 nym-gateway-storage = { path = "../common/gateway-storage" }
+nym-gateway-stats-storage = { path = "../common/gateway-stats-storage" }
 nym-gateway-requests = { path = "../common/gateway-requests" }
 nym-mixnet-client = { path = "../common/client-libs/mixnet-client" }
 nym-mixnode-common = { path = "../common/mixnode-common" }
@@ -76,9 +77,11 @@ nym-network-defaults = { path = "../common/network-defaults" }
 nym-network-requester = { path = "../service-providers/network-requester" }
 nym-node-http-api = { path = "../nym-node/nym-node-http-api" }
 nym-pemstore = { path = "../common/pemstore" }
+nym-sdk = { path = "../sdk/rust/nym-sdk" }
 nym-sphinx = { path = "../common/nymsphinx" }
 nym-statistics-common = { path = "../common/statistics" }
 nym-task = { path = "../common/task" }
+nym-topology = { path = "../common/topology" }
 nym-types = { path = "../common/types" }
 nym-validator-client = { path = "../common/client-libs/validator-client" }
 nym-ip-packet-router = { path = "../service-providers/ip-packet-router" }
@@ -12,6 +12,7 @@ pub const DEFAULT_PRIVATE_SPHINX_KEY_FILENAME: &str = "private_sphinx.pem";
 pub const DEFAULT_PUBLIC_SPHINX_KEY_FILENAME: &str = "public_sphinx.pem";

 pub const DEFAULT_CLIENTS_STORAGE_FILENAME: &str = "db.sqlite";
+pub const DEFAULT_STATS_STORAGE_FILENAME: &str = "stats.sqlite";

 pub const DEFAULT_NETWORK_REQUESTER_CONFIG_FILENAME: &str = "network_requester_config.toml";
 pub const DEFAULT_NETWORK_REQUESTER_DATA_DIR: &str = "network-requester-data";
@@ -39,6 +40,9 @@ pub struct GatewayPaths {
    #[serde(alias = "persistent_storage")]
    pub clients_storage: PathBuf,

+    /// Path to sqlite database containing all persistent stats data.
+    pub stats_storage: PathBuf,
+
    /// Path to the configuration of the embedded network requester.
    #[serde(deserialize_with = "de_maybe_stringified")]
    pub network_requester_config: Option<PathBuf>,
@@ -54,7 +58,9 @@ impl GatewayPaths {
    pub fn new_default<P: AsRef<Path>>(id: P) -> Self {
        GatewayPaths {
            keys: KeysPaths::new_default(id.as_ref()),
-            clients_storage: default_data_directory(id).join(DEFAULT_CLIENTS_STORAGE_FILENAME),
+            clients_storage: default_data_directory(id.as_ref())
+                .join(DEFAULT_CLIENTS_STORAGE_FILENAME),
+            stats_storage: default_data_directory(id).join(DEFAULT_STATS_STORAGE_FILENAME),
            // node_description: default_config_filepath(id).join(DEFAULT_DESCRIPTION_FILENAME),
            network_requester_config: None,
            ip_packet_router_config: None,
@@ -70,6 +76,7 @@ impl GatewayPaths {
                public_sphinx_key_file: Default::default(),
            },
            clients_storage: Default::default(),
+            stats_storage: Default::default(),
            network_requester_config: None,
            ip_packet_router_config: None,
        }
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-only

 use nym_authenticator::error::AuthenticatorError;
+use nym_gateway_stats_storage::error::StatsStorageError;
 use nym_gateway_storage::error::StorageError;
 use nym_ip_packet_router::error::IpPacketRouterError;
 use nym_network_requester::error::{ClientCoreError, NetworkRequesterError};
@@ -115,6 +116,12 @@ pub enum GatewayError {
        source: StorageError,
    },

+    #[error("stats storage failure: {source}")]
+    StatsStorageError {
+        #[from]
+        source: StatsStorageError,
+    },
+
    #[error("Path to network requester configuration file hasn't been specified. Perhaps try to run `setup-network-requester`?")]
    UnspecifiedNetworkRequesterConfig,

@@ -73,6 +73,9 @@ pub(crate) enum InitialAuthenticationError {
    #[error("Only 'Register' or 'Authenticate' requests are allowed")]
    InvalidRequest,

+    #[error("received a Message of type {typ} which was not expected in this context")]
+    UnexpectedMessageType { typ: String },
+
    #[error("Experienced connection error: {0}")]
    ConnectionError(#[from] WsError),

@@ -861,9 +864,27 @@ where
            Message::Binary(_) => {
                return Err(InitialAuthenticationError::BinaryRequestWithoutAuthentication);
            }
-            _ => unreachable!(
-                "the underlying tunsgenite stream should be handling other message types"
-            ),
+            other => {
+                if other.is_ping() {
+                    debug!("unexpected ping message!");
+                    return Err(InitialAuthenticationError::UnexpectedMessageType {
+                        typ: "ping".to_string(),
+                    });
+                } else if other.is_pong() {
+                    debug!("unexpected pong message!");
+                    return Err(InitialAuthenticationError::UnexpectedMessageType {
+                        typ: "pong".to_string(),
+                    });
+                } else if other.is_close() {
+                    debug!("unexpected close message!");
+                    return Err(InitialAuthenticationError::UnexpectedMessageType {
+                        typ: "close".to_string(),
+                    });
+                }
+
+                // at this point this is definitely unreachable, but just in case, let's not panic...
+                return Err(InitialAuthenticationError::InvalidRequest);
+            }
        };

        text.parse()
@@ -3,13 +3,19 @@

 use crate::config::Config;
 use crate::error::GatewayError;
-
+use async_trait::async_trait;
 use nym_crypto::asymmetric::encryption;
+use nym_gateway_stats_storage::PersistentStatsStorage;
 use nym_gateway_storage::PersistentStorage;
 use nym_pemstore::traits::PemStorableKeyPair;
 use nym_pemstore::KeyPairPath;
-
+use nym_sdk::{NymApiTopologyProvider, NymApiTopologyProviderConfig, UserAgent};
+use nym_topology::{gateway, NymTopology, TopologyProvider};
 use std::path::Path;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use tracing::debug;
+use url::Url;

 pub async fn load_network_requester_config<P: AsRef<Path>>(
    id: &str,
@@ -74,6 +80,14 @@ pub(crate) async fn initialise_main_storage(
    Ok(PersistentStorage::init(path, retrieval_limit).await?)
 }

+pub(crate) async fn initialise_stats_storage(
+    config: &Config,
+) -> Result<PersistentStatsStorage, GatewayError> {
+    let path = &config.storage_paths.stats_storage;
+
+    Ok(PersistentStatsStorage::init(path).await?)
+}
+
 pub fn load_keypair<T: PemStorableKeyPair>(
    paths: KeyPairPath,
    name: impl Into<String>,
@@ -93,3 +107,56 @@ pub(crate) fn load_sphinx_keys(config: &Config) -> Result<encryption::KeyPair, G
    );
    load_keypair(sphinx_paths, "gateway sphinx")
 }
+
+#[derive(Clone)]
+pub struct GatewayTopologyProvider {
+    inner: Arc<Mutex<GatewayTopologyProviderInner>>,
+}
+
+impl GatewayTopologyProvider {
+    pub fn new(
+        gateway_node: gateway::LegacyNode,
+        user_agent: UserAgent,
+        nym_api_url: Vec<Url>,
+    ) -> GatewayTopologyProvider {
+        GatewayTopologyProvider {
+            inner: Arc::new(Mutex::new(GatewayTopologyProviderInner {
+                inner: NymApiTopologyProvider::new(
+                    NymApiTopologyProviderConfig {
+                        min_mixnode_performance: 50,
+                        min_gateway_performance: 0,
+                    },
+                    nym_api_url,
+                    env!("CARGO_PKG_VERSION").to_string(),
+                    Some(user_agent),
+                ),
+                gateway_node,
+            })),
+        }
+    }
+}
+
+struct GatewayTopologyProviderInner {
+    inner: NymApiTopologyProvider,
+    gateway_node: gateway::LegacyNode,
+}
+
+#[async_trait]
+impl TopologyProvider for GatewayTopologyProvider {
+    async fn get_new_topology(&mut self) -> Option<NymTopology> {
+        let mut guard = self.inner.lock().await;
+        match guard.inner.get_new_topology().await {
+            None => None,
+            Some(mut base) => {
+                if !base.gateway_exists(&guard.gateway_node.identity_key) {
+                    debug!(
+                        "{} didn't exist in topology. inserting it.",
+                        guard.gateway_node.identity_key
+                    );
+                    base.insert_gateway(guard.gateway_node.clone());
+                }
+                Some(base)
+            }
+        }
+    }
+}
@@ -12,9 +12,13 @@ use crate::http::HttpApiBuilder;
 use crate::node::client_handling::active_clients::ActiveClientsStore;
 use crate::node::client_handling::embedded_clients::{LocalEmbeddedClientHandle, MessageRouter};
 use crate::node::client_handling::websocket;
-use crate::node::helpers::{initialise_main_storage, load_network_requester_config};
+use crate::node::helpers::{
+    initialise_main_storage, initialise_stats_storage, load_network_requester_config,
+    GatewayTopologyProvider,
+};
 use crate::node::mixnet_handling::receiver::connection_handler::ConnectionHandler;
 use futures::channel::{mpsc, oneshot};
+use nym_bin_common::bin_info;
 use nym_credential_verification::ecash::{
    credential_sender::CredentialHandlerConfig, EcashManager,
 };
@@ -25,13 +29,15 @@ use nym_network_requester::{LocalGateway, NRServiceProviderBuilder, RequestFilte
 use nym_node_http_api::state::metrics::SharedSessionStats;
 use nym_statistics_common::events::{self, StatsEventSender};
 use nym_task::{TaskClient, TaskHandle, TaskManager};
+use nym_topology::NetworkAddress;
 use nym_types::gateway::GatewayNodeDetailsResponse;
+use nym_validator_client::client::NodeId;
 use nym_validator_client::nyxd::{Coin, CosmWasmClient};
 use nym_validator_client::{nyxd, DirectSigningHttpRpcNyxdClient};
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use statistics::GatewayStatisticsCollector;
-use std::net::SocketAddr;
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 use std::path::PathBuf;
 use std::sync::Arc;
 use tracing::*;
@@ -41,6 +47,7 @@ pub(crate) mod helpers;
 pub(crate) mod mixnet_handling;
 pub(crate) mod statistics;

+pub use nym_gateway_stats_storage::PersistentStatsStorage;
 pub use nym_gateway_storage::{PersistentStorage, Storage};

 // TODO: should this struct live here?
@@ -96,6 +103,8 @@ pub async fn create_gateway(

    let storage = initialise_main_storage(&config).await?;

+    let stats_storage = initialise_stats_storage(&config).await?;
+
    let nr_opts = network_requester_config.map(|config| LocalNetworkRequesterOpts {
        config: config.clone(),
        custom_mixnet_path: custom_mixnet.clone(),
@@ -106,7 +115,7 @@ pub async fn create_gateway(
        custom_mixnet_path: custom_mixnet.clone(),
    });

-    Gateway::new(config, nr_opts, ip_opts, storage)
+    Gateway::new(config, nr_opts, ip_opts, storage, stats_storage)
 }

 #[derive(Debug, Clone)]
@@ -147,7 +156,9 @@ pub struct Gateway<St = PersistentStorage> {
    /// x25519 keypair used for Diffie-Hellman. Currently only used for sphinx key derivation.
    sphinx_keypair: Arc<encryption::KeyPair>,

-    storage: St,
+    client_storage: St,
+
+    stats_storage: PersistentStatsStorage,

    wireguard_data: Option<nym_wireguard::WireguardData>,

@@ -163,10 +174,12 @@ impl<St> Gateway<St> {
        config: Config,
        network_requester_opts: Option<LocalNetworkRequesterOpts>,
        ip_packet_router_opts: Option<LocalIpPacketRouterOpts>,
-        storage: St,
+        client_storage: St,
+        stats_storage: PersistentStatsStorage,
    ) -> Result<Self, GatewayError> {
        Ok(Gateway {
-            storage,
+            client_storage,
+            stats_storage,
            identity_keypair: Arc::new(load_identity_keys(&config)?),
            sphinx_keypair: Arc::new(helpers::load_sphinx_keys(&config)?),
            config,
@@ -179,7 +192,7 @@ impl<St> Gateway<St> {
            task_client: None,
        })
    }
-
+    #[allow(clippy::too_many_arguments)]
    pub fn new_loaded(
        config: Config,
        network_requester_opts: Option<LocalNetworkRequesterOpts>,
@@ -187,7 +200,8 @@ impl<St> Gateway<St> {
        authenticator_opts: Option<LocalAuthenticatorOpts>,
        identity_keypair: Arc<identity::KeyPair>,
        sphinx_keypair: Arc<encryption::KeyPair>,
-        storage: St,
+        client_storage: St,
+        stats_storage: PersistentStatsStorage,
    ) -> Self {
        Gateway {
            config,
@@ -196,7 +210,8 @@ impl<St> Gateway<St> {
            authenticator_opts,
            identity_keypair,
            sphinx_keypair,
-            storage,
+            client_storage,
+            stats_storage,
            wireguard_data: None,
            session_stats: None,
            run_http_server: true,
@@ -225,6 +240,39 @@ impl<St> Gateway<St> {
        crate::helpers::node_details(&self.config).await
    }

+    fn gateway_topology_provider(&self) -> GatewayTopologyProvider {
+        GatewayTopologyProvider::new(
+            self.as_topology_node(),
+            bin_info!().into(),
+            self.config.gateway.nym_api_urls.clone(),
+        )
+    }
+
+    fn as_topology_node(&self) -> nym_topology::gateway::LegacyNode {
+        let ip = self
+            .config
+            .host
+            .public_ips
+            .first()
+            .copied()
+            .unwrap_or(IpAddr::V4(Ipv4Addr::LOCALHOST));
+        let mix_host = SocketAddr::new(ip, self.config.gateway.mix_port);
+
+        nym_topology::gateway::LegacyNode {
+            // those fields are irrelevant for the purposes of routing so it's fine if they're inaccurate.
+            // the only thing that matters is the identity key (and maybe version)
+            node_id: NodeId::MAX,
+            mix_host,
+            host: NetworkAddress::IpAddr(ip),
+            clients_ws_port: self.config.gateway.clients_port,
+            clients_wss_port: self.config.gateway.clients_wss_port,
+            sphinx_key: *self.sphinx_keypair.public_key(),
+
+            identity_key: *self.identity_keypair.public_key(),
+            version: env!("CARGO_PKG_VERSION").into(),
+        }
+    }
+
    fn start_mix_socket_listener(
        &self,
        ack_sender: MixForwardingSender,
@@ -240,7 +288,7 @@ impl<St> Gateway<St> {

        let connection_handler = ConnectionHandler::new(
            packet_processor,
-            self.storage.clone(),
+            self.client_storage.clone(),
            ack_sender,
            active_clients_store,
        );
@@ -257,6 +305,7 @@ impl<St> Gateway<St> {
    async fn start_authenticator(
        &mut self,
        forwarding_channel: MixForwardingSender,
+        topology_provider: GatewayTopologyProvider,
        shutdown: TaskClient,
        ecash_verifier: Arc<EcashManager<St>>,
    ) -> Result<StartedAuthenticator, Box<dyn std::error::Error + Send + Sync>>
@@ -275,7 +324,7 @@ impl<St> Gateway<St> {
            forwarding_channel,
            router_tx,
        );
-        let all_peers = self.storage.get_all_wireguard_peers().await?;
+        let all_peers = self.client_storage.get_all_wireguard_peers().await?;
        let used_private_network_ips = all_peers
            .iter()
            .cloned()
@@ -304,6 +353,7 @@ impl<St> Gateway<St> {
            .with_shutdown(shutdown.fork("authenticator"))
            .with_wait_for_gateway(true)
            .with_minimum_gateway_performance(0)
+            .with_custom_topology_provider(Box::new(topology_provider))
            .with_on_start(on_start_tx);

            if let Some(custom_mixnet) = &opts.custom_mixnet_path {
@@ -330,7 +380,7 @@ impl<St> Gateway<St> {
                .start_with_shutdown(router_shutdown);

            let wg_api = nym_wireguard::start_wireguard(
-                self.storage.clone(),
+                self.client_storage.clone(),
                all_peers,
                shutdown,
                wireguard_data,
@@ -352,6 +402,7 @@ impl<St> Gateway<St> {
    async fn start_authenticator(
        &self,
        _forwarding_channel: MixForwardingSender,
+        _topology_provider: GatewayTopologyProvider,
        _shutdown: TaskClient,
        _ecash_verifier: Arc<EcashManager<St>>,
    ) -> Result<StartedAuthenticator, Box<dyn std::error::Error + Send + Sync>> {
@@ -377,7 +428,7 @@ impl<St> Gateway<St> {

        let shared_state = websocket::CommonHandlerState {
            ecash_verifier,
-            storage: self.storage.clone(),
+            storage: self.client_storage.clone(),
            local_identity: Arc::clone(&self.identity_keypair),
            only_coconut_credentials: self.config.gateway.only_coconut_credentials,
            bandwidth_cfg: (&self.config).into(),
@@ -415,7 +466,7 @@ impl<St> Gateway<St> {
        info!("Starting gateway stats collector...");

        let (mut stats_collector, stats_event_sender) =
-            GatewayStatisticsCollector::new(shared_session_stats);
+            GatewayStatisticsCollector::new(shared_session_stats, self.stats_storage.clone());
        tokio::spawn(async move { stats_collector.run(shutdown).await });
        stats_event_sender
    }
@@ -424,6 +475,7 @@ impl<St> Gateway<St> {
    async fn start_network_requester(
        &self,
        forwarding_channel: MixForwardingSender,
+        topology_provider: GatewayTopologyProvider,
        shutdown: TaskClient,
    ) -> Result<StartedNetworkRequester, GatewayError> {
        info!("Starting network requester...");
@@ -451,6 +503,7 @@ impl<St> Gateway<St> {
            .with_custom_gateway_transceiver(Box::new(transceiver))
            .with_wait_for_gateway(true)
            .with_minimum_gateway_performance(0)
+            .with_custom_topology_provider(Box::new(topology_provider))
            .with_on_start(on_start_tx);

        if let Some(custom_mixnet) = &nr_opts.custom_mixnet_path {
@@ -488,6 +541,7 @@ impl<St> Gateway<St> {
    async fn start_ip_packet_router(
        &self,
        forwarding_channel: MixForwardingSender,
+        topology_provider: GatewayTopologyProvider,
        shutdown: TaskClient,
    ) -> Result<LocalEmbeddedClientHandle, GatewayError> {
        info!("Starting IP packet provider...");
@@ -516,6 +570,7 @@ impl<St> Gateway<St> {
                .with_custom_gateway_transceiver(Box::new(transceiver))
                .with_wait_for_gateway(true)
                .with_minimum_gateway_performance(0)
+                .with_custom_topology_provider(Box::new(topology_provider))
                .with_on_start(on_start_tx);

        if let Some(custom_mixnet) = &ip_opts.custom_mixnet_path {
@@ -632,6 +687,8 @@ impl<St> Gateway<St> {
            shutdown.fork("statistics::GatewayStatisticsCollector"),
        );

+        let topology_provider = self.gateway_topology_provider();
+
        let handler_config = CredentialHandlerConfig {
            revocation_bandwidth_penalty: self
                .config
@@ -654,7 +711,7 @@ impl<St> Gateway<St> {
                nyxd_client,
                self.identity_keypair.public_key().to_bytes(),
                shutdown.fork("EcashVerifier"),
-                self.storage.clone(),
+                self.client_storage.clone(),
            )
            .await?,
        );
@@ -680,6 +737,7 @@ impl<St> Gateway<St> {
            let embedded_nr = self
                .start_network_requester(
                    mix_forwarding_channel.clone(),
+                    topology_provider.clone(),
                    shutdown.fork("NetworkRequester"),
                )
                .await?;
@@ -695,6 +753,7 @@ impl<St> Gateway<St> {
            let embedded_ip_sp = self
                .start_ip_packet_router(
                    mix_forwarding_channel.clone(),
+                    topology_provider.clone(),
                    shutdown.fork("ip_service_provider"),
                )
                .await?;
@@ -707,6 +766,7 @@ impl<St> Gateway<St> {
            let embedded_auth = self
                .start_authenticator(
                    mix_forwarding_channel,
+                    topology_provider,
                    shutdown.fork("authenticator"),
                    ecash_verifier,
                )
@@ -2,13 +2,14 @@
 // SPDX-License-Identifier: GPL-3.0-only

 use futures::{channel::mpsc, StreamExt};
+use nym_gateway_stats_storage::PersistentStatsStorage;
 use nym_node_http_api::state::metrics::SharedSessionStats;
 use nym_statistics_common::events::{StatsEvent, StatsEventReceiver, StatsEventSender};
 use nym_task::TaskClient;
 use sessions::SessionStatsHandler;
 use std::time::Duration;
 use time::OffsetDateTime;
-use tracing::trace;
+use tracing::{error, trace, warn};

 pub mod sessions;

@@ -23,21 +24,38 @@ pub(crate) struct GatewayStatisticsCollector {
 impl GatewayStatisticsCollector {
    pub fn new(
        shared_session_stats: SharedSessionStats,
+        stats_storage: PersistentStatsStorage,
    ) -> (GatewayStatisticsCollector, StatsEventSender) {
        let (stats_event_tx, stats_event_rx) = mpsc::unbounded();
+
+        let session_stats = SessionStatsHandler::new(shared_session_stats, stats_storage);
        let collector = GatewayStatisticsCollector {
            stats_event_rx,
-            session_stats: SessionStatsHandler::new(shared_session_stats),
+            session_stats,
        };
        (collector, stats_event_tx)
    }

    async fn update_shared_state(&mut self, update_time: OffsetDateTime) {
-        self.session_stats.update_shared_state(update_time).await;
+        if let Err(e) = self
+            .session_stats
+            .maybe_update_shared_state(update_time)
+            .await
+        {
+            error!("Failed to update session stats - {e}");
+        }
        //here goes additionnal stats handler update
    }

+    async fn on_start(&mut self) {
+        if let Err(e) = self.session_stats.on_start().await {
+            error!("Failed to cleanup session stats handler - {e}");
+        }
+        //here goes additionnal stats handler start cleanup
+    }
+
    pub async fn run(&mut self, mut shutdown: TaskClient) {
+        self.on_start().await;
        let mut update_interval = tokio::time::interval(STATISTICS_UPDATE_TIMER_INTERVAL);
        while !shutdown.is_shutdown() {
            tokio::select! {
@@ -53,7 +71,10 @@ impl GatewayStatisticsCollector {
                Some(stat_event) = self.stats_event_rx.next() => {
                    //dispatching event to proper handler
                    match stat_event {
-                        StatsEvent::SessionStatsEvent(event) => self.session_stats.handle_event(event),
+                        StatsEvent::SessionStatsEvent(event) => {
+                            if let Err(e) = self.session_stats.handle_event(event).await{
+                            warn!("Session event handling error - {e}");
+                        }},
                    }
                },

@@ -2,176 +2,158 @@
 // SPDX-License-Identifier: GPL-3.0-only

 use nym_credentials_interface::TicketType;
+use nym_gateway_stats_storage::models::FinishedSession;
+use nym_gateway_stats_storage::PersistentStatsStorage;
+use nym_gateway_stats_storage::{error::StatsStorageError, models::ActiveSession};
 use nym_node_http_api::state::metrics::SharedSessionStats;
 use nym_sphinx::DestinationAddressBytes;
-use std::collections::{HashMap, HashSet};
 use time::{Date, Duration, OffsetDateTime};

 use nym_statistics_common::events::SessionEvent;

-const FINISHED_SESSIONS_CAP: usize = 1_000_000; //to be on the safe side of memory blowups until persistent storage
-
-#[derive(PartialEq)]
-enum SessionType {
-    Vpn,
-    Mixnet,
-    Unknown,
-}
-
-impl SessionType {
-    fn to_string(&self) -> &str {
-        match self {
-            Self::Vpn => "vpn",
-            Self::Mixnet => "mixnet",
-            Self::Unknown => "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,
-        }
-    }
-}
-
-struct FinishedSession {
-    duration: Duration,
-    typ: SessionType,
-}
-
-impl FinishedSession {
-    fn serialize(&self) -> (u64, String) {
-        (
-            self.duration.whole_milliseconds() as u64, //we are sure that it fits in a u64, see `fn end_at`
-            self.typ.to_string().into(),
-        )
-    }
-}
-
-struct ActiveSession {
-    start: OffsetDateTime,
-    typ: SessionType,
-}
-
-impl ActiveSession {
-    fn new(start_time: OffsetDateTime) -> Self {
-        ActiveSession {
-            start: start_time,
-            typ: SessionType::Unknown,
-        }
-    }
-
-    fn set_type(&mut self, ticket_type: TicketType) {
-        self.typ = ticket_type.into();
-    }
-
-    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
-        }
-    }
-}
-
 pub(crate) struct SessionStatsHandler {
-    last_update_day: Date,
+    storage: PersistentStatsStorage,
+    current_day: Date,

    shared_session_stats: SharedSessionStats,
-    active_sessions: HashMap<DestinationAddressBytes, ActiveSession>,
-    unique_users: HashSet<DestinationAddressBytes>,
-    sessions_started: u32,
-    finished_sessions: Vec<FinishedSession>,
 }

 impl SessionStatsHandler {
-    pub fn new(shared_session_stats: SharedSessionStats) -> Self {
+    pub fn new(shared_session_stats: SharedSessionStats, storage: PersistentStatsStorage) -> Self {
        SessionStatsHandler {
-            last_update_day: OffsetDateTime::now_utc().date(),
+            storage,
+            current_day: OffsetDateTime::now_utc().date(),
            shared_session_stats,
-            active_sessions: Default::default(),
-            unique_users: Default::default(),
-            sessions_started: 0,
-            finished_sessions: Default::default(),
        }
    }

-    pub(crate) fn handle_event(&mut self, event: SessionEvent) {
+    pub(crate) async fn handle_event(
+        &mut self,
+        event: SessionEvent,
+    ) -> Result<(), StatsStorageError> {
        match event {
            SessionEvent::SessionStart { start_time, client } => {
-                self.handle_session_start(start_time, client);
+                self.handle_session_start(start_time, client).await
            }
+
            SessionEvent::SessionStop { stop_time, client } => {
-                self.handle_session_stop(stop_time, client);
+                self.handle_session_stop(stop_time, client).await
            }
+
            SessionEvent::EcashTicket {
                ticket_type,
                client,
-            } => self.handle_ecash_ticket(ticket_type, client),
+            } => self.handle_ecash_ticket(ticket_type, client).await,
        }
    }
-    fn handle_session_start(
+    async fn handle_session_start(
        &mut self,
        start_time: OffsetDateTime,
        client: DestinationAddressBytes,
-    ) {
-        self.sessions_started += 1;
-        self.unique_users.insert(client);
-        self.active_sessions
-            .insert(client, ActiveSession::new(start_time));
-    }
-    fn handle_session_stop(&mut self, stop_time: OffsetDateTime, client: DestinationAddressBytes) {
-        if let Some(session) = self.active_sessions.remove(&client) {
-            if let Some(finished_session) = session.end_at(stop_time) {
-                if self.finished_sessions.len() < FINISHED_SESSIONS_CAP {
-                    self.finished_sessions.push(finished_session);
-                }
-            }
-        }
+    ) -> Result<(), StatsStorageError> {
+        self.storage
+            .insert_unique_user(self.current_day, client.as_base58_string())
+            .await?;
+        self.storage
+            .insert_active_session(client, ActiveSession::new(start_time))
+            .await?;
+        Ok(())
    }

-    fn handle_ecash_ticket(&mut self, ticket_type: TicketType, client: DestinationAddressBytes) {
-        if let Some(active_session) = self.active_sessions.get_mut(&client) {
-            if active_session.typ == SessionType::Unknown {
-                active_session.set_type(ticket_type);
+    async fn handle_session_stop(
+        &mut self,
+        stop_time: OffsetDateTime,
+        client: DestinationAddressBytes,
+    ) -> Result<(), StatsStorageError> {
+        if let Some(session) = self.storage.get_active_session(client).await? {
+            if let Some(finished_session) = session.end_at(stop_time) {
+                self.storage
+                    .insert_finished_session(self.current_day, finished_session)
+                    .await?;
+                self.storage.delete_active_session(client).await?;
            }
        }
+        Ok(())
+    }
+
+    async fn handle_ecash_ticket(
+        &mut self,
+        ticket_type: TicketType,
+        client: DestinationAddressBytes,
+    ) -> Result<(), StatsStorageError> {
+        self.storage
+            .update_active_session_type(client, ticket_type.into())
+            .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn on_start(&mut self) -> Result<(), StatsStorageError> {
+        let yesterday = OffsetDateTime::now_utc().date() - Duration::DAY;
+        //publish yesterday's data if any
+        self.publish_stats(yesterday).await?;
+        //store "active" sessions as duration 0
+        for active_session in self.storage.get_all_active_sessions().await? {
+            self.storage
+                .insert_finished_session(
+                    self.current_day,
+                    FinishedSession {
+                        duration: Duration::ZERO,
+                        typ: active_session.typ,
+                    },
+                )
+                .await?
+        }
+        //cleanup active sessions
+        self.storage.cleanup_active_sessions().await?;
+
+        //delete old entries
+        self.delete_old_stats(yesterday - Duration::DAY).await?;
+        Ok(())
    }

    //update shared state once a day has passed, with data from the previous day
-    pub(crate) async fn update_shared_state(&mut self, update_time: OffsetDateTime) {
-        let update_date = update_time.date();
-        if update_date != self.last_update_day {
-            {
-                let mut shared_state = self.shared_session_stats.write().await;
-                shared_state.update_time = self.last_update_day;
-                shared_state.unique_active_users = self.unique_users.len() as u32;
-                shared_state.session_started = self.sessions_started;
-                shared_state.sessions = self
-                    .finished_sessions
-                    .iter()
-                    .map(|s| s.serialize())
-                    .collect();
-            }
-            self.reset_stats(update_date);
+    async fn publish_stats(&mut self, stats_date: Date) -> Result<(), StatsStorageError> {
+        let finished_sessions = self.storage.get_finished_sessions(stats_date).await?;
+        let user_count = self.storage.get_unique_users_count(stats_date).await?;
+        let session_started = self.storage.get_started_sessions_count(stats_date).await? as u32;
+        {
+            let mut shared_state = self.shared_session_stats.write().await;
+            shared_state.update_time = stats_date;
+            shared_state.unique_active_users = user_count as u32;
+            shared_state.session_started = session_started;
+            shared_state.sessions = finished_sessions.iter().map(|s| s.serialize()).collect();
        }
+
+        Ok(())
+    }
+    pub(crate) async fn maybe_update_shared_state(
+        &mut self,
+        update_time: OffsetDateTime,
+    ) -> Result<(), StatsStorageError> {
+        let update_date = update_time.date();
+        if update_date != self.current_day {
+            self.publish_stats(self.current_day).await?;
+            self.delete_old_stats(self.current_day - Duration::DAY)
+                .await?;
+            self.reset_stats(update_date).await?;
+            self.current_day = update_date;
+        }
+        Ok(())
    }

-    fn reset_stats(&mut self, reset_day: Date) {
-        self.last_update_day = reset_day;
-        self.unique_users = self.active_sessions.keys().copied().collect();
-        self.finished_sessions = Default::default();
-        self.sessions_started = 0;
+    async fn reset_stats(&mut self, reset_day: Date) -> Result<(), StatsStorageError> {
+        //active users reset
+        let new_active_users = self.storage.get_active_users().await?;
+        for user in new_active_users {
+            self.storage.insert_unique_user(reset_day, user).await?;
+        }
+
+        Ok(())
+    }
+
+    async fn delete_old_stats(&mut self, delete_before: Date) -> Result<(), StatsStorageError> {
+        self.storage.delete_finished_sessions(delete_before).await?;
+        self.storage.delete_unique_users(delete_before).await?;
+        Ok(())
    }
 }
@@ -0,0 +1,7 @@
+FROM rust:latest AS builder
+
+COPY ./ /usr/src/nym
+WORKDIR /usr/src/nym/nym-api
+RUN cargo build --release
+
+ENTRYPOINT ["/usr/src/nym/nym-api/entrypoint.sh"]
@@ -4,7 +4,7 @@
 [package]
 name = "nym-api"
 license = "GPL-3.0"
-version = "1.1.44"
+version = "1.1.45"
 authors.workspace = true
 edition = "2021"
 rust-version.workspace = true
@@ -18,7 +18,7 @@ bip39 = { workspace = true }
 bincode.workspace = true
 bloomfilter = { workspace = true }
 cfg-if = { workspace = true }
-clap = { workspace = true, features = ["cargo", "derive"] }
+clap = { workspace = true, features = ["cargo", "derive", "env"] }
 console-subscriber = { workspace = true, optional = true } # validator-api needs to be built with RUSTFLAGS="--cfg tokio_unstable"
 dirs = { workspace = true }
 futures = { workspace = true }
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -e
+
+/usr/src/nym/target/release/nym-api init && /usr/src/nym/target/release/nym-api run
@@ -2,10 +2,8 @@
 // SPDX-License-Identifier: GPL-3.0-only

 use cosmwasm_std::Decimal;
-use nym_mixnet_contract_common::mixnode::PendingMixNodeChanges;
-use nym_mixnet_contract_common::{
-    GatewayBond, LegacyMixLayer, MixNodeBond, MixNodeDetails, NodeId, NodeRewarding,
-};
+use nym_mixnet_contract_common::mixnode::LegacyPendingMixNodeChanges;
+use nym_mixnet_contract_common::{GatewayBond, LegacyMixLayer, MixNodeBond, NodeId, NodeRewarding};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::ops::Deref;
@@ -64,7 +62,7 @@ pub struct LegacyMixNodeDetailsWithLayer {

    /// Adjustments to the mixnode that are ought to happen during future epoch transitions.
    #[serde(default)]
-    pub pending_changes: PendingMixNodeChanges,
+    pub pending_changes: LegacyPendingMixNodeChanges,
 }

 impl LegacyMixNodeDetailsWithLayer {
@@ -80,13 +78,3 @@ impl LegacyMixNodeDetailsWithLayer {
        self.bond_information.is_unbonding
    }
 }
-
-impl From<LegacyMixNodeDetailsWithLayer> for MixNodeDetails {
-    fn from(value: LegacyMixNodeDetailsWithLayer) -> Self {
-        MixNodeDetails {
-            bond_information: value.bond_information.into(),
-            rewarding_details: value.rewarding_details,
-            pending_changes: value.pending_changes,
-        }
-    }
-}
@@ -16,7 +16,7 @@ use nym_crypto::asymmetric::x25519::{
 use nym_mixnet_contract_common::nym_node::Role;
 use nym_mixnet_contract_common::reward_params::{Performance, RewardingParams};
 use nym_mixnet_contract_common::rewarding::RewardEstimate;
-use nym_mixnet_contract_common::{IdentityKey, Interval, MixNode, NodeId, Percent};
+use nym_mixnet_contract_common::{GatewayBond, IdentityKey, Interval, MixNode, NodeId, Percent};
 use nym_network_defaults::{DEFAULT_MIX_LISTENING_PORT, DEFAULT_VERLOC_LISTENING_PORT};
 use nym_node_requests::api::v1::authenticator::models::Authenticator;
 use nym_node_requests::api::v1::gateway::models::Wireguard;
@@ -138,6 +138,48 @@ pub struct NodePerformance {
    pub last_24h: Performance,
 }

+#[derive(Serialize, Deserialize, Debug, Clone, Copy, Hash, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
+#[cfg_attr(
+    feature = "generate-ts",
+    ts(export, export_to = "ts-packages/types/src/types/rust/DisplayRole.ts")
+)]
+pub enum DisplayRole {
+    EntryGateway,
+    Layer1,
+    Layer2,
+    Layer3,
+    ExitGateway,
+    Standby,
+}
+
+impl From<Role> for DisplayRole {
+    fn from(role: Role) -> Self {
+        match role {
+            Role::EntryGateway => DisplayRole::EntryGateway,
+            Role::Layer1 => DisplayRole::Layer1,
+            Role::Layer2 => DisplayRole::Layer2,
+            Role::Layer3 => DisplayRole::Layer3,
+            Role::ExitGateway => DisplayRole::ExitGateway,
+            Role::Standby => DisplayRole::Standby,
+        }
+    }
+}
+
+impl From<DisplayRole> for Role {
+    fn from(role: DisplayRole) -> Self {
+        match role {
+            DisplayRole::EntryGateway => Role::EntryGateway,
+            DisplayRole::Layer1 => Role::Layer1,
+            DisplayRole::Layer2 => Role::Layer2,
+            DisplayRole::Layer3 => Role::Layer3,
+            DisplayRole::ExitGateway => Role::ExitGateway,
+            DisplayRole::Standby => Role::Standby,
+        }
+    }
+}
+
 // imo for now there's no point in exposing more than that,
 // nym-api shouldn't be calculating apy or stake saturation for you.
 // it should just return its own metrics (performance) and then you can do with it as you wish
@@ -153,7 +195,7 @@ pub struct NodePerformance {
 pub struct NodeAnnotation {
    #[cfg_attr(feature = "generate-ts", ts(type = "string"))]
    pub last_24h_performance: Performance,
-    pub current_role: Option<Role>,
+    pub current_role: Option<DisplayRole>,
 }

 #[derive(Clone, Copy, Debug, Serialize, Deserialize, JsonSchema, ToSchema)]
@@ -286,7 +328,7 @@ impl MixNodeBondAnnotated {
                .sphinx_key
                .parse()
                .map_err(|_| MalformedNodeBond::InvalidX25519Key)?,
-            epoch_role: role,
+            role,
            supported_roles: DeclaredRoles {
                mixnode: true,
                entry: false,
@@ -345,7 +387,7 @@ impl GatewayBondAnnotated {
                .sphinx_key
                .parse()
                .map_err(|_| MalformedNodeBond::InvalidX25519Key)?,
-            epoch_role: role,
+            role,
            supported_roles: DeclaredRoles {
                mixnode: false,
                entry: true,
@@ -827,7 +869,7 @@ impl NymNodeDescription {
            // we can't use the declared roles, we have to take whatever was provided in the contract.
            // why? say this node COULD operate as an exit, but it might be the case the contract decided
            // to assign it an ENTRY role only. we have to use that one instead.
-            epoch_role: role,
+            role,
            supported_roles: self.description.declared_role,
            entry,
            performance,
@@ -935,14 +977,14 @@ impl NymNodeData {

 #[derive(Clone, Debug, Serialize, Deserialize, schemars::JsonSchema, ToSchema)]
 pub struct LegacyDescribedGateway {
-    pub bond: LegacyGatewayBondWithId,
+    pub bond: GatewayBond,
    pub self_described: Option<NymNodeData>,
 }

 impl From<LegacyGatewayBondWithId> for LegacyDescribedGateway {
    fn from(bond: LegacyGatewayBondWithId) -> Self {
        LegacyDescribedGateway {
-            bond,
+            bond: bond.bond,
            self_described: None,
        }
    }
@@ -141,8 +141,8 @@ pub struct SkimmedNode {
    #[schemars(with = "String")]
    pub x25519_sphinx_pubkey: x25519::PublicKey,

-    #[serde(alias = "role")]
-    pub epoch_role: NodeRole,
+    #[serde(alias = "epoch_role")]
+    pub role: NodeRole,

    // needed for the purposes of sending appropriate test packets
    #[serde(default)]
@@ -157,7 +157,7 @@ pub struct SkimmedNode {

 impl SkimmedNode {
    pub fn get_mix_layer(&self) -> Option<u8> {
-        match self.epoch_role {
+        match self.role {
            NodeRole::Mixnode { layer } => Some(layer),
            _ => None,
        }
@@ -24,21 +24,21 @@ use utoipa::IntoParams;
 pub(crate) fn aggregation_routes(ecash_state: Arc<EcashState>) -> Router<AppState> {
    Router::new()
        .route(
-            "/master-verification-key:epoch_id",
+            "/master-verification-key",
            axum::routing::get({
                let ecash_state = Arc::clone(&ecash_state);
                |epoch_id| master_verification_key(epoch_id, ecash_state)
            }),
        )
        .route(
-            "/aggregated-expiration-date-signatures:expiration_date",
+            "/aggregated-expiration-date-signatures",
            axum::routing::get({
                let ecash_state = Arc::clone(&ecash_state);
                |expiration_date| expiration_date_signatures(expiration_date, ecash_state)
            }),
        )
        .route(
-            "/aggregated-coin-indices-signatures:epoch_id",
+            "/aggregated-coin-indices-signatures",
            axum::routing::get({
                let ecash_state = Arc::clone(&ecash_state);
                |epoch_id| coin_indices_signatures(epoch_id, ecash_state)
@@ -52,7 +52,7 @@ pub(crate) fn aggregation_routes(ecash_state: Arc<EcashState>) -> Router<AppStat
    params(
        EpochIdParam
    ),
-    path = "/v1/ecash/master-verification-key/{epoch_id}",
+    path = "/v1/ecash/master-verification-key",
    responses(
        (status = 200, body = VerificationKeyResponse)
    )
@@ -83,7 +83,7 @@ struct ExpirationDateParam {
    params(
        ExpirationDateParam
    ),
-    path = "/v1/ecash/aggregated-expiration-date-signatures/{epoch_id}",
+    path = "/v1/ecash/aggregated-expiration-date-signatures",
    responses(
        (status = 200, body = AggregatedExpirationDateSignatureResponse)
    )
@@ -120,7 +120,7 @@ async fn expiration_date_signatures(
    params(
        EpochIdParam
    ),
-    path = "/v1/ecash/aggregated-coin-indices-signatures/{epoch_id}",
+    path = "/v1/ecash/aggregated-coin-indices-signatures",
    responses(
        (status = 200, body = AggregatedCoinIndicesSignatureResponse)
    )
@@ -32,14 +32,14 @@ pub(crate) fn partial_signing_routes(ecash_state: Arc<EcashState>) -> Router<App
            }),
        )
        .route(
-            "/partial-expiration-date-signatures:expiration_date",
+            "/partial-expiration-date-signatures",
            axum::routing::get({
                let ecash_state = Arc::clone(&ecash_state);
                |expiration_date| partial_expiration_date_signatures(expiration_date, ecash_state)
            }),
        )
        .route(
-            "/partial-coin-indices-signatures:epoch_id",
+            "/partial-coin-indices-signatures",
            axum::routing::get({
                let ecash_state = Arc::clone(&ecash_state);
                |epoch_id| partial_coin_indices_signatures(epoch_id, ecash_state)
@@ -127,7 +127,7 @@ struct ExpirationDateParam {
    params(
        ExpirationDateParam
    ),
-    path = "/v1/ecash/partial-expiration-date-signatures/{expiration_date}",
+    path = "/v1/ecash/partial-expiration-date-signatures",
    responses(
        (status = 200, body = PartialExpirationDateSignatureResponse),
        (status = 400, body = ErrorResponse, description = "this nym-api is not an ecash signer in the current epoch"),
@@ -165,7 +165,7 @@ async fn partial_expiration_date_signatures(
    params(
        EpochIdParam
    ),
-    path = "/v1/ecash/partial-coin-indices-signatures/{epoch_id}",
+    path = "/v1/ecash/partial-coin-indices-signatures",
    responses(
        (status = 200, body = PartialExpirationDateSignatureResponse),
        (status = 400, body = ErrorResponse, description = "this nym-api is not an ecash signer in the current epoch"),
@@ -20,6 +20,7 @@ use time::macros::time;
 use time::{OffsetDateTime, Time};
 use tracing::{error, warn};

+#[allow(deprecated)]
 pub(crate) fn spending_routes(ecash_state: Arc<EcashState>) -> Router<AppState> {
    Router::new()
        .route(
@@ -242,6 +243,7 @@ async fn batch_redeem_tickets(
        (status = 500, body = ErrorResponse, description = "bloomfilters got disabled"),
    )
 )]
+#[deprecated]
 async fn double_spending_filter_v1(
    _state: Arc<EcashState>,
 ) -> AxumResult<Json<SpentCredentialsResponse>> {
@@ -24,6 +24,9 @@ pub type Result<T, E = EcashError> = std::result::Result<T, E>;

 #[derive(Debug, Error)]
 pub enum EcashError {
+    #[error("permanently restricted")]
+    Restricted,
+
    #[error(transparent)]
    IOError(#[from] std::io::Error),

@@ -169,7 +169,7 @@ impl EpochAdvancer {
        let standby_eligible = all_choices
            .iter()
            .filter(|node| {
-                exit_gateways.contains(&node.0.node_id)
+                !exit_gateways.contains(&node.0.node_id)
                    && !entry_gateways.contains(&node.0.node_id)
                    && !mixnodes.contains(&node.0.node_id)
            })
@@ -228,14 +228,24 @@ impl EpochAdvancer {
            )
        }

-        Ok(RewardedSet {
+        let mut rewarded_set = RewardedSet {
            entry_gateways: entry_gateways.into_iter().collect(),
            exit_gateways: exit_gateways.into_iter().collect(),
            layer1,
            layer2,
            layer3,
            standby,
-        })
+        };
+
+        // make sure to sort the rewarded set values
+        rewarded_set.entry_gateways.sort();
+        rewarded_set.exit_gateways.sort();
+        rewarded_set.layer1.sort();
+        rewarded_set.layer2.sort();
+        rewarded_set.layer3.sort();
+        rewarded_set.standby.sort();
+
+        Ok(rewarded_set)
    }

    async fn attach_performance_to_eligible_nodes(
@@ -274,8 +274,8 @@ impl<R: MessageReceiver + Send> Monitor<R> {
        info!("Received {}/{} packets", total_received, total_sent);

        let summary = self.summary_producer.produce_summary(
-            prepared_packets.tested_mixnodes,
-            prepared_packets.tested_gateways,
+            prepared_packets.mixnodes_under_test,
+            prepared_packets.gateways_under_test,
            received,
            prepared_packets.invalid_mixnodes,
            prepared_packets.invalid_gateways,
@@ -25,7 +25,7 @@ use std::collections::{HashMap, HashSet};
 use std::fmt::{self, Display, Formatter};
 use std::sync::Arc;
 use std::time::Duration;
-use tracing::{error, info, trace};
+use tracing::{debug, error, info, trace};

 const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(200);
 const DEFAULT_AVERAGE_ACK_DELAY: Duration = Duration::from_millis(200);
@@ -59,10 +59,10 @@ pub(crate) struct PreparedPackets {
    pub(super) packets: Vec<GatewayPackets>,

    /// Vector containing list of public keys and owners of all nodes mixnodes being tested.
-    pub(super) tested_mixnodes: Vec<TestableNode>,
+    pub(super) mixnodes_under_test: Vec<TestableNode>,

    /// Vector containing list of public keys and owners of all gateways being tested.
-    pub(super) tested_gateways: Vec<TestableNode>,
+    pub(super) gateways_under_test: Vec<TestableNode>,

    /// All mixnodes that failed to get parsed correctly or were not version compatible.
    /// They will be marked to the validator as being down for the test.
@@ -151,34 +151,38 @@ impl PacketPreparer {
        self.contract_cache.wait_for_initial_values().await;
        self.described_cache.naive_wait_for_initial_values().await;

+        let described_nodes = self
+            .described_cache
+            .get()
+            .await
+            .expect("the self-describe cache should have been initialised!");
+
        // now wait for at least `minimum_full_routes` mixnodes per layer and `minimum_full_routes` gateway to be online
        info!("Waiting for minimal topology to be online");
        let initialisation_backoff = Duration::from_secs(30);
        loop {
            let gateways = self.contract_cache.legacy_gateways_all().await;
            let mixnodes = self.contract_cache.legacy_mixnodes_all_basic().await;
+            let nym_nodes = self.contract_cache.nym_nodes().await;

-            if gateways.len() < minimum_full_routes {
-                self.topology_wait_backoff(initialisation_backoff).await;
-                continue;
-            }
+            let mut gateways_count = gateways.len();
+            let mut mixnodes_count = mixnodes.len();

-            let mut layer1_count = 0;
-            let mut layer2_count = 0;
-            let mut layer3_count = 0;
-
-            for mix in mixnodes {
-                match mix.layer {
-                    LegacyMixLayer::One => layer1_count += 1,
-                    LegacyMixLayer::Two => layer2_count += 1,
-                    LegacyMixLayer::Three => layer3_count += 1,
+            for nym_node in nym_nodes {
+                if let Some(described) = described_nodes.get_description(&nym_node.node_id()) {
+                    if described.declared_role.mixnode {
+                        mixnodes_count += 1;
+                    } else if described.declared_role.entry {
+                        gateways_count += 1;
+                    }
                }
            }

-            if layer1_count >= minimum_full_routes
-                && layer2_count >= minimum_full_routes
-                && layer3_count >= minimum_full_routes
-            {
+            debug!(
+                "we have {mixnodes_count} possible mixnodes and {gateways_count} possible gateways"
+            );
+
+            if gateways_count >= minimum_full_routes && mixnodes_count * 3 >= minimum_full_routes {
                break;
            }

@@ -529,30 +533,41 @@ impl PacketPreparer {
        let mixing_nym_nodes = descriptions.mixing_nym_nodes();
        let gateway_capable_nym_nodes = descriptions.entry_capable_nym_nodes();

-        let (mixnodes, invalid_mixnodes) = self.filter_outdated_and_malformed_mixnodes(mixnodes);
-        let (gateways, invalid_gateways) = self.filter_outdated_and_malformed_gateways(gateways);
+        let (mut mixnodes_to_test_details, invalid_mixnodes) =
+            self.filter_outdated_and_malformed_mixnodes(mixnodes);
+        let (mut gateways_to_test_details, invalid_gateways) =
+            self.filter_outdated_and_malformed_gateways(gateways);

-        let mut tested_mixnodes = mixnodes.iter().map(|node| node.into()).collect::<Vec<_>>();
-        let mut tested_gateways = gateways.iter().map(|node| node.into()).collect::<Vec<_>>();
+        // summary of nodes that got tested
+        let mut mixnodes_under_test = mixnodes_to_test_details
+            .iter()
+            .map(|node| node.into())
+            .collect::<Vec<_>>();
+        let mut gateways_under_test = gateways_to_test_details
+            .iter()
+            .map(|node| node.into())
+            .collect::<Vec<_>>();

        // try to add nym-nodes into the fold
        if let Some(rewarded_set) = rewarded_set {
            let mut rng = thread_rng();
            for mix in mixing_nym_nodes {
                if let Some(parsed) = self.nym_node_to_legacy_mix(&mut rng, &rewarded_set, mix) {
-                    tested_mixnodes.push(TestableNode::from(&parsed));
+                    mixnodes_under_test.push(TestableNode::from(&parsed));
+                    mixnodes_to_test_details.push(parsed);
                }
            }
        }

        for gateway in gateway_capable_nym_nodes {
            if let Some(parsed) = self.nym_node_to_legacy_gateway(gateway) {
-                tested_gateways.push((&parsed, gateway.node_id).into())
+                gateways_under_test.push((&parsed, gateway.node_id).into());
+                gateways_to_test_details.push((parsed, gateway.node_id));
            }
        }

        let packets_to_create = (test_routes.len() * self.per_node_test_packets)
-            * (tested_mixnodes.len() + tested_gateways.len());
+            * (mixnodes_under_test.len() + gateways_under_test.len());
        info!("Need to create {} mix packets", packets_to_create);

        let mut all_gateway_packets = HashMap::new();
@@ -574,7 +589,7 @@ impl PacketPreparer {
            #[allow(clippy::unwrap_used)]
            let mixnode_test_packets = mix_tester
                .mixnodes_test_packets(
-                    &mixnodes,
+                    &mixnodes_to_test_details,
                    route_ext,
                    self.per_node_test_packets as u32,
                    None,
@@ -588,7 +603,7 @@ impl PacketPreparer {
            gateway_packets.push_packets(mix_packets);

            // and generate test packets for gateways (note the variable recipient)
-            for (gateway, node_id) in &gateways {
+            for (gateway, node_id) in &gateways_to_test_details {
                let recipient = self.create_packet_sender(gateway);
                let gateway_identity = gateway.identity_key;
                let gateway_address = gateway.clients_address();
@@ -624,8 +639,8 @@ impl PacketPreparer {

        PreparedPackets {
            packets,
-            tested_mixnodes,
-            tested_gateways,
+            mixnodes_under_test,
+            gateways_under_test,
            invalid_mixnodes,
            invalid_gateways,
        }
@@ -145,6 +145,7 @@ impl NodeDescriptionTopologyExt for NymNodeDescription {
    }
 }

+#[derive(Debug, Clone)]
 pub struct DescribedNodes {
    nodes: HashMap<NodeId, NymNodeDescription>,
 }
@@ -290,6 +291,7 @@ async fn try_get_description(
    })
 }

+#[derive(Debug)]
 struct RefreshData {
    host: String,
    node_id: NodeId,
@@ -210,6 +210,7 @@ impl ResolvedNodeDescribedInfo {
    }
 }

+#[derive(Debug)]
 pub(crate) struct UnwrappedResolvedNodeDescribedInfo {
    pub(crate) build_info: BinaryBuildInformationOwned,
    pub(crate) roles: DeclaredRoles,
@@ -209,7 +209,7 @@ pub(crate) async fn produce_node_annotations(
            legacy_mix.mix_id(),
            NodeAnnotation {
                last_24h_performance: perf,
-                current_role: rewarded_set.role(legacy_mix.mix_id()),
+                current_role: rewarded_set.role(legacy_mix.mix_id()).map(|r| r.into()),
            },
        );
    }
@@ -229,7 +229,7 @@ pub(crate) async fn produce_node_annotations(
            legacy_gateway.node_id,
            NodeAnnotation {
                last_24h_performance: perf,
-                current_role: rewarded_set.role(legacy_gateway.node_id),
+                current_role: rewarded_set.role(legacy_gateway.node_id).map(|r| r.into()),
            },
        );
    }
@@ -249,7 +249,7 @@ pub(crate) async fn produce_node_annotations(
            nym_node.node_id(),
            NodeAnnotation {
                last_24h_performance: perf,
-                current_role: rewarded_set.role(nym_node.node_id()),
+                current_role: rewarded_set.role(nym_node.node_id()).map(|r| r.into()),
            },
        );
    }
@@ -16,6 +16,7 @@ use nym_serde_helpers::date::DATE_FORMAT;
 use reqwest::StatusCode;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use sqlx::Error;
 use std::fmt::Display;
 use thiserror::Error;
 use time::{Date, OffsetDateTime};
@@ -438,7 +439,7 @@ pub enum NymApiStorageError {

    // I don't think we want to expose errors to the user about what really happened
    #[error("experienced internal database error")]
-    InternalDatabaseError(#[from] sqlx::Error),
+    InternalDatabaseError(sqlx::Error),

    // the same is true here (also note that the message is subtly different so we would be able to distinguish them)
    #[error("experienced internal storage error")]
@@ -449,6 +450,14 @@ pub enum NymApiStorageError {
    StartupMigrationFailure(#[from] sqlx::migrate::MigrateError),
 }

+impl From<sqlx::Error> for NymApiStorageError {
+    fn from(err: Error) -> Self {
+        // those should realistically never be happening so an `error!` is warranted
+        error!("storage failure: {err}");
+        NymApiStorageError::InternalDatabaseError(err)
+    }
+}
+
 impl NymApiStorageError {
    pub fn database_inconsistency<S: Into<String>>(reason: S) -> NymApiStorageError {
        NymApiStorageError::DatabaseInconsistency {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Mark Sinclair	acac53d3bf	Rename `vpn-api-lib-wasm` to `nym-credential-proxy-lib-wasm`, and: - change from yarn to npm - fix license so Apache-2.0 (like the rest of the SDK)	2024-10-30 12:39:20 +00:00
dependabot[bot]	2ca7c7a252	build(deps): bump lazy_static from 1.4.0 to 1.5.0 (#4913 )	2024-10-30 07:07:39 +01:00
dependabot[bot]	e680e8dc49	build(deps): bump once_cell from 1.19.0 to 1.20.2 (#4952 ) Bumps [once_cell](https://github.com/matklad/once_cell) from 1.19.0 to 1.20.2. - [Changelog](https://github.com/matklad/once_cell/blob/master/CHANGELOG.md) - [Commits](https://github.com/matklad/once_cell/compare/v1.19.0...v1.20.2) --- updated-dependencies: - dependency-name: once_cell dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-10-29 23:27:10 +01:00
Jon Häggblad	242bc93807	Merge pull request #5027 from nymtech/jon/integrate-credential-proxy-into-workspace Integrate nym-credential-proxy into workspace	2024-10-29 20:47:07 +01:00
dynco-nym	94c6cdc7b2	Type coercion into time::Date	2024-10-29 17:46:35 +01:00
Jon Häggblad	fce322c789	Remove unused workflow	2024-10-29 17:46:35 +01:00
Jon Häggblad	ac5baab693	Add to default workspace	2024-10-29 17:46:35 +01:00
Jon Häggblad	23da0f4d8e	Workspace updates	2024-10-29 17:46:35 +01:00
Jon Häggblad	25e3b4cd83	Delete old Cargo files	2024-10-29 17:46:35 +01:00
Jon Häggblad	8e4d72a565	Update for rebase	2024-10-29 17:46:34 +01:00
Jon Häggblad	ad84a6d85d	Add nym-vpn-api crates to main workspace	2024-10-29 17:45:56 +01:00
Jędrzej Stuczyński	34c5f23684	Merge pull request #5061 from nymtech/merge1/release/2024.13-magura checkpoint merge release/2024.13-magura into develop	2024-10-29 16:17:16 +00:00
Jędrzej Stuczyński	000f2f1c29	Merge branch 'release/2024.13-magura' into develop	2024-10-29 15:31:51 +00:00
Dinko Zdravac	b747308f74	Add subcommand to image (#5056 )	2024-10-29 10:52:33 +01:00
Dinko Zdravac	afdd721cc3	Ns agent workflow (#5055 ) * feat: add dockerfile * add github workflow for node status agent --------- Co-authored-by: Fran Arbanas <arbanasfran@gmail.com>	2024-10-29 10:39:58 +01:00
Jędrzej Stuczyński	317f7fffa9	added hacky routes to return nymnodes alongside legacy nodes (#5051 ) * added hacky routes to return nymnodes alongside legacy nodes * fixed mixing role * Update client (#5054) * removed hacky mixnodes endpoint for its not used * construct explorer-api client with timeout --------- Co-authored-by: Dinko Zdravac <173912580+dynco-nym@users.noreply.github.com>	2024-10-29 08:35:07 +00:00
Dinko Zdravac	9f5c4c5968	Merge pull request #5050 from nymtech/dz-node-status-api Node Status API	2024-10-29 00:43:33 +01:00
dynco-nym	9583a5c6c8	Fix build script	2024-10-29 00:24:18 +01:00
Tommy Verrall	da60fc0ade	Merge pull request #5052 from nymtech/feat/add-node-status-agent-workflow feat: add simple node-status-agent	2024-10-28 19:30:52 +00:00
Fran Arbanas	96b54c455e	feat: add simple node-status-agent	2024-10-28 19:16:46 +01:00
Dinko Zdravac	cc983963d4	Fully functional network scores (#5048 ) * Compile & copy wg probe * Node status agent WIP * Enable debug logging * Agent submits results - add clap to agent - agent runs network probe - /submit endpoint on NS API * Build clients with timeouts * Update logging and dev scripts * Replace /blaclisted endpoint * Testruns fully functional - task that queues testruns periodically - testruns read/write in DB * Probe scores fully working - testruns are assigned on API - submit updates testruns correctly on NS API side - agent registers with API - agent submits results correctly * Clippy fixes * PR feedback * Clippy again * PR feedback * Run clippy earlier in CI * Make refresh delay configurable in server & agent	2024-10-28 17:31:43 +01:00
Fran Arbanas	40d9321aec	Node status API dockerfile and env vars (#4986 ) * feat: add dockerfile and env variables * Added workflow for pushing node status api on harbor * Misc changes to pathing and using yq instead of jq * fix: change the way we read env vars for nyxd, nym api and explorer * fix: docker build workflow * Remove config in favor of clap args * Added naming and tags * change from value to result --------- Co-authored-by: Lawrence Stalder <lawrence@nymtech.net> Co-authored-by: dynco-nym <173912580+dynco-nym@users.noreply.github.com>	2024-10-28 17:07:38 +01:00
dynco-nym	e5a29cc76e	Work with directory pre-v2.1 Rebase + point to earlier network client code Adjust to new Nym API types Refer to earlier client code Revert "Rebase + point to earlier network client code" This reverts commit dd75e7dc0695c25b0883e2f5dd15b7d70165e9e8. Point to earlier commit	2024-10-28 17:04:22 +01:00
Dinko Zdravac	56c55f6b95	Working HTTP server (#4941 ) * Server file structure * Create HTTP server - graceful shutdown - routes - logging, CORS * gateways WIP * gateways API + swagger docs complete * Mixnodes API + swagger docs complete * Services API + swagger docs complete * Commit summary insert * Make troubleshooting DB easier * Summary API + swagger docs * Client log changes * QOL improvements - remove implicit panics via `as` - safer DTO conversions - add logging - new config	2024-10-28 16:59:12 +01:00
Dinko Zdravac	2f051fd943	Node Status API background task (#4854 ) * Setup new package * Setup DB * Fetch & store mixnodes/GWs - refactor db package structure - finally solve DATABASE_URL: absolute path works best * Additional query functionality - missing only daily summary, which requires type refactoring * Replace type alias tuples with structs * Insert summary * Add github job to build package * Build script for sqlx * Remove data dir - useless now that sqlx DB sits in OUT_DIR * PR feedback	2024-10-28 16:54:26 +01:00
Bogdan-Ștefan Neacşu	c03cf86000	Authenticator CLI client mode (#5044 )	2024-10-28 16:42:05 +02:00
Jędrzej Stuczyński	4396def133	bugfix: adjust runtime storage migration (#5047 )	2024-10-28 10:07:51 +00:00
Jędrzej Stuczyński	a56a318a7f	bugfix: supersede 'cb13be27f8f61d9ae74d924e85d2e6787895eb14' by using query parameters (#5046 )	2024-10-28 09:57:14 +00:00
Jędrzej Stuczyński	4d08047c57	bugfix: restore default http port for nym-api (#5045 ) when it was run under 'rocket' server the port used was 8000. let's restore that value	2024-10-28 09:28:47 +00:00
Jędrzej Stuczyński	cb13be27f8	bugfix: fix ecash handlers routes (#5043 )	2024-10-28 09:12:40 +00:00
Jędrzej Stuczyński	fa392169c1	bugfix: use human readable roles for annotations (#5036 ) * bugfix: use human readable roles for annotations * update the wallet code to use 'DisplayRole'	2024-10-28 09:08:17 +00:00
Simon Wicky	ab11508235	[Product Data] Introduce data persistence on gateways (#5022 ) * add stats storage to gateways * config fix * add stats storage model and logic * adapt stats collection to new storage * stats cleanup on start * change to linux only code * tweaks * modified stats cleanup + change session started * change wrong table name * store crashed session as 0 duration * adapt for sqlx 0.7 * remove unused dependencies * revert changes from gateway config, as it is broken anyway * copyright and misc stuff --------- Co-authored-by: Simon Wicky <simon@linode2-2.net>	2024-10-28 09:25:37 +01:00
Jędrzej Stuczyński	3167fb34e6	bugfix: don't assign exit gateways to standby set (#5041 )	2024-10-25 16:53:51 +01:00
Jędrzej Stuczyński	9ca6301e1c	bugfix: make sure nym-nodes are also tested by network monitor (#5040 )	2024-10-25 15:20:39 +01:00
Jędrzej Stuczyński	e16a73338e	bugfix: use bonded nym-nodes for determining initial network monitor nodes (#5039 )	2024-10-25 12:34:25 +01:00
Bogdan-Ștefan Neacşu	bfa3825d70	Pass the Poisson flag on authenticator config (#5037 )	2024-10-25 14:08:52 +03:00
Jędrzej Stuczyński	d626e7689f	bugfix: make gateways insert themselves into [local] topology (#5038 ) * added explicit SP suffix to started tasks * added 'GatewayTopologyProvider' that always injects itself into the network * use the new topology provider to bypass described bootstrapping problem	2024-10-25 12:06:16 +01:00
Jędrzej Stuczyński	9234474565	bugfix: use old name for 'epoch_role' in SkimmedNode (#5034 ) * bugfix: use old name for 'epoch_role' in SkimmedNode * clippy	2024-10-25 09:29:37 +01:00
Jędrzej Stuczyński	29f8386b50	bugfix: make sure to use correct highest node id when assigning role (#5032 ) * bugfix: make sure to use correct highest node id when assigning role * make sure nym-api provides sorted values for older contracts	2024-10-24 17:47:57 +01:00
Jędrzej Stuczyński	0edb9631a6	feature: use axum_client_ip for attempting to extract source ip (#5031 )	2024-10-24 17:38:32 +01:00
Fran Arbanas	e65bfaeb31	Fix/nym data observatory dockerfile (#5021 ) * fix: added needed env vars to dockerfile, updated db env for a bit * feat: add github workflow for pushing data observatory * feat: split the postgresql connection string into multiple variables * fix docker compose * fix workflow * fix: short in clap	2024-10-24 18:10:34 +02:00
Jędrzej Stuczyński	4b0153f5f2	bugfix: fixed backwards incompatibility for /gateways/described endpoint (#5030 )	2024-10-24 15:37:41 +01:00
Jędrzej Stuczyński	c09a17b66d	bugfix: verifying signed information of legacy nodes (#5029 ) * Added new legacy variant of HostInformation * fixed 'option_bs58_x25519_pubkey' for empty string * 'Debug' impl for x25519 and ed25519 to use human-readable representation * HttpClient to use explicit 'serde_json' conversion for better errors * additional 'Debug' derives	2024-10-24 15:00:34 +01:00
Jędrzej Stuczyński	d18ddcdc11	bugfix: introduce 'LegacyPendingMixNodeChanges' that does not contain 'cost_params_change' (#5028 ) * bugfix: introduce 'LegacyPendingMixNodeChanges' that does not contain 'cost_params_change' * updated schema files due to removal of '#[serde(deny_unknown_fields)]'	2024-10-24 10:54:00 +01:00
Jędrzej Stuczyński	d2df542280	bugfix: missing #[serde(default)] for announce port (#5024 )	2024-10-23 16:52:17 +01:00
Jędrzej Stuczyński	6fafd8c03a	bugfix: directory v2.1 `get_all_avg_gateway_reliability_in_interval` query (#5023 ) * log full storage errors on failures * use query_as! macro	2024-10-23 16:36:21 +01:00
Jędrzej Stuczyński	5a6982fd10	Merge pull request #5011 from nymtech/dependabot/cargo/patch-updates-9a83837eff Bump the patch-updates group across 1 directory with 10 updates	2024-10-23 10:51:55 +01:00
Jędrzej Stuczyński	38e66f6ddf	added 'get_all_described_nodes' to NymApiClient and adjusted return type on api itself (#5016 )	2024-10-23 09:48:25 +01:00
Bogdan-Ștefan Neacşu	b9fbe0b8f3	Reapply fixes to new branch (#5014 )	2024-10-22 18:33:18 +03:00
dependabot[bot]	7abe1f505c	Bump the patch-updates group across 1 directory with 10 updates Bumps the patch-updates group with 9 updates in the / directory: \| Package \| From \| To \| \| --- \| --- \| --- \| \| [anyhow](https://github.com/dtolnay/anyhow) \| `1.0.89` \| `1.0.90` \| \| [clap](https://github.com/clap-rs/clap) \| `4.5.18` \| `4.5.20` \| \| [clap_complete](https://github.com/clap-rs/clap) \| `4.5.29` \| `4.5.33` \| \| [pin-project](https://github.com/taiki-e/pin-project) \| `1.1.5` \| `1.1.6` \| \| [serde](https://github.com/serde-rs/serde) \| `1.0.210` \| `1.0.211` \| \| [serde_json](https://github.com/serde-rs/json) \| `1.0.128` \| `1.0.132` \| \| [wasm-bindgen](https://github.com/rustwasm/wasm-bindgen) \| `0.2.93` \| `0.2.95` \| \| [wasm-bindgen-futures](https://github.com/rustwasm/wasm-bindgen) \| `0.4.43` \| `0.4.45` \| \| [web-sys](https://github.com/rustwasm/wasm-bindgen) \| `0.3.70` \| `0.3.72` \| Updates `anyhow` from 1.0.89 to 1.0.90 - [Release notes](https://github.com/dtolnay/anyhow/releases) - [Commits](https://github.com/dtolnay/anyhow/compare/1.0.89...1.0.90) Updates `clap` from 4.5.18 to 4.5.20 - [Release notes](https://github.com/clap-rs/clap/releases) - [Changelog](https://github.com/clap-rs/clap/blob/master/CHANGELOG.md) - [Commits](https://github.com/clap-rs/clap/compare/clap_complete-v4.5.18...clap_complete-v4.5.20) Updates `clap_complete` from 4.5.29 to 4.5.33 - [Release notes](https://github.com/clap-rs/clap/releases) - [Changelog](https://github.com/clap-rs/clap/blob/master/CHANGELOG.md) - [Commits](https://github.com/clap-rs/clap/compare/clap_complete-v4.5.29...clap_complete-v4.5.33) Updates `pin-project` from 1.1.5 to 1.1.6 - [Release notes](https://github.com/taiki-e/pin-project/releases) - [Changelog](https://github.com/taiki-e/pin-project/blob/main/CHANGELOG.md) - [Commits](https://github.com/taiki-e/pin-project/compare/v1.1.5...v1.1.6) Updates `serde` from 1.0.210 to 1.0.211 - [Release notes](https://github.com/serde-rs/serde/releases) - [Commits](https://github.com/serde-rs/serde/compare/v1.0.210...v1.0.211) Updates `serde_derive` from 1.0.210 to 1.0.211 - [Release notes](https://github.com/serde-rs/serde/releases) - [Commits](https://github.com/serde-rs/serde/compare/v1.0.210...v1.0.211) Updates `serde_json` from 1.0.128 to 1.0.132 - [Release notes](https://github.com/serde-rs/json/releases) - [Commits](https://github.com/serde-rs/json/compare/1.0.128...1.0.132) Updates `wasm-bindgen` from 0.2.93 to 0.2.95 - [Release notes](https://github.com/rustwasm/wasm-bindgen/releases) - [Changelog](https://github.com/rustwasm/wasm-bindgen/blob/main/CHANGELOG.md) - [Commits](https://github.com/rustwasm/wasm-bindgen/compare/0.2.93...0.2.95) Updates `wasm-bindgen-futures` from 0.4.43 to 0.4.45 - [Release notes](https://github.com/rustwasm/wasm-bindgen/releases) - [Changelog](https://github.com/rustwasm/wasm-bindgen/blob/main/CHANGELOG.md) - [Commits](https://github.com/rustwasm/wasm-bindgen/commits) Updates `web-sys` from 0.3.70 to 0.3.72 - [Release notes](https://github.com/rustwasm/wasm-bindgen/releases) - [Changelog](https://github.com/rustwasm/wasm-bindgen/blob/main/CHANGELOG.md) - [Commits](https://github.com/rustwasm/wasm-bindgen/commits) --- updated-dependencies: - dependency-name: anyhow dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: clap dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: clap_complete dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: pin-project dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: serde dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: serde_derive dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: serde_json dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: wasm-bindgen dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: wasm-bindgen-futures dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates - dependency-name: web-sys dependency-type: direct:production update-type: version-update:semver-patch dependency-group: patch-updates ... Signed-off-by: dependabot[bot] <support@github.com>	2024-10-22 14:56:39 +00:00
Bogdan-Ștefan Neacşu	daafb5cae4	Consume only positive bandwidth (#5013 )	2024-10-22 17:46:46 +03:00
Fran Arbanas	0ec2514edf	fix: working directory for nym-credential-proxy (#4997 )	2024-10-22 15:58:45 +02:00
Jędrzej Stuczyński	d6435a8270	Merge pull request #5012 from nymtech/merge/release/2024.12-aero Merge/release/2024.12 aero	2024-10-22 14:32:56 +01:00
Jędrzej Stuczyński	9efc50e067	Merge branch 'release/2024.12-aero' into merge/release/2024.12-aero	2024-10-22 13:03:07 +01:00
Tommy Verrall	1532547e2b	Merge pull request #4948 from nymtech/nym-api-container nym-api container	2024-10-22 13:19:17 +02:00
Tommy Verrall	0cb11632e6	Merge pull request #4957 from nymtech/feat/nym-api-env-vars Add env feature to clap and make clap parameters available as env variables	2024-10-22 13:18:52 +02:00
Tommy Verrall	f71ea52d5d	Merge pull request #4972 from nymtech/feat/nym-node-dockerfile feat: add Dockerfile for nym node	2024-10-22 13:17:54 +02:00
Jędrzej Stuczyński	338835698c	feature: adjusted ticket sizes to the agreed amounts (#5009 ) * feature: adjusted ticket sizes to the agreed amounts * adjusted MiB values to MB	2024-10-22 11:47:31 +01:00
Bogdan-Ștefan Neacşu	e65e261cd3	Push private ip before inserting (#5008 )	2024-10-22 12:31:25 +03:00
Bogdan-Ștefan Neacşu	2d78f6939e	Remove as stale instead of erroring (#5007 )	2024-10-22 11:51:04 +03:00
Bogdan-Ștefan Neacşu	9a45de5874	Remove stale free riders after 24 hours (#5002 )	2024-10-21 13:15:08 +03:00
Bogdan-Ștefan Neacşu	2f894b9be3	Remove race on initial req processing (#5001 )	2024-10-21 13:15:01 +03:00
Jędrzej Stuczyński	d36ea20366	bugfix: dont store sent/received fragments unless explicitly enabled (#4991 )	2024-10-21 09:27:48 +01:00
Bogdan-Ștefan Neacşu	18c6fd3e3e	Gateway peer fixes (#4985 ) * Create bandwidth entry * Remove mismatch possibilities	2024-10-18 12:43:36 +03:00
benedettadavico	d75c7eaaaf	update changelog and bump binaries	2024-10-17 08:51:39 +02:00
Fran Arbanas	99cf7d1eec	feat: add Dockerfile for nym node	2024-10-14 18:03:22 +02:00
Jędrzej Stuczyński	f786dbeaa7	Merge pull request #4960 from nymtech/chore/remove-bloomfilters-for-double-spending nym-node: don't use bloomfilters for double spending checks	2024-10-14 09:44:33 +01:00
Jędrzej Stuczyński	eae76cce10	disabled bloomfilter exporting in nym-api	2024-10-11 08:54:50 +01:00
Jędrzej Stuczyński	9341db5d08	removed gateway/nym-node using global double spending bloomfilter	2024-10-10 17:09:51 +01:00
Jędrzej Stuczyński	75a5192c6d	Merge pull request #4958 from nymtech/bugfix/websocket-message-handling bugfix: replace unreachable macro with an error return	2024-10-09 17:24:17 +01:00
Jędrzej Stuczyński	25ad0920cf	bugfix: replace unreachable macro with an error return	2024-10-09 17:15:41 +01:00
Fran Arbanas	a1e75e1dff	change env var naming to be consistent with nym-node	2024-10-09 13:24:28 +02:00
Fran Arbanas	e59a9a59b6	feat: add env feature to clap and change variables to be available as env variables as well	2024-10-09 13:15:38 +02:00
durch	4c51a8975c	Initial stab	2024-10-01 16:39:47 +02:00
Bogdan-Ștefan Neacşu	a4c6f51fe0	Don't kill gateway on handle drop (#4934 )	2024-09-27 11:02:39 +02:00