Apply 250GB/30 days to magura

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 12:06:06 +02:00 · 2024-11-13 10:56:19 +01:00 · 2024-11-11 17:38:21 +01:00 · 2024-11-08 09:33:30 +00:00 · 2024-11-06 09:17:44 +00:00 · 2024-11-05 14:40:50 +00:00
177 changed files with 6704 additions and 517 deletions
@@ -57,6 +57,12 @@ jobs:
          command: fmt
          args: --all -- --check

+      - name: Clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --workspace --all-targets -- -D warnings
+
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
@@ -82,9 +88,3 @@ jobs:
        with:
          command: test
          args: --workspace -- --ignored
-
-      - name: Clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: --workspace --all-targets -- -D warnings
@@ -0,0 +1,56 @@
+name: Build and upload Node Status agent container to harbor.nymte.ch
+
+on:
+  workflow_dispatch:
+
+env:
+  WORKING_DIRECTORY: "nym-node-status-agent"
+  CONTAINER_NAME: "node-status-agent"
+
+jobs:
+  build-container:
+    runs-on: arc-ubuntu-22.04-dind
+    steps:
+      - name: Login to Harbor
+        uses: docker/login-action@v3
+        with:
+          registry: harbor.nymte.ch
+          username: ${{ secrets.HARBOR_ROBOT_USERNAME }}
+          password: ${{ secrets.HARBOR_ROBOT_SECRET }}
+
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Configure git identity
+        run: |
+          git config --global user.email "lawrence@nymtech.net"
+          git config --global user.name "Lawrence Stalder"
+
+      - name: Get version from cargo.toml
+        uses: mikefarah/yq@v4.44.3
+        id: get_version
+        with:
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
+
+      - name: Check if tag exists
+        run: |
+          if git rev-parse ${{ steps.get_version.outputs.value }} >/dev/null 2>&1; then
+            echo "Tag ${{ steps.get_version.outputs.value }} already exists"
+          fi
+
+      - name: Remove existing tag if exists
+        run: |
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
+            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+          fi
+
+      - name: Create tag
+        run: |
+          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
+          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+
+      - name: BuildAndPushImageOnHarbor
+        run: |
+          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
@@ -1,11 +1,55 @@
 name: Build and upload Node Status API container to harbor.nymte.ch
-
 on:
  workflow_dispatch:

+env:
+  WORKING_DIRECTORY: "nym-node-status-api"
+  CONTAINER_NAME: "node-status-api"
+
 jobs:
-  my-job:
-    runs-on: arc-ubuntu-22.04
+  build-container:
+    runs-on: arc-ubuntu-22.04-dind
    steps:
-      - name: my-step
-        run: echo "Hello World!"
+      - name: Login to Harbor
+        uses: docker/login-action@v3
+        with:
+          registry: harbor.nymte.ch
+          username: ${{ secrets.HARBOR_ROBOT_USERNAME }}
+          password: ${{ secrets.HARBOR_ROBOT_SECRET }}
+
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Configure git identity
+        run: |
+          git config --global user.email "lawrence@nymtech.net"
+          git config --global user.name "Lawrence Stalder"
+
+      - name: Get version from cargo.toml
+        uses: mikefarah/yq@v4.44.3
+        id: get_version
+        with:
+          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
+
+      - name: Check if tag exists
+        run: |
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
+            echo "Tag ${{ steps.get_version.outputs.result }} already exists"
+          fi
+
+      - name: Remove existing tag if exists
+        run: |
+          if git rev-parse ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} >/dev/null 2>&1; then
+            git push --delete origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+            git tag -d ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+          fi
+
+      - name: Create tag
+        run: |
+          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
+          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
+
+      - name: BuildAndPushImageOnHarbor
+        run: |
+          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
+          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
@@ -318,10 +318,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35"
 dependencies = [
 "concurrent-queue",
- "event-listener",
+ "event-listener 2.5.3",
 "futures-core",
 ]

