added statement logging to nym-api db

fix: tracing logger to output to stderr
Update publish-nym-binaries.yml
2024-11-20 09:35:56 +00:00 · 2024-11-19 17:47:13 +00:00 · 2024-11-18 17:56:57 +01:00 · 2024-11-18 16:24:52 +01:00 · 2024-11-18 14:07:01 +01:00 · 2024-11-18 13:01:27 +01:00
205 changed files with 9873 additions and 4563 deletions
@@ -0,0 +1,45 @@
+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
@@ -55,6 +55,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
+          override: true

      - name: Build all binaries
        uses: actions-rs/cargo@v1
@@ -14,13 +14,14 @@ jobs:
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: stable
+          toolchain: 1.77
          target: wasm32-unknown-unknown
          override: true
-          components: rustfmt, clippy

      - name: Install wasm-opt
-        run: cargo install --version 0.114.0 wasm-opt
+        uses: ./.github/actions/install-wasm-opt
+        with:
+          version: '114'

      - name: Build release contracts
        run: make contracts
@@ -1,55 +0,0 @@
-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
@@ -2,6 +2,10 @@ name: Build and upload Node Status agent container to harbor.nymte.ch

 on:
  workflow_dispatch:
+    inputs:
+      gateway_probe_git_ref:
+        type: string
+        description: Which gateway probe git ref to build the image with

 env:
  WORKING_DIRECTORY: "nym-node-status-agent"
@@ -32,25 +36,26 @@ jobs:
        with:
          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml

-      - name: Check if tag exists
+      - name: cleanup-gateway-probe-ref
+        id: cleanup_gateway_probe_ref
        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
+          GATEWAY_PROBE_GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }}
+          GIT_REF_SLUG="${GATEWAY_PROBE_GIT_REF//\//-}"
+          echo "git_ref=${GIT_REF_SLUG}" >> $GITHUB_OUTPUT

      - 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 }}
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }} >/dev/null 2>&1; then
+            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
+            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
          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 }}
+          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }} -m "Version ${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}"
+          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}

      - 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
+          docker build --build-arg GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }} -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
@@ -4,6 +4,198 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

