Split daily stats queries

.github/workflows/ci-build-upload-binaries.yml

@@ -38,14 +38,15 @@ jobs:
           rm -rf ci-builds || true
           mkdir -p $OUTPUT_DIR
           echo $OUTPUT_DIR
+
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get -y install libudev-dev
 
       - name: Sets env vars for tokio if set in manual dispatch inputs
-        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true
         run: |
-          echo "RUSTFLAGS=--cfg tokio_unstable" >> $GITHUB_ENV
-          echo "CARGO_FEATURES=--features tokio-console" >> $GITHUB_ENV
+          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
+        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true
+
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
@@ -102,6 +103,7 @@ jobs:
           if [ ${{ github.event_name == 'workflow_dispatch' && inputs.enable_deb == true }} = true ]; then
             cp target/debian/*.deb $OUTPUT_DIR
           fi
+
       - name: Deploy branch to CI www
         continue-on-error: true
         uses: easingthemes/ssh-deploy@main

.github/workflows/ci-build.yml

@@ -38,7 +38,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ arc-linux-latest, custom-windows-11, custom-macos-15 ]
+        os: [ arc-ubuntu-22.04, custom-windows-11, custom-macos-15 ]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
@@ -46,9 +46,9 @@ jobs:
       RUSTUP_PERMIT_COPY_RENAME: 1
     steps:
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler cmake
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
         continue-on-error: true
-        if: contains(matrix.os, 'linux')
+        if: contains(matrix.os, 'ubuntu')
 
       - name: Check out repository code
         uses: actions/checkout@v4
@@ -63,7 +63,7 @@ jobs:
 
       # To avoid running out of disk space, skip generating debug symbols
       - name: Set debug to false (unix)
-        if: contains(matrix.os, 'linux') || contains(matrix.os, 'mac')
+        if: contains(matrix.os, 'ubuntu') || contains(matrix.os, 'mac')
         run: |
           sed -i.bak 's/\[profile.dev\]/\[profile.dev\]\ndebug = false/' Cargo.toml
           git diff
@@ -93,14 +93,14 @@ jobs:
           command: build
 
       - name: Build all examples
-        if: contains(matrix.os, 'linux')
+        if: contains(matrix.os, 'ubuntu')
         uses: actions-rs/cargo@v1
         with:
           command: build
           args: --workspace --examples
 
       - name: Run all tests
-        if: contains(matrix.os, 'linux')
+        if: contains(matrix.os, 'ubuntu')
         uses: actions-rs/cargo@v1
         env:
           NYM_API: https://sandbox-nym-api1.nymtech.net/api
@@ -109,7 +109,7 @@ jobs:
           args: --workspace
 
       - name: Run expensive tests
-        if: (github.ref == 'refs/heads/develop' || github.event.pull_request.base.ref == 'develop' || github.event.pull_request.base.ref == 'master') && contains(matrix.os, 'linux')
+        if: (github.ref == 'refs/heads/develop' || github.event.pull_request.base.ref == 'develop' || github.event.pull_request.base.ref == 'master') && contains(matrix.os, 'ubuntu')
         uses: actions-rs/cargo@v1
         with:
           command: test

.github/workflows/push-node-status-agent.yaml

@@ -40,8 +40,7 @@ jobs:
       - name: Get version from cargo.toml
         id: get_version
         run: |
-          VERSION=$(yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml)
-          echo "result=$VERSION" >> $GITHUB_OUTPUT
+          yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
 
       - name: cleanup-gateway-probe-ref
         id: cleanup_gateway_probe_ref
@@ -53,16 +52,13 @@ jobs:
       - name: Set GIT_TAG variable
         run: echo "GIT_TAG=${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}" >> $GITHUB_ENV
 
-      - name: Initialize RELEASE_TAG
-        run: echo "RELEASE_TAG=" >> $GITHUB_ENV
-      
-      - name: Set RELEASE_TAG for release
+      - name: Set RELEASE_TAG variable
         if: github.event.inputs.release_image == 'true'
         run: echo "RELEASE_TAG=golden-" >> $GITHUB_ENV
-      
+
       - name: Set IMAGE_NAME_AND_TAGS variable
         run: echo "IMAGE_NAME_AND_TAGS=${{ env.CONTAINER_NAME }}:${{ env.RELEASE_TAG }}${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}" >> $GITHUB_ENV
-        
+
       - name: New env vars
         run: echo "RELEASE_TAG='$RELEASE_TAG' GIT_TAG='$GIT_TAG' IMAGE_NAME_AND_TAGS='$IMAGE_NAME_AND_TAGS'"        
 

CHANGELOG.md

@@ -4,42 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
-## [2025.15-gruyere] (2025-08-20)
-
-- Migrate strum to 0.27.2 ([#5960])
-- WG exit policy scripts update ([#5921])
-- Make DNS Resolver fallback optional ([#5920])
-- nym-node debug command to reset providers db ([#5914])
-- basic zulip client for sending messages ([#5913])
-- chore: allow compatibility with 'CDLA-Permissive-2.0' ([#5910])
-- feat: ecash liveness check ([#5890])
-- Remove old free credential handle ([#5864])
-
-[#5960]: https://github.com/nymtech/nym/pull/5960
-[#5921]: https://github.com/nymtech/nym/pull/5921
-[#5920]: https://github.com/nymtech/nym/pull/5920
-[#5914]: https://github.com/nymtech/nym/pull/5914
-[#5913]: https://github.com/nymtech/nym/pull/5913
-[#5910]: https://github.com/nymtech/nym/pull/5910
-[#5890]: https://github.com/nymtech/nym/pull/5890
-[#5864]: https://github.com/nymtech/nym/pull/5864
-
-## [2025.14-feta] (2025-08-05)
-
-- chore: nym node tokio console ([#5909])
-- Feature/dkg snapshot epoch ([#5900])
-- Feature/dkg epoch dealers query ([#5899])
-- sqlx-pool-guard: allocate more memory on windows ([#5896])
-- Support mnemonic in the NS agent ([#5883])
-- Allow PG database backend ([#5880])
-
-[#5909]: https://github.com/nymtech/nym/pull/5909
-[#5900]: https://github.com/nymtech/nym/pull/5900
-[#5899]: https://github.com/nymtech/nym/pull/5899
-[#5896]: https://github.com/nymtech/nym/pull/5896
-[#5883]: https://github.com/nymtech/nym/pull/5883
-[#5880]: https://github.com/nymtech/nym/pull/5880
-
 ## [2025.13-emmental] (2025-07-22)
 
 - fix: don't allow mixnode running in exit mode ([#5898])

Cargo.toml

@@ -39,8 +39,7 @@ members = [
     "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/nym-performance-contract",
+    "common/cosmwasm-smart-contracts/multisig-contract", "common/cosmwasm-smart-contracts/nym-performance-contract",
     "common/cosmwasm-smart-contracts/nym-pool-contract",
     "common/cosmwasm-smart-contracts/vesting-contract",
     "common/credential-storage",
@@ -50,8 +49,6 @@ members = [
     "common/credentials-interface",
     "common/crypto",
     "common/dkg",
-    "common/ecash-signer-check",
-    "common/ecash-signer-check-types",
     "common/ecash-time",
     "common/execute",
     "common/exit-policy",
@@ -92,7 +89,7 @@ members = [
     "common/socks5/requests",
     "common/statistics",
     "common/store-cipher",
-    "common/task", "common/test-utils",
+    "common/task",
     "common/ticketbooks-merkle",
     "common/topology",
     "common/tun",
@@ -102,22 +99,15 @@ members = [
     "common/wasm/storage",
     "common/wasm/utils",
     "common/wireguard",
-    "common/wireguard-private-metadata/client",
-    "common/wireguard-private-metadata/server",
-    "common/wireguard-private-metadata/shared",
-    "common/wireguard-private-metadata/tests",
     "common/wireguard-types",
-    "common/zulip-client",
     "documentation/autodoc",
     "gateway",
     "nym-api",
     "nym-api/nym-api-requests",
-    "nym-authenticator-client",
     "nym-browser-extension/storage",
     "nym-credential-proxy/nym-credential-proxy",
     "nym-credential-proxy/nym-credential-proxy-requests",
     "nym-credential-proxy/vpn-api-lib-wasm",
-    "nym-ip-packet-client",
     "nym-network-monitor",
     "nym-node",
     "nym-node-status-api/nym-node-status-agent",
@@ -128,12 +118,12 @@ members = [
     "nym-outfox",
     "nym-statistics-api",
     "nym-validator-rewarder",
-    "nym-wg-gateway-client",
     "nyx-chain-watcher",
     "sdk/ffi/cpp",
     "sdk/ffi/go",
     "sdk/ffi/shared",
     "sdk/rust/nym-sdk",
+    "service-providers/authenticator",
     "service-providers/common",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
@@ -171,6 +161,7 @@ default-members = [
     "nym-statistics-api",
     "nym-validator-rewarder",
     "nyx-chain-watcher",
+    "service-providers/authenticator",
     "service-providers/ip-packet-router",
     "service-providers/network-requester",
     "tools/nymvisor",
@@ -185,7 +176,7 @@ homepage = "https://nymtech.net"
 documentation = "https://nymtech.net"
 edition = "2021"
 license = "Apache-2.0"
-rust-version = "1.81"
+rust-version = "1.80"
 readme = "README.md"
 
 [workspace.dependencies]
@@ -227,7 +218,7 @@ clap_complete_fig = "4.5"
 colored = "2.2"
 comfy-table = "7.1.4"
 console = "0.15.11"
-console-subscriber = "0.4.1"
+console-subscriber = "0.1.1"
 console_error_panic_hook = "0.1"
 const-str = "0.5.6"
 const_format = "0.2.34"
@@ -326,11 +317,11 @@ si-scale = "0.2.3"
 snow = "0.9.6"
 sphinx-packet = "=0.6.0"
 sqlx = "0.8.6"
-strum = "0.27.2"
-strum_macros = "0.27.2"
+strum = "0.26"
+strum_macros = "0.26"
 subtle-encoding = "0.5"
 syn = "1"
-sysinfo = "0.37.0"
+sysinfo = "0.33.0"
 tap = "1.0.1"
 tar = "0.4.44"
 tempfile = "3.20"
@@ -444,9 +435,6 @@ opt-level = 'z'
 # lto = true
 opt-level = 'z'
 
-[workspace.lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tokio_unstable)'] }
-
 [workspace.lints.clippy]
 unwrap_used = "deny"
 expect_used = "deny"

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.61"
+version = "1.1.59"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"

clients/native/src/client/mod.rs

@@ -111,7 +111,7 @@ impl SocketClient {
         let dkg_query_client = if self.config.base.client.disabled_credentials_mode {
             None
         } else {
-            Some(default_query_dkg_client_from_config(&self.config.base)?)
+            Some(default_query_dkg_client_from_config(&self.config.base))
         };
 
         let storage = self.initialise_storage().await?;

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.61"
+version = "1.1.59"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"

common/bandwidth-controller/src/utils.rs

@@ -13,7 +13,7 @@ use nym_credentials_interface::{
 };
 use nym_ecash_time::Date;
 use nym_validator_client::coconut::all_ecash_api_clients;
-use nym_validator_client::nym_api::{EpochId, NymApiClientExt};
+use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use nym_validator_client::EcashApiClient;
 use rand::prelude::SliceRandom;
@@ -207,7 +207,7 @@ where
     <St as Storage>::StorageError: Send + Sync + 'static,
 {
     if let Some(stored) = storage
-        .get_expiration_date_signatures(expiration_date, epoch_id)
+        .get_expiration_date_signatures(expiration_date)
         .await
         .map_err(BandwidthControllerError::credential_storage_error)?
     {
@@ -220,7 +220,7 @@ where
         ecash_apis,
         |api| async move {
             api.api_client
-                .global_expiration_date_signatures(Some(expiration_date), Some(epoch_id))
+                .global_expiration_date_signatures(Some(expiration_date))
                 .await
         },
         format!("aggregated coin index signatures for date {expiration_date}"),

common/client-core/Cargo.toml

@@ -13,7 +13,6 @@ async-trait = { workspace = true }
 base64 = { workspace = true }
 bs58 = { workspace = true }
 clap = { workspace = true, optional = true }
-cfg-if = { workspace = true }
 comfy-table = { workspace = true, optional = true }
 futures = { workspace = true }
 humantime = { workspace = true }
@@ -53,7 +52,6 @@ nym-client-core-config-types = { path = "./config-types", features = [
 nym-client-core-surb-storage = { path = "./surb-storage" }
 nym-client-core-gateways-storage = { path = "./gateways-storage" }
 nym-ecash-time = { path = "../ecash-time" }
-nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies]
 nym-mixnet-client = { path = "../client-libs/mixnet-client", default-features = false }
@@ -125,6 +123,3 @@ fs-surb-storage = ["nym-client-core-surb-storage/fs-surb-storage"]
 fs-gateways-storage = ["nym-client-core-gateways-storage/fs-gateways-storage"]
 wasm = ["nym-gateway-client/wasm"]
 metrics-server = []
-
-[lints]
-workspace = true

common/client-core/gateways-storage/Cargo.toml

@@ -3,7 +3,6 @@ name = "nym-client-core-gateways-storage"
 version = "0.1.0"
 edition = "2021"
 license.workspace = true
-rust-version.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -27,7 +26,6 @@ features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate", "time"]
 optional = true
 
 [build-dependencies]
-anyhow = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 sqlx = { workspace = true, features = [
     "runtime-tokio-rustls",

common/client-core/gateways-storage/build.rs

@@ -2,30 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #[tokio::main]
-async fn main() -> anyhow::Result<()> {
+async fn main() {
     #[cfg(feature = "fs-gateways-storage")]
     {
-        use anyhow::Context;
         use sqlx::{Connection, SqliteConnection};
         use std::env;
 
-        let out_dir = env::var("OUT_DIR")?;
+        let out_dir = env::var("OUT_DIR").unwrap();
         let database_path = format!("{out_dir}/gateways-storage-example.sqlite");
 
-        // remove the db file if it already existed from previous build
-        // in case it was from a different branch
-        if std::fs::exists(&database_path)? {
-            std::fs::remove_file(&database_path)?;
-        }
-
         let mut conn = SqliteConnection::connect(&format!("sqlite://{database_path}?mode=rwc"))
             .await
-            .context("Failed to create SQLx database connection")?;
+            .expect("Failed to create SQLx database connection");
 
         sqlx::migrate!("./fs_gateways_migrations")
             .run(&mut conn)
             .await
-            .context("Failed to perform SQLx migrations")?;
+            .expect("Failed to perform SQLx migrations");
 
         #[cfg(target_family = "unix")]
         println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
@@ -35,6 +28,4 @@ async fn main() -> anyhow::Result<()> {
         // not a valid windows path... but hey, it works...
         println!("cargo:rustc-env=DATABASE_URL=sqlite:///{}", &database_path);
     }
-
-    Ok(())
 }

common/client-core/src/cli_helpers/client_import_coin_index_signatures.rs

@@ -58,7 +58,6 @@ where
         Some(data) => data,
         None => {
             // SAFETY: one of those arguments must have been set
-            #[allow(clippy::unwrap_used)]
             fs::read(common_args.signatures_path.unwrap())?
         }
     };

common/client-core/src/cli_helpers/client_import_credential.rs

@@ -64,7 +64,6 @@ where
         Some(data) => data,
         None => {
             // SAFETY: one of those arguments must have been set
-            #[allow(clippy::unwrap_used)]
             fs::read(common_args.credential_path.unwrap())?
         }
     };

common/client-core/src/cli_helpers/client_import_expiration_date_signatures.rs

@@ -58,7 +58,6 @@ where
         Some(data) => data,
         None => {
             // SAFETY: one of those arguments must have been set
-            #[allow(clippy::unwrap_used)]
             fs::read(common_args.signatures_path.unwrap())?
         }
     };

common/client-core/src/cli_helpers/client_import_master_verification_key.rs

@@ -58,7 +58,6 @@ where
         Some(data) => data,
         None => {
             // SAFETY: one of those arguments must have been set
-            #[allow(clippy::unwrap_used)]
             fs::read(common_args.key_path.unwrap())?
         }
     };

common/client-core/src/client/base_client/mod.rs

@@ -57,7 +57,7 @@ use nym_task::{TaskClient, TaskHandle};
 use nym_topology::provider_trait::TopologyProvider;
 use nym_topology::HardcodedTopologyProvider;
 use nym_validator_client::nym_api::NymApiClientExt;
-use nym_validator_client::{nyxd::contract_traits::DkgQueryClient, UserAgent};
+use nym_validator_client::{nyxd::contract_traits::DkgQueryClient, NymApiClient, UserAgent};
 use rand::prelude::SliceRandom;
 use rand::rngs::OsRng;
 use rand::thread_rng;
@@ -135,11 +135,9 @@ pub enum ClientInputStatus {
 }
 
 impl ClientInputStatus {
-    #[allow(clippy::panic)]
     pub fn register_producer(&mut self) -> ClientInput {
         match std::mem::replace(self, ClientInputStatus::Connected) {
             ClientInputStatus::AwaitingProducer { client_input } => client_input,
-            // critical failure implying misuse of software
             ClientInputStatus::Connected => panic!("producer was already registered before"),
         }
     }
@@ -151,11 +149,9 @@ pub enum ClientOutputStatus {
 }
 
 impl ClientOutputStatus {
-    #[allow(clippy::panic)]
     pub fn register_consumer(&mut self) -> ClientOutput {
         match std::mem::replace(self, ClientOutputStatus::Connected) {
             ClientOutputStatus::AwaitingConsumer { client_output } => client_output,
-            // critical failure implying misuse of software
             ClientOutputStatus::Connected => panic!("consumer was already registered before"),
         }
     }
@@ -566,7 +562,7 @@ where
         custom_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
         config_topology: config::Topology,
         nym_api_urls: Vec<Url>,
-        nym_api_client: nym_http_api_client::Client,
+        nym_api_client: NymApiClient,
     ) -> Box<dyn TopologyProvider + Send + Sync> {
         // if no custom provider was ... provided ..., create one using nym-api
         custom_provider.unwrap_or_else(|| {
@@ -711,14 +707,11 @@ where
             })?;
 
         let store_clone = mem_store.clone();
-        spawn_future!(
-            async move {
-                persistent_storage
-                    .flush_on_shutdown(store_clone, shutdown)
-                    .await
-            },
-            "PersistentReplyStorage::flush_on_shutdown"
-        );
+        spawn_future(async move {
+            persistent_storage
+                .flush_on_shutdown(store_clone, shutdown)
+                .await
+        });
 
         Ok(mem_store)
     }
@@ -739,7 +732,7 @@ where
             let mut rng = OsRng;
             let keys = if let Some(derivation_material) = derivation_material {
                 ClientKeys::from_master_key(&mut rng, &derivation_material)
-                    .map_err(|_| ClientCoreError::HkdfDerivationError)?
+                    .map_err(|_| ClientCoreError::HkdfDerivationError {})?
             } else {
                 ClientKeys::generate_new(&mut rng)
             };
@@ -749,42 +742,21 @@ where
         setup_gateway(setup_method, key_store, details_store).await
     }
 
-    fn construct_nym_api_client(
-        config: &Config,
-        user_agent: Option<UserAgent>,
-    ) -> Result<nym_http_api_client::Client, ClientCoreError> {
+    fn construct_nym_api_client(config: &Config, user_agent: Option<UserAgent>) -> NymApiClient {
         let mut nym_api_urls = config.get_nym_api_endpoints();
         nym_api_urls.shuffle(&mut thread_rng());
 
-        let mut builder = nym_http_api_client::Client::builder::<
-            _,
-            nym_validator_client::models::RequestError,
-        >(nym_api_urls[0].clone())
-        .map_err(|e| ClientCoreError::NymApiQueryFailure {
-            source: nym_validator_client::nym_api::error::NymAPIError::GenericRequestFailure(
-                e.to_string(),
-            ),
-        })?;
-
         if let Some(user_agent) = user_agent {
-            builder = builder.with_user_agent(user_agent);
+            NymApiClient::new_with_user_agent(nym_api_urls[0].clone(), user_agent)
+        } else {
+            NymApiClient::new(nym_api_urls[0].clone())
         }
-
-        builder = builder.with_bincode();
-
-        builder
-            .build::<nym_validator_client::models::RequestError>()
-            .map_err(|e| ClientCoreError::NymApiQueryFailure {
-                source: nym_validator_client::nym_api::error::NymAPIError::GenericRequestFailure(
-                    e.to_string(),
-                ),
-            })
     }
 
     async fn determine_key_rotation_state(
-        client: &nym_http_api_client::Client,
+        client: &NymApiClient,
     ) -> Result<KeyRotationConfig, ClientCoreError> {
-        Ok(client.get_key_rotation_info().await?.into())
+        Ok(client.nym_api.get_key_rotation_info().await?.into())
     }
 
     pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
@@ -851,7 +823,7 @@ where
             .dkg_query_client
             .map(|client| BandwidthController::new(credential_store, client));
 
-        let nym_api_client = Self::construct_nym_api_client(&self.config, self.user_agent.clone())?;
+        let nym_api_client = Self::construct_nym_api_client(&self.config, self.user_agent.clone());
         let key_rotation_config = Self::determine_key_rotation_state(&nym_api_client).await?;
 
         let topology_provider = Self::setup_topology_provider(

common/client-core/src/client/base_client/non_wasm_helpers.rs

@@ -114,32 +114,41 @@ pub async fn setup_fs_gateways_storage<P: AsRef<Path>>(
         })
 }
 
-pub fn create_bandwidth_controller_with_urls<St: CredentialStorage>(
-    nyxd_url: Url,
-    storage: St,
-) -> Result<BandwidthController<QueryHttpRpcNyxdClient, St>, ClientCoreError> {
-    let client = default_query_dkg_client(nyxd_url)?;
-
-    Ok(BandwidthController::new(storage, client))
-}
-
-pub fn default_query_dkg_client_from_config(
+pub fn create_bandwidth_controller<St: CredentialStorage>(
     config: &Config,
-) -> Result<QueryHttpRpcNyxdClient, ClientCoreError> {
+    storage: St,
+) -> BandwidthController<QueryHttpRpcNyxdClient, St> {
     let nyxd_url = config
         .get_validator_endpoints()
         .pop()
-        .ok_or(ClientCoreError::RpcClientMissingUrl)?;
+        .expect("No nyxd validator endpoint provided");
+
+    create_bandwidth_controller_with_urls(nyxd_url, storage)
+}
+
+pub fn create_bandwidth_controller_with_urls<St: CredentialStorage>(
+    nyxd_url: Url,
+    storage: St,
+) -> BandwidthController<QueryHttpRpcNyxdClient, St> {
+    let client = default_query_dkg_client(nyxd_url);
+
+    BandwidthController::new(storage, client)
+}
+
+pub fn default_query_dkg_client_from_config(config: &Config) -> QueryHttpRpcNyxdClient {
+    let nyxd_url = config
+        .get_validator_endpoints()
+        .pop()
+        .expect("No nyxd validator endpoint provided");
 
     default_query_dkg_client(nyxd_url)
 }
 
-pub fn default_query_dkg_client(nyxd_url: Url) -> Result<QueryHttpRpcNyxdClient, ClientCoreError> {
+pub fn default_query_dkg_client(nyxd_url: Url) -> QueryHttpRpcNyxdClient {
     let details = nym_network_defaults::NymNetworkDetails::new_from_env();
     let client_config = nyxd::Config::try_from_nym_network_details(&details)
-        .map_err(|source| ClientCoreError::InvalidNetworkDetails { source })?;
+        .expect("failed to construct validator client config");
     // overwrite env configuration with config URLs
-
     QueryHttpRpcNyxdClient::connect(client_config, nyxd_url.as_str())
-        .map_err(|source| ClientCoreError::RpcClientCreationFailure { source })
+        .expect("Could not construct query client")
 }

common/client-core/src/client/cover_traffic_stream.rs

@@ -235,7 +235,6 @@ impl LoopCoverTrafficStream<OsRng> {
         tokio::task::yield_now().await;
     }
 
-    #[allow(clippy::panic)]
     pub fn start(mut self) {
         if self.cover_traffic.disable_loop_cover_traffic_stream {
             // we should have never got here in the first place - the task should have never been created to begin with
@@ -252,30 +251,27 @@ impl LoopCoverTrafficStream<OsRng> {
 
         let mut shutdown = self.task_client.fork("select");
 
-        spawn_future!(
-            async move {
-                debug!("Started LoopCoverTrafficStream with graceful shutdown support");
+        spawn_future(async move {
+            debug!("Started LoopCoverTrafficStream with graceful shutdown support");
 
-                while !shutdown.is_shutdown() {
-                    tokio::select! {
-                        biased;
-                        _ = shutdown.recv() => {
-                            tracing::trace!("LoopCoverTrafficStream: Received shutdown");
-                        }
-                        next = self.next() => {
-                            if next.is_some() {
-                                self.on_new_message().await;
-                            } else {
-                                tracing::trace!("LoopCoverTrafficStream: Stopping since channel closed");
-                                break;
-                            }
+            while !shutdown.is_shutdown() {
+                tokio::select! {
+                    biased;
+                    _ = shutdown.recv() => {
+                        tracing::trace!("LoopCoverTrafficStream: Received shutdown");
+                    }
+                    next = self.next() => {
+                        if next.is_some() {
+                            self.on_new_message().await;
+                        } else {
+                            tracing::trace!("LoopCoverTrafficStream: Stopping since channel closed");
+                            break;
                         }
                     }
                 }
-                shutdown.recv_timeout().await;
-                tracing::debug!("LoopCoverTrafficStream: Exiting");
-            },
-            "LoopCoverTrafficStream"
-        )
+            }
+            shutdown.recv_timeout().await;
+            tracing::debug!("LoopCoverTrafficStream: Exiting");
+        })
     }
 }

common/client-core/src/client/mix_traffic/mod.rs

@@ -96,93 +96,72 @@ impl MixTrafficController {
         mut mix_packets: Vec<MixPacket>,
     ) -> Result<(), ErasedGatewayError> {
         debug_assert!(!mix_packets.is_empty());
-        let send_future = if mix_packets.len() == 1 {
-            // SAFETY: we just checked we have one packet
-            #[allow(clippy::unwrap_used)]
+
+        let result = if mix_packets.len() == 1 {
             let mix_packet = mix_packets.pop().unwrap();
-            self.gateway_transceiver.send_mix_packet(mix_packet)
+            self.gateway_transceiver.send_mix_packet(mix_packet).await
         } else {
-            self.gateway_transceiver.batch_send_mix_packets(mix_packets)
+            self.gateway_transceiver
+                .batch_send_mix_packets(mix_packets)
+                .await
         };
 
-        tokio::select! {
-            biased;
-            _ = self.task_client.recv() => {
-                trace!("received shutdown while handling messages");
-                Ok(())
-            }
-            result = send_future => {
-                if result.is_err() {
-                    self.consecutive_gateway_failure_count += 1;
-                } else {
-                    trace!("We *might* have managed to forward sphinx packet(s) to the gateway!");
-                    self.consecutive_gateway_failure_count = 0;
-                }
-
-                result
-            }
+        if result.is_err() {
+            self.consecutive_gateway_failure_count += 1;
+        } else {
+            trace!("We *might* have managed to forward sphinx packet(s) to the gateway!");
+            self.consecutive_gateway_failure_count = 0;
         }
-    }
 
-    async fn on_client_request(&mut self, client_request: ClientRequest) {
-        tokio::select! {
-            biased;
-             _ = self.task_client.recv() => {
-                trace!("received shutdown while handling client request");
-            }
-            result = self.gateway_transceiver.send_client_request(client_request) => {
-                if let Err(err) = result {
-                    error!("Failed to send client request: {err}")
-                }
-            }
-        }
+        result
     }
 
     pub fn start(mut self) {
-        spawn_future!(
-            async move {
-                debug!("Started MixTrafficController with graceful shutdown support");
-                while !self.task_client.is_shutdown() {
-                    tokio::select! {
-                        biased;
-                        _ = self.task_client.recv() => {
-                            tracing::trace!("MixTrafficController: Received shutdown");
+        spawn_future(async move {
+            debug!("Started MixTrafficController with graceful shutdown support");
+
+            while !self.task_client.is_shutdown() {
+                tokio::select! {
+                    mix_packets = self.mix_rx.recv() => match mix_packets {
+                        Some(mix_packets) => {
+                            if let Err(err) = self.on_messages(mix_packets).await {
+                                error!("Failed to send sphinx packet(s) to the gateway: {err}");
+                                if self.consecutive_gateway_failure_count == MAX_FAILURE_COUNT {
+                                    // Disconnect from the gateway. If we should try to re-connect
+                                    // is handled at a higher layer.
+                                    error!("Failed to send sphinx packet to the gateway {MAX_FAILURE_COUNT} times in a row - assuming the gateway is dead");
+                                    // Do we need to handle the embedded mixnet client case
+                                    // separately?
+                                    self.task_client.send_we_stopped(Box::new(ClientCoreError::GatewayFailedToForwardMessages));
+                                    break;
+                                }
+                            }
+                        },
+                        None => {
+                            tracing::trace!("MixTrafficController: Stopping since channel closed");
                             break;
                         }
-                        mix_packets = self.mix_rx.recv() => match mix_packets {
-                            Some(mix_packets) => {
-                                if let Err(err) = self.on_messages(mix_packets).await {
-                                    error!("Failed to send sphinx packet(s) to the gateway: {err}");
-                                    if self.consecutive_gateway_failure_count == MAX_FAILURE_COUNT {
-                                        // Disconnect from the gateway. If we should try to re-connect
-                                        // is handled at a higher layer.
-                                        error!("Failed to send sphinx packet to the gateway {MAX_FAILURE_COUNT} times in a row - assuming the gateway is dead");
-                                        // Do we need to handle the embedded mixnet client case
-                                        // separately?
-                                        self.task_client.send_we_stopped(Box::new(ClientCoreError::GatewayFailedToForwardMessages));
-                                        break;
-                                    }
-                                }
-                            },
-                            None => {
-                                tracing::trace!("MixTrafficController: Stopping since channel closed");
-                                break;
-                            }
-                        },
-                        client_request = self.client_rx.recv() => match client_request {
-                            Some(client_request) => {
-                                self.on_client_request(client_request).await;
-                            },
-                            None => {
-                                tracing::trace!("MixTrafficController, client request channel closed");
-                            }
+                    },
+                    client_request = self.client_rx.recv() => match client_request {
+                        Some(client_request) => {
+                            match self.gateway_transceiver.send_client_request(client_request).await {
+                                Ok(_) => (),
+                                Err(e) => error!("Failed to send client request: {e}"),
+                            };
                         },
+                        None => {
+                            tracing::trace!("MixTrafficController, client request channel closed");
+                        }
+                    },
+                    _ = self.task_client.recv() => {
+                        tracing::trace!("MixTrafficController: Received shutdown");
+                        break;
                     }
                 }
-                self.task_client.recv_timeout().await;
-                tracing::debug!("MixTrafficController: Exiting");
-            },
-            "MixTrafficController"
-        );
+            }
+            self.task_client.recv_timeout().await;
+
+            tracing::debug!("MixTrafficController: Exiting");
+        });
     }
 }

common/client-core/src/client/mix_traffic/transceiver.rs

@@ -269,8 +269,6 @@ pub struct MockGateway {
 }
 
 impl Default for MockGateway {
-    // test code
-    #[allow(clippy::unwrap_used)]
     fn default() -> Self {
         MockGateway {
             dummy_identity: "3ebjp1Fb9hdcS1AR6AZihgeJiMHkB5jjJUsvqNnfQwU7"

common/client-core/src/client/real_messages_control/acknowledgement_control/action_controller.rs

@@ -194,11 +194,10 @@ impl ActionController {
         trace!("{frag_id} is updating its delay");
         // TODO: is it possible to solve this without either locking or temporarily removing the value?
         if let Some((pending_ack_data, queue_key)) = self.pending_acks_data.remove(&frag_id) {
-            // SAFETY: this Action is triggered by `RetransmissionRequestListener` (for 'normal' packets)
+            // this Action is triggered by `RetransmissionRequestListener` (for 'normal' packets)
             // or `ReplyController` (for 'reply' packets) which held the other potential
             // reference to this Arc. HOWEVER, before the Action was pushed onto the queue, the reference
             // was dropped hence this unwrap is safe.
-            #[allow(clippy::unwrap_used)]
             let mut inner_data = Arc::try_unwrap(pending_ack_data).unwrap();
             inner_data.update_retransmitted(delay);
 
@@ -210,7 +209,6 @@ impl ActionController {
     }
 
     // note: when the entry expires it's automatically removed from pending_acks_timers
-    #[allow(clippy::panic)]
     fn handle_expired_ack_timer(&mut self, expired_ack: Expired<FragmentIdentifier>) {
         let frag_id = expired_ack.into_inner();
 

common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -120,7 +120,6 @@ where
         }
     }
 
-    #[allow(clippy::panic)]
     async fn on_input_message(&mut self, msg: InputMessage) {
         match msg {
             InputMessage::Regular {
@@ -214,9 +213,7 @@ where
                     self.handle_premade_packets(msgs, lane).await
                 }
                 // MessageWrappers can't be nested
-                InputMessage::MessageWrapper { .. } => {
-                    panic!("attempted to use nested MessageWrapper")
-                }
+                InputMessage::MessageWrapper { .. } => unimplemented!(),
             },
         };
     }
@@ -226,11 +223,6 @@ where
 
         while !self.task_client.is_shutdown() {
             tokio::select! {
-                biased;
-                _ = self.task_client.recv() => {
-                    tracing::trace!("InputMessageListener: Received shutdown");
-                    break;
-                }
                 input_msg = self.input_receiver.recv() => match input_msg {
                     Some(input_msg) => {
                         self.on_input_message(input_msg).await;
@@ -240,7 +232,9 @@ where
                         break;
                     }
                 },
-
+                _ = self.task_client.recv() => {
+                    tracing::trace!("InputMessageListener: Received shutdown");
+                }
             }
         }
         self.task_client.recv_timeout().await;

common/client-core/src/client/real_messages_control/acknowledgement_control/mod.rs

@@ -298,44 +298,29 @@ where
         let mut sent_notification_listener = self.sent_notification_listener;
         let mut action_controller = self.action_controller;
 
-        spawn_future!(
-            async move {
-                acknowledgement_listener.run().await;
-                debug!("The acknowledgement listener has finished execution!");
-            },
-            "AcknowledgementController::AcknowledgementListener"
-        );
+        spawn_future(async move {
+            acknowledgement_listener.run().await;
+            debug!("The acknowledgement listener has finished execution!");
+        });
 
-        spawn_future!(
-            async move {
-                input_message_listener.run().await;
-                debug!("The input listener has finished execution!");
-            },
-            "AcknowledgementController::InputMessageListener"
-        );
+        spawn_future(async move {
+            input_message_listener.run().await;
+            debug!("The input listener has finished execution!");
+        });
 
-        spawn_future!(
-            async move {
-                retransmission_request_listener.run(packet_type).await;
-                debug!("The retransmission request listener has finished execution!");
-            },
-            "AcknowledgementController::RetransmissionRequestListener"
-        );
+        spawn_future(async move {
+            retransmission_request_listener.run(packet_type).await;
+            debug!("The retransmission request listener has finished execution!");
+        });
 
-        spawn_future!(
-            async move {
-                sent_notification_listener.run().await;
-                debug!("The sent notification listener has finished execution!");
-            },
-            "AcknowledgementController::SentNotificationListener"
-        );
+        spawn_future(async move {
+            sent_notification_listener.run().await;
+            debug!("The sent notification listener has finished execution!");
+        });
 
-        spawn_future!(
-            async move {
-                action_controller.run().await;
-                debug!("The controller has finished execution!");
-            },
-            "AcknowledgementController::ActionController"
-        );
+        spawn_future(async move {
+            action_controller.run().await;
+            debug!("The controller has finished execution!");
+        });
     }
 }

common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs

@@ -179,11 +179,6 @@ where
 
         while !self.task_client.is_shutdown() {
             tokio::select! {
-                biased;
-                 _ = self.task_client.recv() => {
-                    tracing::trace!("RetransmissionRequestListener: Received shutdown");
-                    break;
-                }
                 timed_out_ack = self.request_receiver.next() => match timed_out_ack {
                     Some(timed_out_ack) => self.on_retransmission_request(timed_out_ack, packet_type).await,
                     None => {
@@ -191,7 +186,9 @@ where
                         break;
                     }
                 },
-
+                _ = self.task_client.recv() => {
+                    tracing::trace!("RetransmissionRequestListener: Received shutdown");
+                }
             }
         }
         self.task_client.recv_timeout().await;

common/client-core/src/client/real_messages_control/message_handler.rs

@@ -35,9 +35,6 @@ pub enum PreparationError {
     #[error(transparent)]
     NymTopologyError(#[from] NymTopologyError),
 
-    #[error("message wasn't split into any fragments!")]
-    EmptyFragments,
-
     #[error("message too long for a single SURB, splitting into {fragments} fragments.")]
     MessageTooLongForSingleSurb { fragments: usize },
 
@@ -323,16 +320,6 @@ where
             });
         }
 
-        if fragment.is_empty() {
-            error!("CRITICAL FAILURE: our split message didn't result in any sendable fragments");
-            return Err(SurbWrappedPreparationError {
-                source: PreparationError::EmptyFragments,
-                returned_surbs: Some(vec![reply_surb]),
-            });
-        }
-
-        // SAFETY: we just checked we have one fragment
-        #[allow(clippy::unwrap_used)]
         let chunk = fragment.pop().unwrap();
         let chunk_clone = chunk.clone();
         let prepared_fragment = self
@@ -548,7 +535,6 @@ where
             pending_acks.push(pending_ack);
         }
 
-        drop(topology_permit);
         self.insert_pending_acks(pending_acks);
         self.forward_messages(real_messages, lane).await;
 
@@ -671,7 +657,6 @@ where
             .zip(reply_surbs.into_iter())
             .map(|(fragment, reply_surb)| {
                 // unwrap here is fine as we know we have a valid topology
-                #[allow(clippy::unwrap_used)]
                 self.message_preparer
                     .prepare_reply_chunk_for_sending(
                         fragment,
@@ -731,21 +716,17 @@ where
 
     // tells real message sender (with the poisson timer) to send this to the mix network
     pub(crate) async fn forward_messages(
-        &mut self,
+        &self,
         messages: Vec<RealMessage>,
         transmission_lane: TransmissionLane,
     ) {
-        tokio::select! {
-            biased;
-            _ = self.task_client.recv() => {
-                trace!("received shutdown while attempting to forward mixnet messages");
-            }
-            sending_res = self.real_message_sender.send((messages, transmission_lane)) => {
-                if sending_res.is_err() {
-                    error!(
-                        "failed to forward mixnet messages due to closed channel (outside of shutdown!)"
-                    );
-                }
+        if let Err(err) = self
+            .real_message_sender
+            .send((messages, transmission_lane))
+            .await
+        {
+            if !self.task_client.is_shutdown_poll() {
+                error!("Failed to forward messages to the real message sender: {err}");
             }
         }
     }

common/client-core/src/client/real_messages_control/mod.rs

@@ -224,20 +224,14 @@ impl RealMessagesController<OsRng> {
         let ack_control = self.ack_control;
         let mut reply_control = self.reply_control;
 
-        spawn_future!(
-            async move {
-                out_queue_control.run().await;
-                debug!("The out queue controller has finished execution!");
-            },
-            "RealMessagesController::OutQueueControl)"
-        );
-        spawn_future!(
-            async move {
-                reply_control.run().await;
-                debug!("The reply controller has finished execution!");
-            },
-            "RealMessagesController::ReplyController"
-        );
+        spawn_future(async move {
+            out_queue_control.run().await;
+            debug!("The out queue controller has finished execution!");
+        });
+        spawn_future(async move {
+            reply_control.run().await;
+            debug!("The reply controller has finished execution!");
+        });
 
         ack_control.start(packet_type);
     }

common/client-core/src/client/real_messages_control/real_traffic_stream.rs

@@ -249,8 +249,6 @@ where
                     }
                 };
 
-                // SAFETY: our topology must be valid at this point
-                #[allow(clippy::expect_used)]
                 (
                     generate_loop_cover_packet(
                         &mut self.rng,
@@ -280,33 +278,17 @@ where
             }
         };
 
-        let sending_res = tokio::select! {
-            biased;
-            _ = self.task_client.recv() => {
-                trace!("received shutdown signal while attempting to send mix message");
-                return
-            }
-            sending_res = self.mix_tx.send(vec![next_message]) => {
-                sending_res
-            }
-        };
-
-        match sending_res {
-            Err(_) => {
-                if !self.task_client.is_shutdown_poll() {
-                    tracing::error!(
-                        "failed to send mixnet packet due to closed channel (outside of shutdown!)"
-                    );
-                }
-            }
-            Ok(_) => {
-                let event = if fragment_id.is_some() {
-                    PacketStatisticsEvent::RealPacketSent(packet_size)
-                } else {
-                    PacketStatisticsEvent::CoverPacketSent(packet_size)
-                };
-                self.stats_tx.report(event.into());
+        if let Err(err) = self.mix_tx.send(vec![next_message]).await {
+            if !self.task_client.is_shutdown_poll() {
+                tracing::error!("Failed to send: {err}");
             }
+        } else {
+            let event = if fragment_id.is_some() {
+                PacketStatisticsEvent::RealPacketSent(packet_size)
+            } else {
+                PacketStatisticsEvent::CoverPacketSent(packet_size)
+            };
+            self.stats_tx.report(event.into());
         }
 
         // notify ack controller about sending our message only after we actually managed to push it
@@ -457,8 +439,6 @@ where
                     tracing::trace!("handling real_messages: size: {}", real_messages.len());
 
                     self.transmission_buffer.store(&conn_id, real_messages);
-                    // SAFETY: we just stored the message
-                    #[allow(clippy::expect_used)]
                     let real_next = self.pop_next_message().expect("Just stored one");
 
                     Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))
@@ -507,8 +487,6 @@ where
 
                 // First store what we got for the given connection id
                 self.transmission_buffer.store(&conn_id, real_messages);
-                // SAFETY: we just stored the message
-                #[allow(clippy::expect_used)]
                 let real_next = self.pop_next_message().expect("we just added one");
 
                 Poll::Ready(Some(StreamMessage::Real(Box::new(real_next))))

common/client-core/src/client/received_buffer.rs

@@ -198,7 +198,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
         }
     }
 
-    #[allow(clippy::panic)]
     async fn disconnect_sender(&mut self) {
         let mut guard = self.inner.lock().await;
         if guard.message_sender.is_none() {
@@ -209,7 +208,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
         guard.message_sender = None;
     }
 
-    #[allow(clippy::panic)]
     async fn connect_sender(&mut self, sender: ReconstructedMessagesSender) {
         let mut guard = self.inner.lock().await;
         if guard.message_sender.is_some() {
@@ -601,20 +599,14 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll
         let mut fragmented_message_receiver = self.fragmented_message_receiver;
         let mut request_receiver = self.request_receiver;
 
-        spawn_future!(
-            async move {
-                match fragmented_message_receiver.run().await {
-                    Ok(_) => {}
-                    Err(e) => error!("{e}"),
-                }
-            },
-            "ReceivedMessagesBufferController::FragmentedMessageReceiver"
-        );
-        spawn_future!(
-            async move {
-                request_receiver.run().await;
-            },
-            "ReceivedMessagesBufferController::RequestReceiver"
-        );
+        spawn_future(async move {
+            match fragmented_message_receiver.run().await {
+                Ok(_) => {}
+                Err(e) => error!("{e}"),
+            }
+        });
+        spawn_future(async move {
+            request_receiver.run().await;
+        });
     }
 }

common/client-core/src/client/replies/reply_controller/receiver_controller.rs

@@ -155,9 +155,8 @@ where
         data: Vec<Arc<PendingAcknowledgement>>,
     ) {
         trace!("re-inserting pending retransmissions for {recipient}");
-        // SAFETY: the underlying entry MUST exist as we've just got data from there
+        // the underlying entry MUST exist as we've just got data from there
         // and we hold a mut reference
-        #[allow(clippy::expect_used)]
         let map_entry = &mut self
             .surb_senders
             .get_mut(recipient)
@@ -430,7 +429,6 @@ where
             .pop_at_most_n_next_messages_at_random(amount)
     }
 
-    #[allow(clippy::panic)]
     async fn try_clear_pending_queue(&mut self, target: AnonymousSenderTag) {
         trace!("trying to clear pending queue");
         let available_surbs = self.surbs_storage.available_surbs(&target);

common/client-core/src/client/statistics_control.rs

@@ -165,12 +165,9 @@ impl StatisticsControl {
     }
 
     pub(crate) fn start(mut self) {
-        spawn_future!(
-            async move {
-                self.run().await;
-            },
-            "StatisticsControl"
-        )
+        spawn_future(async move {
+            self.run().await;
+        })
     }
 
     pub(crate) fn create_and_start(

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

@@ -126,7 +126,7 @@ impl TopologyAccessor {
             .map(|p| p.topology.clone())
     }
 
-    pub async fn current_route_provider(&self) -> Option<RwLockReadGuard<'_, NymRouteProvider>> {
+    pub async fn current_route_provider(&self) -> Option<RwLockReadGuard<NymRouteProvider>> {
         let provider = self.inner.topology.read().await;
         if provider.topology.is_empty() {
             None

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

@@ -145,39 +145,36 @@ impl TopologyRefresher {
     }
 
     pub fn start(mut self) {
-        spawn_future!(
-            async move {
-                debug!("Started TopologyRefresher with graceful shutdown support");
+        spawn_future(async move {
+            debug!("Started TopologyRefresher with graceful shutdown support");
 
-                #[cfg(not(target_arch = "wasm32"))]
-                let mut interval = tokio_stream::wrappers::IntervalStream::new(
-                    tokio::time::interval(self.refresh_rate),
-                );
+            #[cfg(not(target_arch = "wasm32"))]
+            let mut interval = tokio_stream::wrappers::IntervalStream::new(tokio::time::interval(
+                self.refresh_rate,
+            ));
 
-                #[cfg(target_arch = "wasm32")]
-                let mut interval =
-                    gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
+            #[cfg(target_arch = "wasm32")]
+            let mut interval =
+                gloo_timers::future::IntervalStream::new(self.refresh_rate.as_millis() as u32);
 
-                // We already have an initial topology, so no need to refresh it immediately.
-                // My understanding is that js setInterval does not fire immediately, so it's not
-                // needed there.
-                #[cfg(not(target_arch = "wasm32"))]
-                interval.next().await;
+            // We already have an initial topology, so no need to refresh it immediately.
+            // My understanding is that js setInterval does not fire immediately, so it's not
+            // needed there.
+            #[cfg(not(target_arch = "wasm32"))]
+            interval.next().await;
 
-                while !self.task_client.is_shutdown() {
-                    tokio::select! {
-                        _ = interval.next() => {
-                            self.try_refresh().await;
-                        },
-                        _ = self.task_client.recv() => {
-                            tracing::trace!("TopologyRefresher: Received shutdown");
-                        },
-                    }
+            while !self.task_client.is_shutdown() {
+                tokio::select! {
+                    _ = interval.next() => {
+                        self.try_refresh().await;
+                    },
+                    _ = self.task_client.recv() => {
+                        tracing::trace!("TopologyRefresher: Received shutdown");
+                    },
                 }
-                self.task_client.recv_timeout().await;
-                tracing::debug!("TopologyRefresher: Exiting");
-            },
-            "TopologyRefresher"
-        )
+            }
+            self.task_client.recv_timeout().await;
+            tracing::debug!("TopologyRefresher: Exiting");
+        })
     }
 }

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

@@ -2,10 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use async_trait::async_trait;
-use nym_mixnet_contract_common::EpochRewardedSet;
 use nym_topology::provider_trait::{ToTopologyMetadata, TopologyProvider};
 use nym_topology::NymTopology;
-use nym_validator_client::nym_api::NymApiClientExt;
 use rand::prelude::SliceRandom;
 use rand::thread_rng;
 use std::cmp::min;
@@ -41,43 +39,30 @@ impl Config {
 pub struct NymApiTopologyProvider {
     config: Config,
 
-    validator_client: nym_http_api_client::Client,
+    validator_client: nym_validator_client::client::NymApiClient,
     nym_api_urls: Vec<Url>,
     currently_used_api: usize,
-    use_bincode: bool,
 }
 
 impl NymApiTopologyProvider {
     pub fn new(
         config: impl Into<Config>,
         mut nym_api_urls: Vec<Url>,
-        validator_client: nym_http_api_client::Client,
+        mut validator_client: nym_validator_client::client::NymApiClient,
     ) -> Self {
         nym_api_urls.shuffle(&mut thread_rng());
-        let mut provider = NymApiTopologyProvider {
+        validator_client.change_nym_api(nym_api_urls[0].clone());
+
+        NymApiTopologyProvider {
             config: config.into(),
             validator_client,
             nym_api_urls,
             currently_used_api: 0,
-            use_bincode: true,
-        };
-        // Set all API URLs - the client will try them in order with automatic failover
-        provider.validator_client.change_base_urls(
-            provider
-                .nym_api_urls
-                .iter()
-                .map(|u| u.clone().into())
-                .collect(),
-        );
-        provider
+        }
     }
 
     pub fn disable_bincode(&mut self) {
-        self.use_bincode = false;
-        // Note: The unified client doesn't support toggling bincode after creation.
-        // This would require recreating the client without bincode.
-        // For now, we'll track the preference but it won't take effect.
-        warn!("Disabling bincode on existing client is not currently supported");
+        self.validator_client.use_bincode = false;
     }
 
     fn use_next_nym_api(&mut self) {
@@ -87,19 +72,8 @@ impl NymApiTopologyProvider {
         }
 
         self.currently_used_api = (self.currently_used_api + 1) % self.nym_api_urls.len();
-
-        // Provide all URLs starting from the next one in rotation order
-        // This enables automatic failover to other endpoints
-        let rotated_urls: Vec<_> = self
-            .nym_api_urls
-            .iter()
-            .cycle()
-            .skip(self.currently_used_api)
-            .take(self.nym_api_urls.len())
-            .map(|u| u.clone().into())
-            .collect();
-
-        self.validator_client.change_base_urls(rotated_urls)
+        self.validator_client
+            .change_nym_api(self.nym_api_urls[self.currently_used_api].clone())
     }
 
     async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
@@ -125,13 +99,8 @@ impl NymApiTopologyProvider {
                 .filter(|n| n.performance.round_to_integer() >= self.config.min_node_performance())
                 .collect::<Vec<_>>();
 
-            let epoch_rewarded_set: EpochRewardedSet = rewarded_set.into();
-            NymTopology::new(
-                metadata.to_topology_metadata(),
-                epoch_rewarded_set,
-                Vec::new(),
-            )
-            .with_skimmed_nodes(&nodes_filtered)
+            NymTopology::new(metadata.to_topology_metadata(), rewarded_set, Vec::new())
+                .with_skimmed_nodes(&nodes_filtered)
         } else {
             // if we're not using extended topology, we're only getting active set mixnodes and gateways
 
@@ -179,13 +148,8 @@ impl NymApiTopologyProvider {
                 }
             }
 
-            let epoch_rewarded_set: EpochRewardedSet = rewarded_set.into();
-            NymTopology::new(
-                metadata.to_topology_metadata(),
-                epoch_rewarded_set,
-                Vec::new(),
-            )
-            .with_skimmed_nodes(&nodes)
+            NymTopology::new(metadata.to_topology_metadata(), rewarded_set, Vec::new())
+                .with_skimmed_nodes(&nodes)
         };
 
         if !topology.is_minimally_routable() {

common/client-core/src/error.rs

@@ -7,9 +7,7 @@ use nym_gateway_client::error::GatewayClientError;
 use nym_topology::node::RoutingNodeError;
 use nym_topology::{NodeId, NymTopologyError};
 use nym_validator_client::nym_api::error::NymAPIError;
-use nym_validator_client::nyxd::error::NyxdError;
 use nym_validator_client::ValidatorClientError;
-use rand::distributions::WeightedError;
 use std::error::Error;
 use std::path::PathBuf;
 
@@ -232,19 +230,7 @@ pub enum ClientCoreError {
     UnexpectedKeyUpgrade { gateway_id: String },
 
     #[error("failed to derive keys from master key")]
-    HkdfDerivationError,
-
-    #[error("missing url for constructing RPC client")]
-    RpcClientMissingUrl,
-
-    #[error("provided nym network details were malformed: {source}")]
-    InvalidNetworkDetails { source: NyxdError },
-
-    #[error("failed to construct RPC client: {source}")]
-    RpcClientCreationFailure { source: NyxdError },
-
-    #[error("failed to select valid gateway due to incomputable latency")]
-    GatewaySelectionFailure { source: WeightedError },
+    HkdfDerivationError {},
 }
 
 impl From<tungstenite::Error> for ClientCoreError {

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

@@ -7,8 +7,7 @@ use futures::{SinkExt, StreamExt};
 use nym_crypto::asymmetric::ed25519;
 use nym_gateway_client::GatewayClient;
 use nym_topology::node::RoutingNode;
-use nym_validator_client::client::{IdentityKeyRef, NymApiClientExt};
-use nym_validator_client::nym_nodes::SkimmedNodesWithMetadata;
+use nym_validator_client::client::IdentityKeyRef;
 use nym_validator_client::UserAgent;
 use rand::{seq::SliceRandom, Rng};
 #[cfg(unix)]
@@ -84,48 +83,6 @@ struct GatewayWithLatency<'a, G: ConnectableGateway> {
     latency: Duration,
 }
 
-// Helper to collect all pages of entry nodes - replicates NymApiClient's convenience method
-async fn get_all_basic_entry_nodes_with_metadata(
-    client: &nym_http_api_client::Client,
-    use_bincode: bool,
-) -> Result<SkimmedNodesWithMetadata, ClientCoreError> {
-    // Get first page to obtain metadata
-    let mut page = 0;
-    let res = client
-        .get_basic_entry_assigned_nodes_v2(false, Some(page), None, use_bincode)
-        .await?;
-    let mut nodes = res.nodes.data;
-    let metadata = res.metadata;
-
-    if res.nodes.pagination.total == nodes.len() {
-        return Ok(SkimmedNodesWithMetadata::new(nodes, metadata));
-    }
-
-    page += 1;
-
-    // Collect remaining pages
-    loop {
-        let mut res = client
-            .get_basic_entry_assigned_nodes_v2(false, Some(page), None, use_bincode)
-            .await?;
-
-        if !metadata.consistency_check(&res.metadata) {
-            return Err(ClientCoreError::ValidatorClientError(
-                nym_validator_client::ValidatorClientError::InconsistentPagedMetadata,
-            ));
-        }
-
-        nodes.append(&mut res.nodes.data);
-        if nodes.len() < res.nodes.pagination.total {
-            page += 1
-        } else {
-            break;
-        }
-    }
-
-    Ok(SkimmedNodesWithMetadata::new(nodes, metadata))
-}
-
 impl<'a, G: ConnectableGateway> GatewayWithLatency<'a, G> {
     fn new(gateway: &'a G, latency: Duration) -> Self {
         GatewayWithLatency { gateway, latency }
@@ -142,32 +99,16 @@ pub async fn gateways_for_init<R: Rng>(
     let nym_api = nym_apis
         .choose(rng)
         .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
-
-    // Use the unified HTTP client directly with optional user agent
-    let mut builder = nym_http_api_client::Client::builder(nym_api.clone())
-        .map_err(|e| {
-            ClientCoreError::ValidatorClientError(
-                nym_validator_client::ValidatorClientError::NymAPIError { source: e },
-            )
-        })?
-        .with_bincode(); // Use bincode for better performance
-
-    if let Some(user_agent) = user_agent {
-        builder = builder.with_user_agent(user_agent);
-    }
-
-    let client = builder
-        .build::<nym_validator_client::models::RequestError>()
-        .map_err(|e| {
-            ClientCoreError::ValidatorClientError(
-                nym_validator_client::ValidatorClientError::NymAPIError { source: e },
-            )
-        })?;
+    let client = if let Some(user_agent) = user_agent {
+        nym_validator_client::client::NymApiClient::new_with_user_agent(nym_api.clone(), user_agent)
+    } else {
+        nym_validator_client::client::NymApiClient::new(nym_api.clone())
+    };
 
     tracing::debug!("Fetching list of gateways from: {nym_api}");
 
-    // Use our helper to handle pagination
-    let gateways = get_all_basic_entry_nodes_with_metadata(&client, true)
+    let gateways = client
+        .get_all_basic_entry_assigned_nodes_with_metadata()
         .await?
         .nodes;
     info!("nym api reports {} gateways", gateways.len());
@@ -207,7 +148,7 @@ async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
     JSWebsocket::new(endpoint).map_err(|_| ClientCoreError::GatewayJsConnectionFailure)
 }
 
-async fn measure_latency<G>(gateway: &G) -> Result<GatewayWithLatency<'_, G>, ClientCoreError>
+async fn measure_latency<G>(gateway: &G) -> Result<GatewayWithLatency<G>, ClientCoreError>
 where
     G: ConnectableGateway,
 {
@@ -304,7 +245,7 @@ pub async fn choose_gateway_by_latency<R: Rng, G: ConnectableGateway + Clone>(
     let gateways_with_latency = gateways_with_latency.lock().await;
     let chosen = gateways_with_latency
         .choose_weighted(rng, |item| 1. / item.latency.as_secs_f32())
-        .map_err(|source| ClientCoreError::GatewaySelectionFailure { source })?;
+        .expect("invalid selection weight!");
 
     info!(
         "chose gateway {} with average latency of {:?}",

common/client-core/src/lib.rs

@@ -18,54 +18,18 @@ pub use nym_topology::{
 };
 
 #[cfg(target_arch = "wasm32")]
-pub fn spawn_future<F>(future: F)
+pub(crate) fn spawn_future<F>(future: F)
 where
     F: Future<Output = ()> + 'static,
 {
     wasm_bindgen_futures::spawn_local(future);
 }
 
-// TODO: expose similar API to the rest of the codebase,
-// perhaps with some simple trait for a task to define its name
-
 #[cfg(not(target_arch = "wasm32"))]
-#[track_caller]
-pub fn spawn_future<F>(future: F)
+pub(crate) fn spawn_future<F>(future: F)
 where
     F: Future + Send + 'static,
     F::Output: Send + 'static,
 {
     tokio::spawn(future);
 }
-
-#[cfg(not(target_arch = "wasm32"))]
-#[track_caller]
-pub fn spawn_named_future<F>(future: F, name: &str)
-where
-    F: Future + Send + 'static,
-    F::Output: Send + 'static,
-{
-    cfg_if::cfg_if! {if #[cfg(tokio_unstable)] {
-        #[allow(clippy::expect_used)]
-        tokio::task::Builder::new().name(name).spawn(future).expect("failed to spawn future");
-    } else {
-        let _ = name;
-        tracing::debug!(r#"the underlying binary hasn't been built with `RUSTFLAGS="--cfg tokio_unstable"` - the future naming won't do anything"#);
-        spawn_future(future);
-    }}
-}
-
-#[macro_export]
-macro_rules! spawn_future {
-    ($future:expr) => {{
-        $crate::spawn_future($future)
-    }};
-    ($future:expr, $name:expr) => {{
-        cfg_if::cfg_if! {if #[cfg(not(target_arch = "wasm32"))] {
-            $crate::spawn_named_future($future, $name)
-        } else {
-            let _ = $name;
-            $crate::spawn_future($future)
-        }}
-    }};
-}

common/client-core/surb-storage/Cargo.toml

@@ -30,7 +30,6 @@ optional = true
 path = "../../../sqlx-pool-guard"
 
 [build-dependencies]
-anyhow = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 sqlx = { workspace = true, features = [
     "runtime-tokio-rustls",

common/client-core/surb-storage/build.rs

@@ -2,24 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #[tokio::main]
-async fn main() -> anyhow::Result<()> {
+async fn main() {
     #[cfg(feature = "fs-surb-storage")]
     {
-        use anyhow::Context;
         use sqlx::{Connection, SqliteConnection};
         use std::env;
 
-        let out_dir = env::var("OUT_DIR")?;
+        let out_dir = env::var("OUT_DIR").unwrap();
         let database_path = format!("{out_dir}/fs-surbs-example.sqlite");
 
         let mut conn = SqliteConnection::connect(&format!("sqlite://{database_path}?mode=rwc"))
             .await
-            .context("Failed to create SQLx database connection")?;
+            .expect("Failed to create SQLx database connection");
 
         sqlx::migrate!("./fs_surbs_migrations")
             .run(&mut conn)
             .await
-            .context("Failed to perform SQLx migrations")?;
+            .expect("Failed to perform SQLx migrations");
 
         #[cfg(target_family = "unix")]
         println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
@@ -29,6 +28,4 @@ async fn main() -> anyhow::Result<()> {
         // not a valid windows path... but hey, it works...
         println!("cargo:rustc-env=DATABASE_URL=sqlite:///{}", &database_path);
     }
-
-    Ok(())
 }

common/client-libs/gateway-client/src/client/mod.rs

@@ -201,7 +201,7 @@ impl<C, St> GatewayClient<C, St> {
     #[cfg(not(target_arch = "wasm32"))]
     pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
         debug!(
-            "Attempting to establish connection to gateway at: {}",
+            "Attemting to establish connection to gateway at: {}",
             self.gateway_address
         );
         let (ws_stream, _) = connect_async(

common/client-libs/gateway-client/src/socket_state.rs

@@ -337,7 +337,7 @@ impl PartiallyDelegatedHandle {
         // check if the split stream didn't error out
         let receive_res = stream_receiver
             .try_recv()
-            .map_err(|_| GatewayClientError::ConnectionAbruptlyClosed)?;
+            .expect("stream sender was somehow dropped without sending anything!");
 
         if let Some(res) = receive_res {
             let _res = res?;

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

@@ -5,8 +5,8 @@ use crate::nyxd::{self, NyxdClient};
 use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 use crate::signing::signer::{NoSigner, OfflineSigner};
 use crate::{
-    DirectSigningReqwestRpcValidatorClient, QueryReqwestRpcValidatorClient, ReqwestRpcClient,
-    ValidatorClientError,
+    nym_api, DirectSigningReqwestRpcValidatorClient, QueryReqwestRpcValidatorClient,
+    ReqwestRpcClient, ValidatorClientError,
 };
 use nym_api_requests::ecash::models::{
     AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
@@ -153,7 +153,7 @@ impl Config {
 pub struct Client<C, S = NoSigner> {
     // ideally they would have been read-only, but unfortunately rust doesn't have such features
     // #[deprecated(note = "please use `nym_api_client` instead")]
-    pub nym_api: nym_http_api_client::Client,
+    pub nym_api: nym_api::Client,
     // pub nym_api_client: NymApiClient,
     pub nyxd: NyxdClient<C, S>,
 }
@@ -214,7 +214,7 @@ impl Client<ReqwestRpcClient> {
 
 impl<C> Client<C> {
     pub fn new_with_rpc_client(config: Config, rpc_client: C) -> Self {
-        let nym_api_client = nym_http_api_client::Client::new(config.api_url.clone(), None);
+        let nym_api_client = nym_api::Client::new(config.api_url.clone(), None);
 
         Client {
             nym_api: nym_api_client,
@@ -228,7 +228,7 @@ impl<C, S> Client<C, S> {
     where
         S: OfflineSigner,
     {
-        let nym_api_client = nym_http_api_client::Client::new(config.api_url.clone(), None);
+        let nym_api_client = nym_api::Client::new(config.api_url.clone(), None);
 
         Client {
             nym_api: nym_api_client,
@@ -385,25 +385,38 @@ impl<C, S> Client<C, S> {
     }
 }
 
-/// DEPRECATED: Use nym_http_api_client::Client with from_network() or with_bincode() instead
-#[deprecated(
-    since = "1.2.0",
-    note = "Use nym_http_api_client::Client::from_network() or ClientBuilder::with_bincode() instead"
-)]
 #[derive(Clone)]
 pub struct NymApiClient {
     pub use_bincode: bool,
-    pub nym_api: nym_http_api_client::Client,
+    pub nym_api: nym_api::Client,
     // TODO: perhaps if we really need it at some (currently I don't see any reasons for it)
     // we could re-implement the communication with the REST API on port 1317
 }
 
+impl From<nym_api::Client> for NymApiClient {
+    fn from(nym_api: nym_api::Client) -> Self {
+        NymApiClient {
+            use_bincode: false,
+            nym_api,
+        }
+    }
+}
+
 // 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);
+
+        NymApiClient {
+            use_bincode: true,
+            nym_api,
+        }
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     pub fn new_with_timeout(api_url: Url, timeout: std::time::Duration) -> Self {
-        let nym_api = nym_http_api_client::Client::new(api_url, Some(timeout));
+        let nym_api = nym_api::Client::new(api_url, Some(timeout));
 
         NymApiClient {
             use_bincode: true,
@@ -418,7 +431,7 @@ impl NymApiClient {
     }
 
     pub fn new_with_user_agent(api_url: Url, user_agent: impl Into<UserAgent>) -> Self {
-        let nym_api = nym_http_api_client::Client::builder::<_, ValidatorClientError>(api_url)
+        let nym_api = nym_api::Client::builder::<_, ValidatorClientError>(api_url)
             .expect("invalid api url")
             .with_user_agent(user_agent.into())
             .build::<ValidatorClientError>()
@@ -706,11 +719,10 @@ impl NymApiClient {
     pub async fn partial_expiration_date_signatures(
         &self,
         expiration_date: Option<Date>,
-        epoch_id: Option<EpochId>,
     ) -> Result<PartialExpirationDateSignatureResponse, ValidatorClientError> {
         Ok(self
             .nym_api
-            .partial_expiration_date_signatures(expiration_date, epoch_id)
+            .partial_expiration_date_signatures(expiration_date)
             .await?)
     }
 
@@ -727,11 +739,10 @@ impl NymApiClient {
     pub async fn global_expiration_date_signatures(
         &self,
         expiration_date: Option<Date>,
-        epoch_id: Option<EpochId>,
     ) -> Result<AggregatedExpirationDateSignatureResponse, ValidatorClientError> {
         Ok(self
             .nym_api
-            .global_expiration_date_signatures(expiration_date, epoch_id)
+            .global_expiration_date_signatures(expiration_date)
             .await?)
     }
 

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

@@ -3,6 +3,7 @@
 
 use crate::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
 use crate::nyxd::error::NyxdError;
+use crate::NymApiClient;
 use nym_coconut_dkg_common::types::{EpochId, NodeIndex};
 use nym_coconut_dkg_common::verification_key::ContractVKShare;
 use nym_compact_ecash::error::CompactEcashError;
@@ -14,7 +15,7 @@ use url::Url;
 // TODO: it really doesn't feel like this should live in this crate.
 #[derive(Clone)]
 pub struct EcashApiClient {
-    pub api_client: nym_http_api_client::Client,
+    pub api_client: NymApiClient,
     pub verification_key: VerificationKeyAuth,
     pub node_id: NodeIndex,
     pub cosmos_address: cosmrs::AccountId,
@@ -24,10 +25,10 @@ impl Display for EcashApiClient {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "[id: {}] {} @ {:?}",
+            "[id: {}] {} @ {}",
             self.node_id,
             self.cosmos_address,
-            self.api_client.base_urls()
+            self.api_client.api_url()
         )
     }
 }
@@ -59,9 +60,6 @@ pub enum EcashApiError {
         source: CompactEcashError,
     },
 
-    #[error("failed to create API client: {0}")]
-    ClientError(String),
-
     #[error("the provided account address is malformed: {source}")]
     MalformedAccountAddress {
         #[from]
@@ -91,16 +89,8 @@ impl TryFrom<ContractVKShare> for EcashApiClient {
         // In non-client applications this resolver can cause warning logs about H2 connection
         // failure. This indicates that the long lived https connection was closed by the remote
         // peer and the resolver will have to reconnect. It should not impact actual functionality
-        let api_client = nym_http_api_client::Client::builder::<
-            _,
-            nym_api_requests::models::RequestError,
-        >(url_address)
-        .map_err(|e| EcashApiError::ClientError(e.to_string()))?
-        .build::<nym_api_requests::models::RequestError>()
-        .map_err(|e| EcashApiError::ClientError(e.to_string()))?;
-
         Ok(EcashApiClient {
-            api_client,
+            api_client: NymApiClient::new(url_address),
             verification_key: VerificationKeyAuth::try_from_bs58(&share.share)?,
             node_id: share.node_index,
             cosmos_address: share.owner.as_str().parse()?,

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

@@ -1,8 +1,7 @@
-use crate::nym_api::NymApiClientExt;
 use crate::nyxd::contract_traits::MixnetQueryClient;
 use crate::nyxd::error::NyxdError;
 use crate::nyxd::Config as ClientConfig;
-use crate::{QueryHttpRpcNyxdClient, ValidatorClientError};
+use crate::{NymApiClient, QueryHttpRpcNyxdClient, ValidatorClientError};
 use colored::Colorize;
 use core::fmt;
 use itertools::Itertools;
@@ -88,19 +87,8 @@ fn setup_connection_tests<H: BuildHasher + 'static>(
         }
     });
 
-    let api_connection_test_clients = api_urls.filter_map(|(network, url)| {
-        match nym_http_api_client::Client::builder(url.clone())
-            .and_then(|b| b.build::<nym_api_requests::models::RequestError>())
-        {
-            Ok(client) => Some(ClientForConnectionTest::Api(network, url, client)),
-            Err(err) => {
-                eprintln!(
-                    "Failed to create API client for {}: {err}",
-                    network.network_name
-                );
-                None
-            }
-        }
+    let api_connection_test_clients = api_urls.map(|(network, url)| {
+        ClientForConnectionTest::Api(network, url.clone(), NymApiClient::new(url))
     });
 
     nyxd_connection_test_clients.chain(api_connection_test_clients)
@@ -172,7 +160,7 @@ async fn test_nyxd_connection(
 async fn test_nym_api_connection(
     network: NymNetworkDetails,
     url: &Url,
-    client: &nym_http_api_client::Client,
+    client: &NymApiClient,
 ) -> ConnectionResult {
     let result = match timeout(
         Duration::from_secs(CONNECTION_TEST_TIMEOUT_SEC),
@@ -198,7 +186,7 @@ async fn test_nym_api_connection(
 
 enum ClientForConnectionTest {
     Nyxd(NymNetworkDetails, Url, Box<QueryHttpRpcNyxdClient>),
-    Api(NymNetworkDetails, Url, nym_http_api_client::Client),
+    Api(NymNetworkDetails, Url, NymApiClient),
 }
 
 impl ClientForConnectionTest {

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

@@ -14,6 +14,7 @@ pub mod signing;
 pub use crate::error::ValidatorClientError;
 pub use crate::rpc::reqwest::ReqwestRpcClient;
 pub use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
+pub use client::NymApiClient;
 pub use client::{Client, Config, EcashApiClient};
 pub use nym_api_requests::*;
 pub use nym_http_api_client::UserAgent;

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

@@ -3,22 +3,19 @@
 
 use crate::nym_api::error::NymAPIError;
 use crate::nym_api::routes::{ecash, CORE_STATUS_COUNT, SINCE_ARG};
-use crate::nym_nodes::SkimmedNodesWithMetadata;
 use async_trait::async_trait;
 use nym_api_requests::ecash::models::{
     AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
-    BatchRedeemTicketsBody, EcashBatchTicketRedemptionResponse, EcashSignerStatusResponse,
-    EcashTicketVerificationResponse, IssuedTicketbooksChallengeCommitmentRequest,
-    IssuedTicketbooksChallengeCommitmentResponse, IssuedTicketbooksDataRequest,
-    IssuedTicketbooksDataResponse, IssuedTicketbooksForCountResponse, IssuedTicketbooksForResponse,
-    VerifyEcashTicketBody,
+    BatchRedeemTicketsBody, EcashBatchTicketRedemptionResponse, EcashTicketVerificationResponse,
+    IssuedTicketbooksChallengeCommitmentRequest, IssuedTicketbooksChallengeCommitmentResponse,
+    IssuedTicketbooksDataRequest, IssuedTicketbooksDataResponse, IssuedTicketbooksForCountResponse,
+    IssuedTicketbooksForResponse, VerifyEcashTicketBody,
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
-    AnnotationResponse, ApiHealthResponse, BinaryBuildInformationOwned, ChainBlocksStatusResponse,
-    ChainStatusResponse, KeyRotationInfoResponse, LegacyDescribedMixNode, NodePerformanceResponse,
-    NodeRefreshBody, NymNodeDescription, PerformanceHistoryResponse, RewardedSetResponse,
-    SignerInformationResponse,
+    AnnotationResponse, ApiHealthResponse, BinaryBuildInformationOwned, ChainStatusResponse,
+    KeyRotationInfoResponse, LegacyDescribedMixNode, NodePerformanceResponse, NodeRefreshBody,
+    NymNodeDescription, PerformanceHistoryResponse, RewardedSetResponse,
 };
 use nym_api_requests::nym_nodes::{
     NodesByAddressesRequestBody, NodesByAddressesResponse, PaginatedCachedNodesResponseV1,
@@ -38,7 +35,7 @@ pub use nym_api_requests::{
         MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
         StakeSaturationResponse, UptimeResponse,
     },
-    nym_nodes::{CachedNodesResponse, SemiSkimmedNode, SemiSkimmedNodesWithMetadata, SkimmedNode},
+    nym_nodes::{CachedNodesResponse, SemiSkimmedNode, SkimmedNode},
     NymNetworkDetailsResponse,
 };
 use nym_contracts_common::IdentityKey;
@@ -50,8 +47,8 @@ use time::format_description::BorrowedFormatItem;
 use time::Date;
 use tracing::instrument;
 
-use crate::ValidatorClientError;
 pub use nym_coconut_dkg_common::types::EpochId;
+pub use nym_http_api_client::Client;
 
 pub mod error;
 pub mod routes;
@@ -63,9 +60,6 @@ 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 {
-    /// Get the current API URL being used by the client
-    fn api_url(&self) -> &url::Url;
-
     async fn health(&self) -> Result<ApiHealthResponse, NymAPIError> {
         self.get_json(
             &[
@@ -245,162 +239,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    async fn get_current_rewarded_set(&self) -> Result<RewardedSetResponse, NymAPIError> {
-        self.get_rewarded_set().await
-    }
-
-    async fn get_all_basic_nodes_with_metadata(
-        &self,
-    ) -> Result<SkimmedNodesWithMetadata, NymAPIError> {
-        // unroll first loop iteration in order to obtain the metadata
-        let mut page = 0;
-        let res = self
-            .get_basic_nodes_v2(false, Some(page), None, true)
-            .await?;
-        let mut nodes = res.nodes.data;
-        let metadata = res.metadata;
-
-        if res.nodes.pagination.total == nodes.len() {
-            return Ok(SkimmedNodesWithMetadata::new(nodes, metadata));
-        }
-
-        page += 1;
-
-        loop {
-            let mut res = self
-                .get_basic_nodes_v2(false, Some(page), None, true)
-                .await?;
-
-            if !metadata.consistency_check(&res.metadata) {
-                // Create a custom error for inconsistent metadata
-                return Err(NymAPIError::EndpointFailure {
-                    status: reqwest::StatusCode::INTERNAL_SERVER_ERROR,
-                    error: nym_api_requests::models::RequestError::new(
-                        "Inconsistent paged metadata",
-                    ),
-                });
-            }
-
-            nodes.append(&mut res.nodes.data);
-            if nodes.len() >= res.nodes.pagination.total {
-                break;
-            } else {
-                page += 1
-            }
-        }
-
-        Ok(SkimmedNodesWithMetadata::new(nodes, metadata))
-    }
-
-    async fn get_all_basic_active_mixing_assigned_nodes_with_metadata(
-        &self,
-    ) -> Result<SkimmedNodesWithMetadata, NymAPIError> {
-        // Get all mixing nodes that are in the active/rewarded set
-        let mut page = 0;
-        let res = self
-            .get_basic_active_mixing_assigned_nodes_v2(false, Some(page), None, false)
-            .await?;
-
-        let metadata = res.metadata;
-        let mut nodes = res.nodes.data;
-
-        if res.nodes.pagination.total == nodes.len() {
-            return Ok(SkimmedNodesWithMetadata::new(nodes, metadata));
-        }
-
-        page += 1;
-
-        loop {
-            let res = self
-                .get_basic_active_mixing_assigned_nodes_v2(false, Some(page), None, false)
-                .await?;
-
-            if !metadata.consistency_check(&res.metadata) {
-                return Err(NymAPIError::EndpointFailure {
-                    status: reqwest::StatusCode::INTERNAL_SERVER_ERROR,
-                    error: nym_api_requests::models::RequestError::new(
-                        "Inconsistent paged metadata",
-                    ),
-                });
-            }
-
-            nodes.append(&mut res.nodes.data.clone());
-
-            // Check if we've got all nodes
-            if nodes.len() >= res.nodes.pagination.total {
-                break;
-            } else {
-                page += 1;
-            }
-        }
-
-        Ok(SkimmedNodesWithMetadata::new(nodes, metadata))
-    }
-
-    async fn get_all_basic_entry_assigned_nodes_with_metadata(
-        &self,
-    ) -> Result<SkimmedNodesWithMetadata, NymAPIError> {
-        // Get all nodes that can act as entry gateways
-        let mut page = 0;
-        let res = self
-            .get_basic_entry_assigned_nodes_v2(false, Some(page), None, false)
-            .await?;
-
-        let metadata = res.metadata;
-        let mut nodes = res.nodes.data;
-
-        if res.nodes.pagination.total == nodes.len() {
-            return Ok(SkimmedNodesWithMetadata::new(nodes, metadata));
-        }
-
-        page += 1;
-
-        loop {
-            let res = self
-                .get_basic_entry_assigned_nodes_v2(false, Some(page), None, false)
-                .await?;
-
-            if !metadata.consistency_check(&res.metadata) {
-                return Err(NymAPIError::EndpointFailure {
-                    status: reqwest::StatusCode::INTERNAL_SERVER_ERROR,
-                    error: nym_api_requests::models::RequestError::new(
-                        "Inconsistent paged metadata",
-                    ),
-                });
-            }
-
-            nodes.append(&mut res.nodes.data.clone());
-
-            // Check if we've got all nodes
-            if nodes.len() >= res.nodes.pagination.total {
-                break;
-            } else {
-                page += 1;
-            }
-        }
-
-        Ok(SkimmedNodesWithMetadata::new(nodes, metadata))
-    }
-
-    async fn get_all_described_nodes(&self) -> Result<Vec<NymNodeDescription>, NymAPIError> {
-        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
-        let mut page = 0;
-        let mut descriptions = Vec::new();
-
-        loop {
-            let mut res = self.get_nodes_described(Some(page), None).await?;
-
-            descriptions.append(&mut res.data);
-            if descriptions.len() < res.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(descriptions)
-    }
-
     #[tracing::instrument(level = "debug", skip_all)]
     async fn get_nym_nodes(
         &self,
@@ -428,25 +266,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    async fn get_all_bonded_nym_nodes(&self) -> Result<Vec<NymNodeDetails>, ValidatorClientError> {
-        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
-        let mut page = 0;
-        let mut bonds = Vec::new();
-
-        loop {
-            let mut res = self.get_nym_nodes(Some(page), None).await?;
-
-            bonds.append(&mut res.data);
-            if bonds.len() < res.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(bonds)
-    }
-
     #[deprecated]
     #[tracing::instrument(level = "debug", skip_all)]
     async fn get_basic_mixnodes(&self) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
@@ -1282,9 +1101,8 @@ pub trait NymApiClientExt: ApiClient {
     async fn partial_expiration_date_signatures(
         &self,
         expiration_date: Option<Date>,
-        epoch_id: Option<EpochId>,
     ) -> Result<PartialExpirationDateSignatureResponse, NymAPIError> {
-        let mut params = match expiration_date {
+        let params = match expiration_date {
             None => Vec::new(),
             Some(exp) => vec![(
                 ecash::EXPIRATION_DATE_PARAM,
@@ -1292,10 +1110,6 @@ pub trait NymApiClientExt: ApiClient {
             )],
         };
 
-        if let Some(epoch_id) = epoch_id {
-            params.push((ecash::EPOCH_ID_PARAM, epoch_id.to_string()));
-        }
-
         self.get_json(
             &[
                 routes::V1_API_VERSION,
@@ -1332,9 +1146,8 @@ pub trait NymApiClientExt: ApiClient {
     async fn global_expiration_date_signatures(
         &self,
         expiration_date: Option<Date>,
-        epoch_id: Option<EpochId>,
     ) -> Result<AggregatedExpirationDateSignatureResponse, NymAPIError> {
-        let mut params = match expiration_date {
+        let params = match expiration_date {
             None => Vec::new(),
             Some(exp) => vec![(
                 ecash::EXPIRATION_DATE_PARAM,
@@ -1342,10 +1155,6 @@ pub trait NymApiClientExt: ApiClient {
             )],
         };
 
-        if let Some(epoch_id) = epoch_id {
-            params.push((ecash::EPOCH_ID_PARAM, epoch_id.to_string()));
-        }
-
         self.get_json(
             &[
                 routes::V1_API_VERSION,
@@ -1522,22 +1331,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    async fn get_chain_blocks_status(&self) -> Result<ChainBlocksStatusResponse, NymAPIError> {
-        self.get_json("/v1/network/chain-blocks-status", NO_PARAMS)
-            .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_signer_status(&self) -> Result<EcashSignerStatusResponse, NymAPIError> {
-        self.get_json("/v1/ecash/signer-status", NO_PARAMS).await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_signer_information(&self) -> Result<SignerInformationResponse, NymAPIError> {
-        self.get_json("/v1/api-status/signer-information", NO_PARAMS)
-            .await
-    }
-
     #[instrument(level = "debug", skip(self))]
     async fn get_key_rotation_info(&self) -> Result<KeyRotationInfoResponse, NymAPIError> {
         self.get_json(
@@ -1550,49 +1343,8 @@ pub trait NymApiClientExt: ApiClient {
         )
         .await
     }
-
-    /// Method to change the base API URLs being used by the client
-    fn change_base_urls(&mut self, urls: Vec<url::Url>);
-
-    /// Retrieve expanded information for all bonded nodes on the network
-    async fn get_all_expanded_nodes(&self) -> Result<SemiSkimmedNodesWithMetadata, NymAPIError> {
-        // Unroll the first iteration to get the metadata
-        let mut page = 0;
-
-        let res = self.get_expanded_nodes(false, Some(page), None).await?;
-        let mut nodes = res.nodes.data;
-        let metadata = res.metadata;
-
-        if res.nodes.pagination.total == nodes.len() {
-            return Ok(SemiSkimmedNodesWithMetadata::new(nodes, metadata));
-        }
-
-        page += 1;
-
-        loop {
-            let mut res = self.get_expanded_nodes(false, Some(page), None).await?;
-
-            nodes.append(&mut res.nodes.data);
-            if nodes.len() < res.nodes.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(SemiSkimmedNodesWithMetadata::new(nodes, metadata))
-    }
 }
 
-// Client is already nym_http_api_client::Client (re-exported above), so just one impl needed
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl NymApiClientExt for nym_http_api_client::Client {
-    fn api_url(&self) -> &url::Url {
-        self.current_url().as_ref()
-    }
-
-    fn change_base_urls(&mut self, urls: Vec<url::Url>) {
-        self.change_base_urls(urls.into_iter().map(|u| u.into()).collect());
-    }
-}
+impl NymApiClientExt for Client {}

common/client-libs/validator-client/src/nyxd/contract_traits/dkg_query_client.rs

@@ -8,11 +8,11 @@ use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
 use cosmwasm_std::Addr;
-use nym_coconut_dkg_common::dealer::RegisteredDealerDetails;
 use nym_coconut_dkg_common::types::{ChunkIndex, NodeIndex, StateAdvanceResponse};
 use serde::Deserialize;
 use tracing::trace;
 
+use nym_coconut_dkg_common::dealer::RegisteredDealerDetails;
 pub use nym_coconut_dkg_common::{
     dealer::{DealerDetailsResponse, PagedDealerIndexResponse, PagedDealerResponse},
     dealing::{
@@ -21,9 +21,7 @@ pub use nym_coconut_dkg_common::{
     },
     msg::QueryMsg as DkgQueryMsg,
     types::{DealerDetails, DealingIndex, Epoch, EpochId, EpochState, State},
-    verification_key::{
-        ContractVKShare, PagedVKSharesResponse, VerificationKeyShare, VkShareResponse,
-    },
+    verification_key::{ContractVKShare, PagedVKSharesResponse, VkShareResponse},
 };
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]

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

@@ -139,22 +139,12 @@ impl NyxdClient<HttpClient> {
         })
     }
 
-    pub fn connect_with_network_details<U>(
-        endpoint: U,
-        network_details: NymNetworkDetails,
-    ) -> Result<QueryHttpRpcNyxdClient, NyxdError>
-    where
-        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
-    {
-        let config = Config::try_from_nym_network_details(&network_details)?;
-        Self::connect(config, endpoint)
-    }
-
     pub fn connect_to_default_env<U>(endpoint: U) -> Result<QueryHttpRpcNyxdClient, NyxdError>
     where
         U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
     {
-        Self::connect_with_network_details(endpoint, NymNetworkDetails::new_from_env())
+        let config = Config::try_from_nym_network_details(&NymNetworkDetails::new_from_env())?;
+        Self::connect(config, endpoint)
     }
 }
 

common/commands/Cargo.toml

@@ -38,7 +38,6 @@ cosmrs = { workspace = true }
 cosmwasm-std = { workspace = true }
 
 nym-validator-client = { path = "../client-libs/validator-client" }
-nym-http-api-client = { path = "../http-api-client" }
 nym-bin-common = { path = "../../common/bin-common", features = ["output_format"] }
 nym-crypto = { path = "../../common/crypto", features = ["asymmetric"] }
 nym-network-defaults = { path = "../network-defaults" }

common/commands/src/context/mod.rs

@@ -2,12 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::context::errors::ContextError;
-pub use nym_http_api_client::Client as NymApiClient;
 use nym_network_defaults::{
     setup_env,
     var_names::{MIXNET_CONTRACT_ADDRESS, NYM_API, NYXD, VESTING_CONTRACT_ADDRESS},
     NymNetworkDetails,
 };
+pub use nym_validator_client::nym_api::Client as NymApiClient;
 use nym_validator_client::nyxd::{self, AccountId, NyxdClient};
 use nym_validator_client::{
     DirectSigningHttpRpcNyxdClient, DirectSigningHttpRpcValidatorClient, QueryHttpRpcNyxdClient,

common/commands/src/ecash/generate_ticket.rs

@@ -86,7 +86,7 @@ pub async fn execute(args: Args) -> anyhow::Result<()> {
             anyhow!("ticketbook got incorrectly imported - the master verification key is missing")
         })?;
     let expiration_signatures = persistent_storage
-        .get_expiration_date_signatures(expiration_date, epoch_id)
+        .get_expiration_date_signatures(expiration_date)
         .await?
         .ok_or_else(|| {
             anyhow!(

common/commands/src/ecash/issue_ticket_book.rs

@@ -120,7 +120,7 @@ async fn issue_to_file(args: Args, client: SigningClient) -> anyhow::Result<()>
 
     if args.include_expiration_date_signatures {
         let signatures = credentials_store
-            .get_expiration_date_signatures(expiration_date, epoch_id)
+            .get_expiration_date_signatures(expiration_date)
             .await?
             .ok_or(anyhow!("missing expiration date signatures!"))?;
 

common/commands/src/internal/mod.rs

@@ -4,7 +4,6 @@
 use clap::{Args, Subcommand};
 
 pub mod ecash;
-pub mod nyx;
 
 #[derive(Debug, Args)]
 #[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
@@ -17,6 +16,4 @@ pub struct Internal {
 pub enum InternalCommands {
     /// Ecash related internal commands
     Ecash(ecash::InternalEcash),
-
-    Nyx(nyx::InternalNyx),
 }

common/commands/src/internal/nyx/force_advance_epoch.rs

@@ -1,116 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::SigningClient;
-use anyhow::bail;
-use clap::Parser;
-use nym_mixnet_contract_common::nym_node::Role;
-use nym_mixnet_contract_common::reward_params::NodeRewardingParameters;
-use nym_mixnet_contract_common::{
-    EpochRewardedSet, EpochState, NodeId, RewardingParams, RoleAssignment,
-};
-use nym_validator_client::nyxd::contract_traits::mixnet_query_client::MixnetQueryClientExt;
-use nym_validator_client::nyxd::contract_traits::{MixnetQueryClient, MixnetSigningClient};
-use rand::prelude::*;
-use rand::thread_rng;
-
-#[derive(Debug, Parser)]
-pub struct Args {}
-
-fn choose_new_nodes(
-    params: &RewardingParams,
-    rewarded_set: &EpochRewardedSet,
-    role: Role,
-) -> Vec<NodeId> {
-    let mut rng = thread_rng();
-
-    match role {
-        Role::EntryGateway => rewarded_set
-            .assignment
-            .entry_gateways
-            .choose_multiple(&mut rng, params.rewarded_set.entry_gateways as usize)
-            .copied()
-            .collect(),
-        Role::Layer1 => rewarded_set
-            .assignment
-            .layer1
-            .choose_multiple(&mut rng, params.rewarded_set.mixnodes as usize / 3)
-            .copied()
-            .collect(),
-        Role::Layer2 => rewarded_set
-            .assignment
-            .layer2
-            .choose_multiple(&mut rng, params.rewarded_set.mixnodes as usize / 3)
-            .copied()
-            .collect(),
-        Role::Layer3 => rewarded_set
-            .assignment
-            .layer3
-            .choose_multiple(&mut rng, params.rewarded_set.mixnodes as usize / 3)
-            .copied()
-            .collect(),
-        Role::ExitGateway => rewarded_set
-            .assignment
-            .exit_gateways
-            .choose_multiple(&mut rng, params.rewarded_set.exit_gateways as usize)
-            .copied()
-            .collect(),
-        Role::Standby => rewarded_set
-            .assignment
-            .standby
-            .choose_multiple(&mut rng, params.rewarded_set.standby as usize)
-            .copied()
-            .collect(),
-    }
-}
-
-pub async fn force_advance_epoch(_: Args, client: SigningClient) -> anyhow::Result<()> {
-    let current_epoch = client.get_current_interval_details().await?;
-    let epoch_status = client.get_current_epoch_status().await?;
-    if epoch_status.being_advanced_by.as_str() != client.address().to_string() {
-        bail!(
-            "this client is not authorised to perform any epoch operations. we need {}",
-            client.address()
-        )
-    }
-
-    let rewarding_params = client.get_rewarding_parameters().await?;
-    let current_rewarded_set = client.get_rewarded_set().await?;
-
-    if !current_epoch.is_current_epoch_over {
-        println!("the current epoch is not over yet - there's nothing to do")
-    }
-
-    // is this most efficient? no. but it's simple
-    loop {
-        let epoch_status = client.get_current_epoch_status().await?;
-
-        match epoch_status.state {
-            EpochState::InProgress => break,
-            EpochState::Rewarding { final_node_id, .. } => {
-                println!("rewarding {final_node_id} with big fat 0...");
-                client
-                    .reward_node(
-                        final_node_id,
-                        NodeRewardingParameters::new(Default::default(), Default::default()),
-                        None,
-                    )
-                    .await?;
-            }
-            EpochState::ReconcilingEvents => {
-                println!("trying to reconcile events...");
-                client.reconcile_epoch_events(None, None).await?;
-            }
-            EpochState::RoleAssignment { next } => {
-                let nodes = choose_new_nodes(&rewarding_params, &current_rewarded_set, next);
-                println!("assigning {nodes:?} as {next}");
-
-                client
-                    .assign_roles(RoleAssignment { role: next, nodes }, None)
-                    .await?;
-            }
-        }
-    }
-
-    Ok(())
-}

common/commands/src/internal/nyx/mod.rs

@@ -1,19 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use clap::{Args, Subcommand};
-
-pub mod force_advance_epoch;
-
-#[derive(Debug, Args)]
-#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
-pub struct InternalNyx {
-    #[clap(subcommand)]
-    pub command: InternalNyxCommands,
-}
-
-#[derive(Debug, Subcommand)]
-pub enum InternalNyxCommands {
-    /// Attempt to force advance the current epoch
-    ForceAdvanceEpoch(force_advance_epoch::Args),
-}

common/commands/src/validator/mixnet/delegators/delegate_to_multiple_mixnodes.rs

@@ -241,7 +241,7 @@ pub async fn delegate_to_multiple_mixnodes(args: Args, client: SigningClient) {
                 let node_id = row.node_id.clone().parse::<u32>().unwrap();
                 let coins: Vec<Coin> = vec![];
                 undelegation_msgs.push((ExecuteMsg::Undelegate { node_id }, coins));
-                undelegation_table.add_row(std::slice::from_ref(&row.node_id));
+                undelegation_table.add_row(&[row.node_id.clone()]);
 
                 if row.amount.amount > 0 {
                     delegation_msgs

common/cosmwasm-smart-contracts/contracts-common-testing/src/tester/mod.rs

@@ -188,7 +188,7 @@ impl<C> ContractTesterBuilder<C> {
         *self.app.api()
     }
 
-    pub fn querier(&self) -> QuerierWrapper<'_> {
+    pub fn querier(&self) -> QuerierWrapper {
         self.app.wrap()
     }
 }

common/cosmwasm-smart-contracts/mixnet-contract/src/helpers.rs

@@ -57,7 +57,7 @@ pub trait NodeBond {
 
     fn is_unbonding(&self) -> bool;
 
-    fn identity(&self) -> IdentityKeyRef<'_>;
+    fn identity(&self) -> IdentityKeyRef;
 
     fn original_pledge(&self) -> &Coin;
 
@@ -125,7 +125,7 @@ impl NodeBond for MixNodeBond {
         self.is_unbonding
     }
 
-    fn identity(&self) -> IdentityKeyRef<'_> {
+    fn identity(&self) -> IdentityKeyRef {
         self.identity()
     }
 
@@ -178,7 +178,7 @@ impl NodeBond for NymNodeBond {
         self.is_unbonding
     }
 
-    fn identity(&self) -> IdentityKeyRef<'_> {
+    fn identity(&self) -> IdentityKeyRef {
         self.identity()
     }
 

common/cosmwasm-smart-contracts/mixnet-contract/src/nym_node.rs

@@ -58,7 +58,7 @@ impl<'a> PrimaryKey<'a> for Role {
     type Suffix = <u8 as PrimaryKey<'a>>::Suffix;
     type SuperSuffix = <u8 as PrimaryKey<'a>>::SuperSuffix;
 
-    fn key(&self) -> Vec<Key<'_>> {
+    fn key(&self) -> Vec<Key> {
         // I'm not sure why it wasn't possible to delegate the call to
         // `(*self as u8).key()` directly...
         // I guess because of the `Key::Ref(&'a [u8])` variant?

common/cosmwasm-smart-contracts/mixnet-contract/src/reward_params.rs

@@ -86,25 +86,6 @@ impl IntervalRewardParams {
     pub fn to_inline_json(&self) -> String {
         to_json_string(self).unwrap_or_else(|_| "serialisation failure".into())
     }
-
-    pub fn active_node_work(&self, standby_node_work: Decimal) -> WorkFactor {
-        self.active_set_work_factor * standby_node_work
-    }
-
-    pub fn standby_node_work(
-        &self,
-        rewarded_set_size: Decimal,
-        standby_set_size: Decimal,
-    ) -> WorkFactor {
-        let f = self.active_set_work_factor;
-        let k = rewarded_set_size;
-        let one = Decimal::one();
-
-        // nodes in reserve
-        let k_r = standby_set_size;
-
-        one / (f * k - (f - one) * k_r)
-    }
 }
 
 /// Parameters used for reward calculation.
@@ -128,15 +109,18 @@ pub struct RewardingParams {
 
 impl RewardingParams {
     pub fn active_node_work(&self) -> WorkFactor {
-        let standby_work = self.standby_node_work();
-        self.interval.active_node_work(standby_work)
+        self.interval.active_set_work_factor * self.standby_node_work()
     }
 
     pub fn standby_node_work(&self) -> WorkFactor {
-        let rewarded_set_size = self.dec_rewarded_set_size();
-        let standby_set_size = self.dec_standby_set_size();
-        self.interval
-            .standby_node_work(rewarded_set_size, standby_set_size)
+        let f = self.interval.active_set_work_factor;
+        let k = self.dec_rewarded_set_size();
+        let one = Decimal::one();
+
+        // nodes in reserve
+        let k_r = self.dec_standby_set_size();
+
+        one / (f * k - (f - one) * k_r)
     }
 
     pub fn rewarded_set_size(&self) -> u32 {

common/cosmwasm-smart-contracts/mixnet-contract/src/types.rs

@@ -3,7 +3,6 @@
 
 use crate::config_score::{ConfigScoreParams, OutdatedVersionWeights, VersionScoreFormulaParams};
 use crate::nym_node::Role;
-use crate::reward_params::RewardedSetParams;
 use crate::EpochId;
 use contracts_common::Percent;
 use cosmwasm_schema::cw_serde;
@@ -86,11 +85,7 @@ impl RewardedSet {
     }
 
     pub fn rewarded_set_size(&self) -> usize {
-        self.active_set_size() + self.standby_set_size()
-    }
-
-    pub fn standby_set_size(&self) -> usize {
-        self.standby.len()
+        self.active_set_size() + self.standby.len()
     }
 
     pub fn get_role(&self, node_id: NodeId) -> Option<Role> {
@@ -115,13 +110,6 @@ impl RewardedSet {
         }
         None
     }
-
-    pub fn matches_parameters(&self, params: RewardedSetParams) -> bool {
-        self.entry_gateways.len() <= params.entry_gateways as usize
-            && self.exit_gateways.len() <= params.exit_gateways as usize
-            && self.layer1.len() + self.layer2.len() + self.layer3.len() <= params.mixnodes as usize
-            && self.standby.len() <= params.standby as usize
-    }
 }
 
 #[cw_serde]

common/credential-storage/Cargo.toml

@@ -3,7 +3,6 @@ name = "nym-credential-storage"
 version = "0.1.0"
 edition = "2021"
 license.workspace = true
-rust-version.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -34,7 +33,6 @@ features = ["rt-multi-thread", "net", "signal", "fs"]
 
 
 [build-dependencies]
-anyhow = { workspace = true }
 sqlx = { workspace = true, features = [
     "runtime-tokio-rustls",
     "sqlite",

common/credential-storage/build.rs

@@ -3,29 +3,22 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-use anyhow::Context;
 use sqlx::{Connection, SqliteConnection};
 use std::env;
 
 #[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    let out_dir = env::var("OUT_DIR")?;
+async fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
     let database_path = format!("{out_dir}/coconut-credential-example.sqlite");
 
-    // remove the db file if it already existed from previous build
-    // in case it was from a different branch
-    if std::fs::exists(&database_path)? {
-        std::fs::remove_file(&database_path)?;
-    }
-
     let mut conn = SqliteConnection::connect(&format!("sqlite://{database_path}?mode=rwc"))
         .await
-        .context("Failed to create SQLx database connection")?;
+        .expect("Failed to create SQLx database connection");
 
     sqlx::migrate!("./migrations")
         .run(&mut conn)
         .await
-        .context("Failed to perform SQLx migrations")?;
+        .expect("Failed to perform SQLx migrations");
 
     #[cfg(target_family = "unix")]
     println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
@@ -34,6 +27,4 @@ async fn main() -> anyhow::Result<()> {
     // 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);
-
-    Ok(())
 }

common/credential-storage/migrations/20250805120000_expiration_date_signatures_epoch_fix.sql

@@ -1,123 +0,0 @@
-/*
- * Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
--- 1. add temporary `epoch_id` column
-ALTER TABLE pending_issuance
-    ADD COLUMN epoch_id INTEGER;
-
--- 2. populate the value
-UPDATE pending_issuance
-SET epoch_id = (SELECT epoch_id
-                FROM expiration_date_signatures
-                WHERE expiration_date_signatures.expiration_date = pending_issuance.expiration_date);
-
--- 3. create new expiration_date_signatures table (with changed constraints)
-CREATE TABLE expiration_date_signatures_new
-(
-    expiration_date        DATE    NOT NULL,
-
-    epoch_id               INTEGER NOT NULL,
-
-    serialization_revision INTEGER NOT NULL,
-
-    -- combined signatures for all tuples issued for given day
-    serialised_signatures  BLOB    NOT NULL,
-
-    PRIMARY KEY (epoch_id, expiration_date)
-);
-
--- 4. migrate the data
-INSERT INTO expiration_date_signatures_new (expiration_date, epoch_id, serialization_revision, serialised_signatures)
-SELECT expiration_date, epoch_id, serialization_revision, serialised_signatures
-FROM expiration_date_signatures;
-
--- 5. drop and recreate the table references (due to new FK)
-
--- 5.1.
--- (data for ticketbooks that have an associated deposit, but failed to get issued)
-CREATE TABLE pending_issuance_new
-(
-    deposit_id              INTEGER NOT NULL PRIMARY KEY,
-
-    -- introduce a way for us to introduce breaking changes in serialization of data
-    serialization_revision  INTEGER NOT NULL,
-
-    pending_ticketbook_data BLOB    NOT NULL UNIQUE,
-
-    -- for each ticketbook we MUST have corresponding expiration date signatures
-    expiration_date         DATE    NOT NULL,
-    epoch_id                INTEGER NOT NULL,
-
-    -- for each ticketbook we MUST have corresponding expiration date signatures
-    FOREIGN KEY (epoch_id, expiration_date) REFERENCES expiration_date_signatures_new (epoch_id, expiration_date)
-);
-
-INSERT INTO pending_issuance_new (deposit_id, serialization_revision, pending_ticketbook_data, expiration_date,
-                                  epoch_id)
-SELECT deposit_id, serialization_revision, pending_ticketbook_data, expiration_date, epoch_id
-FROM pending_issuance;
-
-
--- 5.2.
-CREATE TABLE ecash_ticketbook_new
-(
-    id                     INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-
-    -- introduce a way for us to introduce breaking changes in serialization of data
-    serialization_revision INTEGER NOT NULL,
-
-    -- the type of the associated ticketbook
-    ticketbook_type        TEXT    NOT NULL,
-
-    -- the actual crypto data of the ticketbook (wallet, keys, etc.)
-    ticketbook_data        BLOB    NOT NULL UNIQUE,
-
-    -- for each ticketbook we MUST have corresponding expiration date signatures
-    expiration_date        DATE    NOT NULL,
-
-    -- for each ticketbook we MUST have corresponding coin index signatures
-    epoch_id               INTEGER NOT NULL,
-
-    -- the initial number of tickets the wallet has been created for
-    total_tickets          INTEGER NOT NULL,
-
-    -- how many tickets have been used so far (the `l` value of the wallet)
-    used_tickets           INTEGER NOT NULL,
-
-
-    -- FOREIGN KEYS:
-
-    -- for each ticketbook we MUST have corresponding coin index signatures
-    FOREIGN KEY (epoch_id) REFERENCES coin_indices_signatures (epoch_id),
-
-    -- for each ticketbook we MUST have corresponding expiration date signatures
-    FOREIGN KEY (expiration_date, epoch_id) REFERENCES expiration_date_signatures_new (expiration_date, epoch_id)
-);
-
-INSERT INTO ecash_ticketbook_new (id, serialization_revision, ticketbook_type, ticketbook_data, expiration_date,
-                                  epoch_id, total_tickets, used_tickets)
-SELECT id,
-       serialization_revision,
-       ticketbook_type,
-       ticketbook_data,
-       expiration_date,
-       epoch_id,
-       total_tickets,
-       used_tickets
-FROM ecash_ticketbook;
-
--- 6. finally swap out the old tables
--- drop old tables
-DROP TABLE pending_issuance;
-DROP TABLE ecash_ticketbook;
-DROP TABLE expiration_date_signatures;
-
--- rename new tables
-ALTER TABLE pending_issuance_new
-    RENAME TO pending_issuance;
-ALTER TABLE ecash_ticketbook_new
-    RENAME TO ecash_ticketbook;
-ALTER TABLE expiration_date_signatures_new
-    RENAME TO expiration_date_signatures;

common/credential-storage/src/backends/memory.rs

@@ -28,7 +28,7 @@ struct EcashCredentialManagerInner {
     pending: HashMap<i64, RetrievedPendingTicketbook>,
     master_vk: HashMap<u64, VerificationKeyAuth>,
     coin_indices_sigs: HashMap<u64, Vec<AnnotatedCoinIndexSignature>>,
-    expiration_date_sigs: HashMap<(u64, Date), Vec<AnnotatedExpirationDateSignature>>,
+    expiration_date_sigs: HashMap<Date, Vec<AnnotatedExpirationDateSignature>>,
     _next_id: i64,
 }
 
@@ -242,14 +242,10 @@ impl MemoryEcachTicketbookManager {
     pub(crate) async fn get_expiration_date_signatures(
         &self,
         expiration_date: Date,
-        epoch_id: u64,
     ) -> Option<Vec<AnnotatedExpirationDateSignature>> {
         let guard = self.inner.read().await;
 
-        guard
-            .expiration_date_sigs
-            .get(&(epoch_id, expiration_date))
-            .cloned()
+        guard.expiration_date_sigs.get(&expiration_date).cloned()
     }
 
     pub(crate) async fn insert_expiration_date_signatures(
@@ -258,9 +254,8 @@ impl MemoryEcachTicketbookManager {
     ) {
         let mut guard = self.inner.write().await;
 
-        guard.expiration_date_sigs.insert(
-            (sigs.epoch_id, sigs.expiration_date),
-            sigs.signatures.clone(),
-        );
+        guard
+            .expiration_date_sigs
+            .insert(sigs.expiration_date, sigs.signatures.clone());
     }
 }

common/credential-storage/src/backends/sqlite.rs

@@ -39,7 +39,7 @@ impl SqliteEcashTicketbookManager {
         Ok(())
     }
 
-    pub(crate) async fn begin_storage_tx(&self) -> Result<Transaction<'_, Sqlite>, sqlx::Error> {
+    pub(crate) async fn begin_storage_tx(&self) -> Result<Transaction<Sqlite>, sqlx::Error> {
         self.connection_pool.begin().await
     }
 
@@ -260,17 +260,15 @@ impl SqliteEcashTicketbookManager {
     pub(crate) async fn get_expiration_date_signatures(
         &self,
         expiration_date: Date,
-        epoch_id: i64,
     ) -> Result<Option<RawExpirationDateSignatures>, sqlx::Error> {
         sqlx::query_as!(
             RawExpirationDateSignatures,
             r#"
-                SELECT serialised_signatures, serialization_revision as "serialization_revision: u8"
+                SELECT epoch_id as "epoch_id: u32", serialised_signatures, serialization_revision as "serialization_revision: u8"
                 FROM expiration_date_signatures
-                WHERE expiration_date = ? AND epoch_id = ?
+                WHERE expiration_date = ?
             "#,
-            expiration_date,
-            epoch_id
+            expiration_date
         )
         .fetch_optional(&*self.connection_pool)
         .await

common/credential-storage/src/ephemeral_storage.rs

@@ -166,11 +166,10 @@ impl Storage for EphemeralStorage {
     async fn get_expiration_date_signatures(
         &self,
         expiration_date: Date,
-        epoch_id: u64,
     ) -> Result<Option<Vec<AnnotatedExpirationDateSignature>>, Self::StorageError> {
         Ok(self
             .storage_manager
-            .get_expiration_date_signatures(expiration_date, epoch_id)
+            .get_expiration_date_signatures(expiration_date)
             .await)
     }
 

common/credential-storage/src/models.rs

@@ -60,6 +60,7 @@ pub struct StoredPendingTicketbook {
 
 #[cfg_attr(not(target_arch = "wasm32"), derive(sqlx::FromRow))]
 pub struct RawExpirationDateSignatures {
+    pub epoch_id: u32,
     pub serialised_signatures: Vec<u8>,
     pub serialization_revision: u8,
 }

common/credential-storage/src/persistent_storage/mod.rs

@@ -325,11 +325,10 @@ impl Storage for PersistentStorage {
     async fn get_expiration_date_signatures(
         &self,
         expiration_date: Date,
-        epoch_id: u64,
     ) -> Result<Option<Vec<AnnotatedExpirationDateSignature>>, Self::StorageError> {
         let Some(raw) = self
             .storage_manager
-            .get_expiration_date_signatures(expiration_date, epoch_id as i64)
+            .get_expiration_date_signatures(expiration_date)
             .await?
         else {
             return Ok(None);

common/credential-storage/src/storage.rs

@@ -92,7 +92,6 @@ pub trait Storage: Clone + Send + Sync {
     async fn get_expiration_date_signatures(
         &self,
         expiration_date: Date,
-        epoch_id: u64,
     ) -> Result<Option<Vec<AnnotatedExpirationDateSignature>>, Self::StorageError>;
 
     async fn insert_expiration_date_signatures(

common/credential-verification/src/ecash/credential_sender.rs

@@ -14,7 +14,7 @@ use nym_api_requests::ecash::models::{BatchRedeemTicketsBody, VerifyEcashTicketB
 use nym_credentials_interface::Bandwidth;
 use nym_credentials_interface::{ClientTicket, TicketType};
 use nym_validator_client::coconut::EcashApiError;
-use nym_validator_client::nym_api::{EpochId, NymApiClientExt};
+use nym_validator_client::nym_api::EpochId;
 use nym_validator_client::nyxd::contract_traits::{
     EcashSigningClient, MultisigQueryClient, MultisigSigningClient, PagedMultisigQueryClient,
 };
@@ -354,7 +354,7 @@ impl CredentialHandler {
             Err(err) => {
                 error!("failed to send ticket {ticket_id} for verification to ecash signer '{client}': {err}. if we don't reach quorum, we'll retry later");
                 Err(EcashTicketError::ApiFailure(EcashApiError::NymApi {
-                    source: nym_validator_client::ValidatorClientError::NymAPIError { source: err },
+                    source: err,
                 }))
             }
         }

common/credential-verification/src/ecash/mod.rs

@@ -39,7 +39,7 @@ impl traits::EcashManager for EcashManager {
     async fn verification_key(
         &self,
         epoch_id: EpochId,
-    ) -> Result<RwLockReadGuard<'_, VerificationKeyAuth>, EcashTicketError> {
+    ) -> Result<RwLockReadGuard<VerificationKeyAuth>, EcashTicketError> {
         self.shared_state.verification_key(epoch_id).await
     }
 
@@ -231,7 +231,7 @@ impl traits::EcashManager for MockEcashManager {
     async fn verification_key(
         &self,
         _epoch_id: EpochId,
-    ) -> Result<RwLockReadGuard<'_, VerificationKeyAuth>, EcashTicketError> {
+    ) -> Result<RwLockReadGuard<VerificationKeyAuth>, EcashTicketError> {
         Ok(self.verfication_key.read().await)
     }
 

common/credential-verification/src/ecash/state.rs

@@ -125,7 +125,7 @@ impl SharedState {
     async fn set_epoch_data(
         &self,
         epoch_id: EpochId,
-    ) -> Result<RwLockWriteGuard<'_, BTreeMap<EpochId, EpochState>>, EcashTicketError> {
+    ) -> Result<RwLockWriteGuard<BTreeMap<EpochId, EpochState>>, EcashTicketError> {
         let Some(threshold) = self.threshold(epoch_id).await? else {
             return Err(EcashTicketError::DKGThresholdUnavailable { epoch_id });
         };
@@ -186,7 +186,7 @@ impl SharedState {
     pub(crate) async fn api_clients(
         &self,
         epoch_id: EpochId,
-    ) -> Result<RwLockReadGuard<'_, Vec<EcashApiClient>>, EcashTicketError> {
+    ) -> Result<RwLockReadGuard<Vec<EcashApiClient>>, EcashTicketError> {
         let guard = self.epoch_data.read().await;
 
         // the key was already in the map
@@ -212,7 +212,7 @@ impl SharedState {
     pub(crate) async fn verification_key(
         &self,
         epoch_id: EpochId,
-    ) -> Result<RwLockReadGuard<'_, VerificationKeyAuth>, EcashTicketError> {
+    ) -> Result<RwLockReadGuard<VerificationKeyAuth>, EcashTicketError> {
         let guard = self.epoch_data.read().await;
 
         // the key was already in the map
@@ -235,11 +235,11 @@ impl SharedState {
         }))
     }
 
-    pub(crate) async fn start_tx(&self) -> RwLockWriteGuard<'_, DirectSigningHttpRpcNyxdClient> {
+    pub(crate) async fn start_tx(&self) -> RwLockWriteGuard<DirectSigningHttpRpcNyxdClient> {
         self.nyxd_client.write().await
     }
 
-    pub(crate) async fn start_query(&self) -> RwLockReadGuard<'_, DirectSigningHttpRpcNyxdClient> {
+    pub(crate) async fn start_query(&self) -> RwLockReadGuard<DirectSigningHttpRpcNyxdClient> {
         self.nyxd_client.read().await
     }
 

common/credential-verification/src/ecash/traits.rs

@@ -12,7 +12,7 @@ pub trait EcashManager {
     async fn verification_key(
         &self,
         epoch_id: EpochId,
-    ) -> Result<RwLockReadGuard<'_, VerificationKeyAuth>, EcashTicketError>;
+    ) -> Result<RwLockReadGuard<VerificationKeyAuth>, EcashTicketError>;
     fn storage(&self) -> Box<dyn BandwidthGatewayStorage + Send + Sync>;
     async fn check_payment(
         &self,

common/credential-verification/src/lib.rs

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::ecash::traits::EcashManager;
-use async_trait::async_trait;
 use bandwidth_storage_manager::BandwidthStorageManager;
 use nym_credentials::ecash::utils::{cred_exp_date, ecash_today, EcashTime};
 use nym_credentials_interface::{Bandwidth, ClientTicket, TicketType};
@@ -140,18 +139,3 @@ impl CredentialVerifier {
             .await)
     }
 }
-
-#[async_trait]
-pub trait TicketVerifier {
-    /// Verify that the ticket is valid and cryptographically correct.
-    /// If the verification succeeds, also increase the bandwidth with the ticket's
-    /// amount and return the latest available bandwidth
-    async fn verify(&mut self) -> Result<i64>;
-}
-
-#[async_trait]
-impl TicketVerifier for CredentialVerifier {
-    async fn verify(&mut self) -> Result<i64> {
-        self.verify().await
-    }
-}

common/credentials-interface/Cargo.toml

@@ -15,7 +15,6 @@ bls12_381 = { workspace = true, default-features = false }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 strum = { workspace = true, features = ["derive"] }
-strum_macros = { workspace = true }
 time = { workspace = true, features = ["serde"] }
 utoipa = { workspace = true }
 rand = { workspace = true }

common/credentials-interface/src/lib.rs

@@ -229,9 +229,9 @@ impl From<PayInfo> for NymPayInfo {
     Serialize,
     Deserialize,
     Hash,
-    strum_macros::Display,
-    strum_macros::EnumString,
-    strum_macros::EnumIter,
+    strum::Display,
+    strum::EnumString,
+    strum::EnumIter,
 )]
 #[serde(rename_all = "kebab-case")]
 #[strum(serialize_all = "kebab-case")]

common/credentials/Cargo.toml

@@ -22,7 +22,6 @@ nym-ecash-time = { path = "../ecash-time", features = ["expiration"] }
 nym-credentials-interface = { path = "../credentials-interface" }
 nym-crypto = { path = "../crypto" }
 nym-api-requests = { path = "../../nym-api/nym-api-requests" }
-nym-http-api-client = { path = "../http-api-client" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 nym-ecash-contract-common = { path = "../cosmwasm-smart-contracts/ecash-contract" }
 nym-network-defaults = { path = "../network-defaults" }

common/credentials/src/ecash/bandwidth/issuance.rs

@@ -15,7 +15,7 @@ use nym_credentials_interface::{
 use nym_crypto::asymmetric::ed25519;
 use nym_ecash_contract_common::deposit::DepositId;
 use nym_ecash_time::{ecash_default_expiration_date, ecash_today, EcashTime};
-use nym_validator_client::nym_api::{EpochId, NymApiClientExt};
+use nym_validator_client::nym_api::EpochId;
 use serde::{Deserialize, Serialize};
 use time::Date;
 
@@ -108,7 +108,7 @@ impl IssuanceTicketBook {
             signing_request.withdrawal_request.clone(),
             self.deposit_id,
             request_signature,
-            signing_request.ecash_pub_key,
+            signing_request.ecash_pub_key.clone(),
             signing_request.expiration_date,
             signing_request.ticketbook_type,
         )
@@ -116,7 +116,7 @@ impl IssuanceTicketBook {
 
     pub async fn obtain_blinded_credential(
         &self,
-        client: &nym_http_api_client::Client,
+        client: &nym_validator_client::client::NymApiClient,
         request_body: &BlindSignRequestBody,
     ) -> Result<BlindedSignature, Error> {
         let server_response = client.blind_sign(request_body).await?;
@@ -179,7 +179,7 @@ impl IssuanceTicketBook {
     // ideally this would have been generic over credential type, but we really don't need secp256k1 keys for bandwidth vouchers
     pub async fn obtain_partial_ticketbook_credential(
         &self,
-        client: &nym_http_api_client::Client,
+        client: &nym_validator_client::client::NymApiClient,
         signer_index: u64,
         validator_vk: &VerificationKeyAuth,
         signing_data: CredentialSigningData,

common/credentials/src/ecash/utils.rs

@@ -10,7 +10,6 @@ use nym_credentials_interface::{
     VerificationKeyAuth, WalletSignatures,
 };
 use nym_validator_client::client::EcashApiClient;
-use nym_validator_client::nym_api::NymApiClientExt;
 
 // so we wouldn't break all the existing imports
 pub use nym_ecash_time::{cred_exp_date, ecash_date_offset, ecash_today, EcashTime};
@@ -52,7 +51,7 @@ pub async fn obtain_expiration_date_signatures(
     for ecash_api_client in ecash_api_clients.iter() {
         match ecash_api_client
             .api_client
-            .partial_expiration_date_signatures(None, None)
+            .partial_expiration_date_signatures(None)
             .await
         {
             Ok(signature) => {

common/credentials/src/error.rs

@@ -4,7 +4,7 @@
 use crate::ecash::bandwidth::issued::CURRENT_SERIALIZATION_REVISION;
 use nym_credentials_interface::CompactEcashError;
 use nym_crypto::asymmetric::x25519::KeyRecoveryError;
-use nym_validator_client::{nym_api::error::NymAPIError, ValidatorClientError};
+use nym_validator_client::ValidatorClientError;
 use thiserror::Error;
 
 #[derive(Debug, Error)]
@@ -37,9 +37,6 @@ pub enum Error {
     #[error("Ran into a validator client error - {0}")]
     ValidatorClientError(#[from] ValidatorClientError),
 
-    #[error("Nym API request failed - {0}")]
-    NymAPIError(#[from] NymAPIError),
-
     #[error("Bandwidth operation overflowed. {0}")]
     BandwidthOverflow(String),
 

common/crypto/Cargo.toml

@@ -11,7 +11,6 @@ repository = { workspace = true }
 aes-gcm-siv = { workspace = true, optional = true }
 aes = { workspace = true, optional = true }
 aead = { workspace = true, optional = true }
-base64.workspace = true
 bs58 = { workspace = true }
 blake3 = { workspace = true, features = ["traits-preview"], optional = true }
 ctr = { workspace = true, optional = true }

common/crypto/src/asymmetric/x25519/mod.rs

@@ -1,7 +1,6 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use base64::Engine;
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use std::fmt::{self, Debug, Display, Formatter};
 use std::str::FromStr;
@@ -159,15 +158,6 @@ impl PublicKey {
             .map_err(|source| KeyRecoveryError::MalformedPublicKeyString { source })?;
         Self::from_bytes(&bytes)
     }
-
-    pub fn from_base64(s: &str) -> Option<Self> {
-        let bytes = base64::engine::general_purpose::STANDARD.decode(s).ok()?;
-        Self::from_bytes(&bytes).ok()
-    }
-
-    pub fn to_base64(&self) -> String {
-        base64::engine::general_purpose::STANDARD.encode(self.as_bytes())
-    }
 }
 
 impl FromStr for PublicKey {

common/ecash-signer-check-types/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "nym-ecash-signer-check-types"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-readme.workspace = true
-
-[dependencies]
-semver = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-url = { workspace = true }
-thiserror = { workspace = true }
-time = { workspace = true }
-tracing = { workspace = true }
-utoipa = { workspace = true }
-
-nym-coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
-nym-crypto = { path = "../crypto", features = ["asymmetric"] }
-
-
-[lints]
-workspace = true

common/ecash-signer-check-types/src/dealer_information.rs

@@ -1,97 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_coconut_dkg_common::dealer::DealerDetails;
-use nym_coconut_dkg_common::verification_key::{ContractVKShare, VerificationKeyShare};
-use nym_crypto::asymmetric::ed25519;
-use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-use url::Url;
-use utoipa::ToSchema;
-
-#[derive(Debug, Error)]
-pub enum MalformedDealer {
-    #[error("dealer at {dealer_url} has provided invalid ed25519 pubkey: {source}")]
-    InvalidDealerPubkey {
-        dealer_url: String,
-        source: Ed25519RecoveryError,
-    },
-
-    #[error("dealer at {dealer_url} has provided invalid announce url: {source}")]
-    InvalidDealerAddress {
-        dealer_url: String,
-        source: url::ParseError,
-    },
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
-pub struct RawDealerInformation {
-    pub announce_address: String,
-    pub owner_address: String,
-    pub node_index: u64,
-    pub public_key: String,
-    pub verification_key_share: Option<VerificationKeyShare>,
-    pub share_verified: bool,
-}
-
-impl RawDealerInformation {
-    pub fn new(
-        dealer_details: &DealerDetails,
-        contract_share: Option<&ContractVKShare>,
-    ) -> RawDealerInformation {
-        RawDealerInformation {
-            announce_address: dealer_details.announce_address.clone(),
-            owner_address: dealer_details.address.to_string(),
-            node_index: dealer_details.assigned_index,
-            public_key: dealer_details.ed25519_identity.clone(),
-            verification_key_share: contract_share.map(|s| s.share.clone()),
-            share_verified: contract_share.map(|s| s.verified).unwrap_or(false),
-        }
-    }
-
-    pub fn parse(&self) -> Result<DealerInformation, MalformedDealer> {
-        Ok(DealerInformation {
-            announce_address: self.announce_address.parse().map_err(|source| {
-                MalformedDealer::InvalidDealerAddress {
-                    dealer_url: self.announce_address.clone(),
-                    source,
-                }
-            })?,
-            owner_address: self.owner_address.clone(),
-            node_index: self.node_index,
-            public_key: self.public_key.parse().map_err(|source| {
-                MalformedDealer::InvalidDealerPubkey {
-                    dealer_url: self.announce_address.clone(),
-                    source,
-                }
-            })?,
-            verification_key_share: self.verification_key_share.clone(),
-            share_verified: self.share_verified,
-        })
-    }
-}
-
-#[derive(Debug)]
-pub struct DealerInformation {
-    pub announce_address: Url,
-    pub owner_address: String,
-    pub node_index: u64,
-    pub public_key: ed25519::PublicKey,
-    // no need to parse it into the full type as it doesn't get us anything
-    pub verification_key_share: Option<VerificationKeyShare>,
-    pub share_verified: bool,
-}
-
-impl From<DealerInformation> for RawDealerInformation {
-    fn from(d: DealerInformation) -> Self {
-        RawDealerInformation {
-            announce_address: d.announce_address.to_string(),
-            owner_address: d.owner_address,
-            node_index: d.node_index,
-            public_key: d.public_key.to_base58_string(),
-            verification_key_share: d.verification_key_share,
-            share_verified: d.share_verified,
-        }
-    }
-}

common/ecash-signer-check-types/src/helper_traits.rs

@@ -1,127 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_coconut_dkg_common::types::EpochId;
-use nym_coconut_dkg_common::verification_key::VerificationKeyShare;
-use nym_crypto::asymmetric::ed25519;
-use std::time::Duration;
-use time::OffsetDateTime;
-use tracing::{debug, warn};
-
-pub trait Verifiable {
-    fn verify_signature(&self, pub_key: &ed25519::PublicKey) -> bool;
-}
-
-pub trait TimestampedResponse {
-    fn timestamp(&self) -> OffsetDateTime;
-}
-
-pub trait LegacyChainResponse {
-    fn chain_synced(&self, now: OffsetDateTime, stall_threshold: Duration) -> bool;
-}
-
-pub trait ChainResponse: Verifiable + TimestampedResponse {
-    fn chain_synced(&self) -> bool;
-
-    fn chain_available(
-        &self,
-        pub_key: &ed25519::PublicKey,
-        now: OffsetDateTime,
-        stale_response_threshold: Duration,
-    ) -> bool {
-        if !self.verify_signature(pub_key) {
-            warn!("failed signature verification on chain status response");
-            return false;
-        }
-
-        // we rely on information provided from the api itself AS LONG AS it's not too outdated
-        if self.timestamp() + stale_response_threshold < now {
-            return false;
-        }
-        self.chain_synced()
-    }
-}
-
-pub trait LegacySignerResponse {
-    fn signer_identity(&self) -> &str;
-
-    fn signer_verification_key(&self) -> &Option<String>;
-
-    fn unprovable_signing_available(
-        &self,
-        pub_key: &ed25519::PublicKey,
-        expected_verification_key: Option<VerificationKeyShare>,
-        share_verified: bool,
-    ) -> bool {
-        if self.signer_identity() != pub_key.to_base58_string() {
-            warn!("mismatched identity key on the legacy response");
-            return false;
-        }
-
-        // the contract share hasn't been verified yet, so we're probably in the middle of DKG
-        // thus if there's a bit of desync in the state, it's fine
-        if !share_verified {
-            return true;
-        }
-
-        if self.signer_verification_key() != &expected_verification_key {
-            warn!("mismatched [ecash] verification key on the legacy response");
-            return false;
-        }
-
-        true
-    }
-}
-
-pub trait SignerResponse: Verifiable + TimestampedResponse {
-    fn has_signing_keys(&self) -> bool;
-
-    fn signer_disabled(&self) -> bool;
-
-    fn is_ecash_signer(&self) -> bool;
-
-    fn dkg_ecash_epoch_id(&self) -> EpochId;
-
-    fn provable_signing_available(
-        &self,
-        pub_key: &ed25519::PublicKey,
-        dkg_epoch_id: EpochId,
-        now: OffsetDateTime,
-        stale_response_threshold: Duration,
-    ) -> bool {
-        if !self.verify_signature(pub_key) {
-            warn!("failed signature verification on chain status response");
-            return false;
-        }
-
-        // we rely on information provided from the api itself AS LONG AS it's not too outdated
-        if self.timestamp() + stale_response_threshold < now {
-            return false;
-        }
-
-        if !self.has_signing_keys() {
-            debug!("missing signing keys");
-            return false;
-        }
-
-        if self.signer_disabled() {
-            debug!("signer functionalities explicitly disabled");
-            return false;
-        }
-
-        if !self.is_ecash_signer() {
-            debug!("signer doesn't recognise it's a signer for this epoch");
-            return false;
-        }
-
-        if dkg_epoch_id != self.dkg_ecash_epoch_id() {
-            debug!(
-                "mismatched dkg epoch id. current: {dkg_epoch_id}, signer's: {}",
-                self.dkg_ecash_epoch_id()
-            );
-            return false;
-        }
-
-        true
-    }
-}

common/ecash-signer-check-types/src/lib.rs

@@ -1,6 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod dealer_information;
-pub mod helper_traits;
-pub mod status;

common/ecash-signer-check-types/src/status.rs

@@ -1,303 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::dealer_information::RawDealerInformation;
-use crate::helper_traits::{
-    ChainResponse, LegacyChainResponse, LegacySignerResponse, SignerResponse,
-};
-use nym_coconut_dkg_common::types::EpochId;
-use nym_coconut_dkg_common::verification_key::VerificationKeyShare;
-use nym_crypto::asymmetric::ed25519;
-use serde::{Deserialize, Serialize};
-use std::time::Duration;
-use time::OffsetDateTime;
-use utoipa::ToSchema;
-
-pub(crate) const CHAIN_STALL_THRESHOLD: Duration = Duration::from_secs(5 * 60);
-pub(crate) const STALE_RESPONSE_THRESHOLD: Duration = Duration::from_secs(5 * 60);
-
-// the reason for generics is not to remove duplication of code,
-// but because without them, we'd be having problems with circular dependencies,
-// i.e. nym-api-requests depending on ecash-signer-check-types and
-// ecash-signer-check-types needing nym-api-requests
-#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
-pub enum Status<L, T> {
-    /// The API, even though it reports correct version, did not response to the status query
-    Unreachable,
-
-    /// The API is running an outdated version that does not expose the required endpoint
-    Outdated,
-
-    /// Response to the legacy (unsigned) status query
-    ReachableLegacy { response: Box<L> },
-
-    /// Response to the current (signed) status query
-    Reachable { response: Box<T> },
-}
-
-impl<L, T> Status<L, T>
-where
-    L: LegacyChainResponse,
-    T: ChainResponse,
-{
-    pub fn chain_available(&self, pub_key: ed25519::PublicKey) -> bool {
-        let now = OffsetDateTime::now_utc();
-
-        match self {
-            Status::Unreachable | Status::Outdated => false,
-            Status::ReachableLegacy { response } => {
-                response.chain_synced(now, CHAIN_STALL_THRESHOLD)
-            }
-            Status::Reachable { response } => {
-                response.chain_available(&pub_key, now, STALE_RESPONSE_THRESHOLD)
-            }
-        }
-    }
-
-    pub fn chain_provably_stalled(&self, pub_key: ed25519::PublicKey) -> bool {
-        let now = OffsetDateTime::now_utc();
-
-        match self {
-            Status::Unreachable | Status::Outdated | Status::ReachableLegacy { .. } => false,
-            Status::Reachable { response } => {
-                !response.chain_available(&pub_key, now, STALE_RESPONSE_THRESHOLD)
-            }
-        }
-    }
-
-    pub fn chain_unprovably_stalled(&self) -> bool {
-        let now = OffsetDateTime::now_utc();
-
-        match self {
-            Status::Unreachable | Status::Outdated | Status::Reachable { .. } => false,
-            Status::ReachableLegacy { response } => {
-                !response.chain_synced(now, CHAIN_STALL_THRESHOLD)
-            }
-        }
-    }
-}
-
-impl<L, T> Status<L, T>
-where
-    L: LegacySignerResponse,
-    T: SignerResponse,
-{
-    pub fn signing_available(
-        &self,
-        pub_key: ed25519::PublicKey,
-        dkg_epoch_id: u64,
-        expected_verification_key: Option<VerificationKeyShare>,
-        share_verified: bool,
-    ) -> bool {
-        let now = OffsetDateTime::now_utc();
-
-        match self {
-            Status::Unreachable | Status::Outdated => false,
-            Status::ReachableLegacy { response } => response.unprovable_signing_available(
-                &pub_key,
-                expected_verification_key,
-                share_verified,
-            ),
-            Status::Reachable { response } => response.provable_signing_available(
-                &pub_key,
-                dkg_epoch_id,
-                now,
-                STALE_RESPONSE_THRESHOLD,
-            ),
-        }
-    }
-
-    pub fn signing_provably_unavailable(
-        &self,
-        pub_key: ed25519::PublicKey,
-        dkg_epoch_id: EpochId,
-    ) -> bool {
-        let now = OffsetDateTime::now_utc();
-
-        match self {
-            Status::Unreachable | Status::Outdated | Status::ReachableLegacy { .. } => false,
-            Status::Reachable { response } => !response.provable_signing_available(
-                &pub_key,
-                dkg_epoch_id,
-                now,
-                STALE_RESPONSE_THRESHOLD,
-            ),
-        }
-    }
-
-    pub fn signing_unprovably_unavailable(
-        &self,
-        pub_key: ed25519::PublicKey,
-        expected_verification_key: Option<VerificationKeyShare>,
-        share_verified: bool,
-    ) -> bool {
-        match self {
-            Status::Unreachable | Status::Outdated | Status::Reachable { .. } => false,
-            Status::ReachableLegacy { response } => !response.unprovable_signing_available(
-                &pub_key,
-                expected_verification_key,
-                share_verified,
-            ),
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
-pub struct SignerResult<LS, TS, LC, TC> {
-    pub dkg_epoch_id: u64,
-    pub information: RawDealerInformation,
-    pub status: SignerStatus<LS, TS, LC, TC>,
-}
-
-impl<LS, TS, LC, TC> SignerResult<LS, TS, LC, TC> {
-    pub fn signer_unreachable(&self) -> bool {
-        matches!(self.status, SignerStatus::Unreachable)
-    }
-
-    pub fn malformed_details(&self) -> bool {
-        self.information.parse().is_err()
-    }
-}
-
-impl<LS, TS, LC, TC> SignerResult<LS, TS, LC, TC>
-where
-    LC: LegacyChainResponse,
-    TC: ChainResponse,
-{
-    pub fn unknown_chain_status(&self) -> bool {
-        let Ok(_) = self.information.parse() else {
-            return true;
-        };
-        if let SignerStatus::Tested { .. } = &self.status {
-            return false;
-        }
-        true
-    }
-
-    pub fn chain_available(&self) -> bool {
-        let Ok(parsed_info) = self.information.parse() else {
-            return false;
-        };
-
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-        result
-            .local_chain_status
-            .chain_available(parsed_info.public_key)
-    }
-
-    pub fn chain_provably_stalled(&self) -> bool {
-        let Ok(parsed_info) = self.information.parse() else {
-            return false;
-        };
-
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-
-        result
-            .local_chain_status
-            .chain_provably_stalled(parsed_info.public_key)
-    }
-
-    pub fn chain_unprovably_stalled(&self) -> bool {
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-
-        result.local_chain_status.chain_unprovably_stalled()
-    }
-}
-
-impl<LS, TS, LC, TC> SignerResult<LS, TS, LC, TC>
-where
-    LS: LegacySignerResponse,
-    TS: SignerResponse,
-{
-    pub fn unknown_signing_status(&self) -> bool {
-        let Ok(_) = self.information.parse() else {
-            return true;
-        };
-        if let SignerStatus::Tested { .. } = &self.status {
-            return false;
-        }
-        true
-    }
-
-    pub fn signing_available(&self) -> bool {
-        let Ok(parsed_info) = self.information.parse() else {
-            return false;
-        };
-
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-        result.signing_status.signing_available(
-            parsed_info.public_key,
-            self.dkg_epoch_id,
-            parsed_info.verification_key_share,
-            parsed_info.share_verified,
-        )
-    }
-
-    pub fn signing_provably_unavailable(&self) -> bool {
-        let Ok(parsed_info) = self.information.parse() else {
-            return false;
-        };
-
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-
-        result
-            .signing_status
-            .signing_provably_unavailable(parsed_info.public_key, self.dkg_epoch_id)
-    }
-
-    pub fn signing_unprovably_unavailable(&self) -> bool {
-        let Ok(parsed_info) = self.information.parse() else {
-            return false;
-        };
-
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-
-        result.signing_status.signing_unprovably_unavailable(
-            parsed_info.public_key,
-            parsed_info.verification_key_share,
-            parsed_info.share_verified,
-        )
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
-pub enum SignerStatus<LS, TS, LC, TC> {
-    Unreachable,
-    ProvidedInvalidDetails,
-    Tested {
-        result: SignerTestResult<LS, TS, LC, TC>,
-    },
-}
-
-impl<LS, TS, LC, TC> SignerStatus<LS, TS, LC, TC> {
-    pub fn with_details(
-        self,
-        information: impl Into<RawDealerInformation>,
-        dkg_epoch_id: u64,
-    ) -> SignerResult<LS, TS, LC, TC> {
-        SignerResult {
-            dkg_epoch_id,
-            status: self,
-            information: information.into(),
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
-pub struct SignerTestResult<LS, TS, LC, TC> {
-    pub reported_version: String,
-    pub signing_status: Status<LS, TS>,
-    pub local_chain_status: Status<LC, TC>,
-}

common/ecash-signer-check/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "nym-ecash-signer-check"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-readme.workspace = true
-
-[dependencies]
-futures = { workspace = true }
-thiserror = { workspace = true }
-semver = { workspace = true }
-tokio = { workspace = true, features = ["time"] }
-tracing = { workspace = true }
-url = { workspace = true }
-
-
-nym-validator-client = { path = "../client-libs/validator-client" }
-nym-network-defaults = { path = "../network-defaults" }
-nym-ecash-signer-check-types = { path = "../ecash-signer-check-types" }
-nym-http-api-client = { path = "../http-api-client" }
-
-[lints]
-workspace = true

common/ecash-signer-check/src/client_check.rs

@@ -1,231 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{LocalChainStatus, SignerCheckError, SigningStatus, TypedSignerResult};
-use nym_ecash_signer_check_types::dealer_information::RawDealerInformation;
-use nym_ecash_signer_check_types::status::{SignerStatus, SignerTestResult};
-use nym_validator_client::models::BinaryBuildInformationOwned;
-use nym_validator_client::nym_api::NymApiClientExt;
-use nym_validator_client::nyxd::contract_traits::dkg_query_client::{
-    ContractVKShare, DealerDetails,
-};
-use std::time::Duration;
-use tracing::{error, warn};
-use url::Url;
-
-pub(crate) mod chain_status {
-
-    // Dorina
-    pub(crate) const MINIMUM_VERSION_LEGACY: semver::Version = semver::Version::new(1, 1, 51);
-
-    // Gruyere
-    pub(crate) const MINIMUM_VERSION: semver::Version = semver::Version::new(1, 1, 64);
-}
-
-pub(crate) mod signing_status {
-    // Magura (possibly earlier)
-    pub(crate) const MINIMUM_LEGACY_VERSION: semver::Version = semver::Version::new(1, 1, 46);
-
-    // Gruyere
-    pub(crate) const MINIMUM_VERSION: semver::Version = semver::Version::new(1, 1, 64);
-}
-
-struct ClientUnderTest {
-    api_client: nym_http_api_client::Client,
-    build_info: Option<BinaryBuildInformationOwned>,
-}
-
-impl ClientUnderTest {
-    pub(crate) fn new(api_url: &Url) -> Result<Self, SignerCheckError> {
-        // The builder should not fail with a valid URL that's already parsed
-        // If it does fail, it's an internal error that we can't recover from
-        let api_client = nym_http_api_client::Client::builder(api_url.clone())?.build()?;
-
-        Ok(ClientUnderTest {
-            api_client,
-            build_info: None,
-        })
-    }
-
-    pub(crate) async fn try_retrieve_build_information(&mut self) -> bool {
-        match tokio::time::timeout(Duration::from_secs(5), self.api_client.build_information())
-            .await
-        {
-            Ok(Ok(build_information)) => {
-                self.build_info = Some(build_information);
-                true
-            }
-            Ok(Err(err)) => {
-                warn!("{}: failed to retrieve build information: {err}. the signer is most likely down", self.api_client.current_url());
-                false
-            }
-            Err(_timeout) => {
-                warn!(
-                    "{}: timed out while attempting to retrieve build information",
-                    self.api_client.current_url()
-                );
-                false
-            }
-        }
-    }
-
-    pub(crate) fn version(&self) -> Option<semver::Version> {
-        self.build_info.as_ref().and_then(|build_info| {
-            build_info
-                .build_version
-                .parse()
-                .inspect_err(|err| {
-                    error!(
-                        "ecash signer '{}' reports invalid version {}: {err}",
-                        self.api_client.current_url(),
-                        build_info.build_version
-                    )
-                })
-                .ok()
-        })
-    }
-
-    pub(crate) fn supports_legacy_signing_status_query(&self) -> bool {
-        let Some(version) = self.version() else {
-            return false;
-        };
-        version >= signing_status::MINIMUM_LEGACY_VERSION
-    }
-
-    pub(crate) fn supports_signing_status_query(&self) -> bool {
-        let Some(version) = self.version() else {
-            return false;
-        };
-        version >= signing_status::MINIMUM_VERSION
-    }
-
-    pub(crate) fn supports_chain_status_query(&self) -> bool {
-        let Some(version) = self.version() else {
-            return false;
-        };
-        version >= chain_status::MINIMUM_VERSION
-    }
-
-    pub(crate) fn supports_legacy_chain_status_query(&self) -> bool {
-        let Some(version) = self.version() else {
-            return false;
-        };
-        version >= chain_status::MINIMUM_VERSION_LEGACY
-    }
-
-    pub(crate) async fn check_local_chain(&self) -> LocalChainStatus {
-        // check if it at least supports legacy query
-        if !self.supports_legacy_chain_status_query() {
-            return LocalChainStatus::Outdated;
-        }
-
-        // check if it supports the current query
-        if self.supports_chain_status_query() {
-            return match self.api_client.get_chain_blocks_status().await {
-                Ok(status) => LocalChainStatus::Reachable {
-                    response: Box::new(status),
-                },
-                Err(err) => {
-                    warn!(
-                        "{}: failed to retrieve local chain status: {err}",
-                        self.api_client.current_url()
-                    );
-                    LocalChainStatus::Unreachable
-                }
-            };
-        }
-
-        // fallback to the legacy query
-        match self.api_client.get_chain_status().await {
-            Ok(status) => LocalChainStatus::ReachableLegacy {
-                response: Box::new(status),
-            },
-            Err(err) => {
-                warn!(
-                    "{}: failed to retrieve [legacy] local chain status: {err}",
-                    self.api_client.current_url()
-                );
-                LocalChainStatus::Unreachable
-            }
-        }
-    }
-
-    pub(crate) async fn check_signing_status(&self) -> SigningStatus {
-        // check if it at least supports legacy query
-        if !self.supports_legacy_signing_status_query() {
-            return SigningStatus::Outdated;
-        }
-
-        // check if it supports the current query
-        if self.supports_signing_status_query() {
-            return match self.api_client.get_signer_status().await {
-                Ok(response) => SigningStatus::Reachable {
-                    response: Box::new(response),
-                },
-                Err(err) => {
-                    warn!(
-                        "{}: failed to retrieve signer chain status: {err}",
-                        self.api_client.current_url()
-                    );
-                    SigningStatus::Unreachable
-                }
-            };
-        }
-
-        // fallback to the legacy query
-        match self.api_client.get_signer_information().await {
-            Ok(status) => SigningStatus::ReachableLegacy {
-                response: Box::new(status),
-            },
-            Err(err) => {
-                warn!(
-                    "{}: failed to retrieve [legacy] signer chain status: {err}",
-                    self.api_client.current_url()
-                );
-                // NOTE: this might equally mean the signing is disabled
-                SigningStatus::Unreachable
-            }
-        }
-    }
-}
-
-pub(crate) async fn check_client(
-    dealer_details: DealerDetails,
-    dkg_epoch: u64,
-    contract_share: Option<&ContractVKShare>,
-) -> TypedSignerResult {
-    let dealer_information = RawDealerInformation::new(&dealer_details, contract_share);
-
-    // 7. attempt to construct client instances out of them
-    let Ok(parsed_information) = dealer_information.parse() else {
-        return SignerStatus::ProvidedInvalidDetails.with_details(dealer_information, dkg_epoch);
-    };
-
-    let mut client = match ClientUnderTest::new(&parsed_information.announce_address) {
-        Ok(client) => client,
-        Err(err) => {
-            error!("failed to create client instance: {err}");
-            return SignerStatus::Unreachable.with_details(dealer_information, dkg_epoch);
-        }
-    };
-
-    // 8. check basic connection status - can you retrieve build information?
-    if !client.try_retrieve_build_information().await {
-        return SignerStatus::Unreachable.with_details(dealer_information, dkg_epoch);
-    }
-
-    // 9. check perceived chain status
-    let local_chain_status = client.check_local_chain().await;
-
-    // 10. check signer status
-    let signing_status = client.check_signing_status().await;
-
-    SignerStatus::Tested {
-        result: SignerTestResult {
-            reported_version: client.version().map(|v| v.to_string()).unwrap_or_default(),
-            signing_status,
-            local_chain_status,
-        },
-    }
-    .with_details(dealer_information, dkg_epoch)
-}

common/ecash-signer-check/src/dealer_information.rs

@@ -1,80 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::SignerCheckError;
-use nym_crypto::asymmetric::ed25519;
-use nym_validator_client::nyxd::contract_traits::dkg_query_client::{
-    ContractVKShare, DealerDetails, VerificationKeyShare,
-};
-use url::Url;
-
-#[derive(Debug)]
-pub struct RawDealerInformation {
-    pub announce_address: String,
-    pub owner_address: String,
-    pub node_index: u64,
-    pub public_key: String,
-    pub verification_key_share: Option<VerificationKeyShare>,
-    pub share_verified: bool,
-}
-
-impl RawDealerInformation {
-    pub fn new(
-        dealer_details: &DealerDetails,
-        contract_share: Option<&ContractVKShare>,
-    ) -> RawDealerInformation {
-        RawDealerInformation {
-            announce_address: dealer_details.announce_address.clone(),
-            owner_address: dealer_details.address.to_string(),
-            node_index: dealer_details.assigned_index,
-            public_key: dealer_details.ed25519_identity.clone(),
-            verification_key_share: contract_share.map(|s| s.share.clone()),
-            share_verified: contract_share.map(|s| s.verified).unwrap_or(false),
-        }
-    }
-
-    pub fn parse(&self) -> Result<DealerInformation, SignerCheckError> {
-        Ok(DealerInformation {
-            announce_address: self.announce_address.parse().map_err(|source| {
-                SignerCheckError::InvalidDealerAddress {
-                    dealer_url: self.announce_address.clone(),
-                    source,
-                }
-            })?,
-            owner_address: self.owner_address.clone(),
-            node_index: self.node_index,
-            public_key: self.announce_address.parse().map_err(|source| {
-                SignerCheckError::InvalidDealerPubkey {
-                    dealer_url: self.announce_address.clone(),
-                    source,
-                }
-            })?,
-            verification_key_share: self.verification_key_share.clone(),
-            share_verified: self.share_verified,
-        })
-    }
-}
-
-#[derive(Debug)]
-pub struct DealerInformation {
-    pub announce_address: Url,
-    pub owner_address: String,
-    pub node_index: u64,
-    pub public_key: ed25519::PublicKey,
-    // no need to parse it into the full type as it doesn't get us anything
-    pub verification_key_share: Option<VerificationKeyShare>,
-    pub share_verified: bool,
-}
-
-impl From<DealerInformation> for RawDealerInformation {
-    fn from(d: DealerInformation) -> Self {
-        RawDealerInformation {
-            announce_address: d.announce_address.to_string(),
-            owner_address: d.owner_address,
-            node_index: d.node_index,
-            public_key: d.public_key.to_base58_string(),
-            verification_key_share: d.verification_key_share,
-            share_verified: d.share_verified,
-        }
-    }
-}

common/ecash-signer-check/src/error.rs

@@ -1,31 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_http_api_client::HttpClientError;
-use nym_validator_client::nyxd::error::NyxdError;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum SignerCheckError {
-    #[error("failed to connect to nyxd chain due to invalid connection details: {source}")]
-    InvalidNyxdConnectionDetails { source: NyxdError },
-
-    #[error("failed to query the DKG contract: {source}")]
-    DKGContractQueryFailure { source: NyxdError },
-
-    #[error("failed to build client: {source}")]
-    HttpClient {
-        #[from]
-        source: HttpClientError,
-    },
-}
-
-impl SignerCheckError {
-    pub fn invalid_nyxd_connection_details(source: NyxdError) -> Self {
-        Self::InvalidNyxdConnectionDetails { source }
-    }
-
-    pub fn dkg_contract_query_failure(source: NyxdError) -> Self {
-        Self::DKGContractQueryFailure { source }
-    }
-}

common/ecash-signer-check/src/lib.rs

@@ -1,127 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client_check::check_client;
-use futures::stream::{FuturesUnordered, StreamExt};
-use nym_network_defaults::NymNetworkDetails;
-use nym_validator_client::nyxd::contract_traits::{DkgQueryClient, PagedDkgQueryClient};
-use nym_validator_client::QueryHttpRpcNyxdClient;
-use std::collections::HashMap;
-use url::Url;
-
-pub use error::SignerCheckError;
-use nym_ecash_signer_check_types::status::{SignerResult, Status};
-use nym_validator_client::ecash::models::EcashSignerStatusResponse;
-use nym_validator_client::models::{
-    ChainBlocksStatusResponse, ChainStatusResponse, SignerInformationResponse,
-};
-use nym_validator_client::nyxd::contract_traits::dkg_query_client::{
-    ContractVKShare, DealerDetails, Epoch,
-};
-
-mod client_check;
-pub mod error;
-
-pub type TypedSignerResult = SignerResult<
-    SignerInformationResponse,
-    EcashSignerStatusResponse,
-    ChainStatusResponse,
-    ChainBlocksStatusResponse,
->;
-pub type LocalChainStatus = Status<ChainStatusResponse, ChainBlocksStatusResponse>;
-pub type SigningStatus = Status<SignerInformationResponse, EcashSignerStatusResponse>;
-
-pub struct SignersTestResult {
-    pub threshold: Option<u64>,
-    pub results: Vec<TypedSignerResult>,
-}
-
-pub async fn check_signers(
-    rpc_endpoint: Url,
-    // details such as denoms, prefixes, etc.
-    network_details: NymNetworkDetails,
-) -> Result<SignersTestResult, SignerCheckError> {
-    // 1. create nyx client instance
-    let client = QueryHttpRpcNyxdClient::connect_with_network_details(
-        rpc_endpoint.as_str(),
-        network_details,
-    )
-    .map_err(SignerCheckError::invalid_nyxd_connection_details)?;
-
-    check_signers_with_client(&client).await
-}
-
-pub struct DkgDetails {
-    pub dkg_epoch: Epoch,
-    pub threshold: Option<u64>,
-    pub network_dealers: Vec<DealerDetails>,
-    pub submitted_shared: HashMap<u64, ContractVKShare>,
-}
-
-pub async fn check_signers_with_client<C>(client: &C) -> Result<SignersTestResult, SignerCheckError>
-where
-    C: DkgQueryClient + Sync,
-{
-    let dkg_details = dkg_details_with_client(client).await?;
-    check_known_dealers(dkg_details).await
-}
-
-pub async fn dkg_details_with_client<C>(client: &C) -> Result<DkgDetails, SignerCheckError>
-where
-    C: DkgQueryClient + Sync,
-{
-    // 2. retrieve current dkg epoch
-    let dkg_epoch = client
-        .get_current_epoch()
-        .await
-        .map_err(SignerCheckError::dkg_contract_query_failure)?;
-
-    // 3. retrieve the dkg threshold as reference point
-    let threshold = client
-        .get_epoch_threshold(dkg_epoch.epoch_id)
-        .await
-        .map_err(SignerCheckError::dkg_contract_query_failure)?;
-
-    // 4. retrieve information on current DKG dealers (i.e. eligible signers)
-    let dealers = client
-        .get_all_current_dealers()
-        .await
-        .map_err(SignerCheckError::dkg_contract_query_failure)?;
-
-    // 5. retrieve their published keys (if available)
-    let shares: HashMap<_, _> = client
-        .get_all_verification_key_shares(dkg_epoch.epoch_id)
-        .await
-        .map_err(SignerCheckError::dkg_contract_query_failure)?
-        .into_iter()
-        .map(|share| (share.node_index, share))
-        .collect();
-
-    Ok(DkgDetails {
-        dkg_epoch,
-        threshold,
-        network_dealers: dealers,
-        submitted_shared: shares,
-    })
-}
-
-pub async fn check_known_dealers(
-    dkg_details: DkgDetails,
-) -> Result<SignersTestResult, SignerCheckError> {
-    // 6. for each dealer attempt to perform the checks
-    let results = dkg_details
-        .network_dealers
-        .into_iter()
-        .map(|d| {
-            let share = dkg_details.submitted_shared.get(&d.assigned_index);
-            check_client(d, dkg_details.dkg_epoch.epoch_id, share)
-        })
-        .collect::<FuturesUnordered<_>>()
-        .collect::<Vec<_>>()
-        .await;
-
-    Ok(SignersTestResult {
-        threshold: dkg_details.threshold,
-        results,
-    })
-}

common/ecash-signer-check/src/status.rs

@@ -1,73 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::chain_status::LocalChainStatus;
-use crate::dealer_information::RawDealerInformation;
-use crate::signing_status::SigningStatus;
-use std::time::Duration;
-
-pub(crate) const STALE_RESPONSE_THRESHOLD: Duration = Duration::from_secs(5 * 60);
-
-#[derive(Debug)]
-pub struct SignerResult {
-    pub dkg_epoch_id: u64,
-    pub information: RawDealerInformation,
-    pub status: SignerStatus,
-}
-
-impl SignerResult {
-    pub fn chain_available(&self) -> bool {
-        let Ok(parsed_info) = self.information.parse() else {
-            return false;
-        };
-
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-        result.local_chain_status.available(parsed_info.public_key)
-    }
-
-    pub fn signer_available(&self) -> bool {
-        let Ok(parsed_info) = self.information.parse() else {
-            return false;
-        };
-        let SignerStatus::Tested { result } = &self.status else {
-            return false;
-        };
-
-        result.signing_status.available(
-            parsed_info.public_key,
-            self.dkg_epoch_id,
-            parsed_info.verification_key_share,
-            parsed_info.share_verified,
-        )
-    }
-}
-
-#[derive(Debug)]
-pub enum SignerStatus {
-    Unreachable,
-    ProvidedInvalidDetails,
-    Tested { result: SignerTestResult },
-}
-
-impl SignerStatus {
-    pub fn with_details(
-        self,
-        information: impl Into<RawDealerInformation>,
-        dkg_epoch_id: u64,
-    ) -> SignerResult {
-        SignerResult {
-            dkg_epoch_id,
-            status: self,
-            information: information.into(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct SignerTestResult {
-    pub reported_version: String,
-    pub signing_status: SigningStatus,
-    pub local_chain_status: LocalChainStatus,
-}

common/gateway-requests/Cargo.toml

@@ -47,7 +47,4 @@ workspace = true
 default-features = false
 
 [dev-dependencies]
-anyhow = { workspace = true }
 nym-compact-ecash = { path = "../nym_offline_compact_ecash" } # we need specific imports in tests
-nym-test-utils = { path = "../test-utils" }
-tokio = { workspace = true, features = ["full"] }

common/gateway-requests/src/models.rs

@@ -89,7 +89,7 @@ mod tests {
         .unwrap();
         let blind_sig = issue(
             keypair.secret_key(),
-            sig_req.ecash_pub_key,
+            sig_req.ecash_pub_key.clone(),
             &sig_req.withdrawal_request,
             expiration_date.ecash_unix_timestamp(),
             issuance.ticketbook_type().encode(),

common/gateway-requests/src/registration/handshake/mod.rs

@@ -109,85 +109,3 @@ GATEWAY -> CLIENT
 DONE(status)
 
 */
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::ClientControlRequest;
-    use futures::StreamExt;
-    use nym_test_utils::helpers::u64_seeded_rng;
-    use nym_test_utils::mocks::stream_sink::mock_streams;
-    use nym_test_utils::traits::{Leak, Timeboxed, TimeboxedSpawnable};
-    use tokio::join;
-    use tungstenite::Message;
-
-    #[tokio::test]
-    async fn basic_handshake() -> anyhow::Result<()> {
-        use anyhow::Context as _;
-
-        // solve the lifetime issue by just leaking the contents of the boxes
-        // which is perfectly fine in test
-        let client_rng = u64_seeded_rng(42).leak();
-        let gateway_rng = u64_seeded_rng(69).leak();
-
-        let client_keys = ed25519::KeyPair::new(client_rng).leak();
-        let gateway_keys = ed25519::KeyPair::new(gateway_rng).leak();
-
-        let (client_ws, gateway_ws) = mock_streams::<Message>();
-
-        // we need streams that return Result<Message, WsError>
-        let client_ws = client_ws.map(Ok);
-        let gateway_ws = gateway_ws.map(Ok);
-
-        let client_ws = client_ws.leak();
-        let gateway_ws = gateway_ws.leak();
-
-        let handshake_client = client_handshake(
-            client_rng,
-            client_ws,
-            client_keys,
-            *gateway_keys.public_key(),
-            false,
-            true,
-            TaskClient::dummy(),
-        );
-
-        let client_fut = handshake_client.spawn_timeboxed();
-
-        // we need to receive the first message so that it could be propagated to the gateway side of the handshake
-        let ClientControlRequest::RegisterHandshakeInitRequest {
-            protocol_version: _,
-            data,
-        } = (gateway_ws.next())
-            .timeboxed()
-            .await
-            .context("timeout")?
-            .context("no message!")??
-            .into_text()?
-            .parse::<ClientControlRequest>()?
-        else {
-            panic!("bad message")
-        };
-
-        let init_msg = data;
-
-        let handshake_gateway = gateway_handshake(
-            gateway_rng,
-            gateway_ws,
-            gateway_keys,
-            init_msg,
-            TaskClient::dummy(),
-        );
-
-        let gateway_fut = handshake_gateway.spawn_timeboxed();
-        let (client, gateway) = join!(client_fut, gateway_fut);
-
-        let client_key = client???;
-        let gateway_key = gateway???;
-
-        // ensure the created keys are the same
-        assert_eq!(client_key, gateway_key);
-
-        Ok(())
-    }
-}

