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

- change from yarn to npm
- fix license so Apache-2.0 (like the rest of the SDK)

.github/workflows/ci-nym-credential-proxy.yml

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

.github/workflows/push-data-observatory.yaml

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

Cargo.toml

@@ -19,33 +19,33 @@ members = [
     "clients/native",
     "clients/native/websocket-requests",
     "clients/socks5",
-    "common/authenticator-requests",
     "common/async-file-watcher",
+    "common/authenticator-requests",
     "common/bandwidth-controller",
     "common/bin-common",
     "common/client-core",
     "common/client-core/config-types",
-    "common/client-core/surb-storage",
     "common/client-core/gateways-storage",
+    "common/client-core/surb-storage",
     "common/client-libs/gateway-client",
     "common/client-libs/mixnet-client",
     "common/client-libs/validator-client",
     "common/commands",
     "common/config",
     "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
-    "common/cosmwasm-smart-contracts/ecash-contract",
     "common/cosmwasm-smart-contracts/coconut-dkg",
     "common/cosmwasm-smart-contracts/contracts-common",
+    "common/cosmwasm-smart-contracts/ecash-contract",
     "common/cosmwasm-smart-contracts/group-contract",
     "common/cosmwasm-smart-contracts/mixnet-contract",
     "common/cosmwasm-smart-contracts/multisig-contract",
     "common/cosmwasm-smart-contracts/vesting-contract",
     "common/country-group",
     "common/credential-storage",
-    "common/credentials",
     "common/credential-utils",
-    "common/credentials-interface",
     "common/credential-verification",
+    "common/credentials",
+    "common/credentials-interface",
     "common/crypto",
     "common/dkg",
     "common/ecash-double-spending",
@@ -54,6 +54,7 @@ members = [
     "common/exit-policy",
     "common/gateway-requests",
     "common/gateway-storage",
+    "common/gateway-stats-storage",
     "common/http-api-client",
     "common/http-api-common",
     "common/inclusion-probability",
@@ -64,10 +65,10 @@ members = [
     "common/network-defaults",
     "common/node-tester-utils",
     "common/nonexhaustive-delayqueue",
-    "common/nymcoconut",
-    "common/nym_offline_compact_ecash",
     "common/nym-id",
     "common/nym-metrics",
+    "common/nym_offline_compact_ecash",
+    "common/nymcoconut",
     "common/nymsphinx",
     "common/nymsphinx/acknowledgements",
     "common/nymsphinx/addressing",
@@ -103,20 +104,23 @@ members = [
     "gateway",
     "integrations/bity",
     "mixnode",
+    "sdk/ffi/cpp",
+    "sdk/ffi/go",
+    "sdk/ffi/shared",
     "sdk/lib/socks5-listener",
     "sdk/rust/nym-sdk",
-    "sdk/ffi/shared",
-    "sdk/ffi/go",
-    "sdk/ffi/cpp",
     "service-providers/authenticator",
     "service-providers/common",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
-    "nym-network-monitor",
     "nym-api",
-    "nym-browser-extension/storage",
     "nym-api/nym-api-requests",
+    "nym-browser-extension/storage",
+    "nym-credential-proxy/nym-credential-proxy",
+    "nym-credential-proxy/nym-credential-proxy-requests",
+    "nym-credential-proxy/nym-credential-proxy-lib-wasm",
     "nym-data-observatory",
+    "nym-network-monitor",
     "nym-node",
     "nym-node/nym-node-http-api",
     "nym-node/nym-node-requests",
@@ -139,11 +143,11 @@ members = [
     "wasm/mix-fetch",
     "wasm/node-tester",
     "wasm/zknym-lib",
-    "tools/internal/testnet-manager",
-    "tools/internal/testnet-manager/dkg-bypass-contract",
     "tools/echo-server",
     "tools/internal/contract-state-importer/importer-cli",
     "tools/internal/contract-state-importer/importer-contract",
+    "tools/internal/testnet-manager",
+    "tools/internal/testnet-manager/dkg-bypass-contract",
 ]
 
 default-members = [
@@ -154,6 +158,7 @@ default-members = [
     "gateway",
     "mixnode",
     "nym-api",
+    "nym-credential-proxy/nym-credential-proxy",
     "nym-data-observatory",
     "nym-node",
     "nym-node-status-api",
@@ -189,7 +194,7 @@ aes = "0.8.1"
 aes-gcm = "0.10.1"
 aes-gcm-siv = "0.11.1"
 aead = "0.5.2"
-anyhow = "1.0.89"
+anyhow = "1.0.90"
 argon2 = "0.5.0"
 async-trait = "0.1.83"
 axum-client-ip = "0.6.1"
@@ -198,11 +203,8 @@ axum-extra = "0.9.4"
 base64 = "0.22.1"
 bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
-
-# can we unify those?
-bit-vec = "0.7.0"
+bit-vec = "0.7.0" # can we unify those?
 bitvec = "1.0.0"
-
 blake3 = "1.5.4"
 bloomfilter = "1.0.14"
 bs58 = "0.5.1"
@@ -215,7 +217,7 @@ chacha20 = "0.9.0"
 chacha20poly1305 = "0.10.1"
 chrono = "0.4.31"
 cipher = "0.4.3"
-clap = "4.5.18"
+clap = "4.5.20"
 clap_complete = "4.5"
 clap_complete_fig = "4.5"
 colored = "2.0"
@@ -269,7 +271,7 @@ ipnetwork = "0.20"
 isocountry = "0.3.2"
 itertools = "0.13.0"
 k256 = "0.13"
-lazy_static = "1.4.0"
+lazy_static = "1.5.0"
 ledger-transport = "0.10.0"
 ledger-transport-hid = "0.10.0"
 log = "0.4"
@@ -279,13 +281,13 @@ moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
 okapi = "0.7.0"
-once_cell = "1.7.2"
+once_cell = "1.20.2"
 opentelemetry = "0.19.0"
 opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.3"
 pem = "0.8"
 petgraph = "0.6.5"
-pin-project = "1.0"
+pin-project = "1.1"
 pin-project-lite = "0.2.14"
 pretty_env_logger = "0.4.0"
 publicsuffix = "2.2.3"
@@ -305,7 +307,7 @@ rocket_okapi = "0.8.0"
 safer-ffi = "0.1.13"
 schemars = "0.8.21"
 semver = "1.0.23"
-serde = "1.0.210"
+serde = "1.0.211"
 serde_bytes = "0.11.15"
 serde_derive = "1.0"
 serde_json = "1.0.132"
@@ -402,11 +404,10 @@ indexed_db_futures = { git = "https://github.com/TiemenSch/rust-indexed-db", bra
 js-sys = "0.3.70"
 serde-wasm-bindgen = "0.6.5"
 tsify = "0.4.5"
-wasm-bindgen = "0.2.93"
-wasm-bindgen-futures = "0.4.43"
+wasm-bindgen = "0.2.95"
+wasm-bindgen-futures = "0.4.45"
 wasmtimer = "0.2.0"
-web-sys = "0.3.70"
-
+web-sys = "0.3.72"
 
 # Profile settings for individual crates
 

common/client-core/src/client/topology_control/geo_aware_provider.rs

@@ -112,7 +112,7 @@ impl GeoAwareTopologyProvider {
     async fn get_topology(&self) -> Option<NymTopology> {
         let mixnodes = match self
             .validator_client
-            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
+            .get_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {

common/client-core/src/client/topology_control/nym_api_provider.rs

@@ -99,7 +99,7 @@ impl NymApiTopologyProvider {
     async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
         let mixnodes = match self
             .validator_client
-            .get_all_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
+            .get_basic_active_mixing_assigned_nodes(Some(self.client_version.clone()))
             .await
         {
             Err(err) => {

common/client-core/src/init/helpers.rs

@@ -121,9 +121,7 @@ pub async fn current_mixnodes<R: Rng>(
 
     log::trace!("Fetching list of mixnodes from: {nym_api}");
 
-    let mixnodes = client
-        .get_all_basic_active_mixing_assigned_nodes(None)
-        .await?;
+    let mixnodes = client.get_basic_active_mixing_assigned_nodes(None).await?;
     let valid_mixnodes = mixnodes
         .iter()
         .filter_map(|mixnode| mixnode.try_into().ok())

common/client-libs/validator-client/src/client.rs

@@ -18,7 +18,7 @@ use nym_api_requests::ecash::{
     PartialExpirationDateSignatureResponse, VerificationKeyResponse,
 };
 use nym_api_requests::models::{
-    ApiHealthResponse, GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
+    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
     NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
@@ -192,8 +192,6 @@ 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()
@@ -203,54 +201,46 @@ 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?)
     }
@@ -314,8 +304,6 @@ 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);
@@ -348,7 +336,7 @@ impl NymApiClient {
         self.nym_api.change_base_url(new_endpoint);
     }
 
-    #[deprecated(note = "use get_all_basic_active_mixing_assigned_nodes instead")]
+    #[deprecated(note = "use get_basic_active_mixing_assigned_nodes instead")]
     pub async fn get_basic_mixnodes(
         &self,
         semver_compatibility: Option<String>,
@@ -406,7 +394,7 @@ impl NymApiClient {
 
     /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
     /// this includes legacy mixnodes and nym-nodes
-    pub async fn get_all_basic_active_mixing_assigned_nodes(
+    pub async fn get_basic_active_mixing_assigned_nodes(
         &self,
         semver_compatibility: Option<String>,
     ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
@@ -436,93 +424,26 @@ impl NymApiClient {
         Ok(nodes)
     }
 
-    /// retrieve basic information for nodes are capable of operating as a mixnode
-    /// this includes legacy mixnodes and nym-nodes
-    pub async fn get_all_basic_mixing_capable_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
-        let mut page = 0;
-        let mut nodes = Vec::new();
-
-        loop {
-            let mut res = self
-                .nym_api
-                .get_basic_mixing_capable_nodes(
-                    semver_compatibility.clone(),
-                    false,
-                    Some(page),
-                    None,
-                )
-                .await?;
-
-            nodes.append(&mut res.nodes.data);
-            if nodes.len() < res.nodes.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(nodes)
-    }
-
-    /// retrieve basic information for all bonded nodes on the network
-    pub async fn get_all_basic_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
-        let mut page = 0;
-        let mut nodes = Vec::new();
-
-        loop {
-            let mut res = self
-                .nym_api
-                .get_basic_nodes(semver_compatibility.clone(), false, Some(page), None)
-                .await?;
-
-            nodes.append(&mut res.nodes.data);
-            if nodes.len() < res.nodes.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(nodes)
-    }
-
-    pub async fn health(&self) -> Result<ApiHealthResponse, ValidatorClientError> {
-        Ok(self.nym_api.health().await?)
-    }
-
-    #[deprecated]
     pub async fn get_cached_active_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_active_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_rewarded_mixnodes(
         &self,
     ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_rewarded_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_mixnodes(&self) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
         Ok(self.nym_api.get_mixnodes().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_gateways(&self) -> Result<Vec<GatewayBond>, ValidatorClientError> {
         Ok(self.nym_api.get_gateways().await?)
     }
 
-    #[deprecated]
     pub async fn get_cached_described_gateways(
         &self,
     ) -> Result<Vec<LegacyDescribedGateway>, ValidatorClientError> {
@@ -571,7 +492,6 @@ impl NymApiClient {
         Ok(bonds)
     }
 
-    #[deprecated]
     pub async fn get_gateway_core_status_count(
         &self,
         identity: IdentityKeyRef<'_>,
@@ -583,7 +503,6 @@ impl NymApiClient {
             .await?)
     }
 
-    #[deprecated]
     pub async fn get_mixnode_core_status_count(
         &self,
         mix_id: NodeId,
@@ -595,7 +514,6 @@ impl NymApiClient {
             .await?)
     }
 
-    #[deprecated]
     pub async fn get_mixnode_status(
         &self,
         mix_id: NodeId,
@@ -603,7 +521,6 @@ impl NymApiClient {
         Ok(self.nym_api.get_mixnode_status(mix_id).await?)
     }
 
-    #[deprecated]
     pub async fn get_mixnode_reward_estimation(
         &self,
         mix_id: NodeId,
@@ -611,7 +528,6 @@ 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,
@@ -643,7 +559,6 @@ impl NymApiClient {
             .await?)
     }
 
-    #[deprecated]
     pub async fn spent_credentials_filter(
         &self,
     ) -> Result<SpentCredentialsResponse, ValidatorClientError> {

common/client-libs/validator-client/src/connection_tester.rs

@@ -164,7 +164,7 @@ async fn test_nym_api_connection(
 ) -> ConnectionResult {
     let result = match timeout(
         Duration::from_secs(CONNECTION_TEST_TIMEOUT_SEC),
-        client.health(),
+        client.get_cached_mixnodes(),
     )
     .await
     {

common/client-libs/validator-client/src/nym_api/mod.rs

@@ -11,8 +11,7 @@ use nym_api_requests::ecash::models::{
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
-    AnnotationResponse, ApiHealthResponse, LegacyDescribedMixNode, NodePerformanceResponse,
-    NymNodeDescription,
+    AnnotationResponse, LegacyDescribedMixNode, NodePerformanceResponse, NymNodeDescription,
 };
 use nym_api_requests::nym_nodes::PaginatedCachedNodesResponse;
 use nym_api_requests::pagination::PaginatedResponse;
@@ -55,26 +54,12 @@ 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(
@@ -89,7 +74,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways_detailed(&self) -> Result<Vec<GatewayBondAnnotated>, NymAPIError> {
         self.get_json(
@@ -104,7 +88,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_detailed_unfiltered(
         &self,
@@ -121,14 +104,12 @@ 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(
@@ -138,7 +119,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_described(&self) -> Result<Vec<LegacyDescribedMixNode>, NymAPIError> {
         self.get_json(
@@ -148,7 +128,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[tracing::instrument(level = "debug", skip_all)]
     async fn get_nodes_described(
         &self,
         page: Option<u32>,
@@ -168,7 +147,6 @@ pub trait NymApiClientExt: ApiClient {
             .await
     }
 
-    #[tracing::instrument(level = "debug", skip_all)]
     async fn get_nym_nodes(
         &self,
         page: Option<u32>,
@@ -188,7 +166,6 @@ pub trait NymApiClientExt: ApiClient {
             .await
     }
 
-    #[deprecated]
     #[tracing::instrument(level = "debug", skip_all)]
     async fn get_basic_mixnodes(
         &self,
@@ -213,7 +190,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_basic_gateways(
         &self,
@@ -322,82 +298,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
-    /// this includes legacy mixnodes and nym-nodes
-    #[instrument(level = "debug", skip(self))]
-    async fn get_basic_mixing_capable_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if let Some(arg) = &semver_compatibility {
-            params.push(("semver_compatibility", arg.clone()))
-        }
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                "unstable",
-                "nym-nodes",
-                "skimmed",
-                "mixnodes",
-                "all",
-            ],
-            &params,
-        )
-        .await
-    }
-    #[instrument(level = "debug", skip(self))]
-
-    async fn get_basic_nodes(
-        &self,
-        semver_compatibility: Option<String>,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if let Some(arg) = &semver_compatibility {
-            params.push(("semver_compatibility", arg.clone()))
-        }
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        self.get_json(
-            &[routes::API_VERSION, "unstable", "nym-nodes", "skimmed"],
-            &params,
-        )
-        .await
-    }
-
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(
@@ -407,7 +307,6 @@ 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(
@@ -423,7 +322,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(
@@ -433,7 +331,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_report(
         &self,
@@ -452,7 +349,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateway_report(
         &self,
@@ -471,7 +367,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_history(
         &self,
@@ -490,7 +385,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateway_history(
         &self,
@@ -509,7 +403,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_rewarded_mixnodes_detailed(
         &self,
@@ -527,7 +420,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateway_core_status_count(
         &self,
@@ -560,7 +452,6 @@ pub trait NymApiClientExt: ApiClient {
         }
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_core_status_count(
         &self,
@@ -594,7 +485,6 @@ pub trait NymApiClientExt: ApiClient {
         }
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_status(
         &self,
@@ -613,7 +503,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_reward_estimation(
         &self,
@@ -632,7 +521,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn compute_mixnode_reward_estimation(
         &self,
@@ -653,7 +541,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_stake_saturation(
         &self,
@@ -672,7 +559,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnode_inclusion_probability(
         &self,
@@ -708,7 +594,6 @@ pub trait NymApiClientExt: ApiClient {
             .await
     }
 
-    #[deprecated]
     async fn get_mixnode_avg_uptime(&self, mix_id: NodeId) -> Result<UptimeResponse, NymAPIError> {
         self.get_json(
             &[
@@ -723,7 +608,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_blacklisted(&self) -> Result<Vec<NodeId>, NymAPIError> {
         self.get_json(
@@ -733,7 +617,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways_blacklisted(&self) -> Result<Vec<IdentityKey>, NymAPIError> {
         self.get_json(
@@ -794,7 +677,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn double_spending_filter_v1(&self) -> Result<SpentCredentialsResponse, NymAPIError> {
         self.get_json(

common/client-libs/validator-client/src/nym_api/routes.rs

@@ -36,8 +36,6 @@ 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";

common/commands/src/validator/mixnet/query/query_all_gateways.rs

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::context::QueryClientWithNyxd;
-use crate::utils::show_error;
+use crate::utils::{pretty_cosmwasm_coin, show_error};
 use clap::Parser;
 use comfy_table::Table;
+use nym_validator_client::client::NymApiClientExt;
 
 #[derive(Debug, Parser)]
 pub struct Args {
@@ -14,11 +15,12 @@ pub struct Args {
 }
 
 pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    match client.get_all_cached_described_nodes().await {
+    match client.nym_api.get_gateways().await {
         Ok(res) => match args.identity_key {
             Some(identity_key) => {
                 let node = res.iter().find(|node| {
-                    node.ed25519_identity_key()
+                    node.gateway
+                        .identity_key
                         .to_string()
                         .eq_ignore_ascii_case(&identity_key)
                 });
@@ -30,16 +32,14 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
             None => {
                 let mut table = Table::new();
 
-                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.set_header(vec!["Identity Key", "Owner", "Host", "Bond", "Version"]);
+                for node in res {
                     table.add_row(vec![
-                        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(),
+                        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(),
                     ]);
                 }
 

common/commands/src/validator/mixnet/query/query_all_mixnodes.rs

@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::context::QueryClientWithNyxd;
-use crate::utils::show_error;
+use crate::utils::{pretty_decimal_with_denom, show_error};
 use clap::Parser;
 use comfy_table::Table;
+use nym_validator_client::client::NymApiClientExt;
 
 #[derive(Debug, Parser)]
 pub struct Args {
@@ -14,11 +15,13 @@ pub struct Args {
 }
 
 pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    match client.get_all_cached_described_nodes().await {
+    match client.nym_api.get_mixnodes().await {
         Ok(res) => match args.identity_key {
             Some(identity_key) => {
                 let node = res.iter().find(|node| {
-                    node.ed25519_identity_key()
+                    node.bond_information
+                        .mix_node
+                        .identity_key
                         .to_string()
                         .eq_ignore_ascii_case(&identity_key)
                 });
@@ -30,16 +33,25 @@ pub async fn query(args: Args, client: &QueryClientWithNyxd) {
             None => {
                 let mut table = Table::new();
 
-                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.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.add_row(vec![
-                        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(),
+                        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,
                     ]);
                 }
 

common/credential-verification/src/lib.rs

@@ -6,7 +6,7 @@ use std::sync::Arc;
 use time::{Date, OffsetDateTime};
 use tracing::*;
 
-use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
+use nym_credentials::ecash::utils::{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, cred_exp_date())
+            .increase_bandwidth(bandwidth, spend_date)
             .await?;
 
         Ok(self

common/gateway-stats-storage/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "nym-gateway-stats-storage"
+version = "0.1.0"
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+documentation.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+sqlx = { workspace = true, features = [
+    "runtime-tokio-rustls",
+    "sqlite",
+    "macros",
+    "migrate",
+    "time",
+] }
+time = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+
+nym-sphinx = { path = "../nymsphinx" }
+nym-credentials-interface = { path = "../credentials-interface" }
+
+
+[build-dependencies]
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+sqlx = { workspace = true, features = [
+    "runtime-tokio-rustls",
+    "sqlite",
+    "macros",
+    "migrate",
+] }

common/gateway-stats-storage/build.rs

@@ -0,0 +1,28 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use sqlx::{Connection, SqliteConnection};
+use std::env;
+
+#[tokio::main]
+async fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let database_path = format!("{}/gateway-stats-example.sqlite", out_dir);
+
+    let mut conn = SqliteConnection::connect(&format!("sqlite://{}?mode=rwc", database_path))
+        .await
+        .expect("Failed to create SQLx database connection");
+
+    sqlx::migrate!("./migrations")
+        .run(&mut conn)
+        .await
+        .expect("Failed to perform SQLx migrations");
+
+    #[cfg(target_family = "unix")]
+    println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
+
+    #[cfg(target_family = "windows")]
+    // for some strange reason we need to add a leading `/` to the windows path even though it's
+    // not a valid windows path... but hey, it works...
+    println!("cargo:rustc-env=DATABASE_URL=sqlite:///{}", &database_path);
+}

common/gateway-stats-storage/migrations/20241017120000_create_initial_tables.sql

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+CREATE TABLE sessions_active
+(
+    client_address  TEXT                        NOT NULL PRIMARY KEY UNIQUE,
+    start_time      TIMESTAMP WITHOUT TIME ZONE NOT NULL,
+    typ             TEXT                        NOT NULL
+);
+
+CREATE TABLE sessions_finished
+(
+    id          INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    day         DATE    NOT NULL,
+    duration_ms INTEGER NOT NULL,
+    typ         TEXT    NOT NULL
+);
+
+CREATE TABLE sessions_unique_users
+(
+    day             DATE    NOT NULL,
+    client_address  TEXT    NOT NULL,
+    PRIMARY KEY (day, client_address)
+);

common/gateway-stats-storage/src/error.rs

@@ -0,0 +1,13 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum StatsStorageError {
+    #[error("Database experienced an internal error: {0}")]
+    InternalDatabaseError(#[from] sqlx::Error),
+
+    #[error("Failed to perform database migration: {0}")]
+    MigrationError(#[from] sqlx::migrate::MigrateError),
+}

common/gateway-stats-storage/src/lib.rs

@@ -0,0 +1,195 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use error::StatsStorageError;
+use models::{ActiveSession, FinishedSession, SessionType, StoredFinishedSession};
+use nym_sphinx::DestinationAddressBytes;
+use sessions::SessionManager;
+use sqlx::ConnectOptions;
+use std::path::Path;
+use time::Date;
+use tracing::{debug, error};
+
+pub mod error;
+pub mod models;
+mod sessions;
+
+// note that clone here is fine as upon cloning the same underlying pool will be used
+#[derive(Clone)]
+pub struct PersistentStatsStorage {
+    session_manager: SessionManager,
+}
+
+impl PersistentStatsStorage {
+    /// Initialises `PersistentStatsStorage` using the provided path.
+    ///
+    /// # Arguments
+    ///
+    /// * `database_path`: path to the database.
+    pub async fn init<P: AsRef<Path> + Send>(database_path: P) -> Result<Self, StatsStorageError> {
+        debug!(
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
+        );
+
+        // TODO: we can inject here more stuff based on our gateway global config
+        // struct. Maybe different pool size or timeout intervals?
+        let opts = sqlx::sqlite::SqliteConnectOptions::new()
+            .filename(database_path)
+            .create_if_missing(true)
+            .disable_statement_logging();
+
+        // TODO: do we want auto_vacuum ?
+
+        let connection_pool = match sqlx::SqlitePool::connect_with(opts).await {
+            Ok(db) => db,
+            Err(err) => {
+                error!("Failed to connect to SQLx database: {err}");
+                return Err(err.into());
+            }
+        };
+
+        if let Err(err) = sqlx::migrate!("./migrations").run(&connection_pool).await {
+            error!("Failed to perform migration on the SQLx database: {err}");
+            return Err(err.into());
+        }
+
+        // the cloning here are cheap as connection pool is stored behind an Arc
+        Ok(PersistentStatsStorage {
+            session_manager: sessions::SessionManager::new(connection_pool),
+        })
+    }
+
+    //Sessions fn
+    pub async fn insert_finished_session(
+        &self,
+        date: Date,
+        session: FinishedSession,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .insert_finished_session(
+                date,
+                session.duration.whole_milliseconds() as i64,
+                session.typ.to_string().into(),
+            )
+            .await?)
+    }
+
+    pub async fn get_finished_sessions(
+        &self,
+        date: Date,
+    ) -> Result<Vec<StoredFinishedSession>, StatsStorageError> {
+        Ok(self.session_manager.get_finished_sessions(date).await?)
+    }
+
+    pub async fn delete_finished_sessions(
+        &self,
+        before_date: Date,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .delete_finished_sessions(before_date)
+            .await?)
+    }
+
+    pub async fn insert_unique_user(
+        &self,
+        date: Date,
+        client_address_bs58: String,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .insert_unique_user(date, client_address_bs58)
+            .await?)
+    }
+
+    pub async fn get_unique_users_count(&self, date: Date) -> Result<i32, StatsStorageError> {
+        Ok(self.session_manager.get_unique_users_count(date).await?)
+    }
+
+    pub async fn delete_unique_users(&self, before_date: Date) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .delete_unique_users(before_date)
+            .await?)
+    }
+
+    pub async fn insert_active_session(
+        &self,
+        client_address: DestinationAddressBytes,
+        session: ActiveSession,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .insert_active_session(
+                client_address.as_base58_string(),
+                session.start,
+                session.typ.to_string().into(),
+            )
+            .await?)
+    }
+
+    pub async fn update_active_session_type(
+        &self,
+        client_address: DestinationAddressBytes,
+        session_type: SessionType,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .update_active_session_type(
+                client_address.as_base58_string(),
+                session_type.to_string().into(),
+            )
+            .await?)
+    }
+
+    pub async fn get_active_session(
+        &self,
+        client_address: DestinationAddressBytes,
+    ) -> Result<Option<ActiveSession>, StatsStorageError> {
+        Ok(self
+            .session_manager
+            .get_active_session(client_address.as_base58_string())
+            .await?
+            .map(Into::into))
+    }
+
+    pub async fn get_all_active_sessions(&self) -> Result<Vec<ActiveSession>, StatsStorageError> {
+        Ok(self
+            .session_manager
+            .get_all_active_sessions()
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect())
+    }
+
+    pub async fn get_started_sessions_count(
+        &self,
+        start_date: Date,
+    ) -> Result<i32, StatsStorageError> {
+        Ok(self
+            .session_manager
+            .get_started_sessions_count(start_date)
+            .await?)
+    }
+
+    pub async fn get_active_users(&self) -> Result<Vec<String>, StatsStorageError> {
+        Ok(self.session_manager.get_active_users().await?)
+    }
+
+    pub async fn delete_active_session(
+        &self,
+        client_address: DestinationAddressBytes,
+    ) -> Result<(), StatsStorageError> {
+        Ok(self
+            .session_manager
+            .delete_active_session(client_address.as_base58_string())
+            .await?)
+    }
+
+    pub async fn cleanup_active_sessions(&self) -> Result<(), StatsStorageError> {
+        Ok(self.session_manager.cleanup_active_sessions().await?)
+    }
+}

common/gateway-stats-storage/src/models.rs

@@ -0,0 +1,109 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use nym_credentials_interface::TicketType;
+use sqlx::prelude::FromRow;
+use time::{Duration, OffsetDateTime};
+
+#[derive(FromRow)]
+pub struct StoredFinishedSession {
+    duration_ms: i64,
+    typ: String,
+}
+
+impl StoredFinishedSession {
+    pub fn serialize(&self) -> (u64, String) {
+        (
+            self.duration_ms as u64, //we are sure that it fits in a u64, see `fn end_at`
+            self.typ.clone(),
+        )
+    }
+}
+
+pub struct FinishedSession {
+    pub duration: Duration,
+    pub typ: SessionType,
+}
+
+#[derive(PartialEq)]
+pub enum SessionType {
+    Vpn,
+    Mixnet,
+    Unknown,
+}
+
+impl SessionType {
+    pub fn to_string(&self) -> &str {
+        match self {
+            Self::Vpn => "vpn",
+            Self::Mixnet => "mixnet",
+            Self::Unknown => "unknown",
+        }
+    }
+
+    pub fn from_string(s: &str) -> Self {
+        match s {
+            "vpn" => Self::Vpn,
+            "mixnet" => Self::Mixnet,
+            _ => Self::Unknown,
+        }
+    }
+}
+
+impl From<TicketType> for SessionType {
+    fn from(value: TicketType) -> Self {
+        match value {
+            TicketType::V1MixnetEntry => Self::Mixnet,
+            TicketType::V1MixnetExit => Self::Mixnet,
+            TicketType::V1WireguardEntry => Self::Vpn,
+            TicketType::V1WireguardExit => Self::Vpn,
+        }
+    }
+}
+
+#[derive(FromRow)]
+pub(crate) struct StoredActiveSession {
+    start_time: OffsetDateTime,
+    typ: String,
+}
+
+pub struct ActiveSession {
+    pub start: OffsetDateTime,
+    pub typ: SessionType,
+}
+
+impl ActiveSession {
+    pub fn new(start_time: OffsetDateTime) -> Self {
+        ActiveSession {
+            start: start_time,
+            typ: SessionType::Unknown,
+        }
+    }
+
+    pub fn set_type(&mut self, ticket_type: TicketType) {
+        self.typ = ticket_type.into();
+    }
+
+    pub fn end_at(self, stop_time: OffsetDateTime) -> Option<FinishedSession> {
+        let session_duration = stop_time - self.start;
+        //ensure duration is positive to fit in a u64
+        //u64::max milliseconds is 500k millenia so no overflow issue
+        if session_duration > Duration::ZERO {
+            Some(FinishedSession {
+                duration: session_duration,
+                typ: self.typ,
+            })
+        } else {
+            None
+        }
+    }
+}
+
+impl From<StoredActiveSession> for ActiveSession {
+    fn from(value: StoredActiveSession) -> Self {
+        ActiveSession {
+            start: value.start_time,
+            typ: SessionType::from_string(&value.typ),
+        }
+    }
+}

common/gateway-stats-storage/src/sessions.rs

@@ -0,0 +1,177 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use time::{Date, OffsetDateTime};
+
+use crate::models::{StoredActiveSession, StoredFinishedSession};
+
+pub(crate) type Result<T> = std::result::Result<T, sqlx::Error>;
+
+#[derive(Clone)]
+pub(crate) struct SessionManager {
+    connection_pool: sqlx::SqlitePool,
+}
+
+impl SessionManager {
+    /// Creates new instance of the `SessionsManager` with the provided sqlite connection pool.
+    ///
+    /// # Arguments
+    ///
+    /// * `connection_pool`: database connection pool to use.
+    pub(crate) fn new(connection_pool: sqlx::SqlitePool) -> Self {
+        SessionManager { connection_pool }
+    }
+
+    pub(crate) async fn insert_finished_session(
+        &self,
+        date: Date,
+        duration_ms: i64,
+        typ: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "INSERT INTO sessions_finished (day, duration_ms, typ) VALUES (?, ?, ?)",
+            date,
+            duration_ms,
+            typ
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn get_finished_sessions(
+        &self,
+        date: Date,
+    ) -> Result<Vec<StoredFinishedSession>> {
+        sqlx::query_as("SELECT duration_ms, typ FROM sessions_finished WHERE day = ?")
+            .bind(date)
+            .fetch_all(&self.connection_pool)
+            .await
+    }
+
+    pub(crate) async fn delete_finished_sessions(&self, before_date: Date) -> Result<()> {
+        sqlx::query!("DELETE FROM sessions_finished WHERE day <= ? ", before_date)
+            .execute(&self.connection_pool)
+            .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn insert_unique_user(
+        &self,
+        date: Date,
+        client_address_b58: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "INSERT OR IGNORE INTO sessions_unique_users (day, client_address) VALUES (?, ?)",
+            date,
+            client_address_b58,
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn get_unique_users_count(&self, date: Date) -> Result<i32> {
+        Ok(sqlx::query!(
+            "SELECT COUNT(*) as count FROM sessions_unique_users WHERE day = ?",
+            date
+        )
+        .fetch_one(&self.connection_pool)
+        .await?
+        .count)
+    }
+
+    pub(crate) async fn delete_unique_users(&self, before_date: Date) -> Result<()> {
+        sqlx::query!(
+            "DELETE FROM sessions_unique_users WHERE day <= ? ",
+            before_date
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn insert_active_session(
+        &self,
+        client_address_b58: String,
+        start_time: OffsetDateTime,
+        typ: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "INSERT INTO sessions_active (client_address, start_time, typ) VALUES (?, ?, ?)",
+            client_address_b58,
+            start_time,
+            typ
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn update_active_session_type(
+        &self,
+        client_address_b58: String,
+        typ: String,
+    ) -> Result<()> {
+        sqlx::query!(
+            "UPDATE sessions_active SET typ = ? WHERE client_address = ?",
+            typ,
+            client_address_b58,
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn get_active_session(
+        &self,
+        client_address_b58: String,
+    ) -> Result<Option<StoredActiveSession>> {
+        sqlx::query_as("SELECT start_time, typ FROM sessions_active WHERE client_address = ?")
+            .bind(client_address_b58)
+            .fetch_optional(&self.connection_pool)
+            .await
+    }
+
+    pub(crate) async fn get_all_active_sessions(&self) -> Result<Vec<StoredActiveSession>> {
+        sqlx::query_as("SELECT start_time, typ FROM sessions_active")
+            .fetch_all(&self.connection_pool)
+            .await
+    }
+
+    pub(crate) async fn get_started_sessions_count(&self, start_date: Date) -> Result<i32> {
+        Ok(sqlx::query!(
+            "SELECT COUNT(*) as count FROM sessions_active WHERE date(start_time) = ?",
+            start_date
+        )
+        .fetch_one(&self.connection_pool)
+        .await?
+        .count)
+    }
+
+    pub(crate) async fn get_active_users(&self) -> Result<Vec<String>> {
+        Ok(sqlx::query!("SELECT client_address from sessions_active")
+            .fetch_all(&self.connection_pool)
+            .await?
+            .into_iter()
+            .map(|record| record.client_address)
+            .collect())
+    }
+
+    pub(crate) async fn delete_active_session(&self, client_address_b58: String) -> Result<()> {
+        sqlx::query!(
+            "DELETE FROM sessions_active WHERE client_address = ?",
+            client_address_b58
+        )
+        .execute(&self.connection_pool)
+        .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn cleanup_active_sessions(&self) -> Result<()> {
+        sqlx::query!("DELETE FROM sessions_active")
+            .execute(&self.connection_pool)
+            .await?;
+        Ok(())
+    }
+}

common/http-api-client/src/lib.rs

@@ -534,19 +534,17 @@ where
     }
 
     if res.status().is_success() {
-        #[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()))
+        let text = res.text().await?;
+        match serde_json::from_str(&text) {
+            Ok(res) => Ok(res),
+            Err(source) => {
+                #[cfg(debug_assertions)]
+                {
+                    tracing::trace!("Result:\n{:#?}", text);
+                }
+                Err(HttpClientError::ResponseDeserialisationFailure { source })
+            }
         }
-
-        #[cfg(not(debug_assertions))]
-        Ok(res.json().await?)
     } else if res.status() == StatusCode::NOT_FOUND {
         Err(HttpClientError::NotFound)
     } else {

common/mixnode-common/src/verloc/mod.rs

@@ -14,6 +14,7 @@ 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;
@@ -312,7 +313,7 @@ impl VerlocMeasurer {
             info!("Starting verloc measurements");
             // TODO: should we also measure gateways?
 
-            let all_mixes = match self.validator_client.get_all_described_nodes().await {
+            let all_mixes = match self.validator_client.get_cached_mixnodes().await {
                 Ok(nodes) => nodes,
                 Err(err) => {
                     error!(
@@ -331,14 +332,22 @@ 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| {
-                    // try to parse the identity and host
-                    let node_identity = node.ed25519_identity_key();
+                    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;
+                    }
 
-                    let ip = node.description.host_information.ip_address.first()?;
-                    let verloc_port = node.description.verloc_port();
-                    let verloc_host = SocketAddr::new(*ip, verloc_port);
+                    // try to parse the identity and host
+                    let node_identity =
+                        identity::PublicKey::from_base58_string(mix_node.identity_key).ok()?;
+
+                    let verloc_host = (&*mix_node.host, mix_node.verloc_port)
+                        .to_socket_addrs()
+                        .ok()?
+                        .next()?;
 
                     // 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

common/models/src/ns_api.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct TestrunAssignment {
+    /// has nothing to do with GW identity key. This is PK from `gateways` table
     pub testrun_id: i64,
-    pub gateway_identity_key: String,
+    pub gateway_pk_id: i64,
 }

common/nymsphinx/anonymous-replies/Cargo.toml

@@ -21,7 +21,7 @@ nym-sphinx-types = { path = "../types" }
 nym-topology = { path = "../../topology" }
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
-version = "0.2.93"
+version = "0.2.95"
 
 [dev-dependencies]
 rand_chacha = { workspace = true }

common/wasm/client-core/src/helpers.rs

@@ -68,7 +68,7 @@ pub async fn current_network_topology_async(
 
     let api_client = NymApiClient::new(url);
     let mixnodes = api_client
-        .get_all_basic_active_mixing_assigned_nodes(None)
+        .get_basic_active_mixing_assigned_nodes(None)
         .await?;
     let gateways = api_client.get_all_basic_entry_assigned_nodes(None).await?;
 

common/wireguard/src/lib.rs

@@ -99,25 +99,12 @@ 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<_>, _>>()?
-        .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<_>>();
+        .collect::<Result<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()?;

common/wireguard/src/peer_handle.rs

@@ -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)
@@ -136,12 +136,9 @@ 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?;
                     }
                 }
 

contracts/Cargo.lock

@@ -433,7 +433,7 @@ checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]
 
 [[package]]
@@ -1483,9 +1483,9 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.81"
+version = "1.0.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
+checksum = "f139b0662de085916d1fb67d2b4169d1addddda1919e696f3252b740b629986e"
 dependencies = [
  "unicode-ident",
 ]
@@ -1660,7 +1660,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde_derive_internals",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]
 
 [[package]]
@@ -1702,9 +1702,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.210"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
 dependencies = [
  "serde_derive",
 ]
@@ -1729,13 +1729,13 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.210"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]
 
 [[package]]
@@ -1746,7 +1746,7 @@ checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]
 
 [[package]]
@@ -1769,7 +1769,7 @@ checksum = "6c64451ba24fc7a6a2d60fc75dd9c83c90903b19028d4eff35e88fc1e86564e9"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]
 
 [[package]]
@@ -1928,9 +1928,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.59"
+version = "2.0.85"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a6531ffc7b071655e4ce2e04bd464c4830bb585a61cabb96cf808f05172615a"
+checksum = "5023162dfcd14ef8f32034d8bcd4cc5ddc61ef7a247c024a33e24e1f24d21b56"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1954,7 +1954,7 @@ checksum = "08904e7672f5eb876eaaf87e0ce17857500934f4981c4a0ab2b4aa98baac7fc3"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]
 
 [[package]]
@@ -2120,5 +2120,5 @@ checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.59",
+ "syn 2.0.85",
 ]

contracts/mixnet/src/gateways/transactions.rs

@@ -4,7 +4,6 @@
 use super::helpers::must_get_gateway_bond_by_owner;
 use super::storage;
 use crate::constants::default_node_costs;
-use crate::interval::storage as interval_storage;
 use crate::mixnet_contract_settings::storage as mixnet_params_storage;
 use crate::nodes::helpers::save_new_nymnode_with_id;
 use crate::nodes::transactions::add_nym_node_inner;
@@ -116,10 +115,6 @@ pub fn try_migrate_to_nymnode(
             comment: "legacy gateway did not have a pre-assigned node id".to_string(),
         })?;
 
-    let current_epoch =
-        interval_storage::current_interval(deps.storage)?.current_epoch_absolute_id();
-    let previous_epoch = current_epoch.saturating_sub(1);
-
     // create nym-node entry
     // for gateways it's quite straightforward as there are no delegations or rewards to worry about
     save_new_nymnode_with_id(
@@ -130,7 +125,6 @@ pub fn try_migrate_to_nymnode(
         cost_params,
         info.sender.clone(),
         gateway_bond.pledge_amount,
-        previous_epoch,
     )?;
 
     storage::PREASSIGNED_LEGACY_IDS.remove(deps.storage, gateway_identity.clone());

contracts/mixnet/src/nodes/helpers.rs

@@ -22,8 +22,6 @@ pub(crate) fn save_new_nymnode(
     pledge: Coin,
 ) -> Result<NodeId, MixnetContractError> {
     let node_id = next_nymnode_id_counter(storage)?;
-    let current_epoch = interval_storage::current_interval(storage)?.current_epoch_absolute_id();
-
     save_new_nymnode_with_id(
         storage,
         node_id,
@@ -32,13 +30,11 @@ pub(crate) fn save_new_nymnode(
         cost_params,
         owner,
         pledge,
-        current_epoch,
     )?;
 
     Ok(node_id)
 }
 
-#[allow(clippy::too_many_arguments)]
 pub(crate) fn save_new_nymnode_with_id(
     storage: &mut dyn Storage,
     node_id: NodeId,
@@ -47,9 +43,10 @@ pub(crate) fn save_new_nymnode_with_id(
     cost_params: NodeCostParams,
     owner: Addr,
     pledge: Coin,
-    last_rewarding_epoch: u32,
 ) -> Result<(), MixnetContractError> {
-    let node_rewarding = NodeRewarding::initialise_new(cost_params, &pledge, last_rewarding_epoch)?;
+    let current_epoch = interval_storage::current_interval(storage)?.current_epoch_absolute_id();
+
+    let node_rewarding = NodeRewarding::initialise_new(cost_params, &pledge, current_epoch)?;
     let node_bond = NymNodeBond::new(node_id, owner, pledge, node, bonding_height);
 
     // save node bond data

explorer-api/src/mix_node/econ_stats.rs

@@ -8,9 +8,6 @@ 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,

explorer-api/src/tasks.rs

@@ -17,8 +17,6 @@ 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 }

gateway/Cargo.toml

@@ -69,6 +69,7 @@ nym-credentials-interface = { path = "../common/credentials-interface" }
 nym-credential-verification = { path = "../common/credential-verification" }
 nym-crypto = { path = "../common/crypto" }
 nym-gateway-storage = { path = "../common/gateway-storage" }
+nym-gateway-stats-storage = { path = "../common/gateway-stats-storage" }
 nym-gateway-requests = { path = "../common/gateway-requests" }
 nym-mixnet-client = { path = "../common/client-libs/mixnet-client" }
 nym-mixnode-common = { path = "../common/mixnode-common" }

gateway/src/config/persistence/paths.rs

@@ -12,6 +12,7 @@ pub const DEFAULT_PRIVATE_SPHINX_KEY_FILENAME: &str = "private_sphinx.pem";
 pub const DEFAULT_PUBLIC_SPHINX_KEY_FILENAME: &str = "public_sphinx.pem";
 
 pub const DEFAULT_CLIENTS_STORAGE_FILENAME: &str = "db.sqlite";
+pub const DEFAULT_STATS_STORAGE_FILENAME: &str = "stats.sqlite";
 
 pub const DEFAULT_NETWORK_REQUESTER_CONFIG_FILENAME: &str = "network_requester_config.toml";
 pub const DEFAULT_NETWORK_REQUESTER_DATA_DIR: &str = "network-requester-data";
@@ -39,6 +40,9 @@ pub struct GatewayPaths {
     #[serde(alias = "persistent_storage")]
     pub clients_storage: PathBuf,
 
+    /// Path to sqlite database containing all persistent stats data.
+    pub stats_storage: PathBuf,
+
     /// Path to the configuration of the embedded network requester.
     #[serde(deserialize_with = "de_maybe_stringified")]
     pub network_requester_config: Option<PathBuf>,
@@ -54,7 +58,9 @@ impl GatewayPaths {
     pub fn new_default<P: AsRef<Path>>(id: P) -> Self {
         GatewayPaths {
             keys: KeysPaths::new_default(id.as_ref()),
-            clients_storage: default_data_directory(id).join(DEFAULT_CLIENTS_STORAGE_FILENAME),
+            clients_storage: default_data_directory(id.as_ref())
+                .join(DEFAULT_CLIENTS_STORAGE_FILENAME),
+            stats_storage: default_data_directory(id).join(DEFAULT_STATS_STORAGE_FILENAME),
             // node_description: default_config_filepath(id).join(DEFAULT_DESCRIPTION_FILENAME),
             network_requester_config: None,
             ip_packet_router_config: None,
@@ -70,6 +76,7 @@ impl GatewayPaths {
                 public_sphinx_key_file: Default::default(),
             },
             clients_storage: Default::default(),
+            stats_storage: Default::default(),
             network_requester_config: None,
             ip_packet_router_config: None,
         }

gateway/src/error.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use nym_authenticator::error::AuthenticatorError;
+use nym_gateway_stats_storage::error::StatsStorageError;
 use nym_gateway_storage::error::StorageError;
 use nym_ip_packet_router::error::IpPacketRouterError;
 use nym_network_requester::error::{ClientCoreError, NetworkRequesterError};
@@ -115,6 +116,12 @@ pub enum GatewayError {
         source: StorageError,
     },
 
+    #[error("stats storage failure: {source}")]
+    StatsStorageError {
+        #[from]
+        source: StatsStorageError,
+    },
+
     #[error("Path to network requester configuration file hasn't been specified. Perhaps try to run `setup-network-requester`?")]
     UnspecifiedNetworkRequesterConfig,
 

gateway/src/node/helpers.rs

@@ -5,6 +5,7 @@ use crate::config::Config;
 use crate::error::GatewayError;
 use async_trait::async_trait;
 use nym_crypto::asymmetric::encryption;
+use nym_gateway_stats_storage::PersistentStatsStorage;
 use nym_gateway_storage::PersistentStorage;
 use nym_pemstore::traits::PemStorableKeyPair;
 use nym_pemstore::KeyPairPath;
@@ -79,6 +80,14 @@ pub(crate) async fn initialise_main_storage(
     Ok(PersistentStorage::init(path, retrieval_limit).await?)
 }
 
+pub(crate) async fn initialise_stats_storage(
+    config: &Config,
+) -> Result<PersistentStatsStorage, GatewayError> {
+    let path = &config.storage_paths.stats_storage;
+
+    Ok(PersistentStatsStorage::init(path).await?)
+}
+
 pub fn load_keypair<T: PemStorableKeyPair>(
     paths: KeyPairPath,
     name: impl Into<String>,

gateway/src/node/mod.rs

@@ -13,7 +13,8 @@ use crate::node::client_handling::active_clients::ActiveClientsStore;
 use crate::node::client_handling::embedded_clients::{LocalEmbeddedClientHandle, MessageRouter};
 use crate::node::client_handling::websocket;
 use crate::node::helpers::{
-    initialise_main_storage, load_network_requester_config, GatewayTopologyProvider,
+    initialise_main_storage, initialise_stats_storage, load_network_requester_config,
+    GatewayTopologyProvider,
 };
 use crate::node::mixnet_handling::receiver::connection_handler::ConnectionHandler;
 use futures::channel::{mpsc, oneshot};
@@ -46,6 +47,7 @@ pub(crate) mod helpers;
 pub(crate) mod mixnet_handling;
 pub(crate) mod statistics;
 
+pub use nym_gateway_stats_storage::PersistentStatsStorage;
 pub use nym_gateway_storage::{PersistentStorage, Storage};
 
 // TODO: should this struct live here?
@@ -101,6 +103,8 @@ pub async fn create_gateway(
 
     let storage = initialise_main_storage(&config).await?;
 
+    let stats_storage = initialise_stats_storage(&config).await?;
+
     let nr_opts = network_requester_config.map(|config| LocalNetworkRequesterOpts {
         config: config.clone(),
         custom_mixnet_path: custom_mixnet.clone(),
@@ -111,7 +115,7 @@ pub async fn create_gateway(
         custom_mixnet_path: custom_mixnet.clone(),
     });
 
-    Gateway::new(config, nr_opts, ip_opts, storage)
+    Gateway::new(config, nr_opts, ip_opts, storage, stats_storage)
 }
 
 #[derive(Debug, Clone)]
@@ -152,7 +156,9 @@ pub struct Gateway<St = PersistentStorage> {
     /// x25519 keypair used for Diffie-Hellman. Currently only used for sphinx key derivation.
     sphinx_keypair: Arc<encryption::KeyPair>,
 
-    storage: St,
+    client_storage: St,
+
+    stats_storage: PersistentStatsStorage,
 
     wireguard_data: Option<nym_wireguard::WireguardData>,
 
@@ -168,10 +174,12 @@ impl<St> Gateway<St> {
         config: Config,
         network_requester_opts: Option<LocalNetworkRequesterOpts>,
         ip_packet_router_opts: Option<LocalIpPacketRouterOpts>,
-        storage: St,
+        client_storage: St,
+        stats_storage: PersistentStatsStorage,
     ) -> Result<Self, GatewayError> {
         Ok(Gateway {
-            storage,
+            client_storage,
+            stats_storage,
             identity_keypair: Arc::new(load_identity_keys(&config)?),
             sphinx_keypair: Arc::new(helpers::load_sphinx_keys(&config)?),
             config,
@@ -184,7 +192,7 @@ impl<St> Gateway<St> {
             task_client: None,
         })
     }
-
+    #[allow(clippy::too_many_arguments)]
     pub fn new_loaded(
         config: Config,
         network_requester_opts: Option<LocalNetworkRequesterOpts>,
@@ -192,7 +200,8 @@ impl<St> Gateway<St> {
         authenticator_opts: Option<LocalAuthenticatorOpts>,
         identity_keypair: Arc<identity::KeyPair>,
         sphinx_keypair: Arc<encryption::KeyPair>,
-        storage: St,
+        client_storage: St,
+        stats_storage: PersistentStatsStorage,
     ) -> Self {
         Gateway {
             config,
@@ -201,7 +210,8 @@ impl<St> Gateway<St> {
             authenticator_opts,
             identity_keypair,
             sphinx_keypair,
-            storage,
+            client_storage,
+            stats_storage,
             wireguard_data: None,
             session_stats: None,
             run_http_server: true,
@@ -278,7 +288,7 @@ impl<St> Gateway<St> {
 
         let connection_handler = ConnectionHandler::new(
             packet_processor,
-            self.storage.clone(),
+            self.client_storage.clone(),
             ack_sender,
             active_clients_store,
         );
@@ -314,7 +324,7 @@ impl<St> Gateway<St> {
             forwarding_channel,
             router_tx,
         );
-        let all_peers = self.storage.get_all_wireguard_peers().await?;
+        let all_peers = self.client_storage.get_all_wireguard_peers().await?;
         let used_private_network_ips = all_peers
             .iter()
             .cloned()
@@ -370,7 +380,7 @@ impl<St> Gateway<St> {
                 .start_with_shutdown(router_shutdown);
 
             let wg_api = nym_wireguard::start_wireguard(
-                self.storage.clone(),
+                self.client_storage.clone(),
                 all_peers,
                 shutdown,
                 wireguard_data,
@@ -418,7 +428,7 @@ impl<St> Gateway<St> {
 
         let shared_state = websocket::CommonHandlerState {
             ecash_verifier,
-            storage: self.storage.clone(),
+            storage: self.client_storage.clone(),
             local_identity: Arc::clone(&self.identity_keypair),
             only_coconut_credentials: self.config.gateway.only_coconut_credentials,
             bandwidth_cfg: (&self.config).into(),
@@ -456,7 +466,7 @@ impl<St> Gateway<St> {
         info!("Starting gateway stats collector...");
 
         let (mut stats_collector, stats_event_sender) =
-            GatewayStatisticsCollector::new(shared_session_stats);
+            GatewayStatisticsCollector::new(shared_session_stats, self.stats_storage.clone());
         tokio::spawn(async move { stats_collector.run(shutdown).await });
         stats_event_sender
     }
@@ -622,7 +632,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_all_basic_nodes(None).await {
+        let existing_nodes = match validator_client.get_cached_gateways().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 +640,9 @@ impl<St> Gateway<St> {
             }
         };
 
-        Ok(existing_nodes
-            .iter()
-            .any(|node| &node.ed25519_identity_pubkey == self.identity_keypair.public_key()))
+        Ok(existing_nodes.iter().any(|node| {
+            node.gateway.identity_key == self.identity_keypair.public_key().to_base58_string()
+        }))
     }
 
     pub async fn run(mut self) -> Result<(), GatewayError>
@@ -701,7 +711,7 @@ impl<St> Gateway<St> {
                 nyxd_client,
                 self.identity_keypair.public_key().to_bytes(),
                 shutdown.fork("EcashVerifier"),
-                self.storage.clone(),
+                self.client_storage.clone(),
             )
             .await?,
         );

gateway/src/node/statistics/mod.rs

@@ -2,13 +2,14 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use futures::{channel::mpsc, StreamExt};
+use nym_gateway_stats_storage::PersistentStatsStorage;
 use nym_node_http_api::state::metrics::SharedSessionStats;
 use nym_statistics_common::events::{StatsEvent, StatsEventReceiver, StatsEventSender};
 use nym_task::TaskClient;
 use sessions::SessionStatsHandler;
 use std::time::Duration;
 use time::OffsetDateTime;
-use tracing::trace;
+use tracing::{error, trace, warn};
 
 pub mod sessions;
 
@@ -23,21 +24,38 @@ pub(crate) struct GatewayStatisticsCollector {
 impl GatewayStatisticsCollector {
     pub fn new(
         shared_session_stats: SharedSessionStats,
+        stats_storage: PersistentStatsStorage,
     ) -> (GatewayStatisticsCollector, StatsEventSender) {
         let (stats_event_tx, stats_event_rx) = mpsc::unbounded();
+
+        let session_stats = SessionStatsHandler::new(shared_session_stats, stats_storage);
         let collector = GatewayStatisticsCollector {
             stats_event_rx,
-            session_stats: SessionStatsHandler::new(shared_session_stats),
+            session_stats,
         };
         (collector, stats_event_tx)
     }
 
     async fn update_shared_state(&mut self, update_time: OffsetDateTime) {
-        self.session_stats.update_shared_state(update_time).await;
+        if let Err(e) = self
+            .session_stats
+            .maybe_update_shared_state(update_time)
+            .await
+        {
+            error!("Failed to update session stats - {e}");
+        }
         //here goes additionnal stats handler update
     }
 
+    async fn on_start(&mut self) {
+        if let Err(e) = self.session_stats.on_start().await {
+            error!("Failed to cleanup session stats handler - {e}");
+        }
+        //here goes additionnal stats handler start cleanup
+    }
+
     pub async fn run(&mut self, mut shutdown: TaskClient) {
+        self.on_start().await;
         let mut update_interval = tokio::time::interval(STATISTICS_UPDATE_TIMER_INTERVAL);
         while !shutdown.is_shutdown() {
             tokio::select! {
@@ -53,7 +71,10 @@ impl GatewayStatisticsCollector {
                 Some(stat_event) = self.stats_event_rx.next() => {
                     //dispatching event to proper handler
                     match stat_event {
-                        StatsEvent::SessionStatsEvent(event) => self.session_stats.handle_event(event),
+                        StatsEvent::SessionStatsEvent(event) => {
+                            if let Err(e) = self.session_stats.handle_event(event).await{
+                            warn!("Session event handling error - {e}");
+                        }},
                     }
                 },
 

gateway/src/node/statistics/sessions.rs

@@ -2,176 +2,158 @@
 // SPDX-License-Identifier: GPL-3.0-only
 
 use nym_credentials_interface::TicketType;
+use nym_gateway_stats_storage::models::FinishedSession;
+use nym_gateway_stats_storage::PersistentStatsStorage;
+use nym_gateway_stats_storage::{error::StatsStorageError, models::ActiveSession};
 use nym_node_http_api::state::metrics::SharedSessionStats;
 use nym_sphinx::DestinationAddressBytes;
-use std::collections::{HashMap, HashSet};
 use time::{Date, Duration, OffsetDateTime};
 
 use nym_statistics_common::events::SessionEvent;
 
-const FINISHED_SESSIONS_CAP: usize = 1_000_000; //to be on the safe side of memory blowups until persistent storage
-
-#[derive(PartialEq)]
-enum SessionType {
-    Vpn,
-    Mixnet,
-    Unknown,
-}
-
-impl SessionType {
-    fn to_string(&self) -> &str {
-        match self {
-            Self::Vpn => "vpn",
-            Self::Mixnet => "mixnet",
-            Self::Unknown => "unknown",
-        }
-    }
-}
-
-impl From<TicketType> for SessionType {
-    fn from(value: TicketType) -> Self {
-        match value {
-            TicketType::V1MixnetEntry => Self::Mixnet,
-            TicketType::V1MixnetExit => Self::Mixnet,
-            TicketType::V1WireguardEntry => Self::Vpn,
-            TicketType::V1WireguardExit => Self::Vpn,
-        }
-    }
-}
-
-struct FinishedSession {
-    duration: Duration,
-    typ: SessionType,
-}
-
-impl FinishedSession {
-    fn serialize(&self) -> (u64, String) {
-        (
-            self.duration.whole_milliseconds() as u64, //we are sure that it fits in a u64, see `fn end_at`
-            self.typ.to_string().into(),
-        )
-    }
-}
-
-struct ActiveSession {
-    start: OffsetDateTime,
-    typ: SessionType,
-}
-
-impl ActiveSession {
-    fn new(start_time: OffsetDateTime) -> Self {
-        ActiveSession {
-            start: start_time,
-            typ: SessionType::Unknown,
-        }
-    }
-
-    fn set_type(&mut self, ticket_type: TicketType) {
-        self.typ = ticket_type.into();
-    }
-
-    fn end_at(self, stop_time: OffsetDateTime) -> Option<FinishedSession> {
-        let session_duration = stop_time - self.start;
-        //ensure duration is positive to fit in a u64
-        //u64::max milliseconds is 500k millenia so no overflow issue
-        if session_duration > Duration::ZERO {
-            Some(FinishedSession {
-                duration: session_duration,
-                typ: self.typ,
-            })
-        } else {
-            None
-        }
-    }
-}
-
 pub(crate) struct SessionStatsHandler {
-    last_update_day: Date,
+    storage: PersistentStatsStorage,
+    current_day: Date,
 
     shared_session_stats: SharedSessionStats,
-    active_sessions: HashMap<DestinationAddressBytes, ActiveSession>,
-    unique_users: HashSet<DestinationAddressBytes>,
-    sessions_started: u32,
-    finished_sessions: Vec<FinishedSession>,
 }
 
 impl SessionStatsHandler {
-    pub fn new(shared_session_stats: SharedSessionStats) -> Self {
+    pub fn new(shared_session_stats: SharedSessionStats, storage: PersistentStatsStorage) -> Self {
         SessionStatsHandler {
-            last_update_day: OffsetDateTime::now_utc().date(),
+            storage,
+            current_day: OffsetDateTime::now_utc().date(),
             shared_session_stats,
-            active_sessions: Default::default(),
-            unique_users: Default::default(),
-            sessions_started: 0,
-            finished_sessions: Default::default(),
         }
     }
 
-    pub(crate) fn handle_event(&mut self, event: SessionEvent) {
+    pub(crate) async fn handle_event(
+        &mut self,
+        event: SessionEvent,
+    ) -> Result<(), StatsStorageError> {
         match event {
             SessionEvent::SessionStart { start_time, client } => {
-                self.handle_session_start(start_time, client);
+                self.handle_session_start(start_time, client).await
             }
+
             SessionEvent::SessionStop { stop_time, client } => {
-                self.handle_session_stop(stop_time, client);
+                self.handle_session_stop(stop_time, client).await
             }
+
             SessionEvent::EcashTicket {
                 ticket_type,
                 client,
-            } => self.handle_ecash_ticket(ticket_type, client),
+            } => self.handle_ecash_ticket(ticket_type, client).await,
         }
     }
-    fn handle_session_start(
+    async fn handle_session_start(
         &mut self,
         start_time: OffsetDateTime,
         client: DestinationAddressBytes,
-    ) {
-        self.sessions_started += 1;
-        self.unique_users.insert(client);
-        self.active_sessions
-            .insert(client, ActiveSession::new(start_time));
-    }
-    fn handle_session_stop(&mut self, stop_time: OffsetDateTime, client: DestinationAddressBytes) {
-        if let Some(session) = self.active_sessions.remove(&client) {
-            if let Some(finished_session) = session.end_at(stop_time) {
-                if self.finished_sessions.len() < FINISHED_SESSIONS_CAP {
-                    self.finished_sessions.push(finished_session);
-                }
-            }
-        }
+    ) -> Result<(), StatsStorageError> {
+        self.storage
+            .insert_unique_user(self.current_day, client.as_base58_string())
+            .await?;
+        self.storage
+            .insert_active_session(client, ActiveSession::new(start_time))
+            .await?;
+        Ok(())
     }
 
-    fn handle_ecash_ticket(&mut self, ticket_type: TicketType, client: DestinationAddressBytes) {
-        if let Some(active_session) = self.active_sessions.get_mut(&client) {
-            if active_session.typ == SessionType::Unknown {
-                active_session.set_type(ticket_type);
+    async fn handle_session_stop(
+        &mut self,
+        stop_time: OffsetDateTime,
+        client: DestinationAddressBytes,
+    ) -> Result<(), StatsStorageError> {
+        if let Some(session) = self.storage.get_active_session(client).await? {
+            if let Some(finished_session) = session.end_at(stop_time) {
+                self.storage
+                    .insert_finished_session(self.current_day, finished_session)
+                    .await?;
+                self.storage.delete_active_session(client).await?;
             }
         }
+        Ok(())
+    }
+
+    async fn handle_ecash_ticket(
+        &mut self,
+        ticket_type: TicketType,
+        client: DestinationAddressBytes,
+    ) -> Result<(), StatsStorageError> {
+        self.storage
+            .update_active_session_type(client, ticket_type.into())
+            .await?;
+        Ok(())
+    }
+
+    pub(crate) async fn on_start(&mut self) -> Result<(), StatsStorageError> {
+        let yesterday = OffsetDateTime::now_utc().date() - Duration::DAY;
+        //publish yesterday's data if any
+        self.publish_stats(yesterday).await?;
+        //store "active" sessions as duration 0
+        for active_session in self.storage.get_all_active_sessions().await? {
+            self.storage
+                .insert_finished_session(
+                    self.current_day,
+                    FinishedSession {
+                        duration: Duration::ZERO,
+                        typ: active_session.typ,
+                    },
+                )
+                .await?
+        }
+        //cleanup active sessions
+        self.storage.cleanup_active_sessions().await?;
+
+        //delete old entries
+        self.delete_old_stats(yesterday - Duration::DAY).await?;
+        Ok(())
     }
 
     //update shared state once a day has passed, with data from the previous day
-    pub(crate) async fn update_shared_state(&mut self, update_time: OffsetDateTime) {
-        let update_date = update_time.date();
-        if update_date != self.last_update_day {
-            {
-                let mut shared_state = self.shared_session_stats.write().await;
-                shared_state.update_time = self.last_update_day;
-                shared_state.unique_active_users = self.unique_users.len() as u32;
-                shared_state.session_started = self.sessions_started;
-                shared_state.sessions = self
-                    .finished_sessions
-                    .iter()
-                    .map(|s| s.serialize())
-                    .collect();
-            }
-            self.reset_stats(update_date);
+    async fn publish_stats(&mut self, stats_date: Date) -> Result<(), StatsStorageError> {
+        let finished_sessions = self.storage.get_finished_sessions(stats_date).await?;
+        let user_count = self.storage.get_unique_users_count(stats_date).await?;
+        let session_started = self.storage.get_started_sessions_count(stats_date).await? as u32;
+        {
+            let mut shared_state = self.shared_session_stats.write().await;
+            shared_state.update_time = stats_date;
+            shared_state.unique_active_users = user_count as u32;
+            shared_state.session_started = session_started;
+            shared_state.sessions = finished_sessions.iter().map(|s| s.serialize()).collect();
         }
+
+        Ok(())
+    }
+    pub(crate) async fn maybe_update_shared_state(
+        &mut self,
+        update_time: OffsetDateTime,
+    ) -> Result<(), StatsStorageError> {
+        let update_date = update_time.date();
+        if update_date != self.current_day {
+            self.publish_stats(self.current_day).await?;
+            self.delete_old_stats(self.current_day - Duration::DAY)
+                .await?;
+            self.reset_stats(update_date).await?;
+            self.current_day = update_date;
+        }
+        Ok(())
     }
 
-    fn reset_stats(&mut self, reset_day: Date) {
-        self.last_update_day = reset_day;
-        self.unique_users = self.active_sessions.keys().copied().collect();
-        self.finished_sessions = Default::default();
-        self.sessions_started = 0;
+    async fn reset_stats(&mut self, reset_day: Date) -> Result<(), StatsStorageError> {
+        //active users reset
+        let new_active_users = self.storage.get_active_users().await?;
+        for user in new_active_users {
+            self.storage.insert_unique_user(reset_day, user).await?;
+        }
+
+        Ok(())
+    }
+
+    async fn delete_old_stats(&mut self, delete_before: Date) -> Result<(), StatsStorageError> {
+        self.storage.delete_finished_sessions(delete_before).await?;
+        self.storage.delete_unique_users(delete_before).await?;
+        Ok(())
     }
 }

mixnode/src/node/mod.rs

@@ -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_all_basic_nodes(None).await {
+        let existing_nodes = match validator_client.get_cached_mixnodes().await {
             Ok(nodes) => nodes,
             Err(err) => {
                 error!(
@@ -245,9 +245,10 @@ impl MixNode {
             }
         };
 
-        existing_nodes
-            .iter()
-            .any(|node| &node.ed25519_identity_pubkey == self.identity_keypair.public_key())
+        existing_nodes.iter().any(|node| {
+            node.bond_information.mix_node.identity_key
+                == self.identity_keypair.public_key().to_base58_string()
+        })
     }
 
     async fn wait_for_interrupt(&self, shutdown: TaskHandle) {

nym-api/nym-api-requests/src/models.rs

@@ -852,10 +852,6 @@ impl NymNodeDescription {
         }
     }
 
-    pub fn ed25519_identity_key(&self) -> ed25519::PublicKey {
-        self.description.host_information.keys.ed25519
-    }
-
     pub fn to_skimmed_node(&self, role: NodeRole, performance: Performance) -> SkimmedNode {
         let keys = &self.description.host_information.keys;
         let entry = if self.description.declared_role.entry {
@@ -897,12 +893,6 @@ 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(

nym-api/src/ecash/api_routes/partial_signing.rs

@@ -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::Query;
+use axum::extract::Path;
 use axum::{Json, Router};
 use nym_api_requests::ecash::{
     BlindSignRequestBody, BlindedSignatureResponse, PartialCoinIndicesSignatureResponse,
@@ -134,7 +134,7 @@ struct ExpirationDateParam {
     )
 )]
 async fn partial_expiration_date_signatures(
-    Query(ExpirationDateParam { expiration_date }): Query<ExpirationDateParam>,
+    Path(ExpirationDateParam { expiration_date }): Path<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(
-    Query(EpochIdParam { epoch_id }): Query<EpochIdParam>,
+    Path(EpochIdParam { epoch_id }): Path<EpochIdParam>,
     state: Arc<EcashState>,
 ) -> AxumResult<Json<PartialCoinIndicesSignatureResponse>> {
     state.ensure_signer().await?;

nym-credential-proxy/Cargo.toml

@@ -1,62 +0,0 @@
-[profile.release]
-panic = "abort"
-opt-level = "s"
-overflow-checks = true
-
-[profile.dev]
-panic = "abort"
-
-[workspace]
-
-resolver = "2"
-members = [
-    "nym-credential-proxy",
-    "nym-credential-proxy-requests",
-    "vpn-api-lib-wasm"
-]
-
-[workspace.package]
-authors = ["Nym Technologies SA"]
-repository = "https://github.com/nymtech/nym"
-homepage = "https://nymtech.net"
-documentation = "https://nymtech.net"
-edition = "2021"
-license = "GPL-3.0"
-
-[workspace.dependencies]
-async-trait = "0.1.80"
-axum = "0.7.5"
-anyhow = "1.0.71"
-bip39 = "2.0.0"
-bs58 = "0.5.1"
-colored = "2.1.0"
-cfg-if = "1.0.0"
-clap = "4.5.4"
-dotenv = "0.15.0"
-futures = "0.3.30"
-humantime = "2.1.0"
-thiserror = "1.0.59"
-rand = "0.8.5"
-reqwest = "0.12.4"
-schemars = "0.8.17"
-strum = "0.26.3"
-strum_macros = "0.26.4"
-serde = "1.0.200"
-serde_json = "1.0.117"
-sqlx = "0.7.4"
-tempfile = "3.12.0"
-time = "0.3.36"
-tracing = "0.1.40"
-tsify = "0.4.5"
-tokio = "1.37.0"
-tokio-util = "0.7.10"
-tower = "0.5.0"
-tower-http = "0.5.2"
-uuid = "1.8.0"
-url = "2.5.2"
-utoipa = "4.2.0"
-utoipa-swagger-ui = "7.0.1"
-zeroize = "1.6.0"
-
-wasm-bindgen = "0.2.93"
-wasmtimer = "0.2.0"

nym-credential-proxy/nym-credential-proxy-lib-wasm/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "nym-vpn-api-lib-wasm"
+name = "nym-credential-proxy-lib-wasm"
 version = "0.1.0"
 authors.workspace = true
 repository.workspace = true

nym-credential-proxy/nym-credential-proxy-lib-wasm/Makefile

@@ -0,0 +1,4 @@
+build:
+	wasm-pack build --scope nymproject --target web --out-dir ../../dist/wasm/nym-credential-proxy-lib-wasm
+	wasm-opt -Oz -o ../../dist/wasm/nym-credential-proxy-lib-wasm/nym_credential_proxy_lib_wasm_bg.wasm ../../dist/wasm/nym-credential-proxy-lib-wasm/nym_credential_proxy_lib_wasm_bg.wasm
+

nym-credential-proxy/nym-credential-proxy-lib-wasm/internal-dev/index.js

@@ -1,4 +1,7 @@
-import init, { NymIssuanceTicketbook } from "@nymproject/nym-vpn-api-lib-wasm";
+import init, { NymIssuanceTicketbook } from "@nymproject/nym-credential-proxy-lib-wasm";
+
+const NYM_CREDENTIAL_PROXY_API = "http://localhost:8080";
+const API_TOKEN = "foomp";
 
 async function main() {
   await init();
@@ -6,15 +9,15 @@ async function main() {
   let cryptoData = new NymIssuanceTicketbook({});
 
   console.log("getting partial vks");
-  const partialVksRes = await fetch("http://localhost:8080/api/v1/ticketbook/partial-verification-keys", {
-    headers: new Headers({ "Authorization": "Bearer foomp" })
+  const partialVksRes = await fetch(`${NYM_CREDENTIAL_PROXY_API}/api/v1/ticketbook/partial-verification-keys`, {
+    headers: new Headers({ "Authorization": `Bearer ${API_TOKEN}` })
   });
   const partialVks = await partialVksRes.json();
   console.debug(partialVks);
 
   console.log("getting master vk");
-  const masterVkRes = await fetch("http://localhost:8080/api/v1/ticketbook/master-verification-key", {
-    headers: new Headers({ "Authorization": "Bearer foomp" })
+  const masterVkRes = await fetch(`${NYM_CREDENTIAL_PROXY_API}/api/v1/ticketbook/master-verification-key`, {
+    headers: new Headers({ "Authorization": `Bearer ${API_TOKEN}` })
   });
   const masterVk = await masterVkRes.json();
   console.debug(masterVk);
@@ -24,11 +27,11 @@ async function main() {
 
 
   console.log("getting blinded wallet shares");
-  const sharesRes = await fetch("http://localhost:8080/api/v1/ticketbook/obtain?include-coin-index-signatures=true&include-expiration-date-signatures=true", {
+  const sharesRes = await fetch(`${NYM_CREDENTIAL_PROXY_API}/api/v1/ticketbook/obtain?include-coin-index-signatures=true&include-expiration-date-signatures=true`, {
     method: "POST",
     headers: new Headers(
       {
-        "Authorization": "Bearer foomp",
+        "Authorization": `Bearer ${API_TOKEN}`,
         "Content-Type": "application/json"
       }
     ),

nym-credential-proxy/nym-credential-proxy-lib-wasm/internal-dev/package.json

@@ -21,7 +21,7 @@
     "rust",
     "webpack"
   ],
-  "author": "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
+  "author": "Nym Technologies SA <contact@nymtech.net>",
   "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/nymtech/nym/issues"
@@ -35,6 +35,6 @@
     "webpack-dev-server": "^4.7.4"
   },
   "dependencies": {
-    "@nymproject/nym-vpn-api-lib-wasm": "file:../../../dist/wasm/nym-vpn-api-lib-wasm"
+    "@nymproject/nym-credential-proxy-lib-wasm": "file:../../../dist/wasm/nym-credential-proxy-lib-wasm"
   }
 }

nym-credential-proxy/nym-credential-proxy-lib-wasm/internal-dev/webpack.config.js

@@ -22,7 +22,7 @@ module.exports = {
       patterns: [
         "index.html",
         {
-          from: "../../../dist/wasm/nym-vpn-api-lib-wasm/*.(js|wasm)",
+          from: "../../../dist/wasm/nym-credential-proxy-lib-wasm/*.(js|wasm)",
           to: "[name][ext]"
         }
       ]

nym-credential-proxy/nym-credential-proxy-lib-wasm/src/error.rs

@@ -1,5 +1,5 @@
 // Copyright 2024 Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-License-Identifier: Apache-2.0
 
 use serde_wasm_bindgen::Error;
 use thiserror::Error;

nym-credential-proxy/nym-credential-proxy-lib-wasm/src/lib.rs

@@ -1,5 +1,5 @@
 // Copyright 2024 Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: GPL-3.0-only
+// SPDX-License-Identifier: Apache-2.0
 
 use crate::error::VpnApiLibError;
 use nym_compact_ecash::scheme::keygen::KeyPairUser;

nym-credential-proxy/nym-credential-proxy-requests/Cargo.toml

@@ -22,7 +22,7 @@ reqwest = { workspace = true, features = ["json"] }
 wasm-bindgen = { workspace = true, optional = true }
 
 ## openapi:
-utoipa = { workspace = true, optional = true, features = ["uuid"] }
+utoipa = { workspace = true, optional = true }
 
 nym-credentials = { path = "../../common/credentials" }
 nym-credentials-interface = { path = "../../common/credentials-interface" }

nym-credential-proxy/nym-credential-proxy-requests/src/api/v1/ticketbook/models.rs

@@ -10,7 +10,7 @@ use schemars::schema::Schema;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::ops::{Deref, DerefMut};
-use time::{Date, OffsetDateTime};
+use time::Date;
 
 #[cfg(feature = "query-types")]
 use nym_http_api_common::Output;
@@ -40,7 +40,6 @@ 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
@@ -49,7 +48,6 @@ 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,
@@ -236,28 +234,22 @@ pub struct TicketbookWalletSharesAsyncResponse {
 #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[serde(rename_all = "camelCase")]
-pub struct WebhookTicketbookWalletShares {
+pub struct BlindedWalletSharesResponse {
     pub id: i64,
     pub status: String,
     pub device_id: String,
     pub credential_id: String,
     pub data: Option<TicketbookWalletSharesResponse>,
     pub error_message: Option<String>,
-
-    #[schemars(with = "String")]
-    #[serde(with = "time::serde::rfc3339")]
-    pub created: OffsetDateTime,
-
-    #[schemars(with = "String")]
-    #[serde(with = "time::serde::rfc3339")]
-    pub updated: OffsetDateTime,
+    pub created: String,
+    pub updated: String,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, JsonSchema)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[serde(rename_all = "camelCase")]
-pub struct WebhookTicketbookWalletSharesRequest {
-    pub ticketbook_wallet_shares: WebhookTicketbookWalletShares,
+pub struct WebhookBlindedSharesResponse {
+    pub blinded_shares: BlindedWalletSharesResponse,
     pub secret: String,
 }
 

nym-credential-proxy/nym-credential-proxy/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-credential-proxy"
-version = "0.1.3"
+version = "0.1.1"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true
@@ -19,7 +19,7 @@ bs58.workspace = true
 cfg-if = { workspace = true }
 colored.workspace = true
 clap = { workspace = true, features = ["derive", "env"] }
-dotenv.workspace = true
+dotenvy.workspace = true
 futures.workspace = true
 humantime.workspace = true
 rand.workspace = true

nym-credential-proxy/nym-credential-proxy/migrations/03_blinded_shares_no_foreign_table.sql

@@ -1,20 +0,0 @@
-/*
- * 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
-);

nym-credential-proxy/nym-credential-proxy/src/credentials/ticketbook/mod.rs

@@ -3,12 +3,10 @@
 
 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, WebhookTicketbookWalletShares,
-    WebhookTicketbookWalletSharesRequest,
+    TicketbookWalletSharesResponse, WalletShare,
 };
 use nym_credentials::IssuanceTicketBook;
 use nym_credentials_interface::Base58;
@@ -219,13 +217,11 @@ 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 (
@@ -263,70 +259,19 @@ async fn try_obtain_blinded_ticketbook_async_inner(
         error!(uuid = %request, "failed to update db with issued information: {err}")
     }
 
-    // 4. build the webhook request body
-    let data = Some(TicketbookWalletSharesResponse {
+    // 4. build the response
+    let response = 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, &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)
+        .try_trigger(request, &response)
         .await;
 
     Ok(())
@@ -340,30 +285,16 @@ 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.clone(),
+        request_data,
         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")

nym-credential-proxy/nym-credential-proxy/src/http/router/api/v1/openapi.rs

@@ -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::WebhookTicketbookWalletShares,
-            api_requests::v1::ticketbook::models::WebhookTicketbookWalletSharesRequest,
+            api_requests::v1::ticketbook::models::BlindedWalletSharesResponse,
+            api_requests::v1::ticketbook::models::WebhookBlindedSharesResponse,
             api_requests::v1::ticketbook::models::TicketbookObtainQueryParams,
             api_requests::v1::ticketbook::models::SharesQueryParams,
             api_requests::v1::ticketbook::models::PlaceholderJsonSchemaImpl,

nym-credential-proxy/nym-credential-proxy/src/http/router/api/v1/ticketbook/mod.rs

@@ -192,7 +192,6 @@ 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
@@ -202,7 +201,6 @@ pub(crate) async fn obtain_ticketbook_shares_async(
             requested_on,
             payload,
             params,
-            pending,
         ))
         .is_none()
     {
@@ -215,7 +213,10 @@ pub(crate) async fn obtain_ticketbook_shares_async(
     }
 
     // 4. in the meantime, return the id to the user
-    Ok(output.to_response(TicketbookWalletSharesAsyncResponse { id, uuid }))
+    Ok(output.to_response(TicketbookWalletSharesAsyncResponse {
+        id: pending.id,
+        uuid,
+    }))
 }
 
 /// Obtain the current value of the bandwidth voucher deposit

nym-credential-proxy/nym-credential-proxy/src/http/router/api/v1/ticketbook/shares.rs

@@ -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(SharesQueryParams),
+    params(OutputParams),
     security(
         ("auth_token" = [])
     )

nym-credential-proxy/nym-credential-proxy/src/storage/manager.rs

@@ -40,7 +40,7 @@ impl SqliteStorageManager {
         sqlx::query_as!(
             MinimalWalletShare,
             r#"
-                SELECT t1.node_id, t1.blinded_signature, t1.epoch_id, t1.expiration_date
+                SELECT t1.node_id, t1.blinded_signature, t1.epoch_id, t1.expiration_date as "expiration_date!: Date"
                 FROM partial_blinded_wallet as t1
                 JOIN ticketbook_deposit as t2
                     on t1.corresponding_deposit = t2.deposit_id
@@ -79,14 +79,11 @@ impl SqliteStorageManager {
         device_id: &str,
         credential_id: &str,
     ) -> Result<Vec<MinimalWalletShare>, sqlx::Error> {
+        // https://docs.rs/sqlx/latest/sqlx/macro.query.html#force-a-differentcustom-type
         sqlx::query_as!(
             MinimalWalletShare,
             r#"
-                SELECT 
-                    t1.node_id as "node_id!",
-                    t1.blinded_signature as "blinded_signature!",
-                    t1.epoch_id as "epoch_id!",
-                    t1.expiration_date as "expiration_date!"
+                SELECT t1.node_id, t1.blinded_signature, t1.epoch_id, t1.expiration_date as "expiration_date!: Date"
                 FROM partial_blinded_wallet as t1
                 JOIN ticketbook_deposit as t2
                     on t1.corresponding_deposit = t2.deposit_id

nym-credential-proxy/vpn-api-lib-wasm/Makefile

@@ -1,4 +0,0 @@
-build:
-	wasm-pack build --scope nymproject --target web --out-dir ../../dist/wasm/nym-vpn-api-lib-wasm
-	wasm-opt -Oz -o ../../dist/wasm/nym-vpn-api-lib-wasm/nym_vpn_api_lib_wasm_bg.wasm ../../dist/wasm/nym-vpn-api-lib-wasm/nym_vpn_api_lib_wasm_bg.wasm
-

nym-data-observatory/Dockerfile

@@ -5,6 +5,18 @@ WORKDIR /usr/src/nym/nym-data-observatory
 
 RUN cargo build --release
 
+#-------------------------------------------------------------------
+# The following environment variables are required at runtime:
+#
+# NYM_DATA_OBSERVATORY_CONNECTION_URL
+#
+# And optionally:
+#
+# NYM_DATA_OBSERVATORY_HTTP_PORT
+#
+# see https://github.com/nymtech/nym/blob/develop/nym-data-observatory/src/main.rs for details
+#-------------------------------------------------------------------
+
 FROM ubuntu:24.04
 
 RUN apt update && apt install -yy curl ca-certificates

nym-data-observatory/docker-compose.yml

@@ -18,8 +18,14 @@ services:
       dockerfile: nym-data-observatory/Dockerfile
     container_name: nym-data-observatory
     environment:
-      NYM_DATA_OBSERVATORY_CONNECTION_URL: "postgres://postgres:password@postgres:5432"
+      NYM_DATA_OBSERVATORY_CONNECTION_USERNAME: "postgres"
+      NYM_DATA_OBSERVATORY_CONNECTION_PASSWORD: "password"
+      NYM_DATA_OBSERVATORY_CONNECTION_HOST: "postgres"
+      NYM_DATA_OBSERVATORY_CONNECTION_PORT: "5432"
+      NYM_DATA_OBSERVATORY_CONNECTION_DB: ""
       NYM_DATA_OBSERVATORY_HTTP_PORT: 8000
+    env_file:
+      - ../envs/qa.env
 
 volumes:
   pgdata:

nym-data-observatory/src/db/mod.rs

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

nym-data-observatory/src/main.rs

@@ -18,9 +18,25 @@ struct Args {
     #[arg(short, long, default_value = None, env = "NYM_DATA_OBSERVATORY_ENV_FILE")]
     env_file: Option<String>,
 
-    /// DB connection url
-    #[arg(short, long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_URL")]
-    connection_url: Option<String>,
+    /// DB connection username
+    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_USERNAME")]
+    connection_username: String,
+
+    /// DB connection password
+    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_PASSWORD")]
+    connection_password: String,
+
+    /// DB connection host
+    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_HOST")]
+    connection_host: String,
+
+    /// DB connection port
+    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_PORT")]
+    connection_port: String,
+
+    /// DB connection database name
+    #[arg(long, default_value = None, env = "NYM_DATA_OBSERVATORY_CONNECTION_DB")]
+    connection_db: String,
 }
 
 #[tokio::main]
@@ -31,7 +47,16 @@ async fn main() -> anyhow::Result<()> {
 
     setup_env(args.env_file); // Defaults to mainnet if empty
 
-    let storage = db::Storage::init(args.connection_url).await?;
+    let connection_url = format!(
+        "postgres://{}:{}@{}:{}/{}",
+        args.connection_username,
+        args.connection_password,
+        args.connection_host,
+        args.connection_port,
+        args.connection_db
+    );
+
+    let storage = db::Storage::init(connection_url).await?;
     let db_pool = storage.pool_owned().await;
     tokio::spawn(async move {
         background_task::spawn_in_background(db_pool).await;

nym-node-status-agent/Cargo.toml

@@ -4,7 +4,7 @@
 
 [package]
 name = "nym-node-status-agent"
-version = "0.1.4"
+version = "0.1.0"
 authors.workspace = true
 repository.workspace = true
 homepage.workspace = true

nym-node-status-agent/Dockerfile

@@ -25,4 +25,4 @@ 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" ]
+ENTRYPOINT [ "/nym/nym-node-status-agent", "run-probe" ]

nym-node-status-agent/run.sh

@@ -2,11 +2,7 @@
 
 set -eu
 
-environment="qa"
-
-source ../envs/${environment}.env
-
-export RUST_LOG="debug"
+export RUST_LOG=${RUST_LOG:-debug}
 
 crate_root=$(dirname $(realpath "$0"))
 gateway_probe_src=$(dirname $(dirname "$crate_root"))/nym-vpn-client/nym-vpn-core
@@ -18,8 +14,6 @@ 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
@@ -36,8 +30,8 @@ function swarm() {
 
     build_agent
 
-    for ((i = 1; i <= $workers; i++)); do
-        ../target/release/nym-node-status-agent run-probe &
+    for ((i=1; i<=$workers; i++)); do
+        ../target/release/nym-node-status-agent run-probe  &
     done
 
     wait
@@ -50,6 +44,6 @@ export NODE_STATUS_AGENT_SERVER_PORT="8000"
 
 copy_gw_probe
 
-swarm 8
+swarm 30
 
 # cargo run -- run-probe

nym-node-status-agent/src/cli.rs

@@ -31,19 +31,24 @@ pub(crate) enum Command {
         /// path of binary to run
         #[arg(long, env = "NODE_STATUS_AGENT_PROBE_PATH")]
         probe_path: String,
+        #[arg(short, long, env = "NODE_STATUS_AGENT_GATEWAY_ID")]
+        gateway_id: Option<String>,
     },
 }
 
 impl Args {
     pub(crate) async fn execute(&self) -> anyhow::Result<()> {
         match &self.command {
-            Command::RunProbe { probe_path } => self.run_probe(probe_path).await?,
+            Command::RunProbe {
+                probe_path,
+                gateway_id,
+            } => self.run_probe(probe_path, gateway_id).await?,
         }
 
         Ok(())
     }
 
-    async fn run_probe(&self, probe_path: &str) -> anyhow::Result<()> {
+    async fn run_probe(&self, probe_path: &str, gateway_id: &Option<String>) -> anyhow::Result<()> {
         let server_address = format!("{}:{}", &self.server_address, self.server_port);
 
         let probe = GwProbe::new(probe_path.to_string());
@@ -53,7 +58,7 @@ impl Args {
 
         let testrun = request_testrun(&server_address).await?;
 
-        let log = probe.run_and_get_log(&Some(testrun.gateway_identity_key));
+        let log = probe.run_and_get_log(gateway_id);
 
         submit_results(&server_address, testrun.testrun_id, log).await?;
 
@@ -92,7 +97,6 @@ async fn submit_results(
 ) -> 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)

nym-node-status-agent/src/probe.rs

@@ -40,12 +40,6 @@ impl GwProbe {
         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());
                 }

nym-node-status-api/.sqlx/query-06b17d1e5f61201a1b7542896ba55c69cd5c1a7e7d87073c94600c783a0a3984.json

@@ -1,20 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-1327b5118f9144dddbcf8edb11f7dc549cf503409fd6dfedcdc02dbcd61d5454.json

@@ -1,32 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-18abc8fde56cf86baed7b4afa38f2c63cdf90f2f3b6d81afb9000bb0968dcaea.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE mixnodes\n                SET bonded = ?, last_updated_utc = ?\n                WHERE id = ?;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 3
-    },
-    "nullable": []
-  },
-  "hash": "18abc8fde56cf86baed7b4afa38f2c63cdf90f2f3b6d81afb9000bb0968dcaea"
-}

nym-node-status-api/.sqlx/query-2236299f9f691376db54cbd58ec5ceb89b9925cba46efcf4ed79ef0759a01129.json

@@ -1,26 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-3c584e211d07c511644c8079187965acf3bcfb3f84ba8d24ed645d79976cf784.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "INSERT INTO testruns (gateway_id, status, ip_address, timestamp_utc, log) VALUES (?, ?, ?, ?, ?)",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 5
-    },
-    "nullable": []
-  },
-  "hash": "3c584e211d07c511644c8079187965acf3bcfb3f84ba8d24ed645d79976cf784"
-}

nym-node-status-api/.sqlx/query-3d3a1fa429e3090741c6b6a8e82e692afc04b51e8782bcbf59f1eb4116112536.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE gateways\n                SET bonded = ?, last_updated_utc = ?\n                WHERE id = ?;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 3
-    },
-    "nullable": []
-  },
-  "hash": "3d3a1fa429e3090741c6b6a8e82e692afc04b51e8782bcbf59f1eb4116112536"
-}

nym-node-status-api/.sqlx/query-3d5fc502f976f5081f01352856b8632c29c81bfafb043bb8744129cf9e0266ad.json

@@ -1,38 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-418944f2eccb838cb3882f34469203c8569f03fdd39ce09d7b74177896e52a8c.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE testruns SET status = ? WHERE id = ?",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 2
-    },
-    "nullable": []
-  },
-  "hash": "418944f2eccb838cb3882f34469203c8569f03fdd39ce09d7b74177896e52a8c"
-}

nym-node-status-api/.sqlx/query-46d76bc6d3fba2dae3b21511a36289dd776749dd7a20cda61b0480f2fba60889.json

@@ -1,50 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-4afcc6673890f795c2793f1e2f8570ee787fc7daf00fcb916f18d1cb7d6c8f08.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE gateways SET last_probe_log = ? WHERE id = ?",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 2
-    },
-    "nullable": []
-  },
-  "hash": "4afcc6673890f795c2793f1e2f8570ee787fc7daf00fcb916f18d1cb7d6c8f08"
-}

nym-node-status-api/.sqlx/query-4b61a4bc32333c92a8f5ad4ad0017b40dc01845f554b5479f37855d89b309e6f.json

@@ -1,32 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-670b7ed7d57a6986181b24be24ca667e8cacdf677ccb906415b3fe92be0c436b.json

@@ -1,20 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-6d7967b831b355d5f2c77950abc56f816956b0824c66a25da611dce688105d36.json

@@ -1,50 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-6eb1a682cf13205cf701590021cdf795147ac3724e89df5b2f24f7215d87dce1.json

@@ -1,12 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-6ef3efde571d46961244cd90420f3de5949a5ff2083453cb879af8a1689efe2f.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE gateways SET last_probe_result = ? WHERE id = ?",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 2
-    },
-    "nullable": []
-  },
-  "hash": "6ef3efde571d46961244cd90420f3de5949a5ff2083453cb879af8a1689efe2f"
-}

nym-node-status-api/.sqlx/query-71a455c705f9c25d3843ff2fb8629d1320a5eb10797cdb5a435455d22c6aeac1.json

@@ -1,98 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-7600823da7ce80b8ffda933608603a2752e28df775d1af8fd943a5fc8d7dc00d.json

@@ -1,38 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-788515c34588aec352773df4b6e6c5e41f3c0bb56a27648b5e25466b8634a578.json

@@ -1,12 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-8571faad2f66e08f24acfbfe036d17ca6eb090df7f6d52ef89c5d51564f8b45c.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE gateways\n             SET blacklisted = true\n             WHERE gateway_identity_key = ?;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 1
-    },
-    "nullable": []
-  },
-  "hash": "8571faad2f66e08f24acfbfe036d17ca6eb090df7f6d52ef89c5d51564f8b45c"
-}

nym-node-status-api/.sqlx/query-86ff64db477a1d6235179b0b88d86b86d1b9be62336c9eac0eef44987a5451b5.json

@@ -1,20 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-930a41e612b4e964ae214843da190f6c66c14d4267a2cc2ca73354becc2c8bb8.json

@@ -1,26 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-c214c001acbbf79fa499816f36ec586c4c29c03efb4cf0c40b73a5c76159cf5c.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE gateways SET last_testrun_utc = ?, last_updated_utc = ? WHERE id = ?",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 3
-    },
-    "nullable": []
-  },
-  "hash": "c214c001acbbf79fa499816f36ec586c4c29c03efb4cf0c40b73a5c76159cf5c"
-}

nym-node-status-api/.sqlx/query-c5e3cd7284b334df5aa979b1627ea1f6dc2aed00cedde25f2be3567e47064351.json

@@ -1,44 +0,0 @@
-{
-  "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"
-}

nym-node-status-api/.sqlx/query-c7ba2621becb9ac4b5dee0ce303dadfcf19095935867a51cbd5b8362d1505fcc.json

@@ -1,32 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "SELECT\n            id as \"id!\",\n            identity_key as \"identity_key!\",\n            bonded as \"bonded: bool\"\n         FROM mixnodes\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": "c7ba2621becb9ac4b5dee0ce303dadfcf19095935867a51cbd5b8362d1505fcc"
-}

nym-node-status-api/.sqlx/query-d8ea93e781666e6267902170709ee2aa37f6163525bbdce1a4cebef4a285f8d9.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "INSERT INTO gateways\n                (gateway_identity_key, bonded, blacklisted,\n                    self_described, explorer_pretty_bond,\n                    last_updated_utc, performance)\n                VALUES (?, ?, ?, ?, ?, ?, ?)\n                ON CONFLICT(gateway_identity_key) DO UPDATE SET\n                bonded=excluded.bonded,\n                blacklisted=excluded.blacklisted,\n                self_described=excluded.self_described,\n                explorer_pretty_bond=excluded.explorer_pretty_bond,\n                last_updated_utc=excluded.last_updated_utc,\n                performance = excluded.performance;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 7
-    },
-    "nullable": []
-  },
-  "hash": "d8ea93e781666e6267902170709ee2aa37f6163525bbdce1a4cebef4a285f8d9"
-}