+[[package]]
+name = "async-lock"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
+dependencies = [
+ "event-listener 5.3.1",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "async-stream"
 version = "0.3.5"
@@ -455,6 +466,7 @@ checksum = "504e3947307ac8326a5437504c517c4b56716c9d98fac0028c2acc7ca47d70ae"
 dependencies = [
 "async-trait",
 "axum-core 0.4.5",
+ "axum-macros",
 "bytes",
 "futures-util",
 "http 1.1.0",
@@ -553,6 +565,17 @@ dependencies = [
 "tracing",
 ]

+[[package]]
+name = "axum-macros"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57d123550fa8d071b7255cb0cc04dc302baa6c8c4a79f55701552684d8399bce"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.66",
+]
+
 [[package]]
 name = "axum-test"
 version = "16.2.0"
@@ -2331,6 +2354,15 @@ dependencies = [
 "termcolor",
 ]

+[[package]]
+name = "envy"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f47e0157f2cb54f5ae1bd371b30a2ae4311e1c028f575cd4e81de7353215965"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "equivalent"
 version = "1.0.1"
@@ -2373,6 +2405,27 @@ version = "2.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"

+[[package]]
+name = "event-listener"
+version = "5.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6032be9bd27023a771701cc49f9f053c751055f71efb2e0ae5c15809093675ba"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1"
+dependencies = [
+ "event-listener 5.3.1",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "explorer-api"
 version = "1.1.41"
@@ -3593,7 +3646,7 @@ dependencies = [
 "crossbeam-utils",
 "curl",
 "curl-sys",
- "event-listener",
+ "event-listener 2.5.3",
 "futures-lite",
 "http 0.2.12",
 "log",
@@ -4075,6 +4128,30 @@ dependencies = [
 "wasm-utils",
 ]

+[[package]]
+name = "moka"
+version = "0.12.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32cf62eb4dd975d2dde76432fb1075c49e3ee2331cf36f1f8fd4b66550d32b6f"
+dependencies = [
+ "async-lock",
+ "async-trait",
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "event-listener 5.3.1",
+ "futures-util",
+ "once_cell",
+ "parking_lot",
+ "quanta",
+ "rustc_version 0.4.0",
+ "smallvec",
+ "tagptr",
+ "thiserror",
+ "triomphe",
+ "uuid",
+]
+
 [[package]]
 name = "multer"
 version = "2.1.0"
@@ -4920,6 +4997,13 @@ dependencies = [
 "nym-multisig-contract-common",
 ]

+[[package]]
+name = "nym-common-models"
+version = "0.1.0"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "nym-compact-ecash"
 version = "0.1.0"
@@ -5235,12 +5319,12 @@ dependencies = [
 name = "nym-explorer-client"
 version = "0.1.0"
 dependencies = [
- "log",
 "nym-explorer-api-requests",
 "reqwest 0.12.4",
 "serde",
 "thiserror",
 "tokio",
+ "tracing",
 "url",
 ]

@@ -5822,6 +5906,7 @@ dependencies = [
 "nym-sphinx-addressing",
 "nym-task",
 "nym-types",
+ "nym-validator-client",
 "nym-wireguard",
 "nym-wireguard-types",
 "rand",
@@ -5894,6 +5979,61 @@ dependencies = [
 "utoipa",
 ]

+[[package]]
+name = "nym-node-status-agent"
+version = "0.1.5"
+dependencies = [
+ "anyhow",
+ "clap 4.5.18",
+ "nym-bin-common",
+ "nym-common-models",
+ "reqwest 0.12.4",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "nym-node-status-api"
+version = "0.1.6"
+dependencies = [
+ "anyhow",
+ "axum 0.7.7",
+ "chrono",
+ "clap 4.5.18",
+ "cosmwasm-std",
+ "envy",
+ "futures-util",
+ "moka",
+ "nym-bin-common",
+ "nym-common-models",
+ "nym-explorer-client",
+ "nym-network-defaults",
+ "nym-node-requests",
+ "nym-task",
+ "nym-validator-client",
+ "regex",
+ "reqwest 0.12.4",
+ "serde",
+ "serde_json",
+ "serde_json_path",
+ "sqlx",
+ "strum 0.26.3",
+ "strum_macros 0.26.4",
+ "thiserror",
+ "tokio",
+ "tokio-util",
+ "tower-http",
+ "tracing",
+ "tracing-log 0.2.0",
+ "tracing-subscriber",
+ "utoipa",
+ "utoipa-swagger-ui",
+ "utoipauto",
+]
+
 [[package]]
 name = "nym-node-tester-utils"
 version = "0.1.0"
@@ -6488,7 +6628,6 @@ dependencies = [
 "flate2",
 "futures",
 "itertools 0.13.0",
- "log",
 "nym-api-requests",
 "nym-coconut-bandwidth-contract-common",
 "nym-coconut-dkg-common",
@@ -6512,6 +6651,7 @@ dependencies = [
 "thiserror",
 "time",
 "tokio",
+ "tracing",
 "ts-rs",
 "url",
 "wasmtimer",
@@ -7421,6 +7561,21 @@ dependencies = [
 "psl-types",
 ]

+[[package]]
+name = "quanta"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5167a477619228a0b284fac2674e3c388cba90631d7b7de620e6f1fcd08da5"
+dependencies = [
+ "crossbeam-utils",
+ "libc",
+ "once_cell",
+ "raw-cpuid",
+ "wasi",
+ "web-sys",
+ "winapi",
+]
+
 [[package]]
 name = "quick-error"
 version = "1.2.3"
@@ -7512,6 +7667,15 @@ dependencies = [
 "rand_core 0.6.4",
 ]

+[[package]]
+name = "raw-cpuid"
+version = "11.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ab240315c661615f2ee9f0f2cd32d5a7343a84d5ebcccb99d46e6637565e7b0"
+dependencies = [
+ "bitflags 2.5.0",
+]
+
 [[package]]
 name = "rayon"
 version = "1.10.0"
@@ -8361,9 +8525,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.128"
+version = "1.0.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
+checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
 dependencies = [
 "itoa",
 "memchr",
@@ -8371,6 +8535,59 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "serde_json_path"
+version = "0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bc0207b6351893eafa1e39aa9aea452abb6425ca7b02dd64faf29109e7a33ba"
+dependencies = [
+ "inventory",
+ "nom",
+ "once_cell",
+ "regex",
+ "serde",
+ "serde_json",
+ "serde_json_path_core",
+ "serde_json_path_macros",
+ "thiserror",
+]
+
+[[package]]
+name = "serde_json_path_core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3d64fe53ce1aaa31bea2b2b46d3b6ab6a37e61854bedcbd9f174e188f3f7d79"
+dependencies = [
+ "inventory",
+ "once_cell",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "serde_json_path_macros"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a31e8177a443fd3e94917f12946ae7891dfb656e6d4c5e79b8c5d202fbcb723"
+dependencies = [
+ "inventory",
+ "once_cell",
+ "serde_json_path_core",
+ "serde_json_path_macros_internal",
+]
+
+[[package]]
+name = "serde_json_path_macros_internal"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75dde5a1d2ed78dfc411fc45592f72d3694436524d3353683ecb3d22009731dc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.66",
+]
+
 [[package]]
 name = "serde_path_to_error"
 version = "0.1.16"
@@ -8735,7 +8952,7 @@ dependencies = [
 "crc",
 "crossbeam-queue",
 "either",
- "event-listener",
+ "event-listener 2.5.3",
 "futures-channel",
 "futures-core",
 "futures-intrusive",
@@ -9145,6 +9362,12 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -9917,6 +10140,12 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "triomphe"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "859eb650cfee7434994602c3a68b25d77ad9e68c8a6cd491616ef86661382eb3"
+
 [[package]]
 name = "try-lock"
 version = "0.2.5"
@@ -60,6 +60,7 @@ members = [
    "common/ip-packet-requests",
    "common/ledger",
    "common/mixnode-common",
+    "common/models",
    "common/network-defaults",
    "common/node-tester-utils",
    "common/nonexhaustive-delayqueue",
@@ -119,6 +120,8 @@ members = [
    "nym-node",
    "nym-node/nym-node-http-api",
    "nym-node/nym-node-requests",
+    "nym-node-status-api",
+    "nym-node-status-agent",
    "nym-outfox",
    "nym-validator-rewarder",
    "tools/echo-server",
@@ -146,13 +149,16 @@ members = [
 default-members = [
    "clients/native",
    "clients/socks5",
+    "common/models",
    "explorer-api",
    "gateway",
    "mixnode",
    "nym-api",
    "nym-data-observatory",
    "nym-node",
+    "nym-node-status-api",
    "nym-validator-rewarder",
+    "nym-node-status-api",
    "service-providers/authenticator",
    "service-providers/ip-packet-router",
    "service-providers/network-requester",
@@ -234,10 +240,12 @@ dotenvy = "0.15.6"
 ecdsa = "0.16"
 ed25519-dalek = "2.1"
 etherparse = "0.13.0"
+envy = "0.4"
 eyre = "0.6.9"
 fastrand = "2.1.1"
 flate2 = "1.0.34"
 futures = "0.3.28"
+futures-util = "0.3"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
 getset = "0.1.3"
@@ -267,6 +275,7 @@ ledger-transport-hid = "0.10.0"
 log = "0.4"
 maxminddb = "0.23.0"
 mime = "0.3.17"
+moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
 okapi = "0.7.0"
@@ -299,7 +308,8 @@ semver = "1.0.23"
 serde = "1.0.210"
 serde_bytes = "0.11.15"
 serde_derive = "1.0"
-serde_json = "1.0.128"
+serde_json = "1.0.132"
+serde_json_path = "0.6.7"
 serde_repr = "0.1"
 serde_with = "3.9.0"
 serde_yaml = "0.9.25"
@@ -308,6 +318,7 @@ si-scale = "0.2.3"
 sphinx-packet = "0.1.1"
 sqlx = "0.7.4"
 strum = "0.26"
+strum_macros = "0.26"
 subtle-encoding = "0.5"
 syn = "1"
 sysinfo = "0.30.13"
@@ -329,6 +340,7 @@ tracing = "0.1.37"
 tracing-opentelemetry = "0.19.0"
 tracing-subscriber = "0.3.16"
 tracing-tree = "0.2.2"
+tracing-log = "0.2"
 ts-rs = "10.0.0"
 tungstenite = { version = "0.20.1", default-features = false }
 url = "2.5"
@@ -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 {
@@ -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 {
@@ -45,3 +45,4 @@ tracing = [
    "opentelemetry",
 ]
 clap = [ "dep:clap", "dep:clap_complete", "dep:clap_complete_fig" ]
+models = []
@@ -25,7 +25,7 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 nym-http-api-client = { path = "../../../common/http-api-client" }
 thiserror = { workspace = true }
-log = { workspace = true }
+tracing = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 tokio = { workspace = true, features = ["sync", "time"] }
 time = { workspace = true, features = ["formatting"] }
@@ -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);
@@ -311,10 +323,17 @@ impl NymApiClient {
        NymApiClient { nym_api }
    }

-    pub fn new_with_user_agent(api_url: Url, user_agent: UserAgent) -> Self {
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn new_with_timeout(api_url: Url, timeout: std::time::Duration) -> Self {
+        let nym_api = nym_api::Client::new(api_url, Some(timeout));
+
+        NymApiClient { nym_api }
+    }
+
+    pub fn new_with_user_agent(api_url: Url, user_agent: 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");

@@ -417,6 +436,38 @@ 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,
@@ -443,26 +494,35 @@ impl NymApiClient {
        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> {
@@ -511,6 +571,7 @@ impl NymApiClient {
        Ok(bonds)
    }

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

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

+    #[deprecated]
    pub async fn get_mixnode_status(
        &self,
        mix_id: NodeId,
@@ -540,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,
@@ -547,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,
@@ -578,6 +643,7 @@ impl NymApiClient {
            .await?)
    }

+    #[deprecated]
    pub async fn spent_credentials_filter(
        &self,
    ) -> Result<SpentCredentialsResponse, ValidatorClientError> {
@@ -121,36 +121,36 @@ async fn test_nyxd_connection(
    {
        Ok(Err(NyxdError::TendermintErrorRpc(e))) => {
            // If we get a tendermint-rpc error, we classify the node as not contactable
-            log::warn!("Checking: nyxd url: {url}: {}: {}", "failed".red(), e);
+            tracing::warn!("Checking: nyxd url: {url}: {}: {}", "failed".red(), e);
            false
        }
        Ok(Err(NyxdError::AbciError { code, log, .. })) => {
            // We accept the mixnet contract not found as ok from a connection standpoint. This happens
            // for example on a pre-launch network.
-            log::debug!(
+            tracing::debug!(
                "Checking: nyxd url: {url}: {}, but with abci error: {code}: {log}",
                "success".green()
            );
            code == 18
        }
        Ok(Err(error @ NyxdError::NoContractAddressAvailable(_))) => {
-            log::warn!("Checking: nyxd url: {url}: {}: {error}", "failed".red());
+            tracing::warn!("Checking: nyxd url: {url}: {}: {error}", "failed".red());
            false
        }
        Ok(Err(e)) => {
            // For any other error, we're optimistic and just try anyway.
-            log::warn!(
+            tracing::warn!(
                "Checking: nyxd_url: {url}: {}, but with error: {e}",
                "success".green()
            );
            true
        }
        Ok(Ok(_)) => {
-            log::debug!("Checking: nyxd_url: {url}: {}", "success".green());
+            tracing::debug!("Checking: nyxd_url: {url}: {}", "success".green());
            true
        }
        Err(e) => {
-            log::warn!("Checking: nyxd_url: {url}: {}: {e}", "failed".red());
+            tracing::warn!("Checking: nyxd_url: {url}: {}: {e}", "failed".red());
            false
        }
    };
@@ -164,20 +164,20 @@ 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
    {
        Ok(Ok(_)) => {
-            log::debug!("Checking: api_url: {url}: {}", "success".green());
+            tracing::debug!("Checking: api_url: {url}: {}", "success".green());
            true
        }
        Ok(Err(e)) => {
-            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
+            tracing::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
            false
        }
        Err(e) => {
-            log::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
+            tracing::debug!("Checking: api_url: {url}: {}: {e}", "failed".red());
            false
        }
    };
@@ -11,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;
@@ -42,6 +43,7 @@ use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, NodeId, NymNodeDetails};
 use time::format_description::BorrowedFormatItem;
 use time::Date;
+use tracing::instrument;

 pub mod error;
 pub mod routes;
@@ -53,11 +55,27 @@ 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(
            &[
@@ -71,6 +89,8 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

+    #[deprecated]
+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnodes_detailed_unfiltered(
        &self,
    ) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
@@ -99,11 +121,15 @@ 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(
            &[routes::API_VERSION, routes::GATEWAYS, routes::DESCRIBED],
@@ -112,6 +138,8 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

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

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

+    #[deprecated]
+    #[tracing::instrument(level = "debug", skip_all)]
    async fn get_basic_mixnodes(
        &self,
        semver_compatibility: Option<String>,
@@ -181,6 +213,8 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

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

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

+    #[deprecated]
+    #[instrument(level = "debug", skip(self))]
    async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
@@ -326,6 +407,8 @@ 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(
            &[
@@ -340,6 +423,8 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

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

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

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

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

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

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

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

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

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

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

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

+    #[deprecated]
+    #[instrument(level = "debug", skip(self))]
    async fn get_mixnode_inclusion_probability(
        &self,
        mix_id: NodeId,
@@ -582,22 +691,40 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    #[instrument(level = "debug", skip(self))]
    async fn get_current_node_performance(
        &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(
            &[
@@ -612,6 +739,8 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

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

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

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

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

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

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

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

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

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

+    #[instrument(level = "debug", skip(self))]
    async fn master_verification_key(
        &self,
        epoch_id: Option<EpochId>,
@@ -793,6 +934,19 @@ 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,
        dkg_epoch: EpochId,
@@ -809,6 +963,7 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

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

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

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

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

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

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

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

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

 pub use cosmrs::abci::MsgResponse;

@@ -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
@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 use std::time::Duration;
 use thiserror::Error;
-use tracing::warn;
+use tracing::{instrument, warn};
 use url::Url;

 pub use reqwest::IntoUrl;
@@ -205,6 +205,7 @@ impl Client {
        self.reqwest_client.get(url)
    }

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

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

+    #[instrument(level = "debug", skip_all)]
    pub async fn get_json<T, K, V, E>(
        &self,
        path: PathSegments<'_>,
@@ -312,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>,
@@ -515,12 +519,14 @@ pub fn sanitize_url<K: AsRef<str>, V: AsRef<str>>(
    url
 }

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

    if !allow_empty {
        if let Some(0) = res.content_length() {
@@ -529,11 +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) => 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
@@ -0,0 +1,14 @@
+[package]
+name = "nym-common-models"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+readme.workspace = true
+
+[dependencies]
+serde = { workspace = true, features = ["derive"] }
@@ -0,0 +1 @@
+pub mod ns_api;
@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct TestrunAssignment {
+    pub testrun_id: i64,
+    pub gateway_identity_key: String,
+}
@@ -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",
@@ -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,
@@ -230,7 +230,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?;
                    }
                }

@@ -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(())
    }
@@ -19,5 +19,5 @@ MULTISIG_CONTRACT_ADDRESS=n1zwv6feuzhy6a9wekh96cd57lsarmqlwxdypdsplw6zhfncqw6ftq
 COCONUT_DKG_CONTRACT_ADDRESS=n1aakfpghcanxtc45gpqlx8j3rq0zcpyf49qmhm9mdjrfx036h4z5sy2vfh9

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

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

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

 STATISTICS_SERVICE_DOMAIN_ADDRESS="http://0.0.0.0"
 EXPLORER_API=https://sandbox-explorer.nymtech.net/api
-NYXD="https://rpc.sandbox.nymtech.net"
-NYXD_WS="wss://rpc.sandbox.nymtech.net/websocket"
-NYM_API="https://sandbox-nym-api1.nymtech.net/api"
+NYXD=https://rpc.sandbox.nymtech.net
+NYXD_WS=wss://rpc.sandbox.nymtech.net/websocket
+NYM_API=https://sandbox-nym-api1.nymtech.net/api
@@ -7,12 +7,12 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

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

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

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

 // Re-export request types
@@ -49,27 +50,28 @@ impl ExplorerClient {
        Ok(Self { client, url })
    }

-    #[cfg(target_arch = "wasm32")]
-    pub fn new(url: url::Url) -> Result<Self, ExplorerApiError> {
-        let client = reqwest::Client::builder().build()?;
-        Ok(Self { client, url })
-    }
-
    #[cfg(not(target_arch = "wasm32"))]
    pub fn new_with_timeout(url: url::Url, timeout: Duration) -> Result<Self, ExplorerApiError> {
        let client = reqwest::Client::builder().timeout(timeout).build()?;
        Ok(Self { client, url })
    }

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

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

@@ -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) {
@@ -622,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");
@@ -630,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>
@@ -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) {
@@ -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,
 };
@@ -897,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(
@@ -1137,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()),
@@ -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)
    }
@@ -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
@@ -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
    }
@@ -214,6 +214,17 @@ dependencies = [
 "tracing",
 ]

+[[package]]
+name = "axum-client-ip"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9eefda7e2b27e1bda4d6fa8a06b50803b8793769045918bc37ad062d48a6efac"
+dependencies = [
+ "axum",
+ "forwarded-header-value",
+ "serde",
+]
+
 [[package]]
 name = "axum-core"
 version = "0.4.5"
@@ -1311,6 +1322,16 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8cbd1169bd7b4a0a20d92b9af7a7e0422888bd38a6f5ec29c1fd8c1558a272e"

+[[package]]
+name = "forwarded-header-value"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8835f84f38484cc86f110a805655697908257fb9a7af005234060891557198e9"
+dependencies = [
+ "nonempty",
+ "thiserror",
+]
+
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -2147,6 +2168,12 @@ dependencies = [
 "minimal-lexical",
 ]

+[[package]]
+name = "nonempty"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9e591e719385e6ebaeb5ce5d3887f7d5676fceca6411d1925ccc95745f3d6f7"
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -2315,7 +2342,7 @@ dependencies = [
 "digest 0.9.0",
 "ff",
 "group",
- "itertools 0.12.1",
+ "itertools 0.13.0",
 "nym-network-defaults",
 "nym-pemstore",
 "rand",
@@ -2355,7 +2382,7 @@ dependencies = [

 [[package]]
 name = "nym-credential-proxy"
-version = "0.1.0"
+version = "0.1.3"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -2540,6 +2567,7 @@ name = "nym-http-api-common"
 version = "0.1.0"
 dependencies = [
 "axum",
+ "axum-client-ip",
 "bytes",
 "colored",
 "mime",
@@ -2663,7 +2691,6 @@ dependencies = [
 "flate2",
 "futures",
 "itertools 0.13.0",
- "log",
 "nym-api-requests",
 "nym-coconut-bandwidth-contract-common",
 "nym-coconut-dkg-common",
@@ -2687,6 +2714,7 @@ dependencies = [
 "thiserror",
 "time",
 "tokio",
+ "tracing",
 "url",
 "wasmtimer",
 "zeroize",
@@ -3763,9 +3791,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.128"
+version = "1.0.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
+checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
 dependencies = [
 "itoa",
 "memchr",
@@ -4889,6 +4917,7 @@ dependencies = [
 "quote",
 "regex",
 "syn 2.0.79",
+ "uuid",
 ]

 [[package]]
@@ -37,7 +37,7 @@ futures = "0.3.30"
 humantime = "2.1.0"
 thiserror = "1.0.59"
 rand = "0.8.5"
-reqwest = "0.12.4"
+reqwest = { version = "0.12.4", default-features = false }
 schemars = "0.8.17"
 strum = "0.26.3"
 strum_macros = "0.26.4"
@@ -18,16 +18,16 @@ 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" }
 nym-http-api-common = { path = "../../common/http-api-common", optional = true }
-nym-http-api-client = { path = "../../common/http-api-client"  }
+nym-http-api-client = { path = "../../common/http-api-client" }
 nym-serde-helpers = { path = "../../common/serde-helpers", features = ["bs58"] }

 [target."cfg(target_arch = \"wasm32\")".dependencies.wasmtimer]
@@ -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
@@ -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" = [])
    )
@@ -82,7 +82,11 @@ impl SqliteStorageManager {
        sqlx::query_as!(
            MinimalWalletShare,
            r#"
-                SELECT t1.node_id, t1.blinded_signature, t1.epoch_id, t1.expiration_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
@@ -68,6 +68,7 @@ warning: no queries found; do you have the `offline` feature enabled
 ### Possible solutions

 - does your `sqlx-cli` version match `sqlx` version from `Cargo.toml`?
+  + `cargo install -f sqlx-cli --version <specific version>`
 ```
 cargo install sqlx-cli --version <exact semver version as sqlx> --force
 ```
@@ -0,0 +1 @@
+nym-gateway-probe
@@ -0,0 +1,27 @@
+# Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+# SPDX-License-Identifier: Apache-2.0
+
+
+[package]
+name = "nym-node-status-agent"
+version = "0.1.5"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+readme.workspace = true
+
+[dependencies]
+anyhow = { workspace = true}
+clap = { workspace = true, features = ["derive", "env"] }
+nym-bin-common = { path = "../common/bin-common", features = ["models"]}
+nym-common-models = { path = "../common/models" }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread", "process"] }
+tokio-util = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+reqwest = { workspace = true, features = ["json"] }
+serde_json = { workspace = true }
@@ -0,0 +1,28 @@
+FROM rust:latest AS builder
+
+RUN apt update && apt install -yy libdbus-1-dev pkg-config libclang-dev
+
+# Install go
+RUN wget https://go.dev/dl/go1.22.5.linux-amd64.tar.gz -O go.tar.gz
+RUN tar -xzvf go.tar.gz -C /usr/local
+
+RUN git clone https://github.com/nymtech/nym-vpn-client /usr/src/nym-vpn-client
+ENV PATH=/go/bin:/usr/local/go/bin:$PATH
+WORKDIR /usr/src/nym-vpn-client/nym-vpn-core
+RUN cargo build --release --package nym-gateway-probe
+
+COPY ./ /usr/src/nym
+WORKDIR /usr/src/nym/nym-node-status-agent
+RUN cargo build --release
+
+FROM ubuntu:24.04
+
+RUN apt-get update && apt-get install -y ca-certificates
+
+WORKDIR /nym
+
+COPY --from=builder /usr/src/nym/target/release/nym-node-status-agent ./
+COPY --from=builder /usr/src/nym-vpn-client/nym-vpn-core/target/release/nym-gateway-probe ./
+
+ENV NODE_STATUS_AGENT_PROBE_PATH=/nym/nym-gateway-probe
+ENTRYPOINT [ "/nym/nym-node-status-agent" ]
@@ -0,0 +1,55 @@
+#!/bin/bash
+
+set -eu
+
+environment="qa"
+
+source ../envs/${environment}.env
+
+export RUST_LOG="debug"
+
+crate_root=$(dirname $(realpath "$0"))
+gateway_probe_src=$(dirname $(dirname "$crate_root"))/nym-vpn-client/nym-vpn-core
+echo "gateway_probe_src=$gateway_probe_src"
+echo "crate_root=$crate_root"
+
+export NODE_STATUS_AGENT_PROBE_PATH="$crate_root/nym-gateway-probe"
+
+# build & copy over GW probe
+function copy_gw_probe() {
+    pushd $gateway_probe_src
+    git switch main
+    git pull
+    cargo build --release --package nym-gateway-probe
+    cp target/release/nym-gateway-probe "$crate_root"
+    $crate_root/nym-gateway-probe --version
+    popd
+}
+
+function build_agent() {
+    cargo build --package nym-node-status-agent --release
+}
+
+function swarm() {
+    local workers=$1
+    echo "Running $workers in parallel"
+
+    build_agent
+
+    for ((i = 1; i <= $workers; i++)); do
+        ../target/release/nym-node-status-agent run-probe &
+    done
+
+    wait
+
+    echo "All agents completed"
+}
+
+export NODE_STATUS_AGENT_SERVER_ADDRESS="http://127.0.0.1"
+export NODE_STATUS_AGENT_SERVER_PORT="8000"
+
+copy_gw_probe
+
+swarm 8
+
+# cargo run -- run-probe
@@ -0,0 +1,118 @@
+use anyhow::bail;
+use clap::{Parser, Subcommand};
+use nym_bin_common::bin_info;
+use nym_common_models::ns_api::TestrunAssignment;
+use std::sync::OnceLock;
+use tracing::instrument;
+
+use crate::probe::GwProbe;
+
+// Helper for passing LONG_VERSION to clap
+fn pretty_build_info_static() -> &'static str {
+    static PRETTY_BUILD_INFORMATION: OnceLock<String> = OnceLock::new();
+    PRETTY_BUILD_INFORMATION.get_or_init(|| bin_info!().pretty_print())
+}
+
+#[derive(Parser, Debug)]
+#[clap(author = "Nymtech", version, long_version = pretty_build_info_static(), about)]
+pub(crate) struct Args {
+    #[command(subcommand)]
+    pub(crate) command: Command,
+    #[arg(short, long, env = "NODE_STATUS_AGENT_SERVER_ADDRESS")]
+    pub(crate) server_address: String,
+
+    #[arg(short = 'p', long, env = "NODE_STATUS_AGENT_SERVER_PORT")]
+    pub(crate) server_port: u16,
+    // TODO dz accept keypair for identification / auth
+}
+
+#[derive(Subcommand, Debug)]
+pub(crate) enum Command {
+    RunProbe {
+        /// path of binary to run
+        #[arg(long, env = "NODE_STATUS_AGENT_PROBE_PATH")]
+        probe_path: String,
+    },
+}
+
+impl Args {
+    pub(crate) async fn execute(&self) -> anyhow::Result<()> {
+        match &self.command {
+            Command::RunProbe { probe_path } => self.run_probe(probe_path).await?,
+        }
+
+        Ok(())
+    }
+
+    async fn run_probe(&self, probe_path: &str) -> anyhow::Result<()> {
+        let server_address = format!("{}:{}", &self.server_address, self.server_port);
+
+        let probe = GwProbe::new(probe_path.to_string());
+
+        let version = probe.version().await;
+        tracing::info!("Probe version:\n{}", version);
+
+        if let Some(testrun) = request_testrun(&server_address).await? {
+            let log = probe.run_and_get_log(&Some(testrun.gateway_identity_key));
+
+            submit_results(&server_address, testrun.testrun_id, log).await?;
+        } else {
+            tracing::info!("No testruns available, exiting")
+        }
+
+        Ok(())
+    }
+}
+
+const URL_BASE: &str = "internal/testruns";
+
+#[instrument(level = "debug", skip_all)]
+async fn request_testrun(server_addr: &str) -> anyhow::Result<Option<TestrunAssignment>> {
+    let target_url = format!("{}/{}", server_addr, URL_BASE);
+    let client = reqwest::Client::new();
+    let res = client.get(target_url).send().await?;
+    let status = res.status();
+    let response_text = res.text().await?;
+
+    if status.is_client_error() {
+        bail!("{}: {}", status, response_text);
+    } else if status.is_server_error() {
+        if matches!(status, reqwest::StatusCode::SERVICE_UNAVAILABLE)
+            && response_text.contains("No testruns available")
+        {
+            return Ok(None);
+        } else {
+            bail!("{}: {}", status, response_text);
+        }
+    }
+
+    serde_json::from_str(&response_text)
+        .map(|testrun| {
+            tracing::info!("Received testrun assignment: {:?}", testrun);
+            testrun
+        })
+        .map_err(|err| {
+            tracing::error!("err");
+            err.into()
+        })
+}
+
+#[instrument(level = "debug", skip(probe_outcome))]
+async fn submit_results(
+    server_addr: &str,
+    testrun_id: i64,
+    probe_outcome: String,
+) -> anyhow::Result<()> {
+    let target_url = format!("{}/{}/{}", server_addr, URL_BASE, testrun_id);
+    let client = reqwest::Client::new();
+
+    let res = client
+        .post(target_url)
+        .body(probe_outcome)
+        .send()
+        .await
+        .and_then(|response| response.error_for_status())?;
+
+    tracing::debug!("Submitted results: {})", res.status());
+    Ok(())
+}
@@ -0,0 +1,78 @@
+use crate::cli::Args;
+use clap::Parser;
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::{filter::Directive, EnvFilter};
+
+mod cli;
+mod probe;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    setup_tracing();
+    let args = Args::parse();
+
+    let server_addr = format!("{}:{}", args.server_address, args.server_port);
+    test_ns_api_conn(&server_addr).await?;
+
+    args.execute().await?;
+
+    Ok(())
+}
+
+async fn test_ns_api_conn(server_addr: &str) -> anyhow::Result<()> {
+    reqwest::get(server_addr)
+        .await
+        .map(|res| {
+            tracing::info!(
+                "Testing connection to NS API at {server_addr}: {}",
+                res.status()
+            );
+        })
+        .map_err(|err| anyhow::anyhow!("Couldn't connect to server on {}: {}", server_addr, err))
+}
+
+pub(crate) fn setup_tracing() {
+    fn directive_checked(directive: impl Into<String>) -> Directive {
+        directive
+            .into()
+            .parse()
+            .expect("Failed to parse log directive")
+    }
+
+    let log_builder = tracing_subscriber::fmt()
+        // Use a more compact, abbreviated log format
+        .compact()
+        // Display source code file paths
+        .with_file(true)
+        // Display source code line numbers
+        .with_line_number(true)
+        .with_thread_ids(true)
+        // Don't display the event's target (module path)
+        .with_target(false);
+
+    let mut filter = EnvFilter::builder()
+        // if RUST_LOG isn't set, set default level
+        .with_default_directive(LevelFilter::INFO.into())
+        .from_env_lossy();
+    // these crates are more granularly filtered
+    let filter_crates = [
+        "reqwest",
+        "rustls",
+        "hyper",
+        "sqlx",
+        "h2",
+        "tendermint_rpc",
+        "tower_http",
+        "axum",
+    ];
+    for crate_name in filter_crates {
+        filter = filter.add_directive(directive_checked(format!("{}=warn", crate_name)));
+    }
+
+    filter = filter.add_directive(directive_checked("nym_bin_common=debug"));
+    filter = filter.add_directive(directive_checked("nym_explorer_client=debug"));
+    filter = filter.add_directive(directive_checked("nym_network_defaults=debug"));
+    filter = filter.add_directive(directive_checked("nym_validator_client=debug"));
+
+    log_builder.with_env_filter(filter).init();
+}
@@ -0,0 +1,60 @@
+use tracing::error;
+
+pub(crate) struct GwProbe {
+    path: String,
+}
+
+impl GwProbe {
+    pub(crate) fn new(probe_path: String) -> Self {
+        Self { path: probe_path }
+    }
+
+    pub(crate) async fn version(&self) -> String {
+        let mut command = tokio::process::Command::new(&self.path);
+        command.stdout(std::process::Stdio::piped());
+        command.arg("--version");
+
+        match command.spawn() {
+            Ok(child) => {
+                if let Ok(output) = child.wait_with_output().await {
+                    return String::from_utf8(output.stdout)
+                        .unwrap_or("Unable to get log from test run".to_string());
+                }
+                "Unable to get probe version".to_string()
+            }
+            Err(e) => {
+                error!("Failed to get probe version: {}", e);
+                "Failed to get probe version".to_string()
+            }
+        }
+    }
+
+    pub(crate) fn run_and_get_log(&self, gateway_key: &Option<String>) -> String {
+        let mut command = std::process::Command::new(&self.path);
+        command.stdout(std::process::Stdio::piped());
+
+        if let Some(gateway_id) = gateway_key {
+            command.arg("--gateway").arg(gateway_id);
+        }
+
+        match command.spawn() {
+            Ok(child) => {
+                if let Ok(output) = child.wait_with_output() {
+                    if !output.status.success() {
+                        let out = String::from_utf8_lossy(&output.stdout);
+                        let err = String::from_utf8_lossy(&output.stderr);
+                        tracing::error!("Probe exited with {:?}:\n{}\n{}", output.status, out, err);
+                    }
+
+                    return String::from_utf8(output.stdout)
+                        .unwrap_or("Unable to get log from test run".to_string());
+                }
+                "Unable to get log from test run".to_string()
+            }
+            Err(e) => {
+                error!("Failed to spawn test: {}", e);
+                "Failed to spawn test run task".to_string()
+            }
+        }
+    }
+}
@@ -0,0 +1,6 @@
+data/
+enter_db.sh
+nym-gateway-probe
+nym-node-status-api
+*.sqlite
+*.sqlite-journal
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            gateway_identity_key\n        FROM\n            gateways\n        WHERE\n            id = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "gateway_identity_key",
+        "ordinal": 0,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "06b17d1e5f61201a1b7542896ba55c69cd5c1a7e7d87073c94600c783a0a3984"
+}
@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            key as \"key!\",\n            value_json as \"value_json!\",\n            last_updated_utc as \"last_updated_utc!\"\n         FROM summary",
+  "describe": {
+    "columns": [
+      {
+        "name": "key!",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "value_json!",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "last_updated_utc!",
+        "ordinal": 2,
+        "type_info": "Int64"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      true,
+      true,
+      false
+    ]
+  },
+  "hash": "1327b5118f9144dddbcf8edb11f7dc549cf503409fd6dfedcdc02dbcd61d5454"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE mixnodes\n                SET bonded = ?, last_updated_utc = ?\n                WHERE id = ?;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "18abc8fde56cf86baed7b4afa38f2c63cdf90f2f3b6d81afb9000bb0968dcaea"
+}
@@ -0,0 +1,26 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                SELECT\n                    id,\n                    gateway_identity_key\n                FROM gateways\n                WHERE id = ?\n                LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "gateway_identity_key",
+        "ordinal": 1,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "2236299f9f691376db54cbd58ec5ceb89b9925cba46efcf4ed79ef0759a01129"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT INTO testruns (gateway_id, status, ip_address, timestamp_utc, log) VALUES (?, ?, ?, ?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 5
+    },
+    "nullable": []
+  },
+  "hash": "3c584e211d07c511644c8079187965acf3bcfb3f84ba8d24ed645d79976cf784"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE gateways\n                SET bonded = ?, last_updated_utc = ?\n                WHERE id = ?;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "3d3a1fa429e3090741c6b6a8e82e692afc04b51e8782bcbf59f1eb4116112536"
+}
@@ -0,0 +1,38 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            id as \"id!\",\n            gateway_identity_key as \"gateway_identity_key!\",\n            self_described as \"self_described?\",\n            explorer_pretty_bond as \"explorer_pretty_bond?\"\n         FROM gateways\n         WHERE gateway_identity_key = ?\n         ORDER BY gateway_identity_key\n         LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "name": "id!",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "gateway_identity_key!",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "self_described?",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "explorer_pretty_bond?",
+        "ordinal": 3,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      true,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "3d5fc502f976f5081f01352856b8632c29c81bfafb043bb8744129cf9e0266ad"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE testruns SET status = ? WHERE id = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "418944f2eccb838cb3882f34469203c8569f03fdd39ce09d7b74177896e52a8c"
+}
@@ -0,0 +1,50 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            id as \"id!\",\n            gateway_id as \"gateway_id!\",\n            status as \"status!\",\n            timestamp_utc as \"timestamp_utc!\",\n            ip_address as \"ip_address!\",\n            log as \"log!\"\n         FROM testruns\n         WHERE gateway_id = ? AND status != 2\n         ORDER BY id DESC\n         LIMIT 1",
+  "describe": {
+    "columns": [
+      {
+        "name": "id!",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "gateway_id!",
+        "ordinal": 1,
+        "type_info": "Int64"
+      },
+      {
+        "name": "status!",
+        "ordinal": 2,
+        "type_info": "Int64"
+      },
+      {
+        "name": "timestamp_utc!",
+        "ordinal": 3,
+        "type_info": "Int64"
+      },
+      {
+        "name": "ip_address!",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "log!",
+        "ordinal": 5,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "46d76bc6d3fba2dae3b21511a36289dd776749dd7a20cda61b0480f2fba60889"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE gateways SET last_probe_log = ? WHERE id = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "4afcc6673890f795c2793f1e2f8570ee787fc7daf00fcb916f18d1cb7d6c8f08"
+}
@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            id as \"id!\",\n            gateway_identity_key as \"identity_key!\",\n            bonded as \"bonded: bool\"\n         FROM gateways\n         WHERE bonded = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "id!",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "identity_key!",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "bonded: bool",
+        "ordinal": 2,
+        "type_info": "Int64"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "4b61a4bc32333c92a8f5ad4ad0017b40dc01845f554b5479f37855d89b309e6f"
+}
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT count(id) FROM mixnodes",
+  "describe": {
+    "columns": [
+      {
+        "name": "count(id)",
+        "ordinal": 0,
+        "type_info": "Int"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "670b7ed7d57a6986181b24be24ca667e8cacdf677ccb906415b3fe92be0c436b"
+}
@@ -0,0 +1,50 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            id as \"id!\",\n            gateway_id as \"gateway_id!\",\n            status as \"status!\",\n            timestamp_utc as \"timestamp_utc!\",\n            ip_address as \"ip_address!\",\n            log as \"log!\"\n         FROM testruns\n         WHERE\n            id = ?\n         AND\n            status = ?\n         ORDER BY timestamp_utc",
+  "describe": {
+    "columns": [
+      {
+        "name": "id!",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "gateway_id!",
+        "ordinal": 1,
+        "type_info": "Int64"
+      },
+      {
+        "name": "status!",
+        "ordinal": 2,
+        "type_info": "Int64"
+      },
+      {
+        "name": "timestamp_utc!",
+        "ordinal": 3,
+        "type_info": "Int64"
+      },
+      {
+        "name": "ip_address!",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "log!",
+        "ordinal": 5,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "6d7967b831b355d5f2c77950abc56f816956b0824c66a25da611dce688105d36"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT INTO mixnodes\n                (mix_id, identity_key, bonded, total_stake,\n                    host, http_api_port, blacklisted, full_details,\n                    self_described, last_updated_utc, is_dp_delegatee)\n                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n                ON CONFLICT(mix_id) DO UPDATE SET\n                bonded=excluded.bonded,\n                total_stake=excluded.total_stake, host=excluded.host,\n                http_api_port=excluded.http_api_port,blacklisted=excluded.blacklisted,\n                full_details=excluded.full_details,self_described=excluded.self_described,\n                last_updated_utc=excluded.last_updated_utc,\n                is_dp_delegatee = excluded.is_dp_delegatee;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 11
+    },
+    "nullable": []
+  },
+  "hash": "6eb1a682cf13205cf701590021cdf795147ac3724e89df5b2f24f7215d87dce1"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE gateways SET last_probe_result = ? WHERE id = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "6ef3efde571d46961244cd90420f3de5949a5ff2083453cb879af8a1689efe2f"
+}
@@ -0,0 +1,98 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            gw.gateway_identity_key as \"gateway_identity_key!\",\n            gw.bonded as \"bonded: bool\",\n            gw.blacklisted as \"blacklisted: bool\",\n            gw.performance as \"performance!\",\n        gw.self_described as \"self_described?\",\n            gw.explorer_pretty_bond as \"explorer_pretty_bond?\",\n            gw.last_probe_result as \"last_probe_result?\",\n            gw.last_probe_log as \"last_probe_log?\",\n            gw.last_testrun_utc as \"last_testrun_utc?\",\n            gw.last_updated_utc as \"last_updated_utc!\",\n            COALESCE(gd.moniker, \"NA\") as \"moniker!\",\n            COALESCE(gd.website, \"NA\") as \"website!\",\n            COALESCE(gd.security_contact, \"NA\") as \"security_contact!\",\n            COALESCE(gd.details, \"NA\") as \"details!\"\n         FROM gateways gw\n         LEFT JOIN gateway_description gd\n         ON gw.gateway_identity_key = gd.gateway_identity_key\n         ORDER BY gw.gateway_identity_key",
+  "describe": {
+    "columns": [
+      {
+        "name": "gateway_identity_key!",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "bonded: bool",
+        "ordinal": 1,
+        "type_info": "Int64"
+      },
+      {
+        "name": "blacklisted: bool",
+        "ordinal": 2,
+        "type_info": "Int64"
+      },
+      {
+        "name": "performance!",
+        "ordinal": 3,
+        "type_info": "Int64"
+      },
+      {
+        "name": "self_described?",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "explorer_pretty_bond?",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "last_probe_result?",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "last_probe_log?",
+        "ordinal": 7,
+        "type_info": "Text"
+      },
+      {
+        "name": "last_testrun_utc?",
+        "ordinal": 8,
+        "type_info": "Int64"
+      },
+      {
+        "name": "last_updated_utc!",
+        "ordinal": 9,
+        "type_info": "Int64"
+      },
+      {
+        "name": "moniker!",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "website!",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "security_contact!",
+        "ordinal": 12,
+        "type_info": "Text"
+      },
+      {
+        "name": "details!",
+        "ordinal": 13,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      true,
+      true,
+      true,
+      true,
+      true,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "71a455c705f9c25d3843ff2fb8629d1320a5eb10797cdb5a435455d22c6aeac1"
+}
@@ -0,0 +1,38 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            id as \"id!\",\n            date as \"date!\",\n            timestamp_utc as \"timestamp_utc!\",\n            value_json as \"value_json!\"\n         FROM summary_history\n         ORDER BY date DESC\n         LIMIT 30",
+  "describe": {
+    "columns": [
+      {
+        "name": "id!",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "date!",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "timestamp_utc!",
+        "ordinal": 2,
+        "type_info": "Int64"
+      },
+      {
+        "name": "value_json!",
+        "ordinal": 3,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      true,
+      false,
+      false,
+      true
+    ]
+  },
+  "hash": "7600823da7ce80b8ffda933608603a2752e28df775d1af8fd943a5fc8d7dc00d"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT INTO summary_history\n                (date, timestamp_utc, value_json)\n                VALUES (?, ?, ?)\n                ON CONFLICT(date) DO UPDATE SET\n                timestamp_utc=excluded.timestamp_utc,\n                value_json=excluded.value_json;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "788515c34588aec352773df4b6e6c5e41f3c0bb56a27648b5e25466b8634a578"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE gateways\n             SET blacklisted = true\n             WHERE gateway_identity_key = ?;",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "8571faad2f66e08f24acfbfe036d17ca6eb090df7f6d52ef89c5d51564f8b45c"
+}
@@ -0,0 +1,20 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT count(id) FROM gateways",
+  "describe": {
+    "columns": [
+      {
+        "name": "count(id)",
+        "ordinal": 0,
+        "type_info": "Int"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false
+    ]
+  },
+  "hash": "86ff64db477a1d6235179b0b88d86b86d1b9be62336c9eac0eef44987a5451b5"
+}
@@ -0,0 +1,26 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT\n            gateway_identity_key as \"gateway_identity_key!\",\n            bonded as \"bonded: bool\"\n         FROM gateways\n         ORDER BY last_testrun_utc",
+  "describe": {
+    "columns": [
+      {
+        "name": "gateway_identity_key!",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "bonded: bool",
+        "ordinal": 1,
+        "type_info": "Int64"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false
+    ]
+  },
+  "hash": "930a41e612b4e964ae214843da190f6c66c14d4267a2cc2ca73354becc2c8bb8"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE gateways SET last_testrun_utc = ?, last_updated_utc = ? WHERE id = ?",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "c214c001acbbf79fa499816f36ec586c4c29c03efb4cf0c40b73a5c76159cf5c"
+}
@@ -0,0 +1,44 @@
+{
+  "db_name": "SQLite",
+  "query": "\n        SELECT\n            date_utc as \"date_utc!\",\n            packets_received as \"total_packets_received!: i64\",\n            packets_sent as \"total_packets_sent!: i64\",\n            packets_dropped as \"total_packets_dropped!: i64\",\n            total_stake as \"total_stake!: i64\"\n        FROM (\n            SELECT\n                date_utc,\n                SUM(packets_received) as packets_received,\n                SUM(packets_sent) as packets_sent,\n                SUM(packets_dropped) as packets_dropped,\n                SUM(total_stake) as total_stake\n            FROM mixnode_daily_stats\n            GROUP BY date_utc\n            ORDER BY date_utc DESC\n            LIMIT 30\n        )\n        GROUP BY date_utc\n        ORDER BY date_utc\n        ",
+  "describe": {
+    "columns": [
+      {
+        "name": "date_utc!",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "total_packets_received!: i64",
+        "ordinal": 1,
+        "type_info": "Int64"
+      },
+      {
+        "name": "total_packets_sent!: i64",
+        "ordinal": 2,
+        "type_info": "Int64"
+      },
+      {
+        "name": "total_packets_dropped!: i64",
+        "ordinal": 3,
+        "type_info": "Int64"
+      },
+      {
+        "name": "total_stake!: i64",
+        "ordinal": 4,
+        "type_info": "Int64"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      true,
+      true,
+      true,
+      false
+    ]
+  },
+  "hash": "c5e3cd7284b334df5aa979b1627ea1f6dc2aed00cedde25f2be3567e47064351"
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Bogdan-Ștefan Neacşu	5d5c402ff6	Apply 250GB/30 days to magura	2024-11-13 12:06:06 +02: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