common/gateway-stats-storage/Cargo.toml

@@ -7,7 +7,6 @@ homepage.workspace = true
 documentation.workspace = true
 edition.workspace = true
 license.workspace = true
-rust-version.workspace = true
 
 [dependencies]
 sqlx = { workspace = true, features = [
@@ -28,7 +27,6 @@ nym-statistics-common = { path = "../statistics" }
 
 
 [build-dependencies]
-anyhow = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 sqlx = { workspace = true, features = [
     "runtime-tokio-rustls",

common/gateway-stats-storage/build.rs

@@ -1,29 +1,22 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
-use anyhow::Context;
 use sqlx::{Connection, SqliteConnection};
 use std::env;
 
 #[tokio::main]
-async fn main() -> anyhow::Result<()> {
-    let out_dir = env::var("OUT_DIR")?;
+async fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
     let database_path = format!("{out_dir}/gateway-stats-example.sqlite");
 
-    // remove the db file if it already existed from previous build
-    // in case it was from a different branch
-    if std::fs::exists(&database_path)? {
-        std::fs::remove_file(&database_path)?;
-    }
-
     let mut conn = SqliteConnection::connect(&format!("sqlite://{database_path}?mode=rwc"))
         .await
-        .context("Failed to create SQLx database connection")?;
+        .expect("Failed to create SQLx database connection");
 
     sqlx::migrate!("./migrations")
         .run(&mut conn)
         .await
-        .context("Failed to perform SQLx migrations")?;
+        .expect("Failed to perform SQLx migrations");
 
     #[cfg(target_family = "unix")]
     println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
@@ -32,6 +25,4 @@ async fn main() -> anyhow::Result<()> {
     // 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);
-
-    Ok(())
 }