+## [2024.13-magura] (2024-11-18)
+
+- Limit race probability ([#5145])
+- bugifx: assign 'node_id' when converting from 'GatewayDetails' to 'TestNode' ([#5143])
+- bugfix: make sure to assign correct node_id and identity during 'gateway_details' table migration ([#5142])
+- Respond to auth messages with same version ([#5140])
+- Pain/polyfill deprecated endpoints ([#5131])
+- change: dont select mixnodes bonded with vested tokens into the rewarded set ([#5129])
+- nym-credential-proxy-requests: reqwest use rustls-tls ([#5116])
+- bugfix: preserve as much as possible of the rewarded set during migration ([#5103])
+- Feature/force refresh node ([#5101])
+- Add NYM_VPN_API to env files ([#5099])
+- bugfix: fixed historical uptimes for nodes ([#5097])
+- Remove old use of 1GB constant ([#5096])
+- Graceful agent 1.1.5 ([#5093])
+- Add more translations from v2 to v3 authenticator ([#5091])
+- Nym node - Fix claim delegator rewards ([#5090])
+- Make 250 GB/30 days for free ride mode ([#5083])
+- Don't increase bandwidth two times ([#5081])
+- Fix expiration date as today + 7 days ([#5076])
+- Fix gateway decreasing bandwidth ([#5075])
+- Allow custom http port to be reset ([#5073])
+- bugfix: additional checks inside credential proxy ([#5072])
+- chore: deprecated old nym-api client methods and replaced them when possible ([#5069])
+- NS API with directory v2 (#5058) ([#5068])
+- bugfix: credential-proxy obtain-async ([#5067])
+- Allow nym node config updates ([#5066])
+- bugfix: use corrext axum extractors for ecash route arguments ([#5065])
+- Merge2/release/2024.13 magura ([#5063])
+- bugfix/feature: added NymApiClient method to get all skimmed nodes ([#5062])
+- Merge1/release/2024.13 magura ([#5061])
+- added hacky routes to return nymnodes alongside legacy nodes ([#5051])
+- bugfix: mark migrated gateways as rewarded in the previous epoch in case theyre in the rewarded set ([#5049])
+- bugfix: adjust runtime storage migration ([#5047])
+- bugfix: supersede 'cb13be27f8f61d9ae74d924e85d2e6787895eb14' by using… ([#5046])
+- bugfix: restore default http port for nym-api ([#5045])
+- bugfix: fix ecash handlers routes ([#5043])
+- bugfix: don't assign exit gateways to standby set ([#5041])
+- bugfix: make sure nym-nodes are also tested by network monitor ([#5040])
+- bugfix: use bonded nym-nodes for determining initial network monitor … ([#5039])
+- bugfix: make gateways insert themselves into [local] topology ([#5038])
+- Pass poisson flag  ([#5037])
+- bugfix: use human readable roles for annotations ([#5036])
+- bugfix: use old name for 'epoch_role' in SkimmedNode ([#5034])
+- bugfix: make sure to use correct highest node id when assigning role ([#5032])
+- feature: use axum_client_ip for attempting to extract source ip ([#5031])
+- bugfix: fixed backwards incompatibility for /gateways/described endpoint ([#5030])
+- bugfix: verifying signed information of legacy nodes ([#5029])
+- bugfix: introduce 'LegacyPendingMixNodeChanges' that does not contain 'cost_params_change' ([#5028])
+- bugfix: missing #[serde(default)] for announce port ([#5024])
+- bugfix: directory v2.1 `get_all_avg_gateway_reliability_in_interval` query ([#5023])
+- added 'get_all_described_nodes' to NymApiClient and adjusted return t… ([#5016])
+- Reapply fixes to new branch ([#5014])
+- Consume only positive bandwidth ([#5013])
+- feature: adjusted ticket sizes to the agreed amounts ([#5009])
+- Push private ip before inserting ([#5008])
+- chore: update itertools in compact ecash ([#4994])
+- feature: make accepting t&c a hard requirement for rewarded set selection ([#4993])
+- Fix rustfmt in nym-credential-proxy ([#4992])
+- bugfix: client memory leak ([#4991])
+- Eliminate 0 bandwidth race check ([#4988])
+- [DOCs;/operators]: Release notes for v2024.12 aero ([#4984])
+- Add topup req constructor ([#4983])
+- Fix critical issues SI86 and SI87 from Cure53 ([#4982])
+- Rename nym-vpn-api to nym-credential-proxy ([#4981])
+- enable global ecash routes even if api is not a signer ([#4980])
+- resolve beta clippy issues in contracts ([#4978])
+- Re-enable vested delegation migration ([#4977])
+- feature: require reporting using nym-node binary for rewarded set selection ([#4976])
+- Top up bandwidth ([#4975])
+- [Product Data] Add session type based on ecash ticket received ([#4974])
+- Bugfix/additional directory fixes ([#4973])
+- feat: add Dockerfile for nym node ([#4972])
+- chore: remove unused rocket code ([#4968])
+- Import nym-vpn-api crates ([#4967])
+- feature: importer-cli to correctly handle mixnet/vesting import ([#4966])
+- bugfix: fix expected return type on /v1/gateways endpoint ([#4965])
+- [Product Data] First step in gateway usage data collection ([#4963])
+- Bump sqlx to 0.7.4 ([#4959])
+- Add env feature to clap and make clap parameters available as env variables ([#4957])
+- Feature/contract state tools ([#4954])
+- expose authenticator address along other address in node-details ([#4953])
+- Extract packet processing from mixnode-common ([#4949])
+- nym-api container ([#4948])
+- Ticket type storage ([#4947])
+- Add "utoipa" feature to nym-node ([#4945])
+- build(deps): bump the patch-updates group across 1 directory with 9 updates ([#4944])
+- V2 performance monitoring feature flag ([#4943])
+- Bugfix/rewarder post pruning adjustments ([#4942])
+- Switch over the last set of jobs to arc runners ([#4938])
+- Fix broken build after merge ([#4937])
+- bugfix: correctly paginate through 'search_tx' endpoint ([#4936])
+- Add more conversions for responses of authenticator messages ([#4929])
+- Directory Sevices v2.1 ([#4903])
+- Migrate Legacy Node (Frontend)  ([#4826])
+- Fix critical issues SI84 and SI85 from Cure53 ([#4758])
+
+[#5145]: https://github.com/nymtech/nym/pull/5145
+[#5143]: https://github.com/nymtech/nym/pull/5143
+[#5142]: https://github.com/nymtech/nym/pull/5142
+[#5140]: https://github.com/nymtech/nym/pull/5140
+[#5131]: https://github.com/nymtech/nym/pull/5131
+[#5129]: https://github.com/nymtech/nym/pull/5129
+[#5116]: https://github.com/nymtech/nym/pull/5116
+[#5103]: https://github.com/nymtech/nym/pull/5103
+[#5101]: https://github.com/nymtech/nym/pull/5101
+[#5099]: https://github.com/nymtech/nym/pull/5099
+[#5097]: https://github.com/nymtech/nym/pull/5097
+[#5096]: https://github.com/nymtech/nym/pull/5096
+[#5093]: https://github.com/nymtech/nym/pull/5093
+[#5091]: https://github.com/nymtech/nym/pull/5091
+[#5090]: https://github.com/nymtech/nym/pull/5090
+[#5083]: https://github.com/nymtech/nym/pull/5083
+[#5081]: https://github.com/nymtech/nym/pull/5081
+[#5076]: https://github.com/nymtech/nym/pull/5076
+[#5075]: https://github.com/nymtech/nym/pull/5075
+[#5073]: https://github.com/nymtech/nym/pull/5073
+[#5072]: https://github.com/nymtech/nym/pull/5072
+[#5069]: https://github.com/nymtech/nym/pull/5069
+[#5068]: https://github.com/nymtech/nym/pull/5068
+[#5067]: https://github.com/nymtech/nym/pull/5067
+[#5066]: https://github.com/nymtech/nym/pull/5066
+[#5065]: https://github.com/nymtech/nym/pull/5065
+[#5063]: https://github.com/nymtech/nym/pull/5063
+[#5062]: https://github.com/nymtech/nym/pull/5062
+[#5061]: https://github.com/nymtech/nym/pull/5061
+[#5051]: https://github.com/nymtech/nym/pull/5051
+[#5049]: https://github.com/nymtech/nym/pull/5049
+[#5047]: https://github.com/nymtech/nym/pull/5047
+[#5046]: https://github.com/nymtech/nym/pull/5046
+[#5045]: https://github.com/nymtech/nym/pull/5045
+[#5043]: https://github.com/nymtech/nym/pull/5043
+[#5041]: https://github.com/nymtech/nym/pull/5041
+[#5040]: https://github.com/nymtech/nym/pull/5040
+[#5039]: https://github.com/nymtech/nym/pull/5039
+[#5038]: https://github.com/nymtech/nym/pull/5038
+[#5037]: https://github.com/nymtech/nym/pull/5037
+[#5036]: https://github.com/nymtech/nym/pull/5036
+[#5034]: https://github.com/nymtech/nym/pull/5034
+[#5032]: https://github.com/nymtech/nym/pull/5032
+[#5031]: https://github.com/nymtech/nym/pull/5031
+[#5030]: https://github.com/nymtech/nym/pull/5030
+[#5029]: https://github.com/nymtech/nym/pull/5029
+[#5028]: https://github.com/nymtech/nym/pull/5028
+[#5024]: https://github.com/nymtech/nym/pull/5024
+[#5023]: https://github.com/nymtech/nym/pull/5023
+[#5016]: https://github.com/nymtech/nym/pull/5016
+[#5014]: https://github.com/nymtech/nym/pull/5014
+[#5013]: https://github.com/nymtech/nym/pull/5013
+[#5009]: https://github.com/nymtech/nym/pull/5009
+[#5008]: https://github.com/nymtech/nym/pull/5008
+[#4994]: https://github.com/nymtech/nym/pull/4994
+[#4993]: https://github.com/nymtech/nym/pull/4993
+[#4992]: https://github.com/nymtech/nym/pull/4992
+[#4991]: https://github.com/nymtech/nym/pull/4991
+[#4988]: https://github.com/nymtech/nym/pull/4988
+[#4984]: https://github.com/nymtech/nym/pull/4984
+[#4983]: https://github.com/nymtech/nym/pull/4983
+[#4982]: https://github.com/nymtech/nym/pull/4982
+[#4981]: https://github.com/nymtech/nym/pull/4981
+[#4980]: https://github.com/nymtech/nym/pull/4980
+[#4978]: https://github.com/nymtech/nym/pull/4978
+[#4977]: https://github.com/nymtech/nym/pull/4977
+[#4976]: https://github.com/nymtech/nym/pull/4976
+[#4975]: https://github.com/nymtech/nym/pull/4975
+[#4974]: https://github.com/nymtech/nym/pull/4974
+[#4973]: https://github.com/nymtech/nym/pull/4973
+[#4972]: https://github.com/nymtech/nym/pull/4972
+[#4968]: https://github.com/nymtech/nym/pull/4968
+[#4967]: https://github.com/nymtech/nym/pull/4967
+[#4966]: https://github.com/nymtech/nym/pull/4966
+[#4965]: https://github.com/nymtech/nym/pull/4965
+[#4963]: https://github.com/nymtech/nym/pull/4963
+[#4959]: https://github.com/nymtech/nym/pull/4959
+[#4957]: https://github.com/nymtech/nym/pull/4957
+[#4954]: https://github.com/nymtech/nym/pull/4954
+[#4953]: https://github.com/nymtech/nym/pull/4953
+[#4949]: https://github.com/nymtech/nym/pull/4949
+[#4948]: https://github.com/nymtech/nym/pull/4948
+[#4947]: https://github.com/nymtech/nym/pull/4947
+[#4945]: https://github.com/nymtech/nym/pull/4945
+[#4944]: https://github.com/nymtech/nym/pull/4944
+[#4943]: https://github.com/nymtech/nym/pull/4943
+[#4942]: https://github.com/nymtech/nym/pull/4942
+[#4938]: https://github.com/nymtech/nym/pull/4938
+[#4937]: https://github.com/nymtech/nym/pull/4937
+[#4936]: https://github.com/nymtech/nym/pull/4936
+[#4929]: https://github.com/nymtech/nym/pull/4929
+[#4903]: https://github.com/nymtech/nym/pull/4903
+[#4826]: https://github.com/nymtech/nym/pull/4826
+[#4758]: https://github.com/nymtech/nym/pull/4758
+
 ## [2024.12-aero] (2024-10-17)

 - nym-node: don't use bloomfilters for double spending checks ([#4960])
@@ -19,33 +19,33 @@ members = [
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
-    "common/async-file-watcher",
    "common/authenticator-requests",
+    "common/async-file-watcher",
    "common/bandwidth-controller",
    "common/bin-common",
    "common/client-core",
    "common/client-core/config-types",
-    "common/client-core/gateways-storage",
    "common/client-core/surb-storage",
+    "common/client-core/gateways-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/credential-utils",
-    "common/credential-verification",
    "common/credentials",
+    "common/credential-utils",
    "common/credentials-interface",
+    "common/credential-verification",
    "common/crypto",
    "common/dkg",
    "common/ecash-double-spending",
@@ -54,7 +54,6 @@ 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",
@@ -65,10 +64,10 @@ members = [
    "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",
@@ -104,23 +103,20 @@ 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-api",
-    "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/vpn-api-lib-wasm",
-    "nym-data-observatory",
    "nym-network-monitor",
+    "nym-api",
+    "nym-browser-extension/storage",
+    "nym-api/nym-api-requests",
+    "nym-data-observatory",
    "nym-node",
    "nym-node/nym-node-http-api",
    "nym-node/nym-node-requests",
@@ -143,11 +139,11 @@ 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 = [
@@ -158,7 +154,6 @@ default-members = [
    "gateway",
    "mixnode",
    "nym-api",
-    "nym-credential-proxy/nym-credential-proxy",
    "nym-data-observatory",
    "nym-node",
    "nym-node-status-api",
@@ -194,7 +189,7 @@ aes = "0.8.1"
 aes-gcm = "0.10.1"
 aes-gcm-siv = "0.11.1"
 aead = "0.5.2"
-anyhow = "1.0.90"
+anyhow = "1.0.89"
 argon2 = "0.5.0"
 async-trait = "0.1.83"
 axum-client-ip = "0.6.1"
@@ -203,8 +198,11 @@ axum-extra = "0.9.4"
 base64 = "0.22.1"
 bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
-bit-vec = "0.7.0" # can we unify those?
+
+# can we unify those?
+bit-vec = "0.7.0"
 bitvec = "1.0.0"
+
 blake3 = "1.5.4"
 bloomfilter = "1.0.14"
 bs58 = "0.5.1"
@@ -217,7 +215,7 @@ chacha20 = "0.9.0"
 chacha20poly1305 = "0.10.1"
 chrono = "0.4.31"
 cipher = "0.4.3"
-clap = "4.5.20"
+clap = "4.5.18"
 clap_complete = "4.5"
 clap_complete_fig = "4.5"
 colored = "2.0"
@@ -281,13 +279,13 @@ moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
 okapi = "0.7.0"
-once_cell = "1.20.2"
+once_cell = "1.7.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.1"
+pin-project = "1.0"
 pin-project-lite = "0.2.14"
 pretty_env_logger = "0.4.0"
 publicsuffix = "2.2.3"
@@ -307,7 +305,7 @@ rocket_okapi = "0.8.0"
 safer-ffi = "0.1.13"
 schemars = "0.8.21"
 semver = "1.0.23"
-serde = "1.0.211"
+serde = "1.0.210"
 serde_bytes = "0.11.15"
 serde_derive = "1.0"
 serde_json = "1.0.132"
@@ -404,10 +402,11 @@ 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.95"
-wasm-bindgen-futures = "0.4.45"
+wasm-bindgen = "0.2.93"
+wasm-bindgen-futures = "0.4.43"
 wasmtimer = "0.2.0"
-web-sys = "0.3.72"
+web-sys = "0.3.70"
+

 # Profile settings for individual crates

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.42"
+version = "1.1.43"
 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.42"
+version = "1.1.43"
 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"
@@ -22,4 +22,7 @@ pub enum Error {

    #[error("conversion: {0}")]
    Conversion(String),
+
+    #[error("failed to serialize response packet: {source}")]
+    FailedToSerializeResponsePacket { source: Box<bincode::ErrorKind> },
 }
@@ -1,6 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+pub mod traits;
 pub mod v1;
 pub mod v2;
 pub mod v3;
@@ -0,0 +1,269 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::net::IpAddr;
+
+use nym_credentials_interface::CredentialSpendingData;
+use nym_crypto::asymmetric::x25519::PrivateKey;
+use nym_service_provider_requests_common::{Protocol, ServiceProviderType};
+use nym_sphinx::addressing::clients::Recipient;
+use nym_wireguard_types::PeerPublicKey;
+
+use crate::{v1, v2, v3, Error};
+
+#[derive(Copy, Clone, Debug)]
+pub enum AuthenticatorVersion {
+    V1,
+    V2,
+    V3,
+    UNKNOWN,
+}
+
+impl From<Protocol> for AuthenticatorVersion {
+    fn from(value: Protocol) -> Self {
+        if value.service_provider_type != ServiceProviderType::Authenticator {
+            AuthenticatorVersion::UNKNOWN
+        } else if value.version == v1::VERSION {
+            AuthenticatorVersion::V1
+        } else if value.version == v2::VERSION {
+            AuthenticatorVersion::V2
+        } else if value.version == v3::VERSION {
+            AuthenticatorVersion::V3
+        } else {
+            AuthenticatorVersion::UNKNOWN
+        }
+    }
+}
+
+pub trait InitMessage {
+    fn pub_key(&self) -> PeerPublicKey;
+}
+
+impl InitMessage for v1::registration::InitMessage {
+    fn pub_key(&self) -> PeerPublicKey {
+        self.pub_key
+    }
+}
+
+impl InitMessage for v2::registration::InitMessage {
+    fn pub_key(&self) -> PeerPublicKey {
+        self.pub_key
+    }
+}
+
+impl InitMessage for v3::registration::InitMessage {
+    fn pub_key(&self) -> PeerPublicKey {
+        self.pub_key
+    }
+}
+
+pub trait FinalMessage {
+    fn pub_key(&self) -> PeerPublicKey;
+    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error>;
+    fn private_ip(&self) -> IpAddr;
+    fn credential(&self) -> Option<CredentialSpendingData>;
+}
+
+impl FinalMessage for v1::GatewayClient {
+    fn pub_key(&self) -> PeerPublicKey {
+        self.pub_key
+    }
+
+    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
+        self.verify(private_key, nonce)
+    }
+
+    fn private_ip(&self) -> IpAddr {
+        self.private_ip
+    }
+
+    fn credential(&self) -> Option<CredentialSpendingData> {
+        None
+    }
+}
+
+impl FinalMessage for v2::registration::FinalMessage {
+    fn pub_key(&self) -> PeerPublicKey {
+        self.gateway_client.pub_key
+    }
+
+    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
+        self.gateway_client.verify(private_key, nonce)
+    }
+
+    fn private_ip(&self) -> IpAddr {
+        self.gateway_client.private_ip
+    }
+
+    fn credential(&self) -> Option<CredentialSpendingData> {
+        self.credential.clone()
+    }
+}
+
+impl FinalMessage for v3::registration::FinalMessage {
+    fn pub_key(&self) -> PeerPublicKey {
+        self.gateway_client.pub_key
+    }
+
+    fn verify(&self, private_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
+        self.gateway_client.verify(private_key, nonce)
+    }
+
+    fn private_ip(&self) -> IpAddr {
+        self.gateway_client.private_ip
+    }
+
+    fn credential(&self) -> Option<CredentialSpendingData> {
+        self.credential.clone()
+    }
+}
+
+pub trait QueryBandwidthMessage {
+    fn pub_key(&self) -> PeerPublicKey;
+}
+
+impl QueryBandwidthMessage for PeerPublicKey {
+    fn pub_key(&self) -> PeerPublicKey {
+        *self
+    }
+}
+
+pub trait TopUpMessage {
+    fn pub_key(&self) -> PeerPublicKey;
+    fn credential(&self) -> CredentialSpendingData;
+}
+
+impl TopUpMessage for v3::topup::TopUpMessage {
+    fn pub_key(&self) -> PeerPublicKey {
+        self.pub_key
+    }
+
+    fn credential(&self) -> CredentialSpendingData {
+        self.credential.clone()
+    }
+}
+
+pub enum AuthenticatorRequest {
+    Initial {
+        msg: Box<dyn InitMessage + Send + Sync + 'static>,
+        protocol: Protocol,
+        reply_to: Recipient,
+        request_id: u64,
+    },
+    Final {
+        msg: Box<dyn FinalMessage + Send + Sync + 'static>,
+        protocol: Protocol,
+        reply_to: Recipient,
+        request_id: u64,
+    },
+    QueryBandwidth {
+        msg: Box<dyn QueryBandwidthMessage + Send + Sync + 'static>,
+        protocol: Protocol,
+        reply_to: Recipient,
+        request_id: u64,
+    },
+    TopUpBandwidth {
+        msg: Box<dyn TopUpMessage + Send + Sync + 'static>,
+        protocol: Protocol,
+        reply_to: Recipient,
+        request_id: u64,
+    },
+}
+
+impl From<v1::request::AuthenticatorRequest> for AuthenticatorRequest {
+    fn from(value: v1::request::AuthenticatorRequest) -> Self {
+        match value.data {
+            v1::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
+                msg: Box::new(init_message),
+                protocol: Protocol {
+                    version: value.version,
+                    service_provider_type: ServiceProviderType::Authenticator,
+                },
+                reply_to: value.reply_to,
+                request_id: value.request_id,
+            },
+            v1::request::AuthenticatorRequestData::Final(gateway_client) => Self::Final {
+                msg: Box::new(gateway_client),
+                protocol: Protocol {
+                    version: value.version,
+                    service_provider_type: ServiceProviderType::Authenticator,
+                },
+                reply_to: value.reply_to,
+                request_id: value.request_id,
+            },
+            v1::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
+                Self::QueryBandwidth {
+                    msg: Box::new(peer_public_key),
+                    protocol: Protocol {
+                        version: value.version,
+                        service_provider_type: ServiceProviderType::Authenticator,
+                    },
+                    reply_to: value.reply_to,
+                    request_id: value.request_id,
+                }
+            }
+        }
+    }
+}
+
+impl From<v2::request::AuthenticatorRequest> for AuthenticatorRequest {
+    fn from(value: v2::request::AuthenticatorRequest) -> Self {
+        match value.data {
+            v2::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
+                msg: Box::new(init_message),
+                protocol: value.protocol,
+                reply_to: value.reply_to,
+                request_id: value.request_id,
+            },
+            v2::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
+                msg: final_message,
+                protocol: value.protocol,
+                reply_to: value.reply_to,
+                request_id: value.request_id,
+            },
+            v2::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
+                Self::QueryBandwidth {
+                    msg: Box::new(peer_public_key),
+                    protocol: value.protocol,
+                    reply_to: value.reply_to,
+                    request_id: value.request_id,
+                }
+            }
+        }
+    }
+}
+
+impl From<v3::request::AuthenticatorRequest> for AuthenticatorRequest {
+    fn from(value: v3::request::AuthenticatorRequest) -> Self {
+        match value.data {
+            v3::request::AuthenticatorRequestData::Initial(init_message) => Self::Initial {
+                msg: Box::new(init_message),
+                protocol: value.protocol,
+                reply_to: value.reply_to,
+                request_id: value.request_id,
+            },
+            v3::request::AuthenticatorRequestData::Final(final_message) => Self::Final {
+                msg: final_message,
+                protocol: value.protocol,
+                reply_to: value.reply_to,
+                request_id: value.request_id,
+            },
+            v3::request::AuthenticatorRequestData::QueryBandwidth(peer_public_key) => {
+                Self::QueryBandwidth {
+                    msg: Box::new(peer_public_key),
+                    protocol: value.protocol,
+                    reply_to: value.reply_to,
+                    request_id: value.request_id,
+                }
+            }
+            v3::request::AuthenticatorRequestData::TopUpBandwidth(top_up_message) => {
+                Self::TopUpBandwidth {
+                    msg: top_up_message,
+                    protocol: value.protocol,
+                    reply_to: value.reply_to,
+                    request_id: value.request_id,
+                }
+            }
+        }
+    }
+}
@@ -98,6 +98,16 @@ impl TryFrom<v3::response::AuthenticatorResponse> for v2::response::Authenticato
    }
 }

+impl From<v2::response::AuthenticatorResponse> for v3::response::AuthenticatorResponse {
+    fn from(value: v2::response::AuthenticatorResponse) -> Self {
+        Self {
+            protocol: value.protocol,
+            data: value.data.into(),
+            reply_to: value.reply_to,
+        }
+    }
+}
+
 impl TryFrom<v3::response::AuthenticatorResponseData> for v2::response::AuthenticatorResponseData {
    type Error = crate::Error;

@@ -129,6 +139,22 @@ impl TryFrom<v3::response::AuthenticatorResponseData> for v2::response::Authenti
    }
 }

+impl From<v2::response::AuthenticatorResponseData> for v3::response::AuthenticatorResponseData {
+    fn from(value: v2::response::AuthenticatorResponseData) -> Self {
+        match value {
+            v2::response::AuthenticatorResponseData::PendingRegistration(
+                pending_registration_response,
+            ) => Self::PendingRegistration(pending_registration_response.into()),
+            v2::response::AuthenticatorResponseData::Registered(registered_response) => {
+                Self::Registered(registered_response.into())
+            }
+            v2::response::AuthenticatorResponseData::RemainingBandwidth(
+                remaining_bandwidth_response,
+            ) => Self::RemainingBandwidth(remaining_bandwidth_response.into()),
+        }
+    }
+}
+
 impl From<v3::response::PendingRegistrationResponse> for v2::response::PendingRegistrationResponse {
    fn from(value: v3::response::PendingRegistrationResponse) -> Self {
        Self {
@@ -139,6 +165,16 @@ impl From<v3::response::PendingRegistrationResponse> for v2::response::PendingRe
    }
 }

+impl From<v2::response::PendingRegistrationResponse> for v3::response::PendingRegistrationResponse {
+    fn from(value: v2::response::PendingRegistrationResponse) -> Self {
+        Self {
+            request_id: value.request_id,
+            reply_to: value.reply_to,
+            reply: value.reply.into(),
+        }
+    }
+}
+
 impl From<v3::response::RegisteredResponse> for v2::response::RegisteredResponse {
    fn from(value: v3::response::RegisteredResponse) -> Self {
        Self {
@@ -149,6 +185,16 @@ impl From<v3::response::RegisteredResponse> for v2::response::RegisteredResponse
    }
 }

+impl From<v2::response::RegisteredResponse> for v3::response::RegisteredResponse {
+    fn from(value: v2::response::RegisteredResponse) -> Self {
+        Self {
+            request_id: value.request_id,
+            reply_to: value.reply_to,
+            reply: value.reply.into(),
+        }
+    }
+}
+
 impl From<v3::response::RemainingBandwidthResponse> for v2::response::RemainingBandwidthResponse {
    fn from(value: v3::response::RemainingBandwidthResponse) -> Self {
        Self {
@@ -159,6 +205,16 @@ impl From<v3::response::RemainingBandwidthResponse> for v2::response::RemainingB
    }
 }

+impl From<v2::response::RemainingBandwidthResponse> for v3::response::RemainingBandwidthResponse {
+    fn from(value: v2::response::RemainingBandwidthResponse) -> Self {
+        Self {
+            request_id: value.request_id,
+            reply_to: value.reply_to,
+            reply: value.reply.map(Into::into),
+        }
+    }
+}
+
 impl From<v3::registration::RegistrationData> for v2::registration::RegistrationData {
    fn from(value: v3::registration::RegistrationData) -> Self {
        Self {
@@ -169,6 +225,16 @@ impl From<v3::registration::RegistrationData> for v2::registration::Registration
    }
 }

+impl From<v2::registration::RegistrationData> for v3::registration::RegistrationData {
+    fn from(value: v2::registration::RegistrationData) -> Self {
+        Self {
+            nonce: value.nonce,
+            gateway_data: value.gateway_data.into(),
+            wg_port: value.wg_port,
+        }
+    }
+}
+
 impl From<v3::registration::RegistredData> for v2::registration::RegistredData {
    fn from(value: v3::registration::RegistredData) -> Self {
        Self {
@@ -179,6 +245,16 @@ impl From<v3::registration::RegistredData> for v2::registration::RegistredData {
    }
 }

+impl From<v2::registration::RegistredData> for v3::registration::RegistredData {
+    fn from(value: v2::registration::RegistredData) -> Self {
+        Self {
+            pub_key: value.pub_key,
+            private_ip: value.private_ip,
+            wg_port: value.wg_port,
+        }
+    }
+}
+
 impl From<v3::registration::RemainingBandwidthData> for v2::registration::RemainingBandwidthData {
    fn from(value: v3::registration::RemainingBandwidthData) -> Self {
        Self {
@@ -186,3 +262,11 @@ impl From<v3::registration::RemainingBandwidthData> for v2::registration::Remain
        }
    }
 }
+
+impl From<v2::registration::RemainingBandwidthData> for v3::registration::RemainingBandwidthData {
+    fn from(value: v2::registration::RemainingBandwidthData) -> Self {
+        Self {
+            available_bandwidth: value.available_bandwidth,
+        }
+    }
+}
@@ -27,7 +27,7 @@ pub type HmacSha256 = Hmac<Sha256>;
 pub type Nonce = u64;
 pub type Taken = Option<SystemTime>;

-pub const BANDWIDTH_CAP_PER_DAY: u64 = 1024 * 1024 * 1024; // 1 GB
+pub const BANDWIDTH_CAP_PER_DAY: u64 = 250 * 1024 * 1024 * 1024; // 250 GB

 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct InitMessage {
@@ -47,6 +47,7 @@ pub fn setup_logging() {
 #[cfg(feature = "basic_tracing")]
 pub fn setup_tracing_logger() {
    let log_builder = tracing_subscriber::fmt()
+        .with_writer(std::io::stderr)
        // Use a more compact, abbreviated log format
        .compact()
        // Display source code file paths
@@ -112,7 +112,7 @@ impl GeoAwareTopologyProvider {
    async fn get_topology(&self) -> Option<NymTopology> {
        let mixnodes = match self
            .validator_client
-            .get_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
+            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
            .await
        {
            Err(err) => {
@@ -99,7 +99,7 @@ impl NymApiTopologyProvider {
    async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
        let mixnodes = match self
            .validator_client
-            .get_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
+            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
            .await
        {
            Err(err) => {
@@ -121,7 +121,9 @@ pub async fn current_mixnodes<R: Rng>(

    log::trace!("Fetching list of mixnodes from: {nym_api}");

-    let mixnodes = client.get_basic_active_mixing_assigned_nodes(None).await?;
+    let mixnodes = client
+        .get_all_basic_active_mixing_assigned_nodes(None)
+        .await?;
    let valid_mixnodes = mixnodes
        .iter()
        .filter_map(|mixnode| mixnode.try_into().ok())
@@ -18,19 +18,19 @@ use nym_api_requests::ecash::{
    PartialExpirationDateSignatureResponse, VerificationKeyResponse,
 };
 use nym_api_requests::models::{
-    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
+    ApiHealthResponse, GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
    NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::nym_nodes::SkimmedNode;
 use nym_coconut_dkg_common::types::EpochId;
 use nym_http_api_client::UserAgent;
+use nym_mixnet_contract_common::NymNodeDetails;
 use nym_network_defaults::NymNetworkDetails;
 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,
 };
@@ -192,6 +192,8 @@ impl<C, S> Client<C, S> {
 }

 // validator-api wrappers
+// we have to allow the use of deprecated method here as they're calling the deprecated trait methods
+#[allow(deprecated)]
 impl<C, S> Client<C, S> {
    pub fn api_url(&self) -> &Url {
        self.nym_api.current_url()
@@ -201,46 +203,54 @@ impl<C, S> Client<C, S> {
        self.nym_api.change_base_url(new_endpoint)
    }

+    #[deprecated]
    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.nym_api.get_mixnodes().await?)
    }

+    #[deprecated]
    pub async fn get_cached_mixnodes_detailed(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
        Ok(self.nym_api.get_mixnodes_detailed().await?)
    }

+    #[deprecated]
    pub async fn get_cached_mixnodes_detailed_unfiltered(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
        Ok(self.nym_api.get_mixnodes_detailed_unfiltered().await?)
    }

+    #[deprecated]
    pub async fn get_cached_rewarded_mixnodes(
        &self,
    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.nym_api.get_rewarded_mixnodes().await?)
    }

+    #[deprecated]
    pub async fn get_cached_rewarded_mixnodes_detailed(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
        Ok(self.nym_api.get_rewarded_mixnodes_detailed().await?)
    }

+    #[deprecated]
    pub async fn get_cached_active_mixnodes(
        &self,
    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.nym_api.get_active_mixnodes().await?)
    }

+    #[deprecated]
    pub async fn get_cached_active_mixnodes_detailed(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, ValidatorClientError> {
        Ok(self.nym_api.get_active_mixnodes_detailed().await?)
    }

+    #[deprecated]
    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
        Ok(self.nym_api.get_gateways().await?)
    }
@@ -304,6 +314,8 @@ pub struct NymApiClient {
    // we could re-implement the communication with the REST API on port 1317
 }

+// we have to allow the use of deprecated method here as they're calling the deprecated trait methods
+#[allow(deprecated)]
 impl NymApiClient {
    pub fn new(api_url: Url) -> Self {
        let nym_api = nym_api::Client::new(api_url, None);
@@ -318,10 +330,10 @@ impl NymApiClient {
        NymApiClient { nym_api }
    }

-    pub fn new_with_user_agent(api_url: Url, user_agent: UserAgent) -> Self {
+    pub fn new_with_user_agent(api_url: Url, user_agent: impl Into<UserAgent>) -> Self {
        let nym_api = nym_api::Client::builder::<_, ValidatorClientError>(api_url)
            .expect("invalid api url")
-            .with_user_agent(user_agent)
+            .with_user_agent(user_agent.into())
            .build::<ValidatorClientError>()
            .expect("failed to build nym api client");

@@ -336,7 +348,7 @@ impl NymApiClient {
        self.nym_api.change_base_url(new_endpoint);
    }

-    #[deprecated(note = "use get_basic_active_mixing_assigned_nodes instead")]
+    #[deprecated(note = "use get_all_basic_active_mixing_assigned_nodes instead")]
    pub async fn get_basic_mixnodes(
        &self,
        semver_compatibility: Option<String>,
@@ -394,7 +406,7 @@ impl NymApiClient {

    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
    /// this includes legacy mixnodes and nym-nodes
-    pub async fn get_basic_active_mixing_assigned_nodes(
+    pub async fn get_all_basic_active_mixing_assigned_nodes(
        &self,
        semver_compatibility: Option<String>,
    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
@@ -424,26 +436,93 @@ impl NymApiClient {
        Ok(nodes)
    }

+    /// retrieve basic information for nodes are capable of operating as a mixnode
+    /// this includes legacy mixnodes and nym-nodes
+    pub async fn get_all_basic_mixing_capable_nodes(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<Vec<SkimmedNode>, 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 nodes = Vec::new();
+
+        loop {
+            let mut res = self
+                .nym_api
+                .get_basic_mixing_capable_nodes(
+                    semver_compatibility.clone(),
+                    false,
+                    Some(page),
+                    None,
+                )
+                .await?;
+
+            nodes.append(&mut res.nodes.data);
+            if nodes.len() < res.nodes.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(nodes)
+    }
+
+    /// retrieve basic information for all bonded nodes on the network
+    pub async fn get_all_basic_nodes(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<Vec<SkimmedNode>, 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 nodes = Vec::new();
+
+        loop {
+            let mut res = self
+                .nym_api
+                .get_basic_nodes(semver_compatibility.clone(), false, Some(page), None)
+                .await?;
+
+            nodes.append(&mut res.nodes.data);
+            if nodes.len() < res.nodes.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(nodes)
+    }
+
+    pub async fn health(&self) -> Result<ApiHealthResponse, ValidatorClientError> {
+        Ok(self.nym_api.health().await?)
+    }
+
+    #[deprecated]
    pub async fn get_cached_active_mixnodes(
        &self,
    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.nym_api.get_active_mixnodes().await?)
    }

+    #[deprecated]
    pub async fn get_cached_rewarded_mixnodes(
        &self,
    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.nym_api.get_rewarded_mixnodes().await?)
    }

+    #[deprecated]
    pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
        Ok(self.nym_api.get_mixnodes().await?)
    }

+    #[deprecated]
    pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
        Ok(self.nym_api.get_gateways().await?)
    }

+    #[deprecated]
    pub async fn get_cached_described_gateways(
        &self,
    ) -> Result<Vec<LegacyDescribedGateway>, ValidatorClientError> {
@@ -492,6 +571,7 @@ impl NymApiClient {
        Ok(bonds)
    }

+    #[deprecated]
    pub async fn get_gateway_core_status_count(
        &self,
        identity: IdentityKeyRef<'_>,
@@ -503,6 +583,7 @@ impl NymApiClient {
            .await?)
    }

+    #[deprecated]
    pub async fn get_mixnode_core_status_count(
        &self,
        mix_id: NodeId,
@@ -514,6 +595,7 @@ impl NymApiClient {
            .await?)
    }

+    #[deprecated]
    pub async fn get_mixnode_status(
        &self,
        mix_id: NodeId,
@@ -521,6 +603,7 @@ impl NymApiClient {
        Ok(self.nym_api.get_mixnode_status(mix_id).await?)
    }

+    #[deprecated]
    pub async fn get_mixnode_reward_estimation(
        &self,
        mix_id: NodeId,
@@ -528,6 +611,7 @@ impl NymApiClient {
        Ok(self.nym_api.get_mixnode_reward_estimation(mix_id).await?)
    }

+    #[deprecated]
    pub async fn get_mixnode_stake_saturation(
        &self,
        mix_id: NodeId,
@@ -559,6 +643,7 @@ impl NymApiClient {
            .await?)
    }

+    #[deprecated]
    pub async fn spent_credentials_filter(
        &self,
    ) -> Result<SpentCredentialsResponse, ValidatorClientError> {
@@ -164,7 +164,7 @@ async fn test_nym_api_connection(
 ) -> ConnectionResult {
    let result = match timeout(
        Duration::from_secs(CONNECTION_TEST_TIMEOUT_SEC),
-        client.get_cached_mixnodes(),
+        client.health(),
    )
    .await
    {
@@ -11,7 +11,8 @@ use nym_api_requests::ecash::models::{
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
-    AnnotationResponse, LegacyDescribedMixNode, NodePerformanceResponse, NymNodeDescription,
+    AnnotationResponse, ApiHealthResponse, LegacyDescribedMixNode, NodePerformanceResponse,
+    NodeRefreshBody, NymNodeDescription,
 };
 use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
 use nym_api_requests::pagination::PaginatedResponse;
@@ -54,12 +55,26 @@ 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 {
+    async fn health(&self) -> Result<ApiHealthResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::API_STATUS_ROUTES,
+                routes::HEALTH,
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    #[deprecated]
    #[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
    }

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

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

+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes_detailed_unfiltered(
        &self,
@@ -104,12 +121,14 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[deprecated]
    #[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
    }

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

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

+    #[tracing::instrument(level = "debug", skip_all)]
    async fn get_nodes_described(
        &self,
        page: Option<u32>,
@@ -147,6 +168,7 @@ pub trait NymApiClientExt: ApiClient {
            .await
    }

+    #[tracing::instrument(level = "debug", skip_all)]
    async fn get_nym_nodes(
        &self,
        page: Option<u32>,
@@ -166,6 +188,7 @@ pub trait NymApiClientExt: ApiClient {
            .await
    }

+    #[deprecated]
    #[tracing::instrument(level = "debug", skip_all)]
    async fn get_basic_mixnodes(
        &self,
@@ -190,6 +213,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_basic_gateways(
        &self,
@@ -298,6 +322,82 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    /// 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_mixing_capable_nodes(
+        &self,
+        semver_compatibility: Option<String>,
+        no_legacy: bool,
+        page: Option<u32>,
+        per_page: Option<u32>,
+    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
+        let mut params = Vec::new();
+
+        if let Some(arg) = &semver_compatibility {
+            params.push(("semver_compatibility", arg.clone()))
+        }
+
+        if no_legacy {
+            params.push(("no_legacy", "true".to_string()))
+        }
+
+        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,
+                "unstable",
+                "nym-nodes",
+                "skimmed",
+                "mixnodes",
+                "all",
+            ],
+            &params,
+        )
+        .await
+    }
+    #[instrument(level = "debug", skip(self))]
+
+    async fn get_basic_nodes(
+        &self,
+        semver_compatibility: Option<String>,
+        no_legacy: bool,
+        page: Option<u32>,
+        per_page: Option<u32>,
+    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
+        let mut params = Vec::new();
+
+        if let Some(arg) = &semver_compatibility {
+            params.push(("semver_compatibility", arg.clone()))
+        }
+
+        if no_legacy {
+            params.push(("no_legacy", "true".to_string()))
+        }
+
+        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, "unstable", "nym-nodes", "skimmed"],
+            &params,
+        )
+        .await
+    }
+
+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
        self.get_json(
@@ -307,6 +407,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

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

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

+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_gateway_report(
        &self,
@@ -367,6 +471,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_gateway_history(
        &self,
@@ -403,6 +509,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_rewarded_mixnodes_detailed(
        &self,
@@ -420,6 +527,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_gateway_core_status_count(
        &self,
@@ -452,6 +560,7 @@ pub trait NymApiClientExt: ApiClient {
        }
    }

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

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

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

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

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

+    #[deprecated]
    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_inclusion_probability(
        &self,
@@ -582,18 +696,35 @@ pub trait NymApiClientExt: ApiClient {
        &self,
        node_id: NodeId,
    ) -> Result<NodePerformanceResponse, NymAPIError> {
-        self.get_json_from(format!("/v1/nym-nodes/performance/{node_id}"))
-            .await
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                "nym-nodes",
+                "performance",
+                &node_id.to_string(),
+            ],
+            NO_PARAMS,
+        )
+        .await
    }

    async fn get_node_annotation(
        &self,
        node_id: NodeId,
    ) -> Result<AnnotationResponse, NymAPIError> {
-        self.get_json_from(format!("/v1/nym-nodes/annotation/{node_id}"))
-            .await
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                "nym-nodes",
+                "annotation",
+                &node_id.to_string(),
+            ],
+            NO_PARAMS,
+        )
+        .await
    }

+    #[deprecated]
    async fn get_mixnode_avg_uptime(&self, mix_id: NodeId) -> Result<UptimeResponse, NymAPIError> {
        self.get_json(
            &[
@@ -608,6 +739,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

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

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

+    async fn force_refresh_describe_cache(
+        &self,
+        request: &NodeRefreshBody,
+    ) -> Result<(), NymAPIError> {
+        self.post_json(
+            &[routes::API_VERSION, "nym-nodes", "refresh-described"],
+            NO_PARAMS,
+            request,
+        )
+        .await
+    }
+
    #[instrument(level = "debug", skip(self))]
    async fn epoch_credentials(
        &self,
@@ -36,6 +36,8 @@ pub mod ecash {
 }

 pub const STATUS_ROUTES: &str = "status";
+pub const API_STATUS_ROUTES: &str = "api-status";
+pub const HEALTH: &str = "health";
 pub const MIXNODE: &str = "mixnode";
 pub const GATEWAY: &str = "gateway";
 pub const NYM_NODES: &str = "nym-nodes";
@@ -10,10 +10,10 @@ use cosmrs::AccountId;
 use nym_contracts_common::signing::Nonce;
 use nym_mixnet_contract_common::gateway::{PreassignedGatewayIdsResponse, PreassignedId};
 use nym_mixnet_contract_common::nym_node::{
-    EpochAssignmentResponse, NodeDetailsByIdentityResponse, NodeOwnershipResponse,
-    NodeRewardingDetailsResponse, PagedNymNodeBondsResponse, PagedNymNodeDetailsResponse,
-    PagedUnbondedNymNodesResponse, Role, RolesMetadataResponse, StakeSaturationResponse,
-    UnbondedNodeResponse, UnbondedNymNode,
+    EpochAssignmentResponse, NodeDetailsByIdentityResponse, NodeDetailsResponse,
+    NodeOwnershipResponse, NodeRewardingDetailsResponse, PagedNymNodeBondsResponse,
+    PagedNymNodeDetailsResponse, PagedUnbondedNymNodesResponse, Role, RolesMetadataResponse,
+    StakeSaturationResponse, UnbondedNodeResponse, UnbondedNymNode,
 };
 use nym_mixnet_contract_common::reward_params::WorkFactor;
 use nym_mixnet_contract_common::{
@@ -316,10 +316,7 @@ pub trait MixnetQueryClient {
        .await
    }

-    async fn get_nymnode_details(
-        &self,
-        node_id: NodeId,
-    ) -> Result<NodeOwnershipResponse, NyxdError> {
+    async fn get_nymnode_details(&self, node_id: NodeId) -> Result<NodeDetailsResponse, NyxdError> {
        self.query_mixnet_contract(MixnetQueryMsg::GetNymNodeDetails { node_id })
            .await
    }
@@ -2,10 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::context::QueryClientWithNyxd;
-use crate::utils::{pretty_cosmwasm_coin, show_error};
+use crate::utils::show_error;
 use clap::Parser;
 use comfy_table::Table;
-use nym_validator_client::client::NymApiClientExt;

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -15,12 +14,11 @@ pub struct Args {
 }

 pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    match client.nym_api.get_gateways().await {
+    match client.get_all_cached_described_nodes().await {
        Ok(res) => match args.identity_key {
            Some(identity_key) => {
                let node = res.iter().find(|node| {
-                    node.gateway
-                        .identity_key
+                    node.ed25519_identity_key()
                        .to_string()
                        .eq_ignore_ascii_case(&identity_key)
                });
@@ -32,14 +30,16 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
            None => {
                let mut table = Table::new();

-                table.set_header(vec!["Identity Key", "Owner", "Host", "Bond", "Version"]);
-                for node in res {
+                table.set_header(vec!["Node Id", "Identity Key", "Version", "Is Legacy"]);
+                for node in res
+                    .into_iter()
+                    .filter(|node| node.description.declared_role.entry)
+                {
                    table.add_row(vec![
-                        node.gateway.identity_key.to_string(),
-                        node.owner.to_string(),
-                        node.gateway.host.to_string(),
-                        pretty_cosmwasm_coin(&node.pledge_amount),
-                        node.gateway.version.clone(),
+                        node.node_id.to_string(),
+                        node.ed25519_identity_key().to_base58_string(),
+                        node.description.build_information.build_version,
+                        (!node.contract_node_type.is_nym_node()).to_string(),
                    ]);
                }

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

 use crate::context::QueryClientWithNyxd;
-use crate::utils::{pretty_decimal_with_denom, show_error};
+use crate::utils::show_error;
 use clap::Parser;
 use comfy_table::Table;
-use nym_validator_client::client::NymApiClientExt;

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -15,13 +14,11 @@ pub struct Args {
 }

 pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    match client.nym_api.get_mixnodes().await {
+    match client.get_all_cached_described_nodes().await {
        Ok(res) => match args.identity_key {
            Some(identity_key) => {
                let node = res.iter().find(|node| {
-                    node.bond_information
-                        .mix_node
-                        .identity_key
+                    node.ed25519_identity_key()
                        .to_string()
                        .eq_ignore_ascii_case(&identity_key)
                });
@@ -33,25 +30,16 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
            None => {
                let mut table = Table::new();

-                table.set_header(vec![
-                    "Mix id",
-                    "Identity Key",
-                    "Owner",
-                    "Host",
-                    "Bond",
-                    "Total Delegations",
-                    "Version",
-                ]);
-                for node in res {
-                    let denom = &node.bond_information.original_pledge().denom;
+                table.set_header(vec!["Node Id", "Identity Key", "Version", "Is Legacy"]);
+                for node in res
+                    .into_iter()
+                    .filter(|node| node.description.declared_role.mixnode)
+                {
                    table.add_row(vec![
-                        node.mix_id().to_string(),
-                        node.bond_information.mix_node.identity_key.clone(),
-                        node.bond_information.owner.clone().into_string(),
-                        node.bond_information.mix_node.host.clone(),
-                        pretty_decimal_with_denom(node.rewarding_details.operator, denom),
-                        pretty_decimal_with_denom(node.rewarding_details.delegates, denom),
-                        node.bond_information.mix_node.version,
+                        node.node_id.to_string(),
+                        node.ed25519_identity_key().to_base58_string(),
+                        node.description.build_information.build_version,
+                        (!node.contract_node_type.is_nym_node()).to_string(),
                    ]);
                }

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use time::{Date, OffsetDateTime};
 use tracing::*;

-use nym_credentials::ecash::utils::{ecash_today, EcashTime};
+use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
 use nym_credentials_interface::{Bandwidth, ClientTicket, TicketType};
 use nym_gateway_requests::models::CredentialSpendingRequest;
 use nym_gateway_storage::Storage;
@@ -131,7 +131,7 @@ impl<S: Storage + Clone + 'static> CredentialVerifier<S> {
        let bandwidth = Bandwidth::ticket_amount(credential_type.into());

        self.bandwidth_storage_manager
-            .increase_bandwidth(bandwidth, spend_date)
+            .increase_bandwidth(bandwidth, cred_exp_date())
            .await?;

        Ok(self
@@ -1,34 +0,0 @@
-[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",
-] }
@@ -1,28 +0,0 @@
-// 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);
-}
@@ -1,26 +0,0 @@
-/*
- * 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)
-);
@@ -1,13 +0,0 @@
-// 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),
-}
@@ -1,195 +0,0 @@
-// 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?)
-    }
-}
@@ -1,109 +0,0 @@
-// 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),
-        }
-    }
-}
@@ -1,177 +0,0 @@
-// 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(())
-    }
-}
@@ -315,6 +315,7 @@ impl Client {
        parse_response(res, true).await
    }

+    #[instrument(level = "debug", skip_all)]
    pub async fn get_json_endpoint<T, S, E>(&self, endpoint: S) -> Result<T, HttpClientError<E>>
    where
        for<'a> T: Deserialize<'a>,
@@ -534,17 +535,19 @@ where
    }

    if res.status().is_success() {
-        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 })
-            }
+        #[cfg(debug_assertions)]
+        {
+            let text = res.text().await.inspect_err(|err| {
+                tracing::error!("Couldn't even get response text: {err}");
+            })?;
+            tracing::trace!("Result:\n{:#?}", text);
+
+            serde_json::from_str(&text)
+                .map_err(|err| HttpClientError::GenericRequestFailure(err.to_string()))
        }
+
+        #[cfg(not(debug_assertions))]
+        Ok(res.json().await?)
    } else if res.status() == StatusCode::NOT_FOUND {
        Err(HttpClientError::NotFound)
    } else {
@@ -14,7 +14,6 @@ use nym_task::TaskClient;
 use rand::seq::SliceRandom;
 use rand::thread_rng;
 use std::net::SocketAddr;
-use std::net::ToSocketAddrs;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::task::JoinHandle;
@@ -313,7 +312,7 @@ impl VerlocMeasurer {
            info!("Starting verloc measurements");
            // TODO: should we also measure gateways?

-            let all_mixes = match self.validator_client.get_cached_mixnodes().await {
+            let all_mixes = match self.validator_client.get_all_described_nodes().await {
                Ok(nodes) => nodes,
                Err(err) => {
                    error!(
@@ -332,22 +331,14 @@ impl VerlocMeasurer {
            // we only care about address and identity
            let tested_nodes = all_mixes
                .into_iter()
+                .filter(|n| n.description.declared_role.mixnode)
                .filter_map(|node| {
-                    let mix_node = node.bond_information.mix_node;
-                    // check if the node has sufficient version to be able to understand the packets
-                    let node_version = parse_version(&mix_node.version).ok()?;
-                    if node_version < self.config.minimum_compatible_node_version {
-                        return None;
-                    }
-
                    // try to parse the identity and host
-                    let node_identity =
-                        identity::PublicKey::from_base58_string(mix_node.identity_key).ok()?;
+                    let node_identity = node.ed25519_identity_key();

-                    let verloc_host = (&*mix_node.host, mix_node.verloc_port)
-                        .to_socket_addrs()
-                        .ok()?
-                        .next()?;
+                    let ip = node.description.host_information.ip_address.first()?;
+                    let verloc_port = node.description.verloc_port();
+                    let verloc_host = SocketAddr::new(*ip, verloc_port);

                    // TODO: possible problem in the future, this does name resolution and theoretically
                    // if a lot of nodes maliciously mis-configured themselves, it might take a while to resolve them all
@@ -21,7 +21,7 @@ nym-sphinx-types = { path = "../types" }
 nym-topology = { path = "../../topology" }

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

 [dev-dependencies]
 rand_chacha = { workspace = true }
@@ -3,7 +3,7 @@

 use serde::{Deserialize, Serialize};

-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[repr(u8)]
 pub enum ServiceProviderType {
    NetworkRequester = 0,
@@ -3,7 +3,7 @@ use crate::deprecated::DelegationEvent;
 use crate::error::TypesError;
 use crate::mixnode::NodeCostParams;
 use cosmwasm_std::Decimal;
-use nym_mixnet_contract_common::{Delegation as MixnetContractDelegation, NodeId};
+use nym_mixnet_contract_common::{Delegation as MixnetContractDelegation, NodeId, NodeRewarding};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

@@ -70,6 +70,14 @@ pub struct DelegationWithEverything {
    pub mixnode_is_unbonding: Option<bool>,
 }

+pub struct NodeInformation {
+    pub owner: String,
+    pub mix_id: NodeId,
+    pub node_identity: String,
+    pub rewarding_details: NodeRewarding,
+    pub is_unbonding: bool,
+}
+
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
    feature = "generate-ts",
@@ -68,7 +68,7 @@ pub async fn current_network_topology_async(

    let api_client = NymApiClient::new(url);
    let mixnodes = api_client
-        .get_basic_active_mixing_assigned_nodes(None)
+        .get_all_basic_active_mixing_assigned_nodes(None)
        .await?;
    let gateways = api_client.get_all_basic_entry_assigned_nodes(None).await?;

@@ -99,12 +99,25 @@ pub async fn start_wireguard<St: nym_gateway_storage::Storage + Clone + 'static>
    let peers = all_peers
        .into_iter()
        .map(Peer::try_from)
-        .collect::<Result<Vec<_>, _>>()?;
+        .collect::<Result<Vec<_>, _>>()?
+        .into_iter()
+        .map(|mut peer| {
+            // since WGApi doesn't set those values on init, let's set them to 0
+            peer.rx_bytes = 0;
+            peer.tx_bytes = 0;
+            peer
+        })
+        .collect::<Vec<_>>();
    for peer in peers.iter() {
        let bandwidth_manager =
            PeerController::generate_bandwidth_manager(storage.clone(), &peer.public_key)
                .await?
                .map(|bw_m| Arc::new(RwLock::new(bw_m)));
+        // Update storage with *x_bytes set to 0, as in kernel peers we can't set those values
+        // so we need to restart counting. Hopefully the bandwidth was counted in available_bandwidth
+        storage
+            .insert_wireguard_peer(peer, bandwidth_manager.is_some())
+            .await?;
        peer_bandwidth_managers.insert(peer.public_key.clone(), bandwidth_manager);
    }
    wg_api.create_interface()?;
@@ -7,8 +7,8 @@ use defguard_wireguard_rs::{
    WireguardInterfaceApi,
 };
 use futures::channel::oneshot;
-use nym_authenticator_requests::{
-    latest::registration::RemainingBandwidthData, v1::registration::BANDWIDTH_CAP_PER_DAY,
+use nym_authenticator_requests::latest::registration::{
+    RemainingBandwidthData, BANDWIDTH_CAP_PER_DAY,
 };
 use nym_credential_verification::{
    bandwidth_storage_manager::BandwidthStorageManager, BandwidthFlushingBehaviourConfig,
@@ -194,6 +194,10 @@ impl<St: Storage + Clone + 'static> PeerController<St> {
        );
        self.bw_storage_managers
            .insert(peer.public_key.clone(), bandwidth_storage_manager);
+        // try to immediately update the host information, to eliminate races
+        if let Ok(host_information) = self.wg_api.inner.read_interface_data() {
+            *self.host_information.write().await = host_information;
+        }
        tokio::spawn(async move {
            if let Err(e) = handle.run().await {
                log::error!("Peer handle shut down ungracefully - {e}");
@@ -230,7 +234,7 @@ impl<St: Storage + Clone + 'static> PeerController<St> {
                // host information not updated yet
                return Ok(None);
            };
-            BANDWIDTH_CAP_PER_DAY.saturating_sub((peer.rx_bytes + peer.tx_bytes) as i64)
+            BANDWIDTH_CAP_PER_DAY.saturating_sub(peer.rx_bytes + peer.tx_bytes) as i64
        };

        Ok(Some(RemainingBandwidthData {
@@ -6,7 +6,7 @@ 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;
+use nym_authenticator_requests::latest::registration::BANDWIDTH_CAP_PER_DAY;
 use nym_credential_verification::bandwidth_storage_manager::BandwidthStorageManager;
 use nym_gateway_storage::models::WireguardPeer;
 use nym_gateway_storage::Storage;
@@ -18,7 +18,7 @@ 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
+const AUTO_REMOVE_AFTER: Duration = Duration::from_secs(60 * 60 * 24 * 30); // 30 days

 pub struct PeerHandle<St> {
    storage: St,
@@ -75,8 +75,8 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {

    async fn active_peer(
        &mut self,
-        storage_peer: WireguardPeer,
-        kernel_peer: Peer,
+        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)
@@ -98,7 +98,7 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
        } else {
            if SystemTime::now().duration_since(self.startup_timestamp)? >= AUTO_REMOVE_AFTER {
                log::debug!(
-                    "Peer {} has been present for 24 hours, removing it",
+                    "Peer {} has been present for 30 days, removing it",
                    self.public_key.to_string()
                );
                let success = self.remove_peer().await?;
@@ -136,9 +136,12 @@ impl<St: Storage + Clone + 'static> PeerHandle<St> {
                        log::debug!("Peer {:?} not in storage anymore, shutting down handle", self.public_key);
                        return Ok(());
                    };
-                    if !self.active_peer(storage_peer, kernel_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(());
+                    } else {
+                        // Update storage values
+                        self.storage.insert_wireguard_peer(&kernel_peer, self.bandwidth_storage_manager.is_some()).await?;
                    }
                }

@@ -433,7 +433,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.59",
 ]

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

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

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

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

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

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

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

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

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

 [[package]]
@@ -2120,5 +2120,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.85",
+ "syn 2.0.59",
 ]
@@ -4,6 +4,7 @@
 use super::helpers::must_get_gateway_bond_by_owner;
 use super::storage;
 use crate::constants::default_node_costs;
+use crate::interval::storage as interval_storage;
 use crate::mixnet_contract_settings::storage as mixnet_params_storage;
 use crate::nodes::helpers::save_new_nymnode_with_id;
 use crate::nodes::transactions::add_nym_node_inner;
@@ -115,6 +116,10 @@ pub fn try_migrate_to_nymnode(
            comment: "legacy gateway did not have a pre-assigned node id".to_string(),
        })?;

+    let current_epoch =
+        interval_storage::current_interval(deps.storage)?.current_epoch_absolute_id();
+    let previous_epoch = current_epoch.saturating_sub(1);
+
    // create nym-node entry
    // for gateways it's quite straightforward as there are no delegations or rewards to worry about
    save_new_nymnode_with_id(
@@ -125,6 +130,7 @@ pub fn try_migrate_to_nymnode(
        cost_params,
        info.sender.clone(),
        gateway_bond.pledge_amount,
+        previous_epoch,
    )?;

    storage::PREASSIGNED_LEGACY_IDS.remove(deps.storage, gateway_identity.clone());
@@ -22,6 +22,8 @@ pub(crate) fn save_new_nymnode(
    pledge: Coin,
 ) -> Result<NodeId, MixnetContractError> {
    let node_id = next_nymnode_id_counter(storage)?;
+    let current_epoch = interval_storage::current_interval(storage)?.current_epoch_absolute_id();
+
    save_new_nymnode_with_id(
        storage,
        node_id,
@@ -30,11 +32,13 @@ pub(crate) fn save_new_nymnode(
        cost_params,
        owner,
        pledge,
+        current_epoch,
    )?;

    Ok(node_id)
 }

+#[allow(clippy::too_many_arguments)]
 pub(crate) fn save_new_nymnode_with_id(
    storage: &mut dyn Storage,
    node_id: NodeId,
@@ -43,10 +47,9 @@ pub(crate) fn save_new_nymnode_with_id(
    cost_params: NodeCostParams,
    owner: Addr,
    pledge: Coin,
+    last_rewarding_epoch: u32,
 ) -> Result<(), MixnetContractError> {
-    let current_epoch = interval_storage::current_interval(storage)?.current_epoch_absolute_id();
-
-    let node_rewarding = NodeRewarding::initialise_new(cost_params, &pledge, current_epoch)?;
+    let node_rewarding = NodeRewarding::initialise_new(cost_params, &pledge, last_rewarding_epoch)?;
    let node_bond = NymNodeBond::new(node_id, owner, pledge, node, bonding_height);

    // save node bond data
@@ -104,7 +104,10 @@ pub(crate) fn next_nymnode_id_counter(store: &mut dyn Storage) -> StdResult<Node
 }

 pub(crate) fn initialise_storage(storage: &mut dyn Storage) -> Result<(), MixnetContractError> {
-    ACTIVE_ROLES_BUCKET.save(storage, &RoleStorageBucket::default())?;
+    let active_bucket = RoleStorageBucket::default();
+    let inactive_bucket = active_bucket.other();
+
+    ACTIVE_ROLES_BUCKET.save(storage, &active_bucket)?;
    let roles = vec![
        Role::Layer1,
        Role::Layer2,
@@ -114,24 +117,12 @@ pub(crate) fn initialise_storage(storage: &mut dyn Storage) -> Result<(), Mixnet
        Role::Standby,
    ];
    for role in roles {
-        ROLES.save(storage, (RoleStorageBucket::default() as u8, role), &vec![])?;
-        ROLES.save(
-            storage,
-            (RoleStorageBucket::default().other() as u8, role),
-            &vec![],
-        )?
+        ROLES.save(storage, (active_bucket as u8, role), &vec![])?;
+        ROLES.save(storage, (inactive_bucket as u8, role), &vec![])?
    }

-    ROLES_METADATA.save(
-        storage,
-        RoleStorageBucket::default() as u8,
-        &Default::default(),
-    )?;
-    ROLES_METADATA.save(
-        storage,
-        RoleStorageBucket::default().other() as u8,
-        &Default::default(),
-    )?;
+    ROLES_METADATA.save(storage, active_bucket as u8, &Default::default())?;
+    ROLES_METADATA.save(storage, inactive_bucket as u8, &Default::default())?;

    Ok(())
 }
@@ -90,12 +90,16 @@ mod families_purge {

 mod nym_nodes_usage {
    use crate::constants::{CONTRACT_STATE_KEY, REWARDING_PARAMS_KEY};
+    use crate::interval::storage::current_interval;
    use crate::mixnet_contract_settings::storage::CONTRACT_STATE;
+    use crate::nodes::storage::helpers::RoleStorageBucket;
+    use crate::nodes::storage::rewarded_set::{ACTIVE_ROLES_BUCKET, ROLES, ROLES_METADATA};
    use crate::rewards::storage::RewardingStorage;
    use crate::support::helpers::ensure_epoch_in_progress_state;
    use cosmwasm_std::{Addr, Coin, DepsMut, Order, StdResult, Storage};
    use cw_storage_plus::{Item, Map};
    use mixnet_contract_common::error::MixnetContractError;
+    use mixnet_contract_common::nym_node::{RewardedSetMetadata, Role};
    use mixnet_contract_common::reward_params::RewardedSetParams;
    use mixnet_contract_common::{
        ContractState, ContractStateParams, IntervalRewardParams, MigrateMsg, NodeId,
@@ -173,7 +177,9 @@ mod nym_nodes_usage {
        Ok(())
    }

-    fn preassign_gateway_ids(storage: &mut dyn Storage) -> Result<(), MixnetContractError> {
+    fn preassign_gateway_ids(
+        storage: &mut dyn Storage,
+    ) -> Result<(Option<NodeId>, Option<NodeId>), MixnetContractError> {
        // that one is a big if. we have ~100 gateways so we **might** be able to fit it within migration.
        // if not, then we'll have to do it in batches/change our approach

@@ -182,8 +188,15 @@ mod nym_nodes_usage {
            .map(|res| res.map(|row| row.1))
            .collect::<StdResult<Vec<_>>>()?;

+        let mut start = None;
+        let mut end = None;
        for gateway in gateways {
            let id = crate::nodes::storage::next_nymnode_id_counter(storage)?;
+            if start.is_none() {
+                start = Some(id)
+            }
+            end = Some(id);
+
            crate::gateways::storage::PREASSIGNED_LEGACY_IDS.save(
                storage,
                gateway.gateway.identity_key,
@@ -191,10 +204,12 @@ mod nym_nodes_usage {
            )?;
        }

-        Ok(())
+        Ok((start, end))
    }

-    fn cleanup_legacy_storage(storage: &mut dyn Storage) -> Result<(), MixnetContractError> {
+    fn cleanup_legacy_storage(
+        storage: &mut dyn Storage,
+    ) -> Result<Vec<NodeId>, MixnetContractError> {
        #[derive(Copy, Clone, Default, Serialize, Deserialize)]
        pub struct LayerDistribution {
            pub layer1: u64,
@@ -224,11 +239,11 @@ mod nym_nodes_usage {
            .keys(storage, None, None, Order::Ascending)
            .collect::<Result<Vec<_>, _>>()?;

-        for node_id in rewarded_ids {
+        for &node_id in &rewarded_ids {
            REWARDED_SET.remove(storage, node_id)
        }

-        Ok(())
+        Ok(rewarded_ids)
    }

    fn migrate_rewarded_set_params(storage: &mut dyn Storage) -> Result<(), MixnetContractError> {
@@ -268,6 +283,98 @@ mod nym_nodes_usage {
        Ok(())
    }

+    fn assign_temporary_rewarded_set(
+        storage: &mut dyn Storage,
+        (min_available_gateway, max_available_gateway): (Option<NodeId>, Option<NodeId>),
+        current_rewarded_set_mixnodes: Vec<NodeId>,
+    ) -> Result<(), MixnetContractError> {
+        let epoch_id = current_interval(storage)?.current_epoch_absolute_id();
+
+        // in the previous step we explicitly set rewarded set to 120 mixnodes and 50 entry gateways
+        // note: we can't assign exit gateways because the contract itself doesn't know which might support it
+
+        let active_bucket = RoleStorageBucket::default();
+        let inactive_bucket = active_bucket.other();
+        ACTIVE_ROLES_BUCKET.save(storage, &active_bucket)?;
+
+        // ACTIVE BUCKET:
+        let mut active_metadata = RewardedSetMetadata::new(epoch_id);
+
+        let mut current_rewarded_set_mixnodes = current_rewarded_set_mixnodes;
+        // ensure it's sorted. it should have already been, but better safe than sorry..
+        current_rewarded_set_mixnodes.sort();
+
+        let mut layer1 = Vec::new();
+        let mut layer2 = Vec::new();
+        let mut layer3 = Vec::new();
+        let mut entry = Vec::new();
+
+        for (i, mix_id) in current_rewarded_set_mixnodes
+            .into_iter()
+            .take(120)
+            .enumerate()
+        {
+            if i % 3 == 0 {
+                layer1.push(mix_id);
+            } else if i % 3 == 1 {
+                layer2.push(mix_id);
+            } else if i % 3 == 2 {
+                layer3.push(mix_id);
+            }
+        }
+
+        if let (Some(min_id), Some(max_id)) = (min_available_gateway, max_available_gateway) {
+            // we can assign the gateway nodes
+            entry = (min_id..=max_id).take(50).collect();
+        }
+
+        // ACTIVE BUCKET:
+        active_metadata.fully_assigned = true;
+
+        // layer1
+        ROLES.save(storage, (active_bucket as u8, Role::Layer1), &layer1)?;
+        active_metadata.layer1_metadata.num_nodes = layer1.len() as u32;
+        active_metadata.layer1_metadata.highest_id = layer1.last().copied().unwrap_or_default();
+
+        // layer2
+        ROLES.save(storage, (active_bucket as u8, Role::Layer2), &layer2)?;
+        active_metadata.layer2_metadata.num_nodes = layer2.len() as u32;
+        active_metadata.layer2_metadata.highest_id = layer2.last().copied().unwrap_or_default();
+
+        // layer3
+        ROLES.save(storage, (active_bucket as u8, Role::Layer3), &layer3)?;
+        active_metadata.layer3_metadata.num_nodes = layer3.len() as u32;
+        active_metadata.layer3_metadata.highest_id = layer3.last().copied().unwrap_or_default();
+
+        // entry
+        ROLES.save(storage, (active_bucket as u8, Role::EntryGateway), &entry)?;
+        active_metadata.entry_gateway_metadata.num_nodes = entry.len() as u32;
+        active_metadata.entry_gateway_metadata.highest_id =
+            entry.last().copied().unwrap_or_default();
+
+        // nothing for exit or standby
+        ROLES.save(storage, (active_bucket as u8, Role::ExitGateway), &vec![])?;
+        ROLES.save(storage, (active_bucket as u8, Role::Standby), &vec![])?;
+        ROLES_METADATA.save(storage, active_bucket as u8, &active_metadata)?;
+
+        // SECONDARY BUCKET
+        let roles = vec![
+            Role::Layer1,
+            Role::Layer2,
+            Role::Layer3,
+            Role::EntryGateway,
+            Role::ExitGateway,
+            Role::Standby,
+        ];
+        for role in roles {
+            ROLES.save(storage, (inactive_bucket as u8, role), &vec![])?
+        }
+
+        ROLES_METADATA.save(storage, inactive_bucket as u8, &Default::default())?;
+
+        Ok(())
+    }
+
    pub(crate) fn migrate_to_nym_nodes_usage(
        deps: DepsMut<'_>,
        _msg: &MigrateMsg,
@@ -284,16 +391,18 @@ mod nym_nodes_usage {

        // pre-assign NodeId to all gateways (that will be applied during nym-node migration)
        // to simplify all other code during the intermediate period
-        preassign_gateway_ids(deps.storage)?;
-
-        // initialise all the storage structures required by nym-nodes
-        crate::nodes::storage::initialise_storage(deps.storage)?;
+        let gateways = preassign_gateway_ids(deps.storage)?;

        // update the simple active/rewarded set sizes to actually contain the distribution of roles
        migrate_rewarded_set_params(deps.storage)?;

        // remove all redundant storage items
-        cleanup_legacy_storage(deps.storage)?;
+        let old_rewarded_set_mixnodes = cleanup_legacy_storage(deps.storage)?;
+
+        // assign initial rewarded set
+        // and initialise all the storage structures required by nym-nodes
+        // based on the nodes that are in the contract right now
+        assign_temporary_rewarded_set(deps.storage, gateways, old_rewarded_set_mixnodes)?;

        Ok(())
    }
@@ -18,6 +18,7 @@ GROUP_CONTRACT_ADDRESS=n1qg5ega6dykkxc307y25pecuufrjkxkaggkkxh7nad0vhyhtuhw3sa07
 MULTISIG_CONTRACT_ADDRESS=n1zwv6feuzhy6a9wekh96cd57lsarmqlwxdypdsplw6zhfncqw6ftqx5a364
 COCONUT_DKG_CONTRACT_ADDRESS=n1aakfpghcanxtc45gpqlx8j3rq0zcpyf49qmhm9mdjrfx036h4z5sy2vfh9

-EXPLORER_API=https://canary-explorer.performance.nymte.ch/api
+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
+NYM_API=https://canary-api.performance.nymte.ch/api/
+NYM_VPN_API=https://nym-vpn-api-git-deploy-canary-nyx-network-staging.vercel.app/api/
@@ -25,4 +25,4 @@ 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/
-NYM_VPN_API="https://nymvpn.com/api"
+NYM_VPN_API="https://nymvpn.com/api/"
@@ -18,6 +18,7 @@ COCONUT_DKG_CONTRACT_ADDRESS=n1pk8jgr6y4c5k93gz7qf3xc0hvygmp7csk88c2tf8l39tkq683
 VESTING_CONTRACT_ADDRESS=n1jlzdxnyces4hrhqz68dqk28mrw5jgwtcfq0c2funcwrmw0dx9l9s8nnnvj
 REWARDING_VALIDATOR_ADDRESS=n1rfvpsynktze6wvn6ldskj8xgwfzzk5v6pnff39

-EXPLORER_API=https://qa-network-explorer.qa.nymte.ch/api
+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
+NYM_API=https://qa-nym-api.qa.nymte.ch/api/
+NYM_VPN_API=https://nym-vpn-api-git-deploy-qa-nyx-network-staging.vercel.app/api/
@@ -19,7 +19,8 @@ COCONUT_DKG_CONTRACT_ADDRESS=n1v3n2ly2dp3a9ng3ff6rh26yfkn0pc5hed7w2shc5u9ca5c865
 ECASH_CONTRACT_ADDRESS=n1v3vydvs2ued84yv3khqwtgldmgwn0elljsdh08dr5s2j9x4rc5fs9jlwz9

 STATISTICS_SERVICE_DOMAIN_ADDRESS="http://0.0.0.0"
-EXPLORER_API=https://sandbox-explorer.nymtech.net/api
+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_WS=wss://rpc.sandbox.nymtech.net/websocket/
+NYM_API=https://sandbox-nym-api1.nymtech.net/api/
+NYM_VPN_API=https://nym-vpn-api-git-deploy-sandbox-nyx-network-staging.vercel.app/api/
@@ -1,6 +1,6 @@
 [package]
 name = "explorer-api"
-version = "1.1.41"
+version = "1.1.42"
 edition = "2021"
 license.workspace = true

@@ -8,6 +8,9 @@ use nym_contracts_common::truncate_decimal;
 use nym_mixnet_contract_common::NodeId;
 use nym_validator_client::client::NymApiClientExt;

+// use deprecated method as hopefully this whole API will be sunset soon-enough...
+// and we're only getting info for legacy node so the relevant data should still exist
+#[allow(deprecated)]
 pub(crate) async fn retrieve_mixnode_econ_stats(
    client: &ThreadsafeValidatorClient,
    mix_id: NodeId,
@@ -17,6 +17,8 @@ pub(crate) struct ExplorerApiTasks {
    shutdown: TaskClient,
 }

+// allow usage of deprecated methods here as we actually want to be explicitly querying for legacy data
+#[allow(deprecated)]
 impl ExplorerApiTasks {
    pub(crate) fn new(state: ExplorerApiStateContext, shutdown: TaskClient) -> Self {
        ExplorerApiTasks { state, shutdown }
@@ -102,7 +102,6 @@ export const isLessThan = (a: number, b: number) => a < b;
 */

 export const isBalanceEnough = (fee: string, tx: string = '0', balance: string = '0') => {
-  console.log('balance', balance, fee, tx);
  try {
    return Big(balance).gte(Big(fee).plus(Big(tx)));
  } catch (e) {
@@ -69,7 +69,6 @@ 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" }
@@ -12,7 +12,6 @@ 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";
@@ -40,9 +39,6 @@ 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>,
@@ -58,9 +54,7 @@ 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.as_ref())
-                .join(DEFAULT_CLIENTS_STORAGE_FILENAME),
-            stats_storage: default_data_directory(id).join(DEFAULT_STATS_STORAGE_FILENAME),
+            clients_storage: default_data_directory(id).join(DEFAULT_CLIENTS_STORAGE_FILENAME),
            // node_description: default_config_filepath(id).join(DEFAULT_DESCRIPTION_FILENAME),
            network_requester_config: None,
            ip_packet_router_config: None,
@@ -76,7 +70,6 @@ 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,7 +2,6 @@
 // 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};
@@ -116,12 +115,6 @@ 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,

@@ -5,7 +5,6 @@ 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;
@@ -80,14 +79,6 @@ 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>,
@@ -13,8 +13,7 @@ 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, initialise_stats_storage, load_network_requester_config,
-    GatewayTopologyProvider,
+    initialise_main_storage, load_network_requester_config, GatewayTopologyProvider,
 };
 use crate::node::mixnet_handling::receiver::connection_handler::ConnectionHandler;
 use futures::channel::{mpsc, oneshot};
@@ -47,7 +46,6 @@ 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?
@@ -103,8 +101,6 @@ 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(),
@@ -115,7 +111,7 @@ pub async fn create_gateway(
        custom_mixnet_path: custom_mixnet.clone(),
    });

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

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

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

    wireguard_data: Option<nym_wireguard::WireguardData>,

@@ -174,12 +168,10 @@ impl<St> Gateway<St> {
        config: Config,
        network_requester_opts: Option<LocalNetworkRequesterOpts>,
        ip_packet_router_opts: Option<LocalIpPacketRouterOpts>,
-        client_storage: St,
-        stats_storage: PersistentStatsStorage,
+        storage: St,
    ) -> Result<Self, GatewayError> {
        Ok(Gateway {
-            client_storage,
-            stats_storage,
+            storage,
            identity_keypair: Arc::new(load_identity_keys(&config)?),
            sphinx_keypair: Arc::new(helpers::load_sphinx_keys(&config)?),
            config,
@@ -192,7 +184,7 @@ impl<St> Gateway<St> {
            task_client: None,
        })
    }
-    #[allow(clippy::too_many_arguments)]
+
    pub fn new_loaded(
        config: Config,
        network_requester_opts: Option<LocalNetworkRequesterOpts>,
@@ -200,8 +192,7 @@ impl<St> Gateway<St> {
        authenticator_opts: Option<LocalAuthenticatorOpts>,
        identity_keypair: Arc<identity::KeyPair>,
        sphinx_keypair: Arc<encryption::KeyPair>,
-        client_storage: St,
-        stats_storage: PersistentStatsStorage,
+        storage: St,
    ) -> Self {
        Gateway {
            config,
@@ -210,8 +201,7 @@ impl<St> Gateway<St> {
            authenticator_opts,
            identity_keypair,
            sphinx_keypair,
-            client_storage,
-            stats_storage,
+            storage,
            wireguard_data: None,
            session_stats: None,
            run_http_server: true,
@@ -288,7 +278,7 @@ impl<St> Gateway<St> {

        let connection_handler = ConnectionHandler::new(
            packet_processor,
-            self.client_storage.clone(),
+            self.storage.clone(),
            ack_sender,
            active_clients_store,
        );
@@ -324,7 +314,7 @@ impl<St> Gateway<St> {
            forwarding_channel,
            router_tx,
        );
-        let all_peers = self.client_storage.get_all_wireguard_peers().await?;
+        let all_peers = self.storage.get_all_wireguard_peers().await?;
        let used_private_network_ips = all_peers
            .iter()
            .cloned()
@@ -380,7 +370,7 @@ impl<St> Gateway<St> {
                .start_with_shutdown(router_shutdown);

            let wg_api = nym_wireguard::start_wireguard(
-                self.client_storage.clone(),
+                self.storage.clone(),
                all_peers,
                shutdown,
                wireguard_data,
@@ -428,7 +418,7 @@ impl<St> Gateway<St> {

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

        let (mut stats_collector, stats_event_sender) =
-            GatewayStatisticsCollector::new(shared_session_stats, self.stats_storage.clone());
+            GatewayStatisticsCollector::new(shared_session_stats);
        tokio::spawn(async move { stats_collector.run(shutdown).await });
        stats_event_sender
    }
@@ -632,7 +622,7 @@ impl<St> Gateway<St> {
        // TODO: if anything, this should be getting data directly from the contract
        // as opposed to the validator API
        let validator_client = self.random_api_client()?;
-        let existing_nodes = match validator_client.get_cached_gateways().await {
+        let existing_nodes = match validator_client.get_all_basic_nodes(None).await {
            Ok(nodes) => nodes,
            Err(err) => {
                error!("failed to grab initial network gateways - {err}\n Please try to startup again in few minutes");
@@ -640,9 +630,9 @@ impl<St> Gateway<St> {
            }
        };

-        Ok(existing_nodes.iter().any(|node| {
-            node.gateway.identity_key == self.identity_keypair.public_key().to_base58_string()
-        }))
+        Ok(existing_nodes
+            .iter()
+            .any(|node| &node.ed25519_identity_pubkey == self.identity_keypair.public_key()))
    }

    pub async fn run(mut self) -> Result<(), GatewayError>
@@ -711,7 +701,7 @@ impl<St> Gateway<St> {
                nyxd_client,
                self.identity_keypair.public_key().to_bytes(),
                shutdown.fork("EcashVerifier"),
-                self.client_storage.clone(),
+                self.storage.clone(),
            )
            .await?,
        );
@@ -2,14 +2,13 @@
 // 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::{error, trace, warn};
+use tracing::trace;

 pub mod sessions;

@@ -24,38 +23,21 @@ 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,
+            session_stats: SessionStatsHandler::new(shared_session_stats),
        };
        (collector, stats_event_tx)
    }

    async fn update_shared_state(&mut self, update_time: OffsetDateTime) {
-        if let Err(e) = self
-            .session_stats
-            .maybe_update_shared_state(update_time)
-            .await
-        {
-            error!("Failed to update session stats - {e}");
-        }
+        self.session_stats.update_shared_state(update_time).await;
        //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! {
@@ -71,10 +53,7 @@ impl GatewayStatisticsCollector {
                Some(stat_event) = self.stats_event_rx.next() => {
                    //dispatching event to proper handler
                    match stat_event {
-                        StatsEvent::SessionStatsEvent(event) => {
-                            if let Err(e) = self.session_stats.handle_event(event).await{
-                            warn!("Session event handling error - {e}");
-                        }},
+                        StatsEvent::SessionStatsEvent(event) => self.session_stats.handle_event(event),
                    }
                },

@@ -2,158 +2,176 @@
 // 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 {
-    storage: PersistentStatsStorage,
-    current_day: Date,
+    last_update_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, storage: PersistentStatsStorage) -> Self {
+    pub fn new(shared_session_stats: SharedSessionStats) -> Self {
        SessionStatsHandler {
-            storage,
-            current_day: OffsetDateTime::now_utc().date(),
+            last_update_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) async fn handle_event(
-        &mut self,
-        event: SessionEvent,
-    ) -> Result<(), StatsStorageError> {
+    pub(crate) fn handle_event(&mut self, event: SessionEvent) {
        match event {
            SessionEvent::SessionStart { start_time, client } => {
-                self.handle_session_start(start_time, client).await
+                self.handle_session_start(start_time, client);
            }
-
            SessionEvent::SessionStop { stop_time, client } => {
-                self.handle_session_stop(stop_time, client).await
+                self.handle_session_stop(stop_time, client);
            }
-
            SessionEvent::EcashTicket {
                ticket_type,
                client,
-            } => self.handle_ecash_ticket(ticket_type, client).await,
+            } => self.handle_ecash_ticket(ticket_type, client),
        }
    }
-    async fn handle_session_start(
+    fn handle_session_start(
        &mut self,
        start_time: OffsetDateTime,
        client: DestinationAddressBytes,
-    ) -> 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(())
+    ) {
+        self.sessions_started += 1;
+        self.unique_users.insert(client);
+        self.active_sessions
+            .insert(client, ActiveSession::new(start_time));
    }
-
-    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? {
+    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) {
-                self.storage
-                    .insert_finished_session(self.current_day, finished_session)
-                    .await?;
-                self.storage.delete_active_session(client).await?;
+                if self.finished_sessions.len() < FINISHED_SESSIONS_CAP {
+                    self.finished_sessions.push(finished_session);
+                }
            }
        }
-        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?
+    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);
+            }
        }
-        //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
-    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> {
+    pub(crate) async fn update_shared_state(&mut self, update_time: OffsetDateTime) {
        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;
+        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);
        }
-        Ok(())
    }

-    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(())
+    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;
    }
 }
@@ -234,7 +234,7 @@ impl MixNode {
        // TODO: if anything, this should be getting data directly from the contract
        // as opposed to the validator API
        let validator_client = self.random_api_client();
-        let existing_nodes = match validator_client.get_cached_mixnodes().await {
+        let existing_nodes = match validator_client.get_all_basic_nodes(None).await {
            Ok(nodes) => nodes,
            Err(err) => {
                error!(
@@ -245,10 +245,9 @@ impl MixNode {
            }
        };

-        existing_nodes.iter().any(|node| {
-            node.bond_information.mix_node.identity_key
-                == self.identity_keypair.public_key().to_base58_string()
-        })
+        existing_nodes
+            .iter()
+            .any(|node| &node.ed25519_identity_pubkey == self.identity_keypair.public_key())
    }

    async fn wait_for_interrupt(&self, shutdown: TaskHandle) {
@@ -4,7 +4,7 @@
 [package]
 name = "nym-api"
 license = "GPL-3.0"
-version = "1.1.45"
+version = "1.1.46"
 authors.workspace = true
 edition = "2021"
 rust-version.workspace = true
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::helpers::unix_epoch;
+use crate::helpers::PlaceholderJsonSchemaImpl;
 use crate::legacy::{
    LegacyGatewayBondWithId, LegacyMixNodeBondWithLayer, LegacyMixNodeDetailsWithLayer,
 };
@@ -852,6 +853,10 @@ impl NymNodeDescription {
        }
    }

+    pub fn ed25519_identity_key(&self) -> ed25519::PublicKey {
+        self.description.host_information.keys.ed25519
+    }
+
    pub fn to_skimmed_node(&self, role: NodeRole, performance: Performance) -> SkimmedNode {
        let keys = &self.description.host_information.keys;
        let entry = if self.description.declared_role.entry {
@@ -893,6 +898,12 @@ pub enum DescribedNodeType {
    NymNode,
 }

+impl DescribedNodeType {
+    pub fn is_nym_node(&self) -> bool {
+        matches!(self, DescribedNodeType::NymNode)
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, schemars::JsonSchema, ToSchema)]
 #[cfg_attr(feature = "generate-ts", derive(ts_rs::TS))]
 #[cfg_attr(
@@ -1133,6 +1144,67 @@ pub struct NoiseDetails {
    pub ip_addresses: Vec<IpAddr>,
 }

+#[derive(Clone, Debug, Serialize, Deserialize, schemars::JsonSchema, ToSchema)]
+pub struct NodeRefreshBody {
+    #[serde(with = "bs58_ed25519_pubkey")]
+    #[schemars(with = "String")]
+    pub node_identity: ed25519::PublicKey,
+
+    // a poor man's nonce
+    pub request_timestamp: i64,
+
+    #[schemars(with = "PlaceholderJsonSchemaImpl")]
+    pub signature: ed25519::Signature,
+}
+
+impl NodeRefreshBody {
+    pub fn plaintext(node_identity: ed25519::PublicKey, request_timestamp: i64) -> Vec<u8> {
+        node_identity
+            .to_bytes()
+            .into_iter()
+            .chain(request_timestamp.to_be_bytes())
+            .chain(b"describe-cache-refresh-request".iter().copied())
+            .collect()
+    }
+
+    pub fn new(private_key: &ed25519::PrivateKey) -> Self {
+        let node_identity = private_key.public_key();
+        let request_timestamp = OffsetDateTime::now_utc().unix_timestamp();
+        let signature = private_key.sign(Self::plaintext(node_identity, request_timestamp));
+        NodeRefreshBody {
+            node_identity,
+            request_timestamp,
+            signature,
+        }
+    }
+
+    pub fn verify_signature(&self) -> bool {
+        self.node_identity
+            .verify(
+                Self::plaintext(self.node_identity, self.request_timestamp),
+                &self.signature,
+            )
+            .is_ok()
+    }
+
+    pub fn is_stale(&self) -> bool {
+        let Ok(encoded) = OffsetDateTime::from_unix_timestamp(self.request_timestamp) else {
+            return true;
+        };
+        let now = OffsetDateTime::now_utc();
+
+        if encoded > now {
+            return true;
+        }
+
+        if (encoded + Duration::from_secs(30)) < now {
+            return true;
+        }
+
+        false
+    }
+}
+
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -7,7 +7,7 @@ use crate::ecash::helpers::blind_sign;
 use crate::ecash::state::EcashState;
 use crate::node_status_api::models::AxumResult;
 use crate::support::http::state::AppState;
-use axum::extract::Path;
+use axum::extract::Query;
 use axum::{Json, Router};
 use nym_api_requests::ecash::{
    BlindSignRequestBody, BlindedSignatureResponse, PartialCoinIndicesSignatureResponse,
@@ -134,7 +134,7 @@ struct ExpirationDateParam {
    )
 )]
 async fn partial_expiration_date_signatures(
-    Path(ExpirationDateParam { expiration_date }): Path<ExpirationDateParam>,
+    Query(ExpirationDateParam { expiration_date }): Query<ExpirationDateParam>,
    state: Arc<EcashState>,
 ) -> AxumResult<Json<PartialExpirationDateSignatureResponse>> {
    state.ensure_signer().await?;
@@ -172,7 +172,7 @@ async fn partial_expiration_date_signatures(
    )
 )]
 async fn partial_coin_indices_signatures(
-    Path(EpochIdParam { epoch_id }): Path<EpochIdParam>,
+    Query(EpochIdParam { epoch_id }): Query<EpochIdParam>,
    state: Arc<EcashState>,
 ) -> AxumResult<Json<PartialCoinIndicesSignatureResponse>> {
    state.ensure_signer().await?;
@@ -1261,6 +1261,7 @@ struct TestFixture {
 impl TestFixture {
    fn build_app_state(storage: NymApiStorage) -> AppState {
        AppState {
+            forced_refresh: Default::default(),
            nym_contract_cache: NymContractCache::new(),
            node_status_cache: NodeStatusCache::new(),
            circulating_supply_cache: CirculatingSupplyCache::new("unym".to_owned()),
@@ -66,6 +66,7 @@ struct IgnoredNodes {
    no_self_described: usize,
    not_nym_node_binary: usize,
    no_terms_and_conditions: usize,
+    use_vested_tokens: usize,
 }

 impl IgnoredNodes {
@@ -75,6 +76,7 @@ impl IgnoredNodes {
            no_self_described: 0,
            not_nym_node_binary: 0,
            no_terms_and_conditions: 0,
+            use_vested_tokens: 0,
        }
    }

@@ -82,6 +84,7 @@ impl IgnoredNodes {
        self.no_self_described == 0
            && self.not_nym_node_binary == 0
            && self.no_terms_and_conditions == 0
+            && self.use_vested_tokens == 0
    }

    fn maybe_log_summary(&self) {
@@ -104,6 +107,12 @@ impl IgnoredNodes {
                self.no_terms_and_conditions, self.typ
            )
        }
+        if self.use_vested_tokens != 0 {
+            warn!(
+                "{} {} operators bonded using vested tokens",
+                self.use_vested_tokens, self.typ
+            )
+        }
    }
 }

@@ -286,6 +295,11 @@ impl EpochAdvancer {
                continue;
            }

+            if mix.bond_information.proxy.is_some() {
+                legacy_mixnodes_info.use_vested_tokens += 1;
+                continue;
+            }
+
            let performance = self
                .load_mixnode_performance(&interval, mix.mix_id())
                .await
@@ -9,9 +9,10 @@ use crate::support::config;
 use crate::support::config::DEFAULT_NODE_DESCRIBE_BATCH_SIZE;
 use async_trait::async_trait;
 use futures::{stream, StreamExt};
+use nym_api_requests::legacy::{LegacyGatewayBondWithId, LegacyMixNodeDetailsWithLayer};
 use nym_api_requests::models::{DescribedNodeType, NymNodeData, NymNodeDescription};
 use nym_config::defaults::DEFAULT_NYM_NODE_HTTP_PORT;
-use nym_mixnet_contract_common::{LegacyMixLayer, NodeId};
+use nym_mixnet_contract_common::{LegacyMixLayer, NodeId, NymNodeDetails};
 use nym_node_requests::api::client::{NymNodeApiClientError, NymNodeApiClientExt};
 use nym_topology::gateway::GatewayConversionError;
 use nym_topology::mix::MixnodeConversionError;
@@ -151,6 +152,10 @@ pub struct DescribedNodes {
 }

 impl DescribedNodes {
+    pub fn force_update(&mut self, node: NymNodeDescription) {
+        self.nodes.insert(node.node_id, node);
+    }
+
    pub fn get_description(&self, node_id: &NodeId) -> Option<&NymNodeData> {
        self.nodes.get(node_id).map(|n| &n.description)
    }
@@ -292,7 +297,7 @@ async fn try_get_description(
 }

 #[derive(Debug)]
-struct RefreshData {
+pub(crate) struct RefreshData {
    host: String,
    node_id: NodeId,
    node_type: DescribedNodeType,
@@ -300,6 +305,39 @@ struct RefreshData {
    port: Option<u16>,
 }

+impl<'a> From<&'a LegacyMixNodeDetailsWithLayer> for RefreshData {
+    fn from(node: &'a LegacyMixNodeDetailsWithLayer) -> Self {
+        RefreshData::new(
+            &node.bond_information.mix_node.host,
+            DescribedNodeType::LegacyMixnode,
+            node.mix_id(),
+            Some(node.bond_information.mix_node.http_api_port),
+        )
+    }
+}
+
+impl<'a> From<&'a LegacyGatewayBondWithId> for RefreshData {
+    fn from(node: &'a LegacyGatewayBondWithId) -> Self {
+        RefreshData::new(
+            &node.bond.gateway.host,
+            DescribedNodeType::LegacyGateway,
+            node.node_id,
+            None,
+        )
+    }
+}
+
+impl<'a> From<&'a NymNodeDetails> for RefreshData {
+    fn from(node: &'a NymNodeDetails) -> Self {
+        RefreshData::new(
+            &node.bond_information.node.host,
+            DescribedNodeType::NymNode,
+            node.node_id(),
+            node.bond_information.node.custom_http_port,
+        )
+    }
+}
+
 impl RefreshData {
    pub fn new(
        host: impl Into<String>,
@@ -315,7 +353,11 @@ impl RefreshData {
        }
    }

-    async fn try_refresh(self) -> Option<NymNodeDescription> {
+    pub(crate) fn node_id(&self) -> NodeId {
+        self.node_id
+    }
+
+    pub(crate) async fn try_refresh(self) -> Option<NymNodeDescription> {
        match try_get_description(self).await {
            Ok(description) => Some(description),
            Err(err) => {
@@ -341,18 +383,13 @@ impl CacheItemProvider for NodeDescriptionProvider {
        // - legacy gateways (because they might already be running nym-nodes, but haven't updated contract info)
        // - nym-nodes

-        let mut nodes_to_query = Vec::new();
+        let mut nodes_to_query: Vec<RefreshData> = Vec::new();

        match self.contract_cache.all_cached_legacy_mixnodes().await {
            None => error!("failed to obtain mixnodes information from the cache"),
            Some(legacy_mixnodes) => {
                for node in &**legacy_mixnodes {
-                    nodes_to_query.push(RefreshData::new(
-                        &node.bond_information.mix_node.host,
-                        DescribedNodeType::LegacyMixnode,
-                        node.mix_id(),
-                        Some(node.bond_information.mix_node.http_api_port),
-                    ))
+                    nodes_to_query.push(node.into())
                }
            }
        }
@@ -361,12 +398,7 @@ impl CacheItemProvider for NodeDescriptionProvider {
            None => error!("failed to obtain gateways information from the cache"),
            Some(legacy_gateways) => {
                for node in &**legacy_gateways {
-                    nodes_to_query.push(RefreshData::new(
-                        &node.bond.gateway.host,
-                        DescribedNodeType::LegacyGateway,
-                        node.node_id,
-                        None,
-                    ))
+                    nodes_to_query.push(node.into())
                }
            }
        }
@@ -375,12 +407,7 @@ impl CacheItemProvider for NodeDescriptionProvider {
            None => error!("failed to obtain nym-nodes information from the cache"),
            Some(nym_nodes) => {
                for node in &**nym_nodes {
-                    nodes_to_query.push(RefreshData::new(
-                        &node.bond_information.node.host,
-                        DescribedNodeType::NymNode,
-                        node.node_id(),
-                        node.bond_information.node.custom_http_port,
-                    ))
+                    nodes_to_query.push(node.into())
                }
            }
        }
@@ -355,6 +355,13 @@ impl AxumErrorResponse {
        }
    }

+    pub(crate) fn unauthorised(msg: impl Display) -> Self {
+        Self {
+            message: RequestError::new(msg.to_string()),
+            status: StatusCode::UNAUTHORIZED,
+        }
+    }
+
    pub(crate) fn unprocessable_entity(msg: impl Display) -> Self {
        Self {
            message: RequestError::new(msg.to_string()),
@@ -375,6 +382,13 @@ impl AxumErrorResponse {
            status: StatusCode::BAD_REQUEST,
        }
    }
+
+    pub(crate) fn too_many(msg: impl Display) -> Self {
+        Self {
+            message: RequestError::new(msg.to_string()),
+            status: StatusCode::TOO_MANY_REQUESTS,
+        }
+    }
 }

 impl From<UninitialisedCache> for AxumErrorResponse {
@@ -1,4 +1,4 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only

 use crate::node_status_api::models::{
@@ -9,7 +9,7 @@ use crate::storage::NymApiStorage;
 use nym_task::{TaskClient, TaskManager};
 use std::time::Duration;
 use time::{OffsetDateTime, PrimitiveDateTime, Time};
-use tokio::time::{interval, sleep};
+use tokio::time::{interval_at, Instant};
 use tracing::error;
 use tracing::{info, trace, warn};

@@ -93,15 +93,8 @@ impl HistoricalUptimeUpdater {
            "waiting until {update_datetime} to update the historical uptimes for the first time ({} seconds left)", time_left.as_secs()
        );

-        tokio::select! {
-            biased;
-            _ = shutdown.recv() => {
-                trace!("UpdateHandler: Received shutdown");
-            }
-            _ = sleep(time_left) => {}
-        }
-
-        let mut interval = interval(ONE_DAY);
+        let start = Instant::now() + time_left;
+        let mut interval = interval_at(start, ONE_DAY);
        while !shutdown.is_shutdown() {
            tokio::select! {
                biased;
@@ -109,6 +102,7 @@ impl HistoricalUptimeUpdater {
                    trace!("UpdateHandler: Received shutdown");
                }
                _ = interval.tick() => {
+                    info!("updating historical uptimes of nodes");
                    // we don't want to have another select here; uptime update is relatively speedy
                    // and we don't want to exit while we're in the middle of database update
                    if let Err(err) = self.update_uptimes().await {
@@ -1,6 +1,7 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only

+use crate::node_describe_cache::RefreshData;
 use crate::nym_contract_cache::cache::data::CachedContractsInfo;
 use crate::support::caching::Cache;
 use data::ValidatorCacheData;
@@ -8,6 +9,7 @@ use nym_api_requests::legacy::{
    LegacyGatewayBondWithId, LegacyMixNodeBondWithLayer, LegacyMixNodeDetailsWithLayer,
 };
 use nym_api_requests::models::MixnodeStatus;
+use nym_crypto::asymmetric::ed25519;
 use nym_mixnet_contract_common::{Interval, NodeId, NymNodeDetails, RewardedSet, RewardingParams};
 use std::{
    collections::HashSet,
@@ -352,6 +354,48 @@ impl NymContractCache {
        self.legacy_mixnode_details(mix_id).await.1
    }

+    pub async fn get_node_refresh_data(
+        &self,
+        node_identity: ed25519::PublicKey,
+    ) -> Option<RefreshData> {
+        if !self.initialised() {
+            return None;
+        }
+
+        let inner = self.inner.read().await;
+
+        let encoded_identity = node_identity.to_base58_string();
+
+        // 1. check nymnodes
+        if let Some(nym_node) = inner
+            .nym_nodes
+            .iter()
+            .find(|n| n.bond_information.identity() == encoded_identity)
+        {
+            return Some(nym_node.into());
+        }
+
+        // 2. check legacy mixnodes
+        if let Some(mixnode) = inner
+            .legacy_mixnodes
+            .iter()
+            .find(|n| n.bond_information.identity() == encoded_identity)
+        {
+            return Some(mixnode.into());
+        }
+
+        // 3. check legacy gateways
+        if let Some(gateway) = inner
+            .legacy_gateways
+            .iter()
+            .find(|n| n.identity() == &encoded_identity)
+        {
+            return Some(gateway.into());
+        }
+
+        None
+    }
+
    pub fn initialised(&self) -> bool {
        self.initialised.load(Ordering::Relaxed)
    }
@@ -6,10 +6,12 @@ use crate::node_status_api::helpers::{
    _get_rewarded_set_legacy_mixnodes_detailed,
 };
 use crate::support::http::state::AppState;
+use crate::support::legacy_helpers::{to_legacy_gateway, to_legacy_mixnode};
 use axum::extract::State;
 use axum::{Json, Router};
 use nym_api_requests::legacy::LegacyMixNodeDetailsWithLayer;
 use nym_api_requests::models::MixNodeBondAnnotated;
+use nym_mixnet_contract_common::reward_params::Performance;
 use nym_mixnet_contract_common::{reward_params::RewardingParams, GatewayBond, Interval, NodeId};
 use std::collections::HashSet;

@@ -58,11 +60,47 @@ pub(crate) fn nym_contract_cache_routes() -> Router<AppState> {
 )]
 #[deprecated]
 async fn get_mixnodes(State(state): State<AppState>) -> Json<Vec<LegacyMixNodeDetailsWithLayer>> {
-    state
-        .nym_contract_cache()
-        .legacy_mixnodes_filtered()
-        .await
-        .into()
+    let mut out = state.nym_contract_cache().legacy_mixnodes_filtered().await;
+
+    let Ok(describe_cache) = state.described_nodes_cache.get().await else {
+        return Json(out);
+    };
+
+    let Some(migrated_nymnodes) = state.nym_contract_cache().all_cached_nym_nodes().await else {
+        return Json(out);
+    };
+
+    let Ok(annotations) = state.node_annotations().await else {
+        return Json(out);
+    };
+
+    // safety: valid percentage value
+    #[allow(clippy::unwrap_used)]
+    let p50 = Performance::from_percentage_value(50).unwrap();
+
+    for nym_node in &**migrated_nymnodes {
+        // if we can't get it self-described data, ignore it
+        let Some(description) = describe_cache.get_description(&nym_node.node_id()) else {
+            continue;
+        };
+        // if the node hasn't declared it can be a mixnode, ignore it
+        if !description.declared_role.mixnode {
+            continue;
+        }
+        // if we don't have annotation for this node, ignore it
+        let Some(annotation) = annotations.get(&nym_node.node_id()) else {
+            continue;
+        };
+        // equivalent of legacy mixnode being blacklisted
+        if annotation.last_24h_performance < p50 {
+            continue;
+        }
+
+        let node = to_legacy_mixnode(nym_node, description);
+        out.push(node);
+    }
+
+    Json(out)
 }

 // DEPRECATED: this endpoint now lives in `node_status_api`. Once all consumers are updated,
@@ -97,15 +135,54 @@ async fn get_mixnodes_detailed(State(state): State<AppState>) -> Json<Vec<MixNod
 )]
 #[deprecated]
 async fn get_gateways(State(state): State<AppState>) -> Json<Vec<GatewayBond>> {
-    Json(
-        state
-            .nym_contract_cache()
-            .legacy_gateways_filtered()
-            .await
-            .into_iter()
-            .map(Into::into)
-            .collect(),
-    )
+    // legacy
+    let mut out: Vec<GatewayBond> = state
+        .nym_contract_cache()
+        .legacy_gateways_filtered()
+        .await
+        .into_iter()
+        .map(Into::into)
+        .collect();
+
+    let Ok(describe_cache) = state.described_nodes_cache.get().await else {
+        return Json(out);
+    };
+
+    let Some(migrated_nymnodes) = state.nym_contract_cache().all_cached_nym_nodes().await else {
+        return Json(out);
+    };
+
+    let Ok(annotations) = state.node_annotations().await else {
+        return Json(out);
+    };
+
+    // safety: valid percentage value
+    #[allow(clippy::unwrap_used)]
+    let p50 = Performance::from_percentage_value(50).unwrap();
+
+    for nym_node in &**migrated_nymnodes {
+        // if we can't get it self-described data, ignore it
+        let Some(description) = describe_cache.get_description(&nym_node.node_id()) else {
+            continue;
+        };
+        // if the node hasn't declared it can be a gateway, ignore it
+        if !description.declared_role.entry {
+            continue;
+        }
+        // if we don't have annotation for this node, ignore it
+        let Some(annotation) = annotations.get(&nym_node.node_id()) else {
+            continue;
+        };
+        // equivalent of legacy gateway being blacklisted
+        if annotation.last_24h_performance < p50 {
+            continue;
+        }
+
+        let node = to_legacy_gateway(nym_node, description);
+        out.push(node);
+    }
+
+    Json(out)
 }

 #[utoipa::path(
@@ -166,12 +243,59 @@ async fn get_rewarded_set_detailed(
 )]
 #[deprecated]
 async fn get_active_set(State(state): State<AppState>) -> Json<Vec<LegacyMixNodeDetailsWithLayer>> {
-    state
+    let mut out = state
        .nym_contract_cache()
        .legacy_v1_active_set_mixnodes()
        .await
-        .clone()
-        .into()
+        .clone();
+
+    let Some(rewarded_set) = state.nym_contract_cache().rewarded_set().await else {
+        return Json(out);
+    };
+
+    let Ok(describe_cache) = state.described_nodes_cache.get().await else {
+        return Json(out);
+    };
+
+    let Some(migrated_nymnodes) = state.nym_contract_cache().all_cached_nym_nodes().await else {
+        return Json(out);
+    };
+
+    let Ok(annotations) = state.node_annotations().await else {
+        return Json(out);
+    };
+
+    // safety: valid percentage value
+    #[allow(clippy::unwrap_used)]
+    let p50 = Performance::from_percentage_value(50).unwrap();
+
+    for nym_node in &**migrated_nymnodes {
+        // if we can't get it self-described data, ignore it
+        let Some(description) = describe_cache.get_description(&nym_node.node_id()) else {
+            continue;
+        };
+        // if the node hasn't declared it can be a mixnode, ignore it
+        if !description.declared_role.mixnode {
+            continue;
+        }
+        // if we don't have annotation for this node, ignore it
+        let Some(annotation) = annotations.get(&nym_node.node_id()) else {
+            continue;
+        };
+        // equivalent of legacy mixnode being blacklisted
+        if annotation.last_24h_performance < p50 {
+            continue;
+        }
+        // if the node is not in the active set, ignore it
+        if !rewarded_set.is_active_mixnode(&nym_node.node_id()) {
+            continue;
+        }
+
+        let node = to_legacy_mixnode(nym_node, description);
+        out.push(node);
+    }
+
+    Json(out)
 }

 // DEPRECATED: this endpoint now lives in `node_status_api`. Once all consumers are updated,
@@ -2,8 +2,10 @@
 // SPDX-License-Identifier: GPL-3.0-only

 use crate::support::http::state::AppState;
+use crate::support::legacy_helpers::{to_legacy_gateway, to_legacy_mixnode};
 use axum::extract::State;
 use axum::{Json, Router};
+use nym_api_requests::legacy::LegacyMixNodeBondWithLayer;
 use nym_api_requests::models::{LegacyDescribedGateway, LegacyDescribedMixNode};

 // we want to mark the routes as deprecated in swagger, but still expose them
@@ -34,25 +36,44 @@ async fn get_gateways_described(
 ) -> Json<Vec<LegacyDescribedGateway>> {
    let contract_cache = state.nym_contract_cache();
    let describe_cache = state.described_nodes_cache();
-    let gateways = contract_cache.legacy_gateways_filtered().await;
-    if gateways.is_empty() {
-        return Json(Vec::new());
-    }
+
+    // legacy
+    let legacy = contract_cache.legacy_gateways_filtered().await;

    // if the self describe cache is unavailable, well, don't attach describe data and only return legacy gateways
-    let Ok(self_descriptions) = describe_cache.get().await else {
-        return Json(gateways.into_iter().map(Into::into).collect());
+    let Ok(describe_cache) = describe_cache.get().await else {
+        return Json(legacy.into_iter().map(Into::into).collect());
    };

-    Json(
-        gateways
-            .into_iter()
-            .map(|bond| LegacyDescribedGateway {
-                self_described: self_descriptions.get_description(&bond.node_id).cloned(),
-                bond: bond.bond,
-            })
-            .collect(),
-    )
+    let migrated_nymnodes = state.nym_contract_cache().nym_nodes().await;
+    let mut out = Vec::new();
+
+    for legacy_bond in legacy {
+        out.push(LegacyDescribedGateway {
+            self_described: describe_cache
+                .get_description(&legacy_bond.node_id)
+                .cloned(),
+            bond: legacy_bond.bond,
+        })
+    }
+
+    for nym_node in migrated_nymnodes {
+        // we ALWAYS need description to set legacy fields
+        let Some(description) = describe_cache.get_description(&nym_node.node_id()) else {
+            continue;
+        };
+        // if the node hasn't declared it can be a gateway, ignore it
+        if !description.declared_role.entry {
+            continue;
+        }
+
+        out.push(LegacyDescribedGateway {
+            bond: to_legacy_gateway(&nym_node, description),
+            self_described: Some(description.clone()),
+        })
+    }
+
+    Json(out)
 }

 #[utoipa::path(
@@ -70,28 +91,43 @@ async fn get_mixnodes_described(
    let contract_cache = state.nym_contract_cache();
    let describe_cache = state.described_nodes_cache();

-    let mixnodes = contract_cache
+    let legacy: Vec<LegacyMixNodeBondWithLayer> = contract_cache
        .legacy_mixnodes_filtered()
        .await
        .into_iter()
        .map(|m| m.bond_information)
        .collect::<Vec<_>>();
-    if mixnodes.is_empty() {
-        return Json(Vec::new());
-    }

-    // if the self describe cache is unavailable, well, don't attach describe data
-    let Ok(self_descriptions) = describe_cache.get().await else {
-        return Json(mixnodes.into_iter().map(Into::into).collect());
+    // if the self describe cache is unavailable, well, don't attach describe data and only return legacy mixnodes
+    let Ok(describe_cache) = describe_cache.get().await else {
+        return Json(legacy.into_iter().map(Into::into).collect());
    };

-    Json(
-        mixnodes
-            .into_iter()
-            .map(|bond| LegacyDescribedMixNode {
-                self_described: self_descriptions.get_description(&bond.mix_id).cloned(),
-                bond,
-            })
-            .collect(),
-    )
+    let migrated_nymnodes = state.nym_contract_cache().nym_nodes().await;
+    let mut out = Vec::new();
+
+    for legacy_bond in legacy {
+        out.push(LegacyDescribedMixNode {
+            self_described: describe_cache.get_description(&legacy_bond.mix_id).cloned(),
+            bond: legacy_bond,
+        })
+    }
+
+    for nym_node in migrated_nymnodes {
+        // we ALWAYS need description to set legacy fields
+        let Some(description) = describe_cache.get_description(&nym_node.node_id()) else {
+            continue;
+        };
+        // if the node hasn't declared it can be a gateway, ignore it
+        if !description.declared_role.mixnode {
+            continue;
+        }
+
+        out.push(LegacyDescribedMixNode {
+            bond: to_legacy_mixnode(&nym_node, description).bond_information,
+            self_described: Some(description.clone()),
+        })
+    }
+
+    Json(out)
 }
@@ -5,11 +5,11 @@ use crate::node_status_api::models::{AxumErrorResponse, AxumResult};
 use crate::support::http::helpers::{NodeIdParam, PaginationRequest};
 use crate::support::http::state::AppState;
 use axum::extract::{Path, Query, State};
-use axum::routing::get;
+use axum::routing::{get, post};
 use axum::{Json, Router};
 use nym_api_requests::models::{
-    AnnotationResponse, NodeDatePerformanceResponse, NodePerformanceResponse, NoiseDetails,
-    NymNodeDescription, PerformanceHistoryResponse, UptimeHistoryResponse,
+    AnnotationResponse, NodeDatePerformanceResponse, NodePerformanceResponse, NodeRefreshBody,
+    NoiseDetails, NymNodeDescription, PerformanceHistoryResponse, UptimeHistoryResponse,
 };
 use nym_api_requests::pagination::{PaginatedResponse, Pagination};
 use nym_contracts_common::NaiveFloat;
@@ -17,7 +17,8 @@ use nym_mixnet_contract_common::reward_params::Performance;
 use nym_mixnet_contract_common::NymNodeDetails;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use time::Date;
+use std::time::Duration;
+use time::{Date, OffsetDateTime};
 use utoipa::{IntoParams, ToSchema};

 pub(crate) mod legacy;
@@ -25,6 +26,7 @@ pub(crate) mod unstable;

 pub(crate) fn nym_node_routes() -> Router<AppState> {
    Router::new()
+        .route("/refresh-described", post(refresh_described))
        .route("/noise", get(nodes_noise))
        .route("/bonded", get(get_bonded_nodes))
        .route("/described", get(get_described_nodes))
@@ -42,6 +44,63 @@ pub(crate) fn nym_node_routes() -> Router<AppState> {
        .route("/uptime-history/:node_id", get(get_node_uptime_history))
 }

+#[utoipa::path(
+    tag = "Nym Nodes",
+    post,
+    request_body = NodeRefreshBody,
+    path = "/refresh-described",
+    context_path = "/v1/nym-nodes",
+)]
+async fn refresh_described(
+    State(state): State<AppState>,
+    Json(request_body): Json<NodeRefreshBody>,
+) -> AxumResult<Json<()>> {
+    let Some(refresh_data) = state
+        .nym_contract_cache()
+        .get_node_refresh_data(request_body.node_identity)
+        .await
+    else {
+        return Err(AxumErrorResponse::not_found(format!(
+            "node with identity {} does not seem to exist",
+            request_body.node_identity
+        )));
+    };
+
+    if !request_body.verify_signature() {
+        return Err(AxumErrorResponse::unauthorised("invalid request signature"));
+    }
+
+    if request_body.is_stale() {
+        return Err(AxumErrorResponse::bad_request("the request is stale"));
+    }
+
+    let node_id = refresh_data.node_id();
+    if let Some(last) = state.forced_refresh.last_refreshed(node_id).await {
+        // max 1 refresh a minute
+        let minute_ago = OffsetDateTime::now_utc() - Duration::from_secs(60);
+        if last > minute_ago {
+            return Err(AxumErrorResponse::too_many(
+                "already refreshed node in the last minute",
+            ));
+        }
+    }
+    // to make sure you can't ddos the endpoint while a request is in progress
+    state.forced_refresh.set_last_refreshed(node_id).await;
+
+    if let Some(updated_data) = refresh_data.try_refresh().await {
+        let Ok(mut describe_cache) = state.described_nodes_cache.write().await else {
+            return Err(AxumErrorResponse::service_unavailable());
+        };
+        describe_cache.get_mut().force_update(updated_data)
+    } else {
+        return Err(AxumErrorResponse::unprocessable_entity(
+            "failed to refresh node description",
+        ));
+    }
+
+    Ok(Json(()))
+}
+
 #[utoipa::path(
    tag = "Nym Nodes",
    get,
@@ -6,7 +6,7 @@ use std::sync::Arc;
 use std::time::Duration;
 use thiserror::Error;
 use time::OffsetDateTime;
-use tokio::sync::{RwLock, RwLockReadGuard};
+use tokio::sync::{RwLock, RwLockMappedWriteGuard, RwLockReadGuard, RwLockWriteGuard};

 #[derive(Debug, Error)]
 #[error("the cache item has not been initialised")]
@@ -45,6 +45,13 @@ impl<T> SharedCache<T> {
        RwLockReadGuard::try_map(guard, |a| a.inner.as_ref()).map_err(|_| UninitialisedCache)
    }

+    pub(crate) async fn write(
+        &self,
+    ) -> Result<RwLockMappedWriteGuard<'_, Cache<T>>, UninitialisedCache> {
+        let guard = self.0.write().await;
+        RwLockWriteGuard::try_map(guard, |a| a.inner.as_mut()).map_err(|_| UninitialisedCache)
+    }
+
    // ignores expiration data
    #[allow(dead_code)]
    pub(crate) async fn unchecked_get_inner(
@@ -134,6 +141,10 @@ impl<T> Cache<T> {
        self.as_at = OffsetDateTime::now_utc()
    }

+    pub(crate) fn get_mut(&mut self) -> &mut T {
+        &mut self.value
+    }
+
    #[allow(dead_code)]
    pub fn has_expired(&self, ttl: Duration, now: Option<OffsetDateTime>) -> bool {
        let now = now.unwrap_or(OffsetDateTime::now_utc());
@@ -188,6 +188,7 @@ async fn start_nym_api_tasks_axum(config: &Config) -> anyhow::Result<ShutdownHan
    };

    let router = router.with_state(AppState {
+        forced_refresh: Default::default(),
        nym_contract_cache: nym_contract_cache_state.clone(),
        node_status_cache: node_status_cache_state.clone(),
        circulating_supply_cache: circulating_supply_cache.clone(),
@@ -20,6 +20,7 @@ use utoipauto::utoipauto;
        models::CirculatingSupplyResponse,
        models::CoinSchema,
        nym_mixnet_contract_common::Interval,
+        nym_api_requests::models::NodeRefreshBody,
        nym_api_requests::models::GatewayStatusReportResponse,
        nym_api_requests::models::GatewayUptimeHistoryResponse,
        nym_api_requests::models::GatewayCoreStatusResponse,
@@ -15,7 +15,9 @@ use nym_api_requests::models::{GatewayBondAnnotated, MixNodeBondAnnotated, NodeA
 use nym_mixnet_contract_common::NodeId;
 use nym_task::TaskManager;
 use std::collections::HashMap;
-use tokio::sync::RwLockReadGuard;
+use std::sync::Arc;
+use time::OffsetDateTime;
+use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio::task::JoinHandle;
 use tokio_util::sync::CancellationToken;

@@ -70,6 +72,7 @@ type AxumJoinHandle = JoinHandle<std::io::Result<()>>;

 #[derive(Clone)]
 pub(crate) struct AppState {
+    pub(crate) forced_refresh: ForcedRefresh,
    pub(crate) nym_contract_cache: NymContractCache,
    pub(crate) node_status_cache: NodeStatusCache,
    pub(crate) circulating_supply_cache: CirculatingSupplyCache,
@@ -79,6 +82,24 @@ pub(crate) struct AppState {
    pub(crate) node_info_cache: unstable::NodeInfoCache,
 }

+#[derive(Clone, Default)]
+pub(crate) struct ForcedRefresh {
+    pub(crate) refreshes: Arc<RwLock<HashMap<NodeId, OffsetDateTime>>>,
+}
+
+impl ForcedRefresh {
+    pub(crate) async fn last_refreshed(&self, node_id: NodeId) -> Option<OffsetDateTime> {
+        self.refreshes.read().await.get(&node_id).copied()
+    }
+
+    pub(crate) async fn set_last_refreshed(&self, node_id: NodeId) {
+        self.refreshes
+            .write()
+            .await
+            .insert(node_id, OffsetDateTime::now_utc());
+    }
+}
+
 impl AppState {
    pub(crate) fn nym_contract_cache(&self) -> &NymContractCache {
        &self.nym_contract_cache
@@ -0,0 +1,85 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use nym_api_requests::legacy::{LegacyMixNodeBondWithLayer, LegacyMixNodeDetailsWithLayer};
+use nym_api_requests::models::NymNodeData;
+use nym_config::defaults::DEFAULT_NYM_NODE_HTTP_PORT;
+use nym_crypto::aes::cipher::crypto_common::rand_core::OsRng;
+use nym_mixnet_contract_common::mixnode::LegacyPendingMixNodeChanges;
+use nym_mixnet_contract_common::{
+    Gateway, GatewayBond, LegacyMixLayer, MixNode, MixNodeBond, NymNodeDetails,
+};
+use rand::prelude::SliceRandom;
+
+pub(crate) fn to_legacy_mixnode(
+    nym_node: &NymNodeDetails,
+    description: &NymNodeData,
+) -> LegacyMixNodeDetailsWithLayer {
+    let layer_choices = [
+        LegacyMixLayer::One,
+        LegacyMixLayer::Two,
+        LegacyMixLayer::Three,
+    ];
+    let mut rng = OsRng;
+
+    // slap a random layer on it because legacy clients don't understand a concept of layerless mixnodes
+    // SAFETY: the slice is not empty so the unwrap is fine
+    #[allow(clippy::unwrap_used)]
+    let layer = layer_choices.choose(&mut rng).copied().unwrap();
+
+    LegacyMixNodeDetailsWithLayer {
+        bond_information: LegacyMixNodeBondWithLayer {
+            bond: MixNodeBond {
+                mix_id: nym_node.node_id(),
+                owner: nym_node.bond_information.owner.clone(),
+                original_pledge: nym_node.bond_information.original_pledge.clone(),
+                mix_node: MixNode {
+                    host: nym_node.bond_information.node.host.clone(),
+                    mix_port: description.mix_port(),
+                    verloc_port: description.verloc_port(),
+                    http_api_port: nym_node
+                        .bond_information
+                        .node
+                        .custom_http_port
+                        .unwrap_or(DEFAULT_NYM_NODE_HTTP_PORT),
+                    sphinx_key: description.host_information.keys.x25519.to_base58_string(),
+                    identity_key: nym_node.bond_information.node.identity_key.clone(),
+                    version: description.build_information.build_version.clone(),
+                },
+                proxy: None,
+                bonding_height: nym_node.bond_information.bonding_height,
+                is_unbonding: nym_node.bond_information.is_unbonding,
+            },
+            layer,
+        },
+        rewarding_details: nym_node.rewarding_details.clone(),
+        pending_changes: LegacyPendingMixNodeChanges {
+            pledge_change: nym_node.pending_changes.pledge_change,
+        },
+    }
+}
+
+pub(crate) fn to_legacy_gateway(
+    nym_node: &NymNodeDetails,
+    description: &NymNodeData,
+) -> GatewayBond {
+    GatewayBond {
+        pledge_amount: nym_node.bond_information.original_pledge.clone(),
+        owner: nym_node.bond_information.owner.clone(),
+        block_height: nym_node.bond_information.bonding_height,
+        gateway: Gateway {
+            host: nym_node.bond_information.node.host.clone(),
+            mix_port: description.mix_port(),
+            clients_port: description.mixnet_websockets.ws_port,
+            location: description
+                .auxiliary_details
+                .location
+                .map(|c| c.to_string())
+                .unwrap_or_default(),
+            sphinx_key: description.host_information.keys.x25519.to_base58_string(),
+            identity_key: nym_node.bond_information.node.identity_key.clone(),
+            version: description.build_information.build_version.clone(),
+        },
+        proxy: None,
+    }
+}
@@ -7,3 +7,5 @@ pub(crate) mod config;
 pub(crate) mod http;
 pub(crate) mod nyxd;
 pub(crate) mod storage;
+
+pub(crate) mod legacy_helpers;
@@ -983,7 +983,8 @@ impl StorageManager {
        since: i64,
        until: i64,
    ) -> Result<Vec<ActiveGateway>, sqlx::Error> {
-        sqlx::query_as(
+        sqlx::query_as!(
+            ActiveGateway,
            r#"
                SELECT DISTINCT identity, node_id as "node_id: NodeId", id
                    FROM gateway_details
@@ -993,9 +994,9 @@ impl StorageManager {
                        SELECT 1 FROM gateway_status WHERE timestamp > ? AND timestamp < ?
                    )
            "#,
+            since,
+            until
        )
-        .bind(since)
-        .bind(until)
        .fetch_all(&self.connection_pool)
        .await
    }
@@ -1328,7 +1329,7 @@ pub(crate) mod v3_migration {
                        identity VARCHAR NOT NULL UNIQUE
                    );

-                    INSERT INTO gateway_details_temp SELECT * FROM gateway_details;
+                    INSERT INTO gateway_details_temp(id, node_id, identity) SELECT id, node_id, identity FROM gateway_details;
                    DROP TABLE gateway_details;
                    ALTER TABLE gateway_details_temp RENAME TO gateway_details;
            "#,
@@ -1,6 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only

+use self::manager::{AvgGatewayReliability, AvgMixnodeReliability};
 use crate::network_monitor::test_route::TestRoute;
 use crate::node_status_api::models::{
    GatewayStatusReport, GatewayUptimeHistory, HistoricalUptime as ApiHistoricalUptime,
@@ -16,11 +17,11 @@ use nym_mixnet_contract_common::NodeId;
 use nym_types::monitoring::NodeResult;
 use sqlx::ConnectOptions;
 use std::path::Path;
+use std::time::Duration;
 use time::{Date, OffsetDateTime};
+use tracing::log::LevelFilter;
 use tracing::{error, info, warn};

-use self::manager::{AvgGatewayReliability, AvgMixnodeReliability};
-
 pub(crate) mod manager;
 pub(crate) mod models;

@@ -37,7 +38,8 @@ impl NymApiStorage {
        let opts = sqlx::sqlite::SqliteConnectOptions::new()
            .filename(database_path)
            .create_if_missing(true)
-            .disable_statement_logging();
+            .log_statements(LevelFilter::Trace)
+            .log_slow_statements(LevelFilter::Warn, Duration::from_millis(250));

        // TODO: do we want auto_vacuum ?

@@ -87,7 +87,7 @@ pub struct GatewayDetails {
 impl From<GatewayDetails> for TestNode {
    fn from(value: GatewayDetails) -> Self {
        TestNode {
-            node_id: None,
+            node_id: Some(value.node_id),
            identity_key: Some(value.identity),
        }
    }
@@ -0,0 +1,62 @@
+[profile.release]
+panic = "abort"
+opt-level = "s"
+overflow-checks = true
+
+[profile.dev]
+panic = "abort"
+
+[workspace]
+
+resolver = "2"
+members = [
+    "nym-credential-proxy",
+    "nym-credential-proxy-requests",
+    "vpn-api-lib-wasm"
+]
+
+[workspace.package]
+authors = ["Nym Technologies SA"]
+repository = "https://github.com/nymtech/nym"
+homepage = "https://nymtech.net"
+documentation = "https://nymtech.net"
+edition = "2021"
+license = "GPL-3.0"
+
+[workspace.dependencies]
+async-trait = "0.1.80"
+axum = "0.7.5"
+anyhow = "1.0.71"
+bip39 = "2.0.0"
+bs58 = "0.5.1"
+colored = "2.1.0"
+cfg-if = "1.0.0"
+clap = "4.5.4"
+dotenv = "0.15.0"
+futures = "0.3.30"
+humantime = "2.1.0"
+thiserror = "1.0.59"
+rand = "0.8.5"
+reqwest = { version = "0.12.4", default-features = false }
+schemars = "0.8.17"
+strum = "0.26.3"
+strum_macros = "0.26.4"
+serde = "1.0.200"
+serde_json = "1.0.117"
+sqlx = "0.7.4"
+tempfile = "3.12.0"
+time = "0.3.36"
+tracing = "0.1.40"
+tsify = "0.4.5"
+tokio = "1.37.0"
+tokio-util = "0.7.10"
+tower = "0.5.0"
+tower-http = "0.5.2"
+uuid = "1.8.0"
+url = "2.5.2"
+utoipa = "4.2.0"
+utoipa-swagger-ui = "7.0.1"
+zeroize = "1.6.0"
+
+wasm-bindgen = "0.2.93"
+wasmtimer = "0.2.0"
@@ -18,11 +18,11 @@ serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 time = { workspace = true, features = ["serde", "formatting", "parsing"] }
 tsify = { workspace = true, optional = true }
-reqwest = { workspace = true, features = ["json"] }
+reqwest = { workspace = true, features = ["json", "rustls-tls"] }
 wasm-bindgen = { workspace = true, optional = true }

 ## openapi:
-utoipa = { workspace = true, optional = true }
+utoipa = { workspace = true, optional = true, features = ["uuid"] }

 nym-credentials = { path = "../../common/credentials" }
 nym-credentials-interface = { path = "../../common/credentials-interface" }
@@ -10,7 +10,7 @@ use schemars::schema::Schema;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::ops::{Deref, DerefMut};
-use time::Date;
+use time::{Date, OffsetDateTime};

 #[cfg(feature = "query-types")]
 use nym_http_api_common::Output;
@@ -40,6 +40,7 @@ pub struct TicketbookRequest {
    /// you **MUST** provide a valid value otherwise blacklisting won't work
    #[schemars(with = "String")]
    #[serde(with = "bs58_ecash")]
+    #[cfg_attr(feature = "openapi", schema(value_type = String))]
    pub ecash_pubkey: PublicKeyUser,

    // needs to be explicit in case user creates request at 23:59:59.999, but it reaches vpn-api at 00:00:00.001
@@ -48,6 +49,7 @@ pub struct TicketbookRequest {
    pub expiration_date: Date,

    #[schemars(with = "String")]
+    #[cfg_attr(feature = "openapi", schema(value_type = String))]
    pub ticketbook_type: TicketType,

    pub is_freepass_request: bool,
@@ -234,22 +236,28 @@ pub struct TicketbookWalletSharesAsyncResponse {
 #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[serde(rename_all = "camelCase")]
-pub struct BlindedWalletSharesResponse {
+pub struct WebhookTicketbookWalletShares {
    pub id: i64,
    pub status: String,
    pub device_id: String,
    pub credential_id: String,
    pub data: Option<TicketbookWalletSharesResponse>,
    pub error_message: Option<String>,
-    pub created: String,
-    pub updated: String,
+
+    #[schemars(with = "String")]
+    #[serde(with = "time::serde::rfc3339")]
+    pub created: OffsetDateTime,
+
+    #[schemars(with = "String")]
+    #[serde(with = "time::serde::rfc3339")]
+    pub updated: OffsetDateTime,
 }

 #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[serde(rename_all = "camelCase")]
-pub struct WebhookBlindedSharesResponse {
-    pub blinded_shares: BlindedWalletSharesResponse,
+pub struct WebhookTicketbookWalletSharesRequest {
+    pub ticketbook_wallet_shares: WebhookTicketbookWalletShares,
    pub secret: String,
 }

@@ -1,6 +1,6 @@
 [package]
 name = "nym-credential-proxy"
-version = "0.1.1"
+version = "0.1.3"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true
@@ -19,7 +19,7 @@ bs58.workspace = true
 cfg-if = { workspace = true }
 colored.workspace = true
 clap = { workspace = true, features = ["derive", "env"] }
-dotenvy.workspace = true
+dotenv.workspace = true
 futures.workspace = true
 humantime.workspace = true
 rand.workspace = true
@@ -0,0 +1,20 @@
+/*
+ * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+
+DROP TABLE blinded_shares;
+CREATE TABLE blinded_shares
+(
+    id               INTEGER                     NOT NULL PRIMARY KEY,
+--    removed reference to `ticketbook_deposit` as the deposit wouldn't actually have been made before the pending share is inserted
+    request_uuid     TEXT                        NOT NULL,
+    status           TEXT                        NOT NULL,
+    device_id        TEXT                        NOT NULL,
+    credential_id    TEXT                        NOT NULL,
+    available_shares INTEGER                     NOT NULL DEFAULT 0,
+    error_message    TEXT                                 DEFAULT NULL,
+    created          TIMESTAMP WITHOUT TIME ZONE NOT NULL,
+    updated          TIMESTAMP WITHOUT TIME ZONE NOT NULL
+);
@@ -3,10 +3,12 @@

 use crate::error::VpnApiError;
 use crate::http::state::ApiState;
+use crate::storage::models::BlindedShares;
 use futures::{stream, StreamExt};
 use nym_credential_proxy_requests::api::v1::ticketbook::models::{
    TicketbookAsyncRequest, TicketbookObtainQueryParams, TicketbookRequest,
-    TicketbookWalletSharesResponse, WalletShare,
+    TicketbookWalletSharesResponse, WalletShare, WebhookTicketbookWalletShares,
+    WebhookTicketbookWalletSharesRequest,
 };
 use nym_credentials::IssuanceTicketBook;
 use nym_credentials_interface::Base58;
@@ -217,11 +219,13 @@ async fn try_obtain_blinded_ticketbook_async_inner(
    requested_on: OffsetDateTime,
    request_data: TicketbookAsyncRequest,
    params: TicketbookObtainQueryParams,
+    pending: &BlindedShares,
 ) -> Result<(), VpnApiError> {
    let epoch_id = state.current_epoch_id().await?;

    let device_id = &request_data.device_id;
    let credential_id = &request_data.credential_id;
+    let secret = request_data.secret.clone();

    // 1. try to obtain global data
    let (
@@ -259,19 +263,70 @@ async fn try_obtain_blinded_ticketbook_async_inner(
        error!(uuid = %request, "failed to update db with issued information: {err}")
    }

-    // 4. build the response
-    let response = TicketbookWalletSharesResponse {
+    // 4. build the webhook request body
+    let data = Some(TicketbookWalletSharesResponse {
        epoch_id,
        shares,
        master_verification_key,
        aggregated_coin_index_signatures,
        aggregated_expiration_date_signatures,
+    });
+
+    let ticketbook_wallet_shares = WebhookTicketbookWalletShares {
+        id: pending.id,
+        status: pending.status.to_string(),
+        device_id: device_id.clone(),
+        credential_id: credential_id.clone(),
+        data,
+        error_message: None,
+        created: pending.created,
+        updated: pending.updated,
+    };
+
+    let webhook_request = WebhookTicketbookWalletSharesRequest {
+        ticketbook_wallet_shares,
+        secret,
    };

    // 5. call the webhook
    state
        .zk_nym_web_hook()
-        .try_trigger(request, &response)
+        .try_trigger(request, &webhook_request)
+        .await;
+
+    Ok(())
+}
+
+async fn try_trigger_webhook_request_for_error(
+    state: &ApiState,
+    request: Uuid,
+    request_data: TicketbookAsyncRequest,
+    pending: &BlindedShares,
+    error_message: String,
+) -> Result<(), VpnApiError> {
+    let device_id = &request_data.device_id;
+    let credential_id = &request_data.credential_id;
+    let secret = request_data.secret.clone();
+
+    let ticketbook_wallet_shares = WebhookTicketbookWalletShares {
+        id: pending.id,
+        status: "error".to_string(),
+        device_id: device_id.clone(),
+        credential_id: credential_id.clone(),
+        data: None,
+        error_message: Some(error_message),
+        created: pending.created,
+        updated: pending.updated,
+    };
+
+    let webhook_request = WebhookTicketbookWalletSharesRequest {
+        ticketbook_wallet_shares,
+        secret,
+    };
+
+    state
+        .zk_nym_web_hook()
+        .try_trigger(request, &webhook_request)
        .await;

    Ok(())
@@ -285,16 +340,30 @@ pub(crate) async fn try_obtain_blinded_ticketbook_async(
    requested_on: OffsetDateTime,
    request_data: TicketbookAsyncRequest,
    params: TicketbookObtainQueryParams,
+    pending: BlindedShares,
 ) {
    if let Err(err) = try_obtain_blinded_ticketbook_async_inner(
        &state,
        request,
        requested_on,
-        request_data,
+        request_data.clone(),
        params,
+        &pending,
    )
    .await
    {
+        // post to the webhook to notify of errors on this side
+        if let Err(webhook_err) = try_trigger_webhook_request_for_error(
+            &state,
+            request,
+            request_data,
+            &pending,
+            format!("Failed to get ticketbook: {err}"),
+        )
+        .await
+        {
+            error!(uuid = %request, "failed to make webhook request to report error: {webhook_err}")
+        }
        error!(uuid = %request, "failed to resolve the blinded ticketbook issuance: {err}")
    } else {
        info!(uuid = %request, "managed to resolve the blinded ticketbook issuance")
@@ -84,8 +84,8 @@ pub(crate) struct ApiDoc;
            api_requests::v1::ticketbook::models::WalletShare,
            api_requests::v1::ticketbook::models::TicketbookWalletSharesResponse,
            api_requests::v1::ticketbook::models::TicketbookWalletSharesAsyncResponse,
-            api_requests::v1::ticketbook::models::BlindedWalletSharesResponse,
-            api_requests::v1::ticketbook::models::WebhookBlindedSharesResponse,
+            api_requests::v1::ticketbook::models::WebhookTicketbookWalletShares,
+            api_requests::v1::ticketbook::models::WebhookTicketbookWalletSharesRequest,
            api_requests::v1::ticketbook::models::TicketbookObtainQueryParams,
            api_requests::v1::ticketbook::models::SharesQueryParams,
            api_requests::v1::ticketbook::models::PlaceholderJsonSchemaImpl,
@@ -192,6 +192,7 @@ pub(crate) async fn obtain_ticketbook_shares_async(
        }
        Ok(pending) => pending,
    };
+    let id = pending.id;

    // 3. try to spawn a new task attempting to resolve the request
    if state
@@ -201,6 +202,7 @@ pub(crate) async fn obtain_ticketbook_shares_async(
            requested_on,
            payload,
            params,
+            pending,
        ))
        .is_none()
    {
@@ -213,10 +215,7 @@ pub(crate) async fn obtain_ticketbook_shares_async(
    }

    // 4. in the meantime, return the id to the user
-    Ok(output.to_response(TicketbookWalletSharesAsyncResponse {
-        id: pending.id,
-        uuid,
-    }))
+    Ok(output.to_response(TicketbookWalletSharesAsyncResponse { id, uuid }))
 }

 /// Obtain the current value of the bandwidth voucher deposit
@@ -149,7 +149,7 @@ pub(crate) async fn query_for_shares_by_id(
        (status = 401, description = "authentication token is missing or is invalid"),
        (status = 500, body = ErrorResponse, description = "failed to query for bandwidth blinded shares"),
    ),
-    params(OutputParams),
+    params(SharesQueryParams),
    security(
        ("auth_token" = [])
    )
@@ -40,7 +40,7 @@ impl SqliteStorageManager {
        sqlx::query_as!(
            MinimalWalletShare,
            r#"
-                SELECT t1.node_id, t1.blinded_signature, t1.epoch_id, t1.expiration_date as "expiration_date!: Date"
+                SELECT t1.node_id, t1.blinded_signature, t1.epoch_id, t1.expiration_date
                FROM partial_blinded_wallet as t1
                JOIN ticketbook_deposit as t2
                    on t1.corresponding_deposit = t2.deposit_id
@@ -79,11 +79,14 @@ impl SqliteStorageManager {
        device_id: &str,
        credential_id: &str,
    ) -> Result<Vec<MinimalWalletShare>, sqlx::Error> {
-        // https://docs.rs/sqlx/latest/sqlx/macro.query.html#force-a-differentcustom-type
        sqlx::query_as!(
            MinimalWalletShare,
            r#"
-                SELECT t1.node_id, t1.blinded_signature, t1.epoch_id, t1.expiration_date as "expiration_date!: Date"
+                SELECT 
+                    t1.node_id as "node_id!",
+                    t1.blinded_signature as "blinded_signature!",
+                    t1.epoch_id as "epoch_id!",
+                    t1.expiration_date as "expiration_date!"
                FROM partial_blinded_wallet as t1
                JOIN ticketbook_deposit as t2
                    on t1.corresponding_deposit = t2.deposit_id
@@ -5,18 +5,6 @@ WORKDIR /usr/src/nym/nym-data-observatory

 RUN cargo build --release

-#-------------------------------------------------------------------
-# The following environment variables are required at runtime:
-#
-# NYM_DATA_OBSERVATORY_CONNECTION_URL
-#
-# And optionally:
-#
-# NYM_DATA_OBSERVATORY_HTTP_PORT
-#
-# see https://github.com/nymtech/nym/blob/develop/nym-data-observatory/src/main.rs for details
-#-------------------------------------------------------------------
-
 FROM ubuntu:24.04

 RUN apt update && apt install -yy curl ca-certificates
@@ -18,14 +18,8 @@ services:
      dockerfile: nym-data-observatory/Dockerfile
    container_name: nym-data-observatory
    environment:
-      NYM_DATA_OBSERVATORY_CONNECTION_USERNAME: "postgres"
-      NYM_DATA_OBSERVATORY_CONNECTION_PASSWORD: "password"
-      NYM_DATA_OBSERVATORY_CONNECTION_HOST: "postgres"
-      NYM_DATA_OBSERVATORY_CONNECTION_PORT: "5432"
-      NYM_DATA_OBSERVATORY_CONNECTION_DB: ""
+      NYM_DATA_OBSERVATORY_CONNECTION_URL: "postgres://postgres:password@postgres:5432"
      NYM_DATA_OBSERVATORY_HTTP_PORT: 8000
-    env_file:
-      - ../envs/qa.env

 volumes:
  pgdata:
@@ -14,7 +14,9 @@ pub(crate) struct Storage {
 }

 impl Storage {
-    pub async fn init(connection_url: String) -> Result<Self> {
+    pub async fn init(connection_url: Option<String>) -> Result<Self> {
+        let connection_url =
+            connection_url.ok_or_else(|| anyhow!("Missing the connection url for database!"))?;
        let connect_options =
            PgConnectOptions::from_str(&connection_url)?.disable_statement_logging();

@@ -18,25 +18,9 @@ struct Args {
    #[arg(short, long, default_value = None, env = "NYM_DATA_OBSERVATORY_ENV_FILE")]
    env_file: Option<String>,

-    /// DB connection username
-    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_USERNAME")]
-    connection_username: String,
-
-    /// DB connection password
-    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_PASSWORD")]
-    connection_password: String,
-
-    /// DB connection host
-    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_HOST")]
-    connection_host: String,
-
-    /// DB connection port
-    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_PORT")]
-    connection_port: String,
-
-    /// DB connection database name
-    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_DB")]
-    connection_db: String,
+    /// DB connection url
+    #[arg(short, long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_URL")]
+    connection_url: Option<String>,
 }

 #[tokio::main]
@@ -47,16 +31,7 @@ async fn main() -> anyhow::Result<()> {

    setup_env(args.env_file); // Defaults to mainnet if empty

-    let connection_url = format!(
-        "postgres://{}:{}@{}:{}/{}",
-        args.connection_username,
-        args.connection_password,
-        args.connection_host,
-        args.connection_port,
-        args.connection_db
-    );
-
-    let storage = db::Storage::init(connection_url).await?;
+    let storage = db::Storage::init(args.connection_url).await?;
    let db_pool = storage.pool_owned().await;
    tokio::spawn(async move {
        background_task::spawn_in_background(db_pool).await;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jędrzej Stuczyński	d75fdfab02	added statement logging to nym-api db	2024-11-20 09:35:56 +00:00
Jędrzej Stuczyński	6b5b97199b	fix: tracing logger to output to stderr	2024-11-19 17:47:13 +00:00
Tommy Verrall	b49ef643df	Update publish-nym-binaries.yml	2024-11-18 17:56:57 +01:00
Tommy Verrall	62e0771236	Update publish-nym-contracts.yml	2024-11-18 16:24:52 +01:00
benedettadavico	b5f1d674fe	update wallet versions and changelog	2024-11-18 14:07:01 +01:00
benedettadavico	086b4f6f54	update changelog	2024-11-18 13:01:27 +01:00
Bogdan-Ștefan Neacşu	5ad11f2048	Limit race probability (#5145 ) * Limit race probability * Actually assign value	2024-11-18 13:33:19 +02:00
Jędrzej Stuczyński	6dc9b79ace	bugifx: assign 'node_id' when converting from 'GatewayDetails' to 'TestNode' (#5143 )	2024-11-18 10:28:46 +00:00
Jędrzej Stuczyński	35343b5220	bugfix: make sure to assign correct node_id and identity during 'gateway_details' table migration (#5142 )	2024-11-18 10:00:40 +00:00
Bogdan-Ștefan Neacşu	e44a36e5b5	Respond to auth messages with same version (#5140 ) * Introduce traits for response * Ugly responde with same protocol version * Don't pull sdk crate unnecessarily	2024-11-18 11:21:07 +02:00
Mark Sinclair	db20c2e2fa	node-status-agent: cherry-pick GH Actions pipeline and dockerfile from `9c680fd`	2024-11-15 17:55:07 +00:00
Mark Sinclair	94f247563b	nym-node-status-agent bump version	2024-11-15 17:45:26 +00:00
Jędrzej Stuczyński	6809f7302e	Pain/polyfill deprecated endpoints (#5131 ) * polyfilled contract cache endpoints * polyfilled legacy described endpoints	2024-11-14 15:32:20 +00:00
Andrej Mihajlov	46a33b5ef6	Add NYM_VPN_API to env files (#5099 ) * Add missing NYM_VPN_API uri to environment files * Add trailing slashes --------- Co-authored-by: Jon Häggblad <jon.haggblad@gmail.com>	2024-11-14 13:05:03 +01:00
Jędrzej Stuczyński	532c25c4f5	change: dont allow mixnodes bonded with vested tokens into the rewarded set (#5129 )	2024-11-14 08:48:06 +00:00
Fouad	c0aadebf80	Migrate node when events pending (#5125 ) * dont show node migration if there are vesting tokens * catch and set errors	2024-11-13 12:53:57 +00:00
benedettadavico	5b216e8d40	update versions	2024-11-13 11:23:07 +01:00
Tommy Verrall	4fab7eac3f	temporarily disable playground and test my node in the wallet once we have time to fix these we will import these again	2024-11-13 10:56:19 +01:00
Jon Häggblad	ac77712cc0	nym-credential-proxy-requests: reqwest use rustls-tls (#5116 ) * nym-credential-proxy-requests: reqwest use rustls-tls * nym-credential-proxy: reqwest default-features false	2024-11-11 17:38:21 +01:00
Jędrzej Stuczyński	a400aa8928	bugfix: preserve as much as possible of the rewarded set during migration (#5103 )	2024-11-08 09:33:30 +00:00
Jędrzej Stuczyński	c001059af9	Feature/force refresh node (#5101 ) * introduced nym-api endpoint for force refreshing described node data * client code + updated return types * nym-node to update self-described data cache on startup + change request type * send request to all available nym-apis * fixed 'is_stale' check	2024-11-06 09:17:44 +00:00
Jędrzej Stuczyński	fd8dc63c88	fixed HistoricalUptimeUpdater (#5097 )	2024-11-05 14:40:50 +00:00
Dinko Zdravac	d03c5b3650	Graceful agent 1.1.5 (#5093 ) * Bump NS agent to 0.1.5 * API improvements - agent exits gracefully when no testrun available - API doesn't log every error * Bump NSAPI to 0.1.6	2024-11-05 15:36:16 +01:00
Bogdan-Ștefan Neacşu	69e97b3bbc	Remove old use of 1GB constant (#5096 ) * Remove old use of 1GB constant * Fix clippy	2024-11-05 16:16:59 +02:00
Bogdan-Ștefan Neacşu	15ca24b848	Add more translations from v2 to v3 authenticator (#5091 )	2024-11-05 15:30:00 +02:00
Fouad	fa551b6d9d	Nym node - Fix claim delegator rewards (#5090 ) * update function param from mixId to nodeId * fix claim operator rewards	2024-11-05 13:01:22 +00:00
Bogdan-Ștefan Neacşu	c6959d3e2d	Make 250 GB/30 days for free ride mode (#5083 )	2024-11-05 11:14:43 +02:00
Jędrzej Stuczyński	2569deb080	bugfix: [wallet] displaying delegations for native nymnodes (#5087 ) * fixed return type for getting nymnode details * fixed nym-api queries if using relative paths * fixed queries for delegations of native nymnodes	2024-11-04 21:15:29 +00:00
Bogdan-Ștefan Neacşu	5cefa7fdd4	Don't increase bandwidth again (#5081 )	2024-11-04 13:15:27 +02:00
Mark Sinclair	80b590d50d	bug-fix: nym-credential-proxy webhook request is the correct shape and added reporting errors via webhook (#5077 ) Co-authored-by: Mark Sinclair <mmsinclair@users.noreply.github.com>	2024-11-01 21:48:04 +01:00
Bogdan-Ștefan Neacşu	f9b363648f	Fix expiration date as today + 7 days (#5076 )	2024-11-01 16:01:24 +02:00
Bogdan-Ștefan Neacşu	b73561f1c9	Fix gateway decreasing bandwidth (#5075 ) * Update storage peers after periodic check * Reset storage bytes on restart * Fix clippy	2024-11-01 15:40:22 +02:00
Dinko Zdravac	09b68a8204	Cherry pick NS API from develop (#5074 ) * Revert "NS API with directory v2 (#5068)" This reverts commit `cf4fe5f875`. * Merge pull request #5050 from nymtech/dz-node-status-api Node Status API * Ns agent workflow (#5055) * feat: add dockerfile * add github workflow for node status agent --------- Co-authored-by: Fran Arbanas <arbanasfran@gmail.com> * NS API with directory v2 (#5058) * Use unstable explorer client * Clean up stale testruns & logging - log gw identity key - better agent testrun logging - log responses - change response code for agents * Better logging on agent * Testrun stores gw identity key instead of gw pk * Agent 0.1.3 * Agent 0.1.4 * Sqlx offline query data + clippy * Compatible with directory v2 * Point to internal deps + rebase + v0.1.5 * self described field not null * Fix build.rs typo * Fix clippy --------- Co-authored-by: Fran Arbanas <arbanasfran@gmail.com>	2024-11-01 01:24:41 +01:00
Fouad	0374626960	Allow custom http port to be reset (#5073 ) * allow custom port to be reset in wallet	2024-10-31 16:53:55 +00:00
Dinko Zdravac	cf4fe5f875	NS API with directory v2 (#5068 ) * Use unstable explorer client * Clean up stale testruns & logging - log gw identity key - better agent testrun logging - log responses - change response code for agents * Better logging on agent * Testrun stores gw identity key instead of gw pk * Agent 0.1.3 * Agent 0.1.4 * Sqlx offline query data + clippy * Compatible with directory v2 * Point to internal deps + rebase + v0.1.5 * self described field not null * Fix build.rs typo	2024-10-31 13:52:20 +01:00
Jędrzej Stuczyński	9f8bf2d080	bugfix: wallet backend fixes (#5070 ) * fixed simulation arguments * make sure 'try_convert_pubkey_to_node_id' checks for native nymnodes	2024-10-31 12:23:20 +00:00
Jędrzej Stuczyński	b9d1fc40e7	deprecated old nym-api client methods and replaced them when possible (#5069 )	2024-10-31 12:08:58 +00:00
Jędrzej Stuczyński	be67234093	bugfix: credential-proxy obtain-async (#5067 ) * removed foreign key constraint on deposit table * fixed sql nullability * fixed swagger arguments for '/api/v1/ticketbook/shares/device/{device_id}/credential/{credential_id}' route * fixed missing swagger component definitions	2024-10-31 10:33:38 +00:00
Fouad	8b0b70a727	allow nym node config updates (#5066 )	2024-10-31 09:59:22 +00:00
Fouad	c90ebf0a6a	Feature/wallet bonding fixes (#5064 ) * bonding and unbonding for nym nodes	2024-10-30 17:15:38 +00:00
Jędrzej Stuczyński	07ff2639ec	bugfix: use corrext axum extractors for ecash route arguments (#5065 )	2024-10-30 16:05:16 +00:00
Jędrzej Stuczyński	753a21f8ca	bugfix/feature: added NymApiClient method to get all skimmed nodes (#5062 ) * bugfix/feature: added NymApiClient method to get all skimmed nodes * wasm * helper: utility method for getting ed25519 identity directly from node description	2024-10-30 12:21:27 +00:00
Jędrzej Stuczyński	76da4ab532	bugfix: mark migrated gateways as rewarded in the previous epoch in case theyre in the rewarded set (#5049 )	2024-10-30 09:11:13 +00:00