test: remove file after closing for a test

.github/actions/nym-hash-releases/src/package-lock.json

@@ -415,9 +415,9 @@
       }
     },
     "node_modules/undici": {
-      "version": "5.29.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-5.29.0.tgz",
-      "integrity": "sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==",
+      "version": "5.28.5",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-5.28.5.tgz",
+      "integrity": "sha512-zICwjrDrcrUE0pyyJc1I2QzBkLM8FINsgOrt6WjA+BgajVq9Nxu2PbFFXUrAggLfDXlZGZBVZYw7WNV5KiBiBA==",
       "license": "MIT",
       "dependencies": {
         "@fastify/busboy": "^2.0.0"

.github/workflows/ci-build.yml

@@ -5,6 +5,7 @@ on:
     paths:
       - 'clients/**'
       - 'common/**'
+      - 'explorer-api/**'
       - 'gateway/**'
       - 'integrations/**'
       - 'nym-api/**'
@@ -38,7 +39,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ arc-ubuntu-22.04, custom-windows-11, custom-macos-15 ]
+        os: [ arc-ubuntu-22.04, custom-windows-11, custom-runner-mac-m1 ]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always

.github/workflows/ci-check-ns-api-version.yml

@@ -44,10 +44,8 @@ jobs:
             echo "Tag is empty"
             exit 1
           fi
-          # first, list all tags for logging purposes
           curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq
-          # check if there's a matching tag
-          exists=$(curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq -r --arg tag "$TAG" 'any(.tags[]; . == $tag)' )
+          exists=$(curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq --arg tag $TAG '.tags | contains([$tag])' )
           if [[ $exists = "true" ]]; then
             echo "Version '$TAG' defined in Cargo.toml ALREADY EXISTS as tag in harbor repo"
             exit 1
@@ -55,5 +53,5 @@ jobs:
             echo "Version '$TAG' doesn't exist on the remote"
           else
             echo "Unknown output '$exists'"
-            exit 2
+            exit 1
           fi

.github/workflows/ci-check-nym-stats-api-version.yml

@@ -1,59 +0,0 @@
-name: ci-check-nym-stats-api-version
-
-on:
-  pull_request:
-    paths:
-      - "nym-statistics-api/**"
-
-env:
-  WORKING_DIRECTORY: "nym-statistics-api"
-
-jobs:
-  check-if-tag-exists:
-    runs-on: arc-ubuntu-22.04-dind
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v4
-
-      - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.45.4
-        id: get_version
-        with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
-
-      - name: Check if git tag exists
-        run: |
-          TAG=${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-          if [[ -z "$TAG" ]]; then
-            echo "Tag is empty"
-            exit 1
-          fi
-          git ls-remote --tags origin | awk '{print $2}'
-          if git ls-remote --tags origin | awk '{print $2}' | grep -q "refs/tags/$TAG$" ; then
-              echo "Tag '$TAG' ALREADY EXISTS on the remote"
-              exit 1
-          else
-              echo "Tag '$TAG' does not exist on the remote"
-          fi
-      - name: Check if harbor tag exists
-        run: |
-          TAG=${{ steps.get_version.outputs.result }}
-          registry=https://harbor.nymte.ch
-          repo_name=nym/nym-statistics-api
-          if [[ -z $TAG ]]; then
-            echo "Tag is empty"
-            exit 1
-          fi
-          # first, list all tags for logging purposes
-          curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq
-          # check if there's a matching tag
-          exists=$(curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq -r --arg tag "$TAG" 'any(.tags[]; . == $tag)' )
-          if [[ $exists = "true" ]]; then
-            echo "Version '$TAG' defined in Cargo.toml ALREADY EXISTS as tag in harbor repo"
-            exit 1
-          elif [[ $exists = "false" ]]; then
-            echo "Version '$TAG' doesn't exist on the remote"
-          else
-            echo "Unknown output '$exists'"
-            exit 2
-          fi

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

@@ -56,7 +56,6 @@ jobs:
           cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/nym_ecash.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_pool_contract.wasm $OUTPUT_DIR
 
       - name: Deploy branch to CI www
         continue-on-error: true

.github/workflows/publish-nym-binaries.yml

@@ -74,10 +74,10 @@ jobs:
             target/release/nymvisor
             target/release/nym-node
           retention-days: 30
-    
+
       - id: create-release
         name: Upload to release based on tag name
-        uses: softprops/action-gh-release@da05d552573ad5aba039eaac05058a918a7bf631
+        uses: softprops/action-gh-release@v2
         if: github.event_name == 'release'
         with:
           files: |

.github/workflows/push-nym-statistics-api.yaml

@@ -1,42 +0,0 @@
-name: Build and upload Nym Statistics API container to harbor.nymte.ch
-on:
-  workflow_dispatch:
-
-env:
-  WORKING_DIRECTORY: "nym-statistics-api"
-  CONTAINER_NAME: "nym-statistics-api"
-
-jobs:
-  build-container:
-    runs-on: arc-ubuntu-22.04-dind
-    steps:
-      - name: Login to Harbor
-        uses: docker/login-action@v3
-        with:
-          registry: harbor.nymte.ch
-          username: ${{ secrets.HARBOR_ROBOT_USERNAME }}
-          password: ${{ secrets.HARBOR_ROBOT_SECRET }}
-
-      - name: Checkout repo
-        uses: actions/checkout@v4
-
-      - name: Configure git identity
-        run: |
-          git config --global user.email "lawrence@nymtech.net"
-          git config --global user.name "Lawrence Stalder"
-
-      - name: Get version from cargo.toml
-        uses: mikefarah/yq@v4.45.4
-        id: get_version
-        with:
-          cmd: yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml
-
-      - name: Create tag
-        run: |
-          git tag -a ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }} -m "Version ${{ steps.get_version.outputs.result }}"
-          git push origin ${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}
-
-      - name: BuildAndPushImageOnHarbor
-        run: |
-          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:${{ steps.get_version.outputs.result }} -t harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }}:latest
-          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags

.gitignore

@@ -40,6 +40,7 @@ validator-config
 validator-api-config.toml
 dist
 storybook-static
+envs/qwerty.env
 .parcel-cache
 **/.DS_Store
 cpu-cycles/libcpucycles/build

Cargo.toml

@@ -33,13 +33,11 @@ members = [
     "common/commands",
     "common/config",
     "common/cosmwasm-smart-contracts/coconut-dkg",
-    "common/cosmwasm-smart-contracts/contracts-common",
-    "common/cosmwasm-smart-contracts/easy_addr",
+    "common/cosmwasm-smart-contracts/contracts-common", "common/cosmwasm-smart-contracts/easy_addr",
     "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-pool-contract",
     "common/cosmwasm-smart-contracts/vesting-contract",
     "common/credential-storage",
     "common/credential-utils",
@@ -64,11 +62,8 @@ members = [
     "common/node-tester-utils",
     "common/nonexhaustive-delayqueue",
     "common/nym-id",
-    "common/nym-psq-kkt",
     "common/nym-metrics",
     "common/nym_offline_compact_ecash",
-    "common/nymnoise",
-    "common/nymnoise/keys",
     "common/nymsphinx",
     "common/nymsphinx/acknowledgements",
     "common/nymsphinx/addressing",
@@ -102,6 +97,7 @@ members = [
     "common/wireguard-types",
     "documentation/autodoc",
     "gateway",
+    "integrations/bity",
     "nym-api",
     "nym-api/nym-api-requests",
     "nym-browser-extension/storage",
@@ -137,8 +133,7 @@ members = [
     "tools/internal/testnet-manager",
     "tools/internal/testnet-manager",
     "tools/internal/testnet-manager/dkg-bypass-contract",
-    "tools/internal/testnet-manager/dkg-bypass-contract",
-    "tools/internal/validator-status-check",
+    "tools/internal/testnet-manager/dkg-bypass-contract", "tools/internal/validator-status-check",
     "tools/nym-cli",
     "tools/nym-id-cli",
     "tools/nym-nr-query",
@@ -206,7 +201,7 @@ bloomfilter = "3.0.1"
 bs58 = "0.5.1"
 bytecodec = "0.4.15"
 bytes = "1.10.1"
-cargo_metadata = "0.19.2"
+cargo_metadata = "0.18.1"
 celes = "2.6.0"
 cfg-if = "1.0.0"
 chacha20 = "0.9.0"
@@ -314,9 +309,8 @@ serde_with = "3.9.0"
 serde_yaml = "0.9.25"
 sha2 = "0.10.9"
 si-scale = "0.2.3"
-snow = "0.9.6"
 sphinx-packet = "=0.6.0"
-sqlx = "0.8.6"
+sqlx = "0.7.4"
 strum = "0.26"
 strum_macros = "0.26"
 subtle-encoding = "0.5"
@@ -324,10 +318,10 @@ syn = "1"
 sysinfo = "0.33.0"
 tap = "1.0.1"
 tar = "0.4.44"
-tempfile = "3.20"
+tempfile = "3.19"
 thiserror = "2.0"
 time = "0.3.41"
-tokio = "1.45"
+tokio = "1.44"
 tokio-postgres = "0.7"
 tokio-stream = "0.1.17"
 tokio-test = "0.4.4"
@@ -354,6 +348,7 @@ utoipauto = "0.2"
 uuid = "*"
 vergen = { version = "=8.3.1", default-features = false }
 walkdir = "2"
+wasm-bindgen-test = "0.3.49"
 x25519-dalek = "2.0.0"
 zeroize = "1.7.0"
 
@@ -401,7 +396,6 @@ serde-wasm-bindgen = "0.6.5"
 tsify = "0.4.5"
 wasm-bindgen = "0.2.99"
 wasm-bindgen-futures = "0.4.49"
-wasm-bindgen-test = "0.3.49"
 wasmtimer = "0.4.1"
 web-sys = "0.3.76"
 

Makefile

@@ -133,7 +133,7 @@ clippy: sdk-wasm-lint
 # Build contracts ready for deploy
 # -----------------------------------------------------------------------------
 
-CONTRACTS=vesting_contract mixnet_contract nym_ecash cw3_flex_multisig cw4_group nym_coconut_dkg nym_pool_contract
+CONTRACTS=vesting_contract mixnet_contract nym_ecash cw3_flex_multisig cw4_group nym_coconut_dkg
 CONTRACTS_WASM=$(addsuffix .wasm, $(CONTRACTS))
 CONTRACTS_OUT_DIR=contracts/target/wasm32-unknown-unknown/release
 

clients/native/examples/js-examples/websocket/package-lock.json

@@ -2048,11 +2048,10 @@
       }
     },
     "node_modules/http-proxy-middleware": {
-      "version": "2.0.9",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz",
-      "integrity": "sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.4.tgz",
+      "integrity": "sha512-m/4FxX17SUvz4lJ5WPXOHDUuCwIqXLfLHs1s0uZ3oYjhoXlx9csYxaOa0ElDEJ+h8Q4iJ1s+lTMbiCa4EXIJqg==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@types/http-proxy": "^1.17.8",
         "http-proxy": "^1.18.1",
@@ -6096,9 +6095,9 @@
       }
     },
     "http-proxy-middleware": {
-      "version": "2.0.9",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz",
-      "integrity": "sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.4.tgz",
+      "integrity": "sha512-m/4FxX17SUvz4lJ5WPXOHDUuCwIqXLfLHs1s0uZ3oYjhoXlx9csYxaOa0ElDEJ+h8Q4iJ1s+lTMbiCa4EXIJqg==",
       "dev": true,
       "requires": {
         "@types/http-proxy": "^1.17.8",

common/authenticator-requests/src/v1/registration.rs

@@ -108,7 +108,7 @@ impl GatewayClient {
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
         // use gateways key as a ref to an x25519_dalek key
-        let dh = gateway_key.inner().diffie_hellman(&self.pub_key);
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]

common/authenticator-requests/src/v2/registration.rs

@@ -117,7 +117,7 @@ impl GatewayClient {
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
         // use gateways key as a ref to an x25519_dalek key
-        let dh = gateway_key.inner().diffie_hellman(&self.pub_key);
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]

common/authenticator-requests/src/v3/registration.rs

@@ -117,7 +117,7 @@ impl GatewayClient {
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
         // use gateways key as a ref to an x25519_dalek key
-        let dh = gateway_key.inner().diffie_hellman(&self.pub_key);
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]

common/authenticator-requests/src/v4/registration.rs

@@ -169,7 +169,7 @@ impl GatewayClient {
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
         // use gateways key as a ref to an x25519_dalek key
-        let dh = gateway_key.inner().diffie_hellman(&self.pub_key);
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]

common/authenticator-requests/src/v5/registration.rs

@@ -169,7 +169,7 @@ impl GatewayClient {
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
         // use gateways key as a ref to an x25519_dalek key
-        let dh = gateway_key.inner().diffie_hellman(&self.pub_key);
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]

common/client-core/Cargo.toml

@@ -44,6 +44,7 @@ nym-sphinx = { path = "../nymsphinx" }
 nym-statistics-common = { path = "../statistics" }
 nym-pemstore = { path = "../pemstore" }
 nym-topology = { path = "../topology", features = ["persistence"] }
+nym-mixnet-client = { path = "../client-libs/mixnet-client", default-features = false }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 nym-task = { path = "../task" }
 nym-credentials-interface = { path = "../credentials-interface" }
@@ -56,9 +57,6 @@ nym-client-core-surb-storage = { path = "./surb-storage" }
 nym-client-core-gateways-storage = { path = "./gateways-storage" }
 nym-ecash-time = { path = "../ecash-time" }
 
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies]
-nym-mixnet-client = { path = "../client-libs/mixnet-client", default-features = false }
-
 ### For serving prometheus metrics
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.hyper]
 workspace = true

common/client-core/gateways-storage/src/backend/fs_backend/manager.rs

@@ -87,7 +87,7 @@ impl StorageManager {
         sqlx::query!("SELECT EXISTS (SELECT 1 FROM registered_gateway WHERE gateway_id_bs58 = ?) AS 'exists'", gateway_id)
             .fetch_one(&self.connection_pool)
             .await
-            .map(|result| result.exists == 1)
+            .map(|result| result.exists == Some(1))
     }
 
     pub(crate) async fn maybe_get_registered_gateway(

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

@@ -12,7 +12,7 @@ use crate::client::topology_control::{TopologyAccessor, TopologyReadPermit};
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessage, ReplyMessage};
-use nym_sphinx::anonymous_replies::ReplySurbWithKeyRotation;
+use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey};
 use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx::message::NymMessage;
 use nym_sphinx::params::{PacketSize, PacketType};
@@ -44,10 +44,7 @@ pub enum PreparationError {
 }
 
 impl PreparationError {
-    fn return_surbs(
-        self,
-        returned_surbs: Vec<ReplySurbWithKeyRotation>,
-    ) -> SurbWrappedPreparationError {
+    fn return_surbs(self, returned_surbs: Vec<ReplySurb>) -> SurbWrappedPreparationError {
         SurbWrappedPreparationError {
             source: self,
             returned_surbs: Some(returned_surbs),
@@ -61,7 +58,7 @@ pub struct SurbWrappedPreparationError {
     #[source]
     source: PreparationError,
 
-    returned_surbs: Option<Vec<ReplySurbWithKeyRotation>>,
+    returned_surbs: Option<Vec<ReplySurb>>,
 }
 
 impl<T> From<T> for SurbWrappedPreparationError
@@ -271,10 +268,10 @@ where
         }
     }
 
-    async fn generate_reply_surbs(
+    async fn generate_reply_surbs_with_keys(
         &mut self,
         amount: usize,
-    ) -> Result<Vec<ReplySurbWithKeyRotation>, PreparationError> {
+    ) -> Result<(Vec<ReplySurb>, Vec<SurbEncryptionKey>), PreparationError> {
         let topology_permit = self.topology_access.get_read_permit().await;
         let topology = self.get_topology(&topology_permit)?;
 
@@ -284,14 +281,19 @@ where
             topology,
         )?;
 
-        Ok(reply_surbs)
+        let reply_keys = reply_surbs
+            .iter()
+            .map(|s| *s.encryption_key())
+            .collect::<Vec<_>>();
+
+        Ok((reply_surbs, reply_keys))
     }
 
     pub(crate) async fn try_send_single_surb_message(
         &mut self,
         target: AnonymousSenderTag,
         message: ReplyMessage,
-        reply_surb: ReplySurbWithKeyRotation,
+        reply_surb: ReplySurb,
         is_extra_surb_request: bool,
     ) -> Result<(), SurbWrappedPreparationError> {
         let msg = NymMessage::new_reply(message);
@@ -345,7 +347,7 @@ where
     pub(crate) async fn try_request_additional_reply_surbs(
         &mut self,
         from: AnonymousSenderTag,
-        reply_surb: ReplySurbWithKeyRotation,
+        reply_surb: ReplySurb,
         amount: u32,
     ) -> Result<(), SurbWrappedPreparationError> {
         debug!("requesting {amount} reply SURBs from {from}");
@@ -385,7 +387,7 @@ where
         &mut self,
         target: AnonymousSenderTag,
         fragments: Vec<FragmentWithMaxRetransmissions>,
-        reply_surbs: Vec<ReplySurbWithKeyRotation>,
+        reply_surbs: Vec<ReplySurb>,
         lane: TransmissionLane,
     ) -> Result<(), SurbWrappedPreparationError> {
         // TODO: technically this is performing an unnecessary cloning, but in the grand scheme of things
@@ -402,7 +404,7 @@ where
         &mut self,
         target: AnonymousSenderTag,
         fragments: Vec<(TransmissionLane, FragmentWithMaxRetransmissions)>,
-        reply_surbs: Vec<ReplySurbWithKeyRotation>,
+        reply_surbs: Vec<ReplySurb>,
     ) -> Result<(), SurbWrappedPreparationError> {
         let prepared_fragments = self
             .prepare_reply_chunks_for_sending(
@@ -539,12 +541,8 @@ where
     ) -> Result<(), PreparationError> {
         debug!("Sending additional reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
-        let reply_surbs = self.generate_reply_surbs(amount as usize).await?;
-
-        let reply_keys = reply_surbs
-            .iter()
-            .map(|s| *s.encryption_key())
-            .collect::<Vec<_>>();
+        let (reply_surbs, reply_keys) =
+            self.generate_reply_surbs_with_keys(amount as usize).await?;
 
         let message = NymMessage::new_repliable(RepliableMessage::new_additional_surbs(
             self.config.use_legacy_sphinx_format,
@@ -581,12 +579,9 @@ where
     ) -> Result<(), SurbWrappedPreparationError> {
         debug!("Sending message with reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
-        let reply_surbs = self.generate_reply_surbs(num_reply_surbs as usize).await?;
-
-        let reply_keys = reply_surbs
-            .iter()
-            .map(|s| *s.encryption_key())
-            .collect::<Vec<_>>();
+        let (reply_surbs, reply_keys) = self
+            .generate_reply_surbs_with_keys(num_reply_surbs as usize)
+            .await?;
 
         let message = NymMessage::new_repliable(RepliableMessage::new_data(
             self.config.use_legacy_sphinx_format,
@@ -634,7 +629,7 @@ where
     pub(crate) async fn prepare_reply_chunks_for_sending(
         &mut self,
         fragments: Vec<Fragment>,
-        reply_surbs: Vec<ReplySurbWithKeyRotation>,
+        reply_surbs: Vec<ReplySurb>,
     ) -> Result<Vec<PreparedFragment>, SurbWrappedPreparationError> {
         debug_assert_eq!(
             fragments.len(),
@@ -670,7 +665,7 @@ where
 
     pub(crate) async fn try_prepare_single_reply_chunk_for_sending(
         &mut self,
-        reply_surb: ReplySurbWithKeyRotation,
+        reply_surb: ReplySurb,
         chunk: Fragment,
     ) -> Result<PreparedFragment, SurbWrappedPreparationError> {
         let topology_permit = self.topology_access.get_read_permit().await;

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

@@ -11,7 +11,7 @@ use futures::StreamExt;
 use log::{debug, error, info, trace, warn};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::anonymous_replies::ReplySurbWithKeyRotation;
+use nym_sphinx::anonymous_replies::ReplySurb;
 use nym_sphinx::chunking::fragment::FragmentIdentifier;
 use nym_task::connections::{ConnectionId, TransmissionLane};
 use nym_task::TaskClient;
@@ -499,7 +499,7 @@ where
     async fn handle_received_surbs(
         &mut self,
         from: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurbWithKeyRotation>,
+        reply_surbs: Vec<ReplySurb>,
         from_surb_request: bool,
     ) {
         trace!("handling received surbs");

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

@@ -6,7 +6,7 @@ use futures::channel::{mpsc, oneshot};
 use log::error;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::anonymous_replies::ReplySurbWithKeyRotation;
+use nym_sphinx::anonymous_replies::ReplySurb;
 use nym_task::connections::{ConnectionId, TransmissionLane};
 use std::sync::Weak;
 
@@ -81,7 +81,7 @@ impl ReplyControllerSender {
     pub(crate) fn send_additional_surbs(
         &self,
         sender_tag: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurbWithKeyRotation>,
+        reply_surbs: Vec<ReplySurb>,
         from_surb_request: bool,
     ) -> Result<(), ReplyControllerSenderError> {
         self.0
@@ -167,7 +167,7 @@ pub enum ReplyControllerMessage {
 
     AdditionalSurbs {
         sender_tag: AnonymousSenderTag,
-        reply_surbs: Vec<ReplySurbWithKeyRotation>,
+        reply_surbs: Vec<ReplySurb>,
         from_surb_request: bool,
     },
 

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

@@ -4,7 +4,7 @@
 use async_trait::async_trait;
 use log::{debug, error, warn};
 use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::{NymTopology, NymTopologyMetadata};
+use nym_topology::NymTopology;
 use nym_validator_client::UserAgent;
 use rand::prelude::SliceRandom;
 use rand::thread_rng;
@@ -89,84 +89,55 @@ impl NymApiTopologyProvider {
         let rewarded_set_fut = self.validator_client.get_current_rewarded_set();
 
         let topology = if self.config.use_extended_topology {
-            let all_nodes_fut = self.validator_client.get_all_basic_nodes_with_metadata();
+            let all_nodes_fut = self.validator_client.get_all_basic_nodes();
 
             // Join rewarded_set_fut and all_nodes_fut concurrently
-            let (rewarded_set, all_nodes_res) = futures::try_join!(rewarded_set_fut, all_nodes_fut)
+            let (rewarded_set, all_nodes) = futures::try_join!(rewarded_set_fut, all_nodes_fut)
                 .inspect_err(|err| error!("failed to get network nodes: {err}"))
                 .ok()?;
 
-            let metadata = all_nodes_res.metadata;
-            let all_nodes = all_nodes_res.nodes;
-
             debug!(
                 "there are {} nodes on the network (before filtering)",
                 all_nodes.len()
             );
-            let nodes_filtered = all_nodes
-                .into_iter()
-                .filter(|n| n.performance.round_to_integer() >= self.config.min_node_performance())
-                .collect::<Vec<_>>();
+            let mut topology = NymTopology::new_empty(rewarded_set);
+            topology.add_additional_nodes(all_nodes.iter().filter(|n| {
+                n.performance.round_to_integer() >= self.config.min_node_performance()
+            }));
 
-            NymTopology::new(
-                NymTopologyMetadata::new(metadata.rotation_id, metadata.absolute_epoch_id),
-                rewarded_set,
-                Vec::new(),
-            )
-            .with_skimmed_nodes(&nodes_filtered)
+            topology
         } else {
             // if we're not using extended topology, we're only getting active set mixnodes and gateways
 
             let mixnodes_fut = self
                 .validator_client
-                .get_all_basic_active_mixing_assigned_nodes_with_metadata();
+                .get_all_basic_active_mixing_assigned_nodes();
 
             // TODO: we really should be getting ACTIVE gateways only
-            let gateways_fut = self
-                .validator_client
-                .get_all_basic_entry_assigned_nodes_v2();
+            let gateways_fut = self.validator_client.get_all_basic_entry_assigned_nodes();
 
-            let (rewarded_set, mixnodes_res, gateways_res) =
+            let (rewarded_set, mixnodes, gateways) =
                 futures::try_join!(rewarded_set_fut, mixnodes_fut, gateways_fut)
                     .inspect_err(|err| {
                         error!("failed to get network nodes: {err}");
                     })
                     .ok()?;
 
-            let metadata = mixnodes_res.metadata;
-            let mixnodes = mixnodes_res.nodes;
-
-            if gateways_res.metadata != metadata {
-                warn!("inconsistent nodes metadata between mixnodes and gateways calls! {metadata:?} and {:?}", gateways_res.metadata);
-                return None;
-            }
-
-            let gateways = gateways_res.nodes;
-
             debug!(
                 "there are {} mixnodes and {} gateways in total (before performance filtering)",
                 mixnodes.len(),
                 gateways.len()
             );
 
-            let mut nodes = Vec::new();
-            for mix in mixnodes {
-                if mix.performance.round_to_integer() >= self.config.min_mixnode_performance {
-                    nodes.push(mix)
-                }
-            }
-            for gateway in gateways {
-                if gateway.performance.round_to_integer() >= self.config.min_gateway_performance {
-                    nodes.push(gateway)
-                }
-            }
+            let mut topology = NymTopology::new_empty(rewarded_set);
+            topology.add_additional_nodes(mixnodes.iter().filter(|m| {
+                m.performance.round_to_integer() >= self.config.min_mixnode_performance
+            }));
+            topology.add_additional_nodes(gateways.iter().filter(|m| {
+                m.performance.round_to_integer() >= self.config.min_gateway_performance
+            }));
 
-            NymTopology::new(
-                NymTopologyMetadata::new(metadata.rotation_id, metadata.absolute_epoch_id),
-                rewarded_set,
-                Vec::new(),
-            )
-            .with_skimmed_nodes(&nodes)
+            topology
         };
 
         if !topology.is_minimally_routable() {

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

@@ -107,7 +107,7 @@ pub async fn gateways_for_init<R: Rng>(
 
     log::debug!("Fetching list of gateways from: {nym_api}");
 
-    let gateways = client.get_all_basic_entry_assigned_nodes_v2().await?.nodes;
+    let gateways = client.get_all_basic_entry_assigned_nodes().await?;
     info!("nym api reports {} gateways", gateways.len());
 
     log::trace!("Gateways: {:#?}", gateways);

common/client-core/surb-storage/fs_surbs_migrations/20250425120000_add_surb_key_rotation.sql

@@ -1,8 +0,0 @@
-/*
- * Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
--- default value of 0 implies 'unknown' variant
-ALTER TABLE reply_surb
-    ADD COLUMN encoded_key_rotation TINYINT NOT NULL DEFAULT 0;

common/client-core/surb-storage/src/backend/fs_backend/manager.rs

@@ -216,10 +216,7 @@ impl StorageManager {
     ) -> Result<Vec<StoredReplySurb>, sqlx::Error> {
         sqlx::query_as!(
             StoredReplySurb,
-            r#"
-                SELECT reply_surb_sender_id, reply_surb, encoded_key_rotation as "encoded_key_rotation: u8" FROM reply_surb 
-                WHERE reply_surb_sender_id = ?
-            "#,
+            "SELECT * FROM reply_surb WHERE reply_surb_sender_id = ?",
             sender_id
         )
         .fetch_all(&*self.connection_pool)
@@ -244,11 +241,10 @@ impl StorageManager {
     ) -> Result<(), sqlx::Error> {
         sqlx::query!(
             r#"
-                INSERT INTO reply_surb(reply_surb_sender_id, reply_surb, encoded_key_rotation) VALUES (?, ?, ?);
+                INSERT INTO reply_surb(reply_surb_sender_id, reply_surb) VALUES (?, ?);
             "#,
             stored_reply_surb.reply_surb_sender_id,
-            stored_reply_surb.reply_surb,
-            stored_reply_surb.encoded_key_rotation
+            stored_reply_surb.reply_surb
         )
         .execute(&*self.connection_pool)
         .await?;

common/client-core/surb-storage/src/backend/fs_backend/models.rs

@@ -8,10 +8,8 @@ use nym_crypto::Digest;
 use nym_sphinx::addressing::clients::{Recipient, RecipientBytes};
 use nym_sphinx::anonymous_replies::encryption_key::EncryptionKeyDigest;
 use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, SENDER_TAG_SIZE};
-use nym_sphinx::anonymous_replies::{
-    ReplySurb, ReplySurbWithKeyRotation, SurbEncryptionKey, SurbEncryptionKeySize,
-};
-use nym_sphinx::params::{ReplySurbKeyDigestAlgorithm, SphinxKeyRotation};
+use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey, SurbEncryptionKeySize};
+use nym_sphinx::params::ReplySurbKeyDigestAlgorithm;
 
 #[derive(Debug, Clone)]
 pub struct StoredSenderTag {
@@ -148,40 +146,24 @@ impl TryFrom<StoredSurbSender> for (AnonymousSenderTag, i64) {
 pub struct StoredReplySurb {
     pub reply_surb_sender_id: i64,
     pub reply_surb: Vec<u8>,
-
-    // encodes only whether it's 'even', 'odd' or 'unknown' (default)
-    // and not the whole id because that's redundant
-    pub encoded_key_rotation: u8,
 }
 
 impl StoredReplySurb {
-    pub fn new(reply_surb_sender_id: i64, reply_surb: &ReplySurbWithKeyRotation) -> Self {
+    pub fn new(reply_surb_sender_id: i64, reply_surb: &ReplySurb) -> Self {
         StoredReplySurb {
             reply_surb_sender_id,
-            reply_surb: reply_surb.inner_reply_surb().to_bytes(),
-            encoded_key_rotation: reply_surb.key_rotation() as u8,
+            reply_surb: reply_surb.to_bytes(),
         }
     }
 }
 
-impl TryFrom<StoredReplySurb> for ReplySurbWithKeyRotation {
+impl TryFrom<StoredReplySurb> for ReplySurb {
     type Error = StorageError;
 
     fn try_from(value: StoredReplySurb) -> Result<Self, Self::Error> {
-        let key_rotation =
-            SphinxKeyRotation::try_from(value.encoded_key_rotation).map_err(|err| {
-                StorageError::CorruptedData {
-                    details: format!("stored key rotation was malformed: {err}"),
-                }
-            })?;
-
-        let reply_surb = ReplySurb::from_bytes(&value.reply_surb).map_err(|err| {
-            StorageError::CorruptedData {
-                details: format!("failed to recover the reply surb: {err}"),
-            }
-        })?;
-
-        Ok(reply_surb.with_key_rotation(key_rotation))
+        ReplySurb::from_bytes(&value.reply_surb).map_err(|err| StorageError::CorruptedData {
+            details: format!("failed to recover the reply surb: {err}"),
+        })
     }
 }
 

common/client-core/surb-storage/src/lib.rs

@@ -33,6 +33,7 @@ where
         self.backend.load_surb_storage().await
     }
 
+    // this will have to get enabled after merging develop
     pub async fn flush_on_shutdown(
         mut self,
         mem_state: CombinedReplyStorage,
@@ -49,6 +50,7 @@ where
         shutdown.recv().await;
 
         info!("PersistentReplyStorage is flushing all reply-related data to underlying storage");
+        info!("you MUST NOT forcefully shutdown now or you risk data corruption!");
         if let Err(err) = self.backend.flush_surb_storage(&mem_state).await {
             error!("failed to flush our reply-related data to the persistent storage: {err}")
         } else {

common/client-core/surb-storage/src/surb_storage.rs

@@ -5,7 +5,7 @@ use dashmap::iter::Iter;
 use dashmap::DashMap;
 use log::trace;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
-use nym_sphinx::anonymous_replies::ReplySurbWithKeyRotation;
+use nym_sphinx::anonymous_replies::ReplySurb;
 use std::collections::VecDeque;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
@@ -134,7 +134,7 @@ impl ReceivedReplySurbsMap {
         &self,
         target: &AnonymousSenderTag,
         amount: usize,
-    ) -> (Option<Vec<ReplySurbWithKeyRotation>>, usize) {
+    ) -> (Option<Vec<ReplySurb>>, usize) {
         if let Some(mut entry) = self.inner.data.get_mut(target) {
             let surbs_left = entry.items_left();
             if surbs_left < self.min_surb_threshold() + amount {
@@ -150,7 +150,7 @@ impl ReceivedReplySurbsMap {
     pub fn get_reply_surb_ignoring_threshold(
         &self,
         target: &AnonymousSenderTag,
-    ) -> Option<(Option<ReplySurbWithKeyRotation>, usize)> {
+    ) -> Option<(Option<ReplySurb>, usize)> {
         self.inner
             .data
             .get_mut(target)
@@ -160,7 +160,7 @@ impl ReceivedReplySurbsMap {
     pub fn get_reply_surb(
         &self,
         target: &AnonymousSenderTag,
-    ) -> Option<(Option<ReplySurbWithKeyRotation>, usize)> {
+    ) -> Option<(Option<ReplySurb>, usize)> {
         self.inner.data.get_mut(target).map(|mut entry| {
             let surbs_left = entry.items_left();
             if surbs_left < self.min_surb_threshold() {
@@ -171,7 +171,7 @@ impl ReceivedReplySurbsMap {
         })
     }
 
-    pub fn insert_surbs<I: IntoIterator<Item = ReplySurbWithKeyRotation>>(
+    pub fn insert_surbs<I: IntoIterator<Item = ReplySurb>>(
         &self,
         target: &AnonymousSenderTag,
         surbs: I,
@@ -189,14 +189,14 @@ impl ReceivedReplySurbsMap {
 pub struct ReceivedReplySurbs {
     // in the future we'd probably want to put extra data here to indicate when the SURBs got received
     // so we could invalidate entries from the previous key rotations
-    data: VecDeque<ReplySurbWithKeyRotation>,
+    data: VecDeque<ReplySurb>,
 
     pending_reception: u32,
     surbs_last_received_at_timestamp: i64,
 }
 
 impl ReceivedReplySurbs {
-    fn new(initial_surbs: VecDeque<ReplySurbWithKeyRotation>) -> Self {
+    fn new(initial_surbs: VecDeque<ReplySurb>) -> Self {
         ReceivedReplySurbs {
             data: initial_surbs,
             pending_reception: 0,
@@ -206,7 +206,7 @@ impl ReceivedReplySurbs {
 
     #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
     pub fn new_retrieved(
-        surbs: Vec<ReplySurbWithKeyRotation>,
+        surbs: Vec<ReplySurb>,
         surbs_last_received_at_timestamp: i64,
     ) -> ReceivedReplySurbs {
         ReceivedReplySurbs {
@@ -217,7 +217,7 @@ impl ReceivedReplySurbs {
     }
 
     #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
-    pub fn surbs_ref(&self) -> &VecDeque<ReplySurbWithKeyRotation> {
+    pub fn surbs_ref(&self) -> &VecDeque<ReplySurb> {
         &self.data
     }
 
@@ -243,10 +243,7 @@ impl ReceivedReplySurbs {
         self.pending_reception = 0;
     }
 
-    pub fn get_reply_surbs(
-        &mut self,
-        amount: usize,
-    ) -> (Option<Vec<ReplySurbWithKeyRotation>>, usize) {
+    pub fn get_reply_surbs(&mut self, amount: usize) -> (Option<Vec<ReplySurb>>, usize) {
         if self.items_left() < amount {
             (None, self.items_left())
         } else {
@@ -255,11 +252,11 @@ impl ReceivedReplySurbs {
         }
     }
 
-    pub fn get_reply_surb(&mut self) -> (Option<ReplySurbWithKeyRotation>, usize) {
+    pub fn get_reply_surb(&mut self) -> (Option<ReplySurb>, usize) {
         (self.pop_surb(), self.items_left())
     }
 
-    fn pop_surb(&mut self) -> Option<ReplySurbWithKeyRotation> {
+    fn pop_surb(&mut self) -> Option<ReplySurb> {
         self.data.pop_front()
     }
 
@@ -268,10 +265,7 @@ impl ReceivedReplySurbs {
     }
 
     // realistically we're always going to be getting multiple surbs at once
-    pub fn insert_reply_surbs<I: IntoIterator<Item = ReplySurbWithKeyRotation>>(
-        &mut self,
-        surbs: I,
-    ) {
+    pub fn insert_reply_surbs<I: IntoIterator<Item = ReplySurb>>(&mut self, surbs: I) {
         let mut v = surbs.into_iter().collect::<VecDeque<_>>();
         trace!("storing {} surbs in the storage", v.len());
         self.data.append(&mut v);

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

@@ -21,8 +21,8 @@ use nym_crypto::asymmetric::ed25519;
 use nym_gateway_requests::registration::handshake::client_handshake;
 use nym_gateway_requests::{
     BinaryRequest, ClientControlRequest, ClientRequest, GatewayProtocolVersionExt,
-    GatewayRequestsError, SensitiveServerResponse, ServerResponse, SharedGatewayKey,
-    SharedSymmetricKey, CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION, CURRENT_PROTOCOL_VERSION,
+    SensitiveServerResponse, ServerResponse, SharedGatewayKey, SharedSymmetricKey,
+    CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION, CURRENT_PROTOCOL_VERSION,
 };
 use nym_sphinx::forwarding::packet::MixPacket;
 use nym_statistics_common::clients::connection::ConnectionStatsEvent;
@@ -662,7 +662,6 @@ impl<C, St> GatewayClient<C, St> {
 
         let supports_aes_gcm_siv = gw_protocol.supports_aes256_gcm_siv();
         let supports_auth_v2 = gw_protocol.supports_authenticate_v2();
-        let supports_key_rotation_info = gw_protocol.supports_key_rotation_packet();
 
         if !supports_aes_gcm_siv {
             warn!("this gateway is on an old version that doesn't support AES256-GCM-SIV");
@@ -670,9 +669,6 @@ impl<C, St> GatewayClient<C, St> {
         if !supports_auth_v2 {
             warn!("this gateway is on an old version that doesn't support authentication v2")
         }
-        if !supports_key_rotation_info {
-            warn!("this gateway is on an old version that doesn't support key rotation packets")
-        }
 
         if self.authenticated {
             debug!("Already authenticated");
@@ -853,22 +849,6 @@ impl<C, St> GatewayClient<C, St> {
         }
     }
 
-    fn mix_packet_to_ws_message(&self, packet: MixPacket) -> Result<Message, GatewayRequestsError> {
-        // note: into_ws_message encrypts the requests and adds a MAC on it. Perhaps it should
-        // be more explicit in the naming?
-        let req = if self.negotiated_protocol.supports_key_rotation_packet() {
-            BinaryRequest::ForwardSphinxV2 { packet }
-        } else {
-            BinaryRequest::ForwardSphinx { packet }
-        };
-
-        req.into_ws_message(
-            self.shared_key
-                .as_ref()
-                .expect("no shared key present even though we're authenticated!"),
-        )
-    }
-
     pub async fn batch_send_mix_packets(
         &mut self,
         packets: Vec<MixPacket>,
@@ -897,7 +877,13 @@ impl<C, St> GatewayClient<C, St> {
 
         let messages: Result<Vec<_>, _> = packets
             .into_iter()
-            .map(|mix_packet| self.mix_packet_to_ws_message(mix_packet))
+            .map(|mix_packet| {
+                BinaryRequest::ForwardSphinx { packet: mix_packet }.into_ws_message(
+                    self.shared_key
+                        .as_ref()
+                        .expect("no shared key present even though we're authenticated!"),
+                )
+            })
             .collect();
 
         if let Err(err) = self
@@ -963,8 +949,13 @@ impl<C, St> GatewayClient<C, St> {
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
         }
-
-        let msg = self.mix_packet_to_ws_message(mix_packet)?;
+        // note: into_ws_message encrypts the requests and adds a MAC on it. Perhaps it should
+        // be more explicit in the naming?
+        let msg = BinaryRequest::ForwardSphinx { packet: mix_packet }.into_ws_message(
+            self.shared_key
+                .as_ref()
+                .expect("no shared key present even though we're authenticated!"),
+        )?;
         self.send_with_reconnection_on_failure(msg).await
     }
 

common/client-libs/mixnet-client/Cargo.toml

@@ -16,14 +16,9 @@ tokio-util = { workspace = true, features = ["codec"], optional = true }
 tokio-stream = { workspace = true }
 
 # internal
-nym-noise = { path = "../../nymnoise" }
 nym-sphinx = { path = "../../nymsphinx" }
 nym-task = { path = "../../task", optional = true }
 
 [features]
 default = ["client"]
-client = ["tokio-util", "nym-task", "tokio/net", "tokio/rt"]
-
-[dev-dependencies]
-nym-crypto = { path = "../../crypto" }
-rand = { workspace = true }
+client = ["tokio-util", "nym-task", "tokio/net", "tokio/rt"]

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

@@ -3,11 +3,11 @@
 
 use dashmap::DashMap;
 use futures::StreamExt;
-use nym_noise::config::NoiseConfig;
-use nym_noise::upgrade_noise_initiator;
 use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx::framing::codec::NymCodec;
 use nym_sphinx::framing::packet::FramedNymPacket;
+use nym_sphinx::params::PacketType;
+use nym_sphinx::NymPacket;
 use std::io;
 use std::net::SocketAddr;
 use std::ops::Deref;
@@ -49,19 +49,23 @@ impl Config {
 pub trait SendWithoutResponse {
     // Without response in this context means we will not listen for anything we might get back (not
     // that we should get anything), including any possible io errors
-    fn send_without_response(&self, packet: MixPacket) -> io::Result<()>;
+    fn send_without_response(
+        &self,
+        address: NymNodeRoutingAddress,
+        packet: NymPacket,
+        packet_type: PacketType,
+    ) -> io::Result<()>;
 }
 
 pub struct Client {
     active_connections: ActiveConnections,
-    noise_config: NoiseConfig,
     connections_count: Arc<AtomicUsize>,
     config: Config,
 }
 
 #[derive(Default, Clone)]
 pub struct ActiveConnections {
-    inner: Arc<DashMap<SocketAddr, ConnectionSender>>,
+    inner: Arc<DashMap<NymNodeRoutingAddress, ConnectionSender>>,
 }
 
 impl ActiveConnections {
@@ -78,7 +82,7 @@ impl ActiveConnections {
 }
 
 impl Deref for ActiveConnections {
-    type Target = DashMap<SocketAddr, ConnectionSender>;
+    type Target = DashMap<NymNodeRoutingAddress, ConnectionSender>;
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
@@ -100,7 +104,6 @@ impl ConnectionSender {
 
 struct ManagedConnection {
     address: SocketAddr,
-    noise_config: NoiseConfig,
     message_receiver: ReceiverStream<FramedNymPacket>,
     connection_timeout: Duration,
     current_reconnection: Arc<AtomicU32>,
@@ -109,14 +112,12 @@ struct ManagedConnection {
 impl ManagedConnection {
     fn new(
         address: SocketAddr,
-        noise_config: NoiseConfig,
         message_receiver: mpsc::Receiver<FramedNymPacket>,
         connection_timeout: Duration,
         current_reconnection: Arc<AtomicU32>,
     ) -> Self {
         ManagedConnection {
             address,
-            noise_config,
             message_receiver: ReceiverStream::new(message_receiver),
             connection_timeout,
             current_reconnection,
@@ -131,21 +132,9 @@ impl ManagedConnection {
             Ok(stream_res) => match stream_res {
                 Ok(stream) => {
                     debug!("Managed to establish connection to {}", self.address);
-
-                    let noise_stream =
-                        match upgrade_noise_initiator(stream, &self.noise_config).await {
-                            Ok(noise_stream) => noise_stream,
-                            Err(err) => {
-                                error!("Failed to perform Noise handshake with {address} - {err}");
-                                // we failed to finish the noise handshake - increase reconnection attempt
-                                self.current_reconnection.fetch_add(1, Ordering::SeqCst);
-                                return;
-                            }
-                        };
-                    // if we managed to connect AND do the noise handshake, reset the reconnection count (whatever it might have been)
+                    // if we managed to connect, reset the reconnection count (whatever it might have been)
                     self.current_reconnection.store(0, Ordering::Release);
-                    debug!("Noise initiator handshake completed for {:?}", address);
-                    Framed::new(noise_stream, NymCodec)
+                    Framed::new(stream, NymCodec)
                 }
                 Err(err) => {
                     debug!("failed to establish connection to {address} (err: {err})",);
@@ -178,14 +167,9 @@ impl ManagedConnection {
 }
 
 impl Client {
-    pub fn new(
-        config: Config,
-        noise_config: NoiseConfig,
-        connections_count: Arc<AtomicUsize>,
-    ) -> Client {
+    pub fn new(config: Config, connections_count: Arc<AtomicUsize>) -> Client {
         Client {
             active_connections: Default::default(),
-            noise_config,
             connections_count,
             config,
         }
@@ -212,7 +196,7 @@ impl Client {
         }
     }
 
-    fn make_connection(&self, address: SocketAddr, pending_packet: FramedNymPacket) {
+    fn make_connection(&self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
         let (sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);
 
         // this CAN'T fail because we just created the channel which has a non-zero capacity
@@ -240,7 +224,6 @@ impl Client {
         let initial_connection_timeout = self.config.initial_connection_timeout;
 
         let connections_count = self.connections_count.clone();
-        let noise_config = self.noise_config.clone();
         tokio::spawn(async move {
             // before executing the manager, wait for what was specified, if anything
             if let Some(backoff) = backoff {
@@ -251,7 +234,6 @@ impl Client {
             connections_count.fetch_add(1, Ordering::SeqCst);
             ManagedConnection::new(
                 address.into(),
-                noise_config,
                 receiver,
                 initial_connection_timeout,
                 current_reconnection_attempt,
@@ -264,14 +246,18 @@ impl Client {
 }
 
 impl SendWithoutResponse for Client {
-    fn send_without_response(&self, packet: MixPacket) -> io::Result<()> {
-        let address = packet.next_hop_address();
-        trace!("Sending packet to {address}");
-        let framed_packet = FramedNymPacket::from(packet);
+    fn send_without_response(
+        &self,
+        address: NymNodeRoutingAddress,
+        packet: NymPacket,
+        packet_type: PacketType,
+    ) -> io::Result<()> {
+        trace!("Sending packet to {address:?}");
+        let framed_packet = FramedNymPacket::new(packet, packet_type);
 
         let Some(sender) = self.active_connections.get_mut(&address) else {
             // there was never a connection to begin with
-            debug!("establishing initial connection to {address}");
+            debug!("establishing initial connection to {}", address);
             // it's not a 'big' error, but we did not manage to send the packet, but queue the packet
             // for sending for as soon as the connection is created
             self.make_connection(address, framed_packet);
@@ -316,12 +302,8 @@ impl SendWithoutResponse for Client {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nym_crypto::asymmetric::x25519;
-    use nym_noise::config::NoiseNetworkView;
-    use rand::rngs::OsRng;
 
     fn dummy_client() -> Client {
-        let mut rng = OsRng; //for test only, so we don't care if rng source isn't crypto grade
         Client::new(
             Config {
                 initial_reconnection_backoff: Duration::from_millis(10_000),
@@ -329,11 +311,6 @@ mod tests {
                 initial_connection_timeout: Duration::from_millis(1_500),
                 maximum_connection_buffer_size: 128,
             },
-            NoiseConfig::new(
-                Arc::new(x25519::KeyPair::new(&mut rng)),
-                NoiseNetworkView::new_empty(),
-                Duration::from_millis(1_500),
-            ),
             Default::default(),
         )
     }

common/client-libs/validator-client/examples/offline_signing.rs

@@ -16,8 +16,8 @@ async fn main() {
     let prefix = "n";
     let denom: Denom = "unym".parse().unwrap();
     let signer_mnemonic: bip39::Mnemonic = "<MNEMONIC WITH FUNDS HERE>".parse().unwrap();
-    let validator = "https://rpc.sandbox.nymtech.net";
-    let to_address: AccountId = "n1pefc2utwpy5w78p2kqdsfmpjxfwmn9d39k5mqa".parse().unwrap();
+    let validator = "https://qwerty-validator.qa.nymte.ch";
+    let to_address: AccountId = "n19kdst4srf76xgwe55jg32mpcpcyf6aqgp6qrdk".parse().unwrap();
 
     let signer = DirectSecp256k1HdWallet::from_mnemonic(prefix, signer_mnemonic);
     let signer_address = signer.try_derive_accounts().unwrap()[0].address().clone();

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

@@ -25,7 +25,7 @@ use nym_api_requests::models::{
     NymNodeDescription, RewardEstimationResponse, StakeSaturationResponse,
 };
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
-use nym_api_requests::nym_nodes::{NodesByAddressesResponse, SemiSkimmedNode, SkimmedNode};
+use nym_api_requests::nym_nodes::{NodesByAddressesResponse, SkimmedNode};
 use nym_coconut_dkg_common::types::EpochId;
 use nym_http_api_client::UserAgent;
 use nym_mixnet_contract_common::EpochRewardedSet;
@@ -46,46 +46,6 @@ use crate::rpc::http_client;
 #[cfg(feature = "http-client")]
 use crate::{DirectSigningHttpRpcValidatorClient, HttpRpcClient, QueryHttpRpcValidatorClient};
 
-// a simple helper macro to define to repeatedly call a paged query until a full response is constructed
-macro_rules! collect_paged_skimmed_v2 {
-    ( $self:ident, $f: ident ) => {{
-        // unroll first loop iteration in order to obtain the metadata
-        let mut page = 0;
-        let res = $self
-            .nym_api
-            .$f(false, Some(page), None, $self.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;
-
-        loop {
-            let mut res = $self
-                .nym_api
-                .$f(false, Some(page), None, $self.use_bincode)
-                .await?;
-
-            if metadata != res.metadata {
-                return Err(ValidatorClientError::InconsistentPagedMetadata);
-            }
-
-            nodes.append(&mut res.nodes.data);
-            if nodes.len() < res.nodes.pagination.total {
-                page += 1
-            } else {
-                break;
-            }
-        }
-
-        Ok(SkimmedNodesWithMetadata::new(nodes, metadata))
-    }};
-}
-
 #[must_use]
 #[derive(Debug, Clone)]
 pub struct Config {
@@ -240,11 +200,11 @@ impl<C, S> Client<C, S> {
 #[allow(deprecated)]
 impl<C, S> Client<C, S> {
     pub fn api_url(&self) -> &Url {
-        self.nym_api.current_url().as_ref()
+        self.nym_api.current_url()
     }
 
     pub fn change_nym_api(&mut self, new_endpoint: Url) {
-        self.nym_api.change_base_urls(vec![new_endpoint.into()])
+        self.nym_api.change_base_url(new_endpoint)
     }
 
     #[deprecated]
@@ -442,11 +402,11 @@ impl NymApiClient {
     }
 
     pub fn api_url(&self) -> &Url {
-        self.nym_api.current_url().as_ref()
+        self.nym_api.current_url()
     }
 
     pub fn change_nym_api(&mut self, new_endpoint: Url) {
-        self.nym_api.change_base_urls(vec![new_endpoint.into()]);
+        self.nym_api.change_base_url(new_endpoint);
     }
 
     #[deprecated(note = "use get_all_basic_active_mixing_assigned_nodes instead")]
@@ -465,93 +425,17 @@ impl NymApiClient {
 
     /// retrieve basic information for nodes are capable of operating as an entry gateway
     /// this includes legacy gateways and nym-nodes
-    #[deprecated(note = "use get_all_basic_entry_assigned_nodes_with_metadata instead")]
     pub async fn get_all_basic_entry_assigned_nodes(
         &self,
     ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        self.get_all_basic_entry_assigned_nodes_v2()
-            .await
-            .map(|res| res.nodes)
-    }
-
-    pub async fn get_all_basic_entry_assigned_nodes_v2(
-        &self,
-    ) -> Result<SkimmedNodesWithMetadata, ValidatorClientError> {
-        collect_paged_skimmed_v2!(self, get_basic_entry_assigned_nodes_v2)
-    }
-
-    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
-    /// this includes legacy mixnodes and nym-nodes
-    #[deprecated(note = "use get_all_basic_active_mixing_assigned_nodes_with_metadata instead")]
-    pub async fn get_all_basic_active_mixing_assigned_nodes(
-        &self,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        self.get_all_basic_active_mixing_assigned_nodes_with_metadata()
-            .await
-            .map(|res| res.nodes)
-    }
-
-    pub async fn get_all_basic_active_mixing_assigned_nodes_with_metadata(
-        &self,
-    ) -> Result<SkimmedNodesWithMetadata, ValidatorClientError> {
-        collect_paged_skimmed_v2!(self, get_basic_active_mixing_assigned_nodes_v2)
-    }
-
-    /// retrieve basic information for nodes are capable of operating as a mixnode
-    /// this includes legacy mixnodes and nym-nodes
-    #[deprecated(note = "use get_all_basic_mixing_capable_nodes_with_metadata instead")]
-    pub async fn get_all_basic_mixing_capable_nodes(
-        &self,
-    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        self.get_all_basic_mixing_capable_nodes_with_metadata()
-            .await
-            .map(|res| res.nodes)
-    }
-
-    pub async fn get_all_basic_mixing_capable_nodes_with_metadata(
-        &self,
-    ) -> Result<SkimmedNodesWithMetadata, ValidatorClientError> {
-        collect_paged_skimmed_v2!(self, get_basic_mixing_capable_nodes_v2)
-    }
-
-    /// retrieve basic information for all bonded nodes on the network
-    #[deprecated(note = "use get_all_basic_nodes_with_metadata instead")]
-    pub async fn get_all_basic_nodes(&self) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
-        self.get_all_basic_nodes_with_metadata()
-            .await
-            .map(|res| res.nodes)
-    }
-
-    pub async fn get_all_basic_nodes_with_metadata(
-        &self,
-    ) -> Result<SkimmedNodesWithMetadata, ValidatorClientError> {
-        collect_paged_skimmed_v2!(self, get_basic_nodes_v2)
-    }
-
-    /// retrieve expanded information for all bonded nodes on the network
-    pub async fn get_all_expanded_nodes(
-        &self,
-    ) -> Result<SemiSkimmedNodesWithMetadata, ValidatorClientError> {
-        // Unroll the first iteration to get the metadata
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
         let mut page = 0;
-
-        let res = self
-            .nym_api
-            .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;
+        let mut nodes = Vec::new();
 
         loop {
             let mut res = self
                 .nym_api
-                .get_expanded_nodes(false, Some(page), None)
+                .get_basic_entry_assigned_nodes(false, Some(page), None, self.use_bincode)
                 .await?;
 
             nodes.append(&mut res.nodes.data);
@@ -562,13 +446,14 @@ impl NymApiClient {
             }
         }
 
-        Ok(SemiSkimmedNodesWithMetadata::new(nodes, metadata))
+        Ok(nodes)
     }
 
-    /// retrieve expanded information for all bonded nodes on the network
-    pub async fn get_all_expanded_nodes(
+    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
+    /// this includes legacy mixnodes and nym-nodes
+    pub async fn get_all_basic_active_mixing_assigned_nodes(
         &self,
-    ) -> Result<Vec<SemiSkimmedNode>, ValidatorClientError> {
+    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
         // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
         let mut page = 0;
         let mut nodes = Vec::new();
@@ -576,7 +461,56 @@ impl NymApiClient {
         loop {
             let mut res = self
                 .nym_api
-                .get_expanded_nodes(false, Some(page), None)
+                .get_basic_active_mixing_assigned_nodes(false, Some(page), None, self.use_bincode)
+                .await?;
+
+            nodes.append(&mut res.nodes.data);
+            if nodes.len() < res.nodes.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(nodes)
+    }
+
+    /// retrieve basic information for nodes are capable of operating as a mixnode
+    /// this includes legacy mixnodes and nym-nodes
+    pub async fn get_all_basic_mixing_capable_nodes(
+        &self,
+    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
+        let mut page = 0;
+        let mut nodes = Vec::new();
+
+        loop {
+            let mut res = self
+                .nym_api
+                .get_basic_mixing_capable_nodes(false, Some(page), None, self.use_bincode)
+                .await?;
+
+            nodes.append(&mut res.nodes.data);
+            if nodes.len() < res.nodes.pagination.total {
+                page += 1
+            } else {
+                break;
+            }
+        }
+
+        Ok(nodes)
+    }
+
+    /// retrieve basic information for all bonded nodes on the network
+    pub async fn get_all_basic_nodes(&self) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+        // TODO: deal with paging in macro or some helper function or something, because it's the same pattern everywhere
+        let mut page = 0;
+        let mut nodes = Vec::new();
+
+        loop {
+            let mut res = self
+                .nym_api
+                .get_basic_nodes(false, Some(page), None, self.use_bincode)
                 .await?;
 
             nodes.append(&mut res.nodes.data);

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

@@ -22,9 +22,6 @@ pub enum ValidatorClientError {
     #[error("nyxd request failed: {0}")]
     NyxdError(#[from] crate::nyxd::error::NyxdError),
 
-    #[error("the response metadata has changed between pages")]
-    InconsistentPagedMetadata,
-
     #[error("No validator API url has been provided")]
     NoAPIUrlAvailable,
 }

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

@@ -14,12 +14,11 @@ use nym_api_requests::ecash::models::{
 use nym_api_requests::ecash::VerificationKeyResponse;
 use nym_api_requests::models::{
     AnnotationResponse, ApiHealthResponse, BinaryBuildInformationOwned, ChainStatusResponse,
-    KeyRotationInfoResponse, LegacyDescribedMixNode, NodePerformanceResponse, NodeRefreshBody,
-    NymNodeDescription, PerformanceHistoryResponse, RewardedSetResponse,
+    LegacyDescribedMixNode, NodePerformanceResponse, NodeRefreshBody, NymNodeDescription,
+    PerformanceHistoryResponse, RewardedSetResponse,
 };
 use nym_api_requests::nym_nodes::{
     NodesByAddressesRequestBody, NodesByAddressesResponse, PaginatedCachedNodesResponse,
-    SemiSkimmedNode,
 };
 use nym_api_requests::pagination::PaginatedResponse;
 pub use nym_api_requests::{
@@ -35,7 +34,7 @@ pub use nym_api_requests::{
         MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
         StakeSaturationResponse, UptimeResponse,
     },
-    nym_nodes::{CachedNodesResponse, SemiSkimmedNode, SkimmedNode},
+    nym_nodes::{CachedNodesResponse, SkimmedNode},
     NymNetworkDetailsResponse,
 };
 use nym_contracts_common::IdentityKey;
@@ -63,7 +62,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn health(&self) -> Result<ApiHealthResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::API_STATUS_ROUTES,
                 routes::HEALTH,
             ],
@@ -76,7 +75,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn build_information(&self) -> Result<BinaryBuildInformationOwned, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::API_STATUS_ROUTES,
                 routes::BUILD_INFORMATION,
             ],
@@ -88,7 +87,7 @@ pub trait NymApiClientExt: ApiClient {
     #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
-        self.get_json(&[routes::V1_API_VERSION, routes::MIXNODES], NO_PARAMS)
+        self.get_json(&[routes::API_VERSION, routes::MIXNODES], NO_PARAMS)
             .await
     }
 
@@ -97,7 +96,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn get_mixnodes_detailed(&self) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::MIXNODES,
                 routes::DETAILED,
@@ -112,7 +111,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn get_gateways_detailed(&self) -> Result<Vec<GatewayBondAnnotated>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::GATEWAYS,
                 routes::DETAILED,
@@ -129,7 +128,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<Vec<GatewayBondAnnotated>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::GATEWAYS,
                 routes::DETAILED_UNFILTERED,
@@ -146,7 +145,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::MIXNODES,
                 routes::DETAILED_UNFILTERED,
@@ -159,7 +158,7 @@ pub trait NymApiClientExt: ApiClient {
     #[deprecated]
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways(&self) -> Result<Vec<GatewayBond>, NymAPIError> {
-        self.get_json(&[routes::V1_API_VERSION, routes::GATEWAYS], NO_PARAMS)
+        self.get_json(&[routes::API_VERSION, routes::GATEWAYS], NO_PARAMS)
             .await
     }
 
@@ -167,7 +166,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways_described(&self) -> Result<Vec<LegacyDescribedGateway>, NymAPIError> {
         self.get_json(
-            &[routes::V1_API_VERSION, routes::GATEWAYS, routes::DESCRIBED],
+            &[routes::API_VERSION, routes::GATEWAYS, routes::DESCRIBED],
             NO_PARAMS,
         )
         .await
@@ -177,7 +176,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_described(&self) -> Result<Vec<LegacyDescribedMixNode>, NymAPIError> {
         self.get_json(
-            &[routes::V1_API_VERSION, routes::MIXNODES, routes::DESCRIBED],
+            &[routes::API_VERSION, routes::MIXNODES, routes::DESCRIBED],
             NO_PARAMS,
         )
         .await
@@ -202,7 +201,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::NYM_NODES_ROUTES,
                 routes::NYM_NODES_PERFORMANCE_HISTORY,
                 &*node_id.to_string(),
@@ -230,7 +229,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::NYM_NODES_ROUTES,
                 routes::NYM_NODES_DESCRIBED,
             ],
@@ -257,7 +256,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::NYM_NODES_ROUTES,
                 routes::NYM_NODES_BONDED,
             ],
@@ -271,7 +270,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn get_basic_mixnodes(&self) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 "unstable",
                 routes::NYM_NODES_ROUTES,
                 "mixnodes",
@@ -287,7 +286,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn get_basic_gateways(&self) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 "unstable",
                 routes::NYM_NODES_ROUTES,
                 "gateways",
@@ -302,7 +301,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn get_rewarded_set(&self) -> Result<RewardedSetResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::NYM_NODES_ROUTES,
                 routes::NYM_NODES_REWARDED_SET,
             ],
@@ -313,7 +312,6 @@ pub trait NymApiClientExt: ApiClient {
 
     /// retrieve basic information for nodes are capable of operating as an entry gateway
     /// this includes legacy gateways and nym-nodes
-    #[deprecated(note = "use get_basic_entry_assigned_nodes_v2")]
     #[instrument(level = "debug", skip(self))]
     async fn get_basic_entry_assigned_nodes(
         &self,
@@ -321,7 +319,7 @@ pub trait NymApiClientExt: ApiClient {
         page: Option<u32>,
         per_page: Option<u32>,
         use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV1<SkimmedNode>, NymAPIError> {
+    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
         let mut params = Vec::new();
 
         if no_legacy {
@@ -342,49 +340,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_response(
             &[
-                routes::V1_API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                "skimmed",
-                "entry-gateways",
-                "all",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    /// retrieve basic information for nodes are capable of operating as an entry gateway
-    /// this includes legacy gateways and nym-nodes
-    #[instrument(level = "debug", skip(self))]
-    async fn get_basic_entry_assigned_nodes_v2(
-        &self,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-        use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV2<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        if use_bincode {
-            params.push(("output", "bincode".to_string()))
-        }
-
-        self.get_response(
-            &[
-                routes::V2_API_VERSION,
+                routes::API_VERSION,
                 "unstable",
                 routes::NYM_NODES_ROUTES,
                 "skimmed",
@@ -398,7 +354,6 @@ pub trait NymApiClientExt: ApiClient {
 
     /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
     /// this includes legacy mixnodes and nym-nodes
-    #[deprecated(note = "use get_basic_active_mixing_assigned_nodes_v2")]
     #[instrument(level = "debug", skip(self))]
     async fn get_basic_active_mixing_assigned_nodes(
         &self,
@@ -406,7 +361,7 @@ pub trait NymApiClientExt: ApiClient {
         page: Option<u32>,
         per_page: Option<u32>,
         use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV1<SkimmedNode>, NymAPIError> {
+    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
         let mut params = Vec::new();
 
         if no_legacy {
@@ -427,7 +382,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_response(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 "unstable",
                 routes::NYM_NODES_ROUTES,
                 "skimmed",
@@ -442,56 +397,13 @@ pub trait NymApiClientExt: ApiClient {
     /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
     /// this includes legacy mixnodes and nym-nodes
     #[instrument(level = "debug", skip(self))]
-    async fn get_basic_active_mixing_assigned_nodes_v2(
-        &self,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-        use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV2<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        if use_bincode {
-            params.push(("output", "bincode".to_string()))
-        }
-
-        self.get_response(
-            &[
-                routes::V2_API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                "skimmed",
-                "mixnodes",
-                "active",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
-    /// this includes legacy mixnodes and nym-nodes
-    #[deprecated(note = "use get_basic_mixing_capable_nodes_v2")]
-    #[instrument(level = "debug", skip(self))]
     async fn get_basic_mixing_capable_nodes(
         &self,
         no_legacy: bool,
         page: Option<u32>,
         per_page: Option<u32>,
         use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV1<SkimmedNode>, NymAPIError> {
+    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
         let mut params = Vec::new();
 
         if no_legacy {
@@ -512,7 +424,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_response(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 "unstable",
                 routes::NYM_NODES_ROUTES,
                 "skimmed",
@@ -524,49 +436,6 @@ pub trait NymApiClientExt: ApiClient {
         .await
     }
 
-    /// retrieve basic information for nodes that got assigned 'mixing' node in this epoch
-    /// this includes legacy mixnodes and nym-nodes
-    #[instrument(level = "debug", skip(self))]
-    async fn get_basic_mixing_capable_nodes_v2(
-        &self,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-        use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV2<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        if use_bincode {
-            params.push(("output", "bincode".to_string()))
-        }
-
-        self.get_response(
-            &[
-                routes::V2_API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                "skimmed",
-                "mixnodes",
-                "all",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    #[deprecated(note = "use get_basic_nodes_v2")]
     #[instrument(level = "debug", skip(self))]
     async fn get_basic_nodes(
         &self,
@@ -574,7 +443,7 @@ pub trait NymApiClientExt: ApiClient {
         page: Option<u32>,
         per_page: Option<u32>,
         use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV1<SkimmedNode>, NymAPIError> {
+    ) -> Result<PaginatedCachedNodesResponse<SkimmedNode>, NymAPIError> {
         let mut params = Vec::new();
 
         if no_legacy {
@@ -594,115 +463,11 @@ pub trait NymApiClientExt: ApiClient {
         }
 
         self.get_response(
-            &[
-                routes::V1_API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                "skimmed",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_basic_nodes_v2(
-        &self,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-        use_bincode: bool,
-    ) -> Result<PaginatedCachedNodesResponseV2<SkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        if use_bincode {
-            params.push(("output", "bincode".to_string()))
-        }
-
-        self.get_response(
-            &[
-                routes::V2_API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                "skimmed",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_expanded_nodes(
-        &self,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-    ) -> Result<PaginatedCachedNodesResponseV2<SemiSkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        self.get_json(
-            &[
-                routes::V2_API_VERSION,
-                "unstable",
-                routes::NYM_NODES_ROUTES,
-                "semi-skimmed",
-            ],
-            &params,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_expanded_nodes(
-        &self,
-        no_legacy: bool,
-        page: Option<u32>,
-        per_page: Option<u32>,
-    ) -> Result<PaginatedCachedNodesResponse<SemiSkimmedNode>, NymAPIError> {
-        let mut params = Vec::new();
-
-        if no_legacy {
-            params.push(("no_legacy", "true".to_string()))
-        }
-
-        if let Some(page) = page {
-            params.push(("page", page.to_string()))
-        }
-
-        if let Some(per_page) = per_page {
-            params.push(("per_page", per_page.to_string()))
-        }
-
-        self.get_json(
             &[
                 routes::API_VERSION,
                 "unstable",
                 routes::NYM_NODES_ROUTES,
-                "semi-skimmed",
+                "skimmed",
             ],
             &params,
         )
@@ -713,7 +478,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(
-            &[routes::V1_API_VERSION, routes::MIXNODES, routes::ACTIVE],
+            &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
             NO_PARAMS,
         )
         .await
@@ -724,7 +489,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn get_active_mixnodes_detailed(&self) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::MIXNODES,
                 routes::ACTIVE,
@@ -739,7 +504,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_rewarded_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
         self.get_json(
-            &[routes::V1_API_VERSION, routes::MIXNODES, routes::REWARDED],
+            &[routes::API_VERSION, routes::MIXNODES, routes::REWARDED],
             NO_PARAMS,
         )
         .await
@@ -753,7 +518,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<MixnodeStatusReportResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -772,7 +537,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<GatewayStatusReportResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::GATEWAY,
                 identity,
@@ -791,7 +556,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<MixnodeUptimeHistoryResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -810,7 +575,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<GatewayUptimeHistoryResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::GATEWAY,
                 identity,
@@ -828,7 +593,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<Vec<MixNodeBondAnnotated>, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS,
                 routes::MIXNODES,
                 routes::REWARDED,
@@ -849,7 +614,7 @@ pub trait NymApiClientExt: ApiClient {
         if let Some(since) = since {
             self.get_json(
                 &[
-                    routes::V1_API_VERSION,
+                    routes::API_VERSION,
                     routes::STATUS_ROUTES,
                     routes::GATEWAY,
                     identity,
@@ -861,7 +626,7 @@ pub trait NymApiClientExt: ApiClient {
         } else {
             self.get_json(
                 &[
-                    routes::V1_API_VERSION,
+                    routes::API_VERSION,
                     routes::STATUS_ROUTES,
                     routes::GATEWAY,
                     identity,
@@ -882,7 +647,7 @@ pub trait NymApiClientExt: ApiClient {
         if let Some(since) = since {
             self.get_json(
                 &[
-                    routes::V1_API_VERSION,
+                    routes::API_VERSION,
                     routes::STATUS_ROUTES,
                     routes::MIXNODE,
                     &mix_id.to_string(),
@@ -894,7 +659,7 @@ pub trait NymApiClientExt: ApiClient {
         } else {
             self.get_json(
                 &[
-                    routes::V1_API_VERSION,
+                    routes::API_VERSION,
                     routes::STATUS_ROUTES,
                     routes::MIXNODE,
                     &mix_id.to_string(),
@@ -914,7 +679,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<MixnodeStatusResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -933,7 +698,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<RewardEstimationResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -953,7 +718,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<RewardEstimationResponse, NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -973,7 +738,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<StakeSaturationResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -993,7 +758,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<nym_api_requests::models::InclusionProbabilityResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -1011,7 +776,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<NodePerformanceResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::NYM_NODES_ROUTES,
                 routes::NYM_NODES_PERFORMANCE,
                 &node_id.to_string(),
@@ -1027,7 +792,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<AnnotationResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::NYM_NODES_ROUTES,
                 routes::NYM_NODES_ANNOTATION,
                 &node_id.to_string(),
@@ -1041,7 +806,7 @@ pub trait NymApiClientExt: ApiClient {
     async fn get_mixnode_avg_uptime(&self, mix_id: NodeId) -> Result<UptimeResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::STATUS_ROUTES,
                 routes::MIXNODE,
                 &mix_id.to_string(),
@@ -1056,11 +821,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_mixnodes_blacklisted(&self) -> Result<Vec<NodeId>, NymAPIError> {
         self.get_json(
-            &[
-                routes::V1_API_VERSION,
-                routes::MIXNODES,
-                routes::BLACKLISTED,
-            ],
+            &[routes::API_VERSION, routes::MIXNODES, routes::BLACKLISTED],
             NO_PARAMS,
         )
         .await
@@ -1070,11 +831,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_gateways_blacklisted(&self) -> Result<Vec<IdentityKey>, NymAPIError> {
         self.get_json(
-            &[
-                routes::V1_API_VERSION,
-                routes::GATEWAYS,
-                routes::BLACKLISTED,
-            ],
+            &[routes::API_VERSION, routes::GATEWAYS, routes::BLACKLISTED],
             NO_PARAMS,
         )
         .await
@@ -1087,7 +844,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<BlindedSignatureResponse, NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::ECASH_BLIND_SIGN,
             ],
@@ -1104,7 +861,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<EcashTicketVerificationResponse, NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::VERIFY_ECASH_TICKET,
             ],
@@ -1121,7 +878,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<EcashBatchTicketRedemptionResponse, NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::BATCH_REDEEM_ECASH_TICKETS,
             ],
@@ -1146,7 +903,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::PARTIAL_EXPIRATION_DATE_SIGNATURES,
             ],
@@ -1167,7 +924,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::PARTIAL_COIN_INDICES_SIGNATURES,
             ],
@@ -1191,7 +948,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::GLOBAL_EXPIRATION_DATE_SIGNATURES,
             ],
@@ -1212,7 +969,7 @@ pub trait NymApiClientExt: ApiClient {
 
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::GLOBAL_COIN_INDICES_SIGNATURES,
             ],
@@ -1232,7 +989,7 @@ pub trait NymApiClientExt: ApiClient {
         };
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 ecash::MASTER_VERIFICATION_KEY,
             ],
@@ -1248,7 +1005,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<(), NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::NYM_NODES_ROUTES,
                 routes::NYM_NODES_REFRESH_DESCRIBED,
             ],
@@ -1265,7 +1022,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<IssuedTicketbooksForResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::ECASH_ISSUED_TICKETBOOKS_FOR,
                 &expiration_date.to_string(),
@@ -1282,7 +1039,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<IssuedTicketbooksForCountResponse, NymAPIError> {
         self.get_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::ECASH_ISSUED_TICKETBOOKS_FOR_COUNT,
                 &expiration_date.to_string(),
@@ -1299,7 +1056,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<IssuedTicketbooksChallengeCommitmentResponse, NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::ECASH_ISSUED_TICKETBOOKS_CHALLENGE_COMMITMENT,
             ],
@@ -1316,7 +1073,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<IssuedTicketbooksDataResponse, NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 routes::ECASH_ROUTES,
                 routes::ECASH_ISSUED_TICKETBOOKS_DATA,
             ],
@@ -1332,7 +1089,7 @@ pub trait NymApiClientExt: ApiClient {
     ) -> Result<NodesByAddressesResponse, NymAPIError> {
         self.post_json(
             &[
-                routes::V1_API_VERSION,
+                routes::API_VERSION,
                 "unstable",
                 routes::NYM_NODES_ROUTES,
                 routes::nym_nodes::BY_ADDRESSES,
@@ -1346,7 +1103,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_network_details(&self) -> Result<NymNetworkDetailsResponse, NymAPIError> {
         self.get_json(
-            &[routes::V1_API_VERSION, routes::NETWORK, routes::DETAILS],
+            &[routes::API_VERSION, routes::NETWORK, routes::DETAILS],
             NO_PARAMS,
         )
         .await
@@ -1355,24 +1112,7 @@ pub trait NymApiClientExt: ApiClient {
     #[instrument(level = "debug", skip(self))]
     async fn get_chain_status(&self) -> Result<ChainStatusResponse, NymAPIError> {
         self.get_json(
-            &[
-                routes::V1_API_VERSION,
-                routes::NETWORK,
-                routes::CHAIN_STATUS,
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn get_key_rotation_info(&self) -> Result<KeyRotationInfoResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::V1_API_VERSION,
-                routes::EPOCH,
-                routes::KEY_ROTATION_INFO,
-            ],
+            &[routes::API_VERSION, routes::NETWORK, routes::CHAIN_STATUS],
             NO_PARAMS,
         )
         .await

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

@@ -1,8 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub const V1_API_VERSION: &str = "v1";
-pub const V2_API_VERSION: &str = "v2";
+use nym_network_defaults::NYM_API_VERSION;
+
+pub const API_VERSION: &str = NYM_API_VERSION;
 pub const MIXNODES: &str = "mixnodes";
 pub const GATEWAYS: &str = "gateways";
 pub const DESCRIBED: &str = "described";
@@ -78,11 +79,3 @@ pub const SERVICE_PROVIDERS: &str = "services";
 pub const DETAILS: &str = "details";
 pub const CHAIN_STATUS: &str = "chain-status";
 pub const NETWORK: &str = "network";
-
-pub const EPOCH: &str = "epoch";
-
-pub use epoch_routes::*;
-pub mod epoch_routes {
-    pub const CURRENT: &str = "current";
-    pub const KEY_ROTATION_INFO: &str = "key-rotation-info";
-}

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

@@ -12,8 +12,8 @@ use nym_mixnet_contract_common::gateway::{PreassignedGatewayIdsResponse, Preassi
 use nym_mixnet_contract_common::nym_node::{
     EpochAssignmentResponse, NodeDetailsByIdentityResponse, NodeDetailsResponse,
     NodeOwnershipResponse, NodeRewardingDetailsResponse, PagedNymNodeBondsResponse,
-    PagedNymNodeDetailsResponse, PagedUnbondedNymNodesResponse, RewardedSetMetadata, Role,
-    RolesMetadataResponse, StakeSaturationResponse, UnbondedNodeResponse, UnbondedNymNode,
+    PagedNymNodeDetailsResponse, PagedUnbondedNymNodesResponse, Role, RolesMetadataResponse,
+    StakeSaturationResponse, UnbondedNodeResponse, UnbondedNymNode,
 };
 use nym_mixnet_contract_common::reward_params::WorkFactor;
 use nym_mixnet_contract_common::{
@@ -28,12 +28,12 @@ use nym_mixnet_contract_common::{
     ContractBuildInformation, ContractState, ContractStateParams, CurrentIntervalResponse,
     CurrentNymNodeVersionResponse, Delegation, EpochEventId, EpochRewardedSet, EpochStatus,
     GatewayBond, GatewayBondResponse, GatewayOwnershipResponse, HistoricalNymNodeVersionEntry,
-    IdentityKey, IdentityKeyRef, IntervalEventId, KeyRotationIdResponse, KeyRotationState,
-    MixNodeBond, MixNodeDetails, MixOwnershipResponse, MixnodeDetailsByIdentityResponse,
-    MixnodeDetailsResponse, NodeId, NumberOfPendingEventsResponse, NymNodeBond, NymNodeDetails,
-    NymNodeVersionHistoryResponse, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
-    PagedGatewayResponse, PagedMixnodeBondsResponse, PagedNodeDelegationsResponse,
-    PendingEpochEvent, PendingEpochEventResponse, PendingEpochEventsResponse, PendingIntervalEvent,
+    IdentityKey, IdentityKeyRef, IntervalEventId, MixNodeBond, MixNodeDetails,
+    MixOwnershipResponse, MixnodeDetailsByIdentityResponse, MixnodeDetailsResponse, NodeId,
+    NumberOfPendingEventsResponse, NymNodeBond, NymNodeDetails, NymNodeVersionHistoryResponse,
+    PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse, PagedGatewayResponse,
+    PagedMixnodeBondsResponse, PagedNodeDelegationsResponse, PendingEpochEvent,
+    PendingEpochEventResponse, PendingEpochEventsResponse, PendingIntervalEvent,
     PendingIntervalEventResponse, PendingIntervalEventsResponse, QueryMsg as MixnetQueryMsg,
     RewardedSet, UnbondedMixnode,
 };
@@ -546,16 +546,6 @@ pub trait MixnetQueryClient {
         })
         .await
     }
-
-    async fn get_key_rotation_state(&self) -> Result<KeyRotationState, NyxdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetKeyRotationState {})
-            .await
-    }
-
-    async fn get_key_rotation_id(&self) -> Result<KeyRotationIdResponse, NyxdError> {
-        self.query_mixnet_contract(MixnetQueryMsg::GetKeyRotationId {})
-            .await
-    }
 }
 
 // extension trait to the query client to deal with the paged queries
@@ -683,20 +673,12 @@ pub trait MixnetQueryClientExt: MixnetQueryClient {
     async fn get_rewarded_set(&self) -> Result<EpochRewardedSet, NyxdError> {
         let error_response = |message| Err(NyxdError::extension_query_failure("mixnet", message));
 
-        // bypass for catch 22 for fresh contracts. we can't refresh cache because there's no rewarded set,
-        // but we can't set the rewarded set because we didn't refresh the cache
         let metadata = self.get_rewarded_set_metadata().await?;
-
-        let is_default = metadata.metadata == RewardedSetMetadata::default();
-        if !metadata.metadata.fully_assigned && !is_default {
+        if !metadata.metadata.fully_assigned {
             return error_response("the rewarded set hasn't been fully assigned for this epoch");
         }
         let expected_epoch_id = metadata.metadata.epoch_id;
 
-        if is_default {
-            return Ok(Default::default());
-        }
-
         // if we have to query those things more frequently, we could do it concurrently,
         // but as it stands now, it happens so infrequently it might as well be sequential
         let entry = self.get_role_assignment(Role::EntryGateway).await?;
@@ -973,8 +955,6 @@ mod tests {
             QueryMsg::GetNymNodeVersionHistory { limit, start_after } => client
                 .get_nym_node_version_history_paged(start_after, limit)
                 .ignore(),
-            QueryMsg::GetKeyRotationState {} => client.get_key_rotation_state().ignore(),
-            QueryMsg::GetKeyRotationId {} => client.get_key_rotation_id().ignore(),
         }
     }
 }

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

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

common/commands/src/validator/account/send.rs

@@ -60,7 +60,7 @@ pub async fn send(args: Args, client: &SigningClient) {
         "Nodesguru: https://nym.explorers.guru/transaction/{}",
         &res.hash
     );
-    println!("Mintscan: https://ping.pub/nyx/tx/{}", &res.hash);
+    println!("Mintscan: https://www.mintscan.io/nyx/txs/{}", &res.hash);
     println!("Transaction result code: {}", &res.tx_result.code.value());
     println!("Transaction hash: {}", &res.hash);
 }

common/commands/src/validator/account/send_multiple.rs

@@ -95,7 +95,7 @@ pub async fn send_multiple(args: Args, client: &SigningClient) {
         "Nodesguru: https://nym.explorers.guru/transaction/{}",
         &res.hash
     );
-    println!("Mintscan: https://ping.pub/nyx/tx/{}", &res.hash);
+    println!("Mintscan: https://www.mintscan.io/nyx/txs/{}", &res.hash);
     println!("Transaction result code: {}", &res.tx_result.code.value());
     println!("Transaction hash: {}", &res.hash);
 

common/commands/src/validator/cosmwasm/generators/mixnet.rs

@@ -157,7 +157,6 @@ pub async fn generate(args: Args) {
             minimum: args.minimum_interval_operating_cost.amount.into(),
             maximum: args.maximum_interval_operating_cost.amount.into(),
         },
-        key_validity_in_epochs: None,
     };
 
     debug!("instantiate_msg: {:?}", instantiate_msg);

common/commands/src/validator/vesting/withdraw_vested.rs

@@ -76,7 +76,7 @@ pub async fn execute(args: Args, client: SigningClient) {
                         &res.transaction_hash
                     );
                     println!(
-                        "Mintscan: https://ping.pub/nyx/tx/{}",
+                        "Mintscan: https://www.mintscan.io/nyx/txs/{}",
                         &res.transaction_hash
                     );
                     println!("Transaction hash: {}", &res.transaction_hash);

common/cosmwasm-smart-contracts/mixnet-contract/Cargo.toml

@@ -40,6 +40,3 @@ contract-testing = []
 utoipa = ["dep:utoipa"]
 schema = ["cw2"]
 generate-ts = ['ts-rs']
-
-[lints]
-workspace = true

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

@@ -193,9 +193,6 @@ pub enum MixnetContractError {
     #[error("attempted to perform the operation with 0 coins. This is not allowed")]
     ZeroCoinAmount,
 
-    #[error("key rotation validity below minimum value")]
-    TooShortRotationInterval,
-
     #[error("this validator ({current_validator}) is not the one responsible for advancing this epoch. It's responsibility of {chosen_validator}.")]
     RewardingValidatorMismatch {
         current_validator: Addr,

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

@@ -358,7 +358,7 @@ impl Interval {
         self.total_elapsed_epochs
     }
 
-    pub const fn current_epoch_absolute_id(&self) -> EpochId {
+    pub const fn current_epoch_absolute_id(&self) -> u32 {
         // since we count epochs starting from 0, if n epochs have elapsed, the current one has absolute id of n
         self.total_elapsed_epochs
     }

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

@@ -1,155 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::EpochId;
-use cosmwasm_schema::cw_serde;
-
-pub type KeyRotationId = u32;
-
-#[cw_serde]
-#[derive(Copy)]
-#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
-pub struct KeyRotationState {
-    /// Defines how long each key rotation is valid for (in terms of epochs)
-    pub validity_epochs: u32,
-
-    /// Records the initial epoch_id when the key rotation has been introduced (0 for fresh contracts).
-    /// It is used for determining when rotation is meant to advance.
-    #[cfg_attr(feature = "utoipa", schema(value_type = u32))]
-    pub initial_epoch_id: EpochId,
-}
-
-impl KeyRotationState {
-    pub fn key_rotation_id(&self, current_epoch_id: EpochId) -> KeyRotationId {
-        let diff = current_epoch_id.saturating_sub(self.initial_epoch_id);
-        diff / self.validity_epochs
-    }
-
-    pub fn next_rotation_starting_epoch_id(&self, current_epoch_id: EpochId) -> EpochId {
-        self.current_rotation_starting_epoch_id(current_epoch_id) + self.validity_epochs
-    }
-
-    pub fn current_rotation_starting_epoch_id(&self, current_epoch_id: EpochId) -> EpochId {
-        let current_rotation_id = self.key_rotation_id(current_epoch_id);
-
-        self.initial_epoch_id + self.validity_epochs * current_rotation_id
-    }
-}
-
-#[cw_serde]
-pub struct KeyRotationIdResponse {
-    pub rotation_id: KeyRotationId,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn key_rotation_id() {
-        let state = KeyRotationState {
-            validity_epochs: 24,
-            initial_epoch_id: 0,
-        };
-        assert_eq!(0, state.key_rotation_id(0));
-        assert_eq!(0, state.key_rotation_id(23));
-        assert_eq!(1, state.key_rotation_id(24));
-        assert_eq!(1, state.key_rotation_id(47));
-        assert_eq!(2, state.key_rotation_id(48));
-
-        let state = KeyRotationState {
-            validity_epochs: 12,
-            initial_epoch_id: 0,
-        };
-        assert_eq!(0, state.key_rotation_id(0));
-        assert_eq!(0, state.key_rotation_id(11));
-        assert_eq!(1, state.key_rotation_id(12));
-        assert_eq!(1, state.key_rotation_id(23));
-        assert_eq!(2, state.key_rotation_id(24));
-
-        let state = KeyRotationState {
-            validity_epochs: 24,
-            initial_epoch_id: 10000,
-        };
-        assert_eq!(0, state.key_rotation_id(123));
-        assert_eq!(0, state.key_rotation_id(10000));
-        assert_eq!(0, state.key_rotation_id(10001));
-        assert_eq!(0, state.key_rotation_id(10023));
-        assert_eq!(1, state.key_rotation_id(10024));
-        assert_eq!(1, state.key_rotation_id(10047));
-        assert_eq!(2, state.key_rotation_id(10048));
-        assert_eq!(2, state.key_rotation_id(10060));
-    }
-
-    #[test]
-    fn next_rotation_starting_epoch_id() {
-        let state = KeyRotationState {
-            validity_epochs: 24,
-            initial_epoch_id: 0,
-        };
-        assert_eq!(24, state.next_rotation_starting_epoch_id(0));
-        assert_eq!(24, state.next_rotation_starting_epoch_id(23));
-        assert_eq!(48, state.next_rotation_starting_epoch_id(24));
-        assert_eq!(48, state.next_rotation_starting_epoch_id(47));
-        assert_eq!(72, state.next_rotation_starting_epoch_id(48));
-
-        let state = KeyRotationState {
-            validity_epochs: 12,
-            initial_epoch_id: 0,
-        };
-        assert_eq!(12, state.next_rotation_starting_epoch_id(0));
-        assert_eq!(12, state.next_rotation_starting_epoch_id(11));
-        assert_eq!(24, state.next_rotation_starting_epoch_id(12));
-        assert_eq!(24, state.next_rotation_starting_epoch_id(23));
-        assert_eq!(36, state.next_rotation_starting_epoch_id(24));
-
-        let state = KeyRotationState {
-            validity_epochs: 24,
-            initial_epoch_id: 10000,
-        };
-        assert_eq!(10024, state.next_rotation_starting_epoch_id(123));
-        assert_eq!(10024, state.next_rotation_starting_epoch_id(10000));
-        assert_eq!(10024, state.next_rotation_starting_epoch_id(10001));
-        assert_eq!(10024, state.next_rotation_starting_epoch_id(10023));
-        assert_eq!(10048, state.next_rotation_starting_epoch_id(10024));
-        assert_eq!(10048, state.next_rotation_starting_epoch_id(10047));
-        assert_eq!(10072, state.next_rotation_starting_epoch_id(10048));
-        assert_eq!(10072, state.next_rotation_starting_epoch_id(10060));
-    }
-
-    #[test]
-    fn current_rotation_starting_epoch_id() {
-        let state = KeyRotationState {
-            validity_epochs: 24,
-            initial_epoch_id: 0,
-        };
-        assert_eq!(0, state.current_rotation_starting_epoch_id(0));
-        assert_eq!(0, state.current_rotation_starting_epoch_id(23));
-        assert_eq!(24, state.current_rotation_starting_epoch_id(24));
-        assert_eq!(24, state.current_rotation_starting_epoch_id(47));
-        assert_eq!(48, state.current_rotation_starting_epoch_id(48));
-
-        let state = KeyRotationState {
-            validity_epochs: 12,
-            initial_epoch_id: 0,
-        };
-        assert_eq!(0, state.current_rotation_starting_epoch_id(0));
-        assert_eq!(0, state.current_rotation_starting_epoch_id(11));
-        assert_eq!(12, state.current_rotation_starting_epoch_id(12));
-        assert_eq!(12, state.current_rotation_starting_epoch_id(23));
-        assert_eq!(24, state.current_rotation_starting_epoch_id(24));
-
-        let state = KeyRotationState {
-            validity_epochs: 24,
-            initial_epoch_id: 10000,
-        };
-        assert_eq!(10000, state.current_rotation_starting_epoch_id(123));
-        assert_eq!(10000, state.current_rotation_starting_epoch_id(10000));
-        assert_eq!(10000, state.current_rotation_starting_epoch_id(10001));
-        assert_eq!(10000, state.current_rotation_starting_epoch_id(10023));
-        assert_eq!(10024, state.current_rotation_starting_epoch_id(10024));
-        assert_eq!(10024, state.current_rotation_starting_epoch_id(10047));
-        assert_eq!(10048, state.current_rotation_starting_epoch_id(10048));
-        assert_eq!(10048, state.current_rotation_starting_epoch_id(10060));
-    }
-}

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

@@ -1,6 +1,10 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+#![warn(clippy::expect_used)]
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::todo)]
+
 mod config_score;
 pub mod constants;
 pub mod delegation;
@@ -9,7 +13,6 @@ pub mod events;
 pub mod gateway;
 pub mod helpers;
 pub mod interval;
-pub mod key_rotation;
 pub mod mixnode;
 pub mod msg;
 pub mod nym_node;
@@ -34,7 +37,6 @@ pub use gateway::{
 pub use interval::{
     CurrentIntervalResponse, EpochId, EpochState, EpochStatus, Interval, IntervalId,
 };
-pub use key_rotation::*;
 pub use mixnode::{
     LegacyMixLayer, MixNode, MixNodeBond, MixNodeConfigUpdate, MixNodeDetails,
     MixOwnershipResponse, MixnodeDetailsByIdentityResponse, MixnodeDetailsResponse, NodeCostParams,

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

@@ -170,11 +170,6 @@ impl NodeRewarding {
         }
     }
 
-    // we panic here as opposed to returning an error as this is undefined behaviour,
-    // because the pledge amount has decreased (i.e. slashing has occurred) which
-    // should not be possible under any situation. at this point we don't know how many other things
-    // might have failed so we have to bail
-    #[allow(clippy::panic)]
     pub fn pending_detailed_operator_reward(&self, original_pledge: &Coin) -> StdResult<Decimal> {
         let initial_dec = original_pledge.amount.into_base_decimal()?;
         if initial_dec > self.operator {
@@ -194,11 +189,6 @@ impl NodeRewarding {
         Ok(truncate_reward(delegator_reward, &delegation.amount.denom))
     }
 
-    // we panic here as opposed to returning an error as this is undefined behaviour,
-    // because the pledge amount has decreased (i.e. slashing has occurred) which
-    // should not be possible under any situation. at this point we don't know how many other things
-    // might have failed so we have to bail
-    #[allow(clippy::panic)]
     pub fn withdraw_operator_reward(
         &mut self,
         original_pledge: &Coin,

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

@@ -35,7 +35,6 @@ use crate::{
         PreassignedGatewayIdsResponse,
     },
     interval::{CurrentIntervalResponse, EpochStatus},
-    key_rotation::{KeyRotationIdResponse, KeyRotationState},
     mixnode::{
         MixOwnershipResponse, MixStakeSaturationResponse, MixnodeDetailsByIdentityResponse,
         MixnodeDetailsResponse, MixnodeRewardingDetailsResponse, PagedMixnodeBondsResponse,
@@ -82,18 +81,6 @@ pub struct InstantiateMsg {
 
     #[serde(default)]
     pub interval_operating_cost: OperatingCostRange,
-
-    #[serde(default)]
-    pub key_validity_in_epochs: Option<u32>,
-}
-
-impl InstantiateMsg {
-    // needs to give us enough time to pre-announce key for following epoch
-    // and have an overlap with the preceding epoch
-    pub const MIN_KEY_ROTATION_VALIDITY: u32 = 3;
-    pub fn key_validity_in_epochs(&self) -> u32 {
-        self.key_validity_in_epochs.unwrap_or(24)
-    }
 }
 
 #[cw_serde]
@@ -870,15 +857,6 @@ pub enum QueryMsg {
         /// Cosmos address used for the query of the signing nonce.
         address: String,
     },
-
-    // sphinx key rotation-related
-    #[cfg_attr(feature = "schema", returns(KeyRotationState))]
-    /// Gets the current state config of the key rotation (i.e. starting epoch id and validity duration)
-    GetKeyRotationState {},
-
-    /// Gets the current key rotation id
-    #[cfg_attr(feature = "schema", returns(KeyRotationIdResponse))]
-    GetKeyRotationId {},
 }
 
 #[cw_serde]

common/cosmwasm-smart-contracts/mixnet-contract/src/rewarding/simulator/mod.rs

@@ -151,9 +151,6 @@ impl Simulator {
         }
     }
 
-    // this code is not meant to be used in production systems, only in tests
-    // so a panic due to inconsistent arguments is fine
-    #[allow(clippy::panic)]
     pub fn simulate_epoch(
         &mut self,
         node_params: &BTreeMap<NodeId, NodeRewardingParameters>,

common/cosmwasm-smart-contracts/nym-pool-contract/Cargo.toml

@@ -1,27 +0,0 @@
-[package]
-name = "nym-pool-contract-common"
-version = "0.1.0"
-description = "Common library for the Nym Pool contract"
-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]
-thiserror = { workspace = true }
-serde = { workspace = true }
-schemars = { workspace = true }
-
-cosmwasm-std = { workspace = true }
-cosmwasm-schema = { workspace = true }
-cw-controllers = { workspace = true }
-
-[dev-dependencies]
-time = { workspace = true, features = ["macros"] }
-
-[features]
-schema = []

common/cosmwasm-smart-contracts/nym-pool-contract/src/constants.rs

@@ -1,11 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod storage_keys {
-    pub const CONTRACT_ADMIN: &str = "contract-admin";
-    pub const POOL_DENOMINATION: &str = "pool_denom";
-    pub const GRANTERS: &str = "granters";
-    pub const GRANTS: &str = "grants";
-    pub const TOTAL_LOCKED: &str = "total_locked";
-    pub const LOCKED_GRANTEES: &str = "locked_grantees";
-}

common/cosmwasm-smart-contracts/nym-pool-contract/src/error.rs

@@ -1,98 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_std::{Coin, Uint128};
-use cw_controllers::AdminError;
-use thiserror::Error;
-
-#[derive(Error, Debug, PartialEq)]
-pub enum NymPoolContractError {
-    #[error("could not perform contract migration: {comment}")]
-    FailedMigration { comment: String },
-
-    #[error(transparent)]
-    Admin(#[from] AdminError),
-
-    #[error(transparent)]
-    StdErr(#[from] cosmwasm_std::StdError),
-
-    #[error("this sender is not authorised to revoke this grant. its neither the admin or the original (and still whitelisted) granter")]
-    UnauthorizedGrantRevocation,
-
-    #[error("the specified address is already a whitelisted granter")]
-    AlreadyAGranter,
-
-    #[error("{addr} is not a permitted granter")]
-    InvalidGranter { addr: String },
-
-    #[error("invalid coin denomination. got {got}, but expected {expected}")]
-    InvalidDenom { expected: String, got: String },
-
-    #[error("there already exists an active grant for {grantee}. it was granted by {granter} at block height {created_at_height}")]
-    GrantAlreadyExist {
-        granter: String,
-        grantee: String,
-        created_at_height: u64,
-    },
-
-    #[error("could not find any active grants for {grantee}")]
-    GrantNotFound { grantee: String },
-
-    #[error("the provided timestamp value ({timestamp}) is set in the past. the current block timestamp is {current_block_timestamp}")]
-    TimestampInThePast {
-        timestamp: u64,
-        current_block_timestamp: u64,
-    },
-
-    #[error("there are not enough tokens to process this request. {available} are available, but {required} is needed.")]
-    InsufficientTokens { available: Coin, required: Coin },
-
-    #[error("the period length can't be zero")]
-    ZeroAllowancePeriod,
-
-    #[error("the provided coin value is zero")]
-    ZeroAmount,
-
-    #[error("the periodic spend limit of {periodic} was set to be higher than the total spend limit {total_limit}")]
-    PeriodicGrantOverSpendLimit { periodic: Coin, total_limit: Coin },
-
-    #[error("the accumulation spend limit of {accumulation} was set to be lower than the periodic grant amount of {periodic_grant}")]
-    AccumulationBelowGrantAmount {
-        accumulation: Coin,
-        periodic_grant: Coin,
-    },
-
-    #[error("the accumulation spend limit of {accumulation} was set to be higher than the total spend limit of {total_limit}")]
-    AccumulationOverSpendLimit {
-        accumulation: Coin,
-        total_limit: Coin,
-    },
-
-    #[error("the specified delayed allowance would never be available. it would become active at {available_timestamp} yet it expires at {expiration_timestamp}")]
-    UnattainableDelayedAllowance {
-        expiration_timestamp: u64,
-        available_timestamp: u64,
-    },
-
-    #[error("could not unlock {requested} tokens from {grantee}. it only has {locked} locked")]
-    InsufficientLockedTokens {
-        grantee: String,
-        locked: Uint128,
-        requested: Uint128,
-    },
-
-    #[error("attempted to spend more tokens than permitted by the current allowance")]
-    SpendingAboveAllowance,
-
-    #[error("attempted to send an empty allowance usage request")]
-    EmptyUsageRequest,
-
-    #[error("the associated grant has already expired")]
-    GrantExpired,
-
-    #[error("the associated grant hasn't expired yet")]
-    GrantNotExpired,
-
-    #[error("this grant is not available yet. it will become usable at {available_at_timestamp}")]
-    GrantNotYetAvailable { available_at_timestamp: u64 },
-}

common/cosmwasm-smart-contracts/nym-pool-contract/src/lib.rs

@@ -1,12 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod constants;
-pub mod error;
-pub mod msg;
-pub mod types;
-mod utils;
-
-pub use error::*;
-pub use msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
-pub use types::*;

common/cosmwasm-smart-contracts/nym-pool-contract/src/msg.rs

@@ -1,125 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{Allowance, TransferRecipient};
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Coin;
-use std::collections::HashMap;
-
-#[cfg(feature = "schema")]
-use crate::types::{
-    AvailableTokensResponse, GrantResponse, GranterResponse, GrantersPagedResponse,
-    GrantsPagedResponse, LockedTokensPagedResponse, LockedTokensResponse,
-    TotalLockedTokensResponse,
-};
-
-#[cw_serde]
-pub struct InstantiateMsg {
-    pub pool_denomination: String,
-
-    /// Initial map of grants to be created at instantiation
-    pub grants: HashMap<String, Allowance>,
-}
-
-#[cw_serde]
-pub enum ExecuteMsg {
-    /// Change the admin
-    UpdateAdmin {
-        admin: String,
-        // flag to determine whether old admin should be removed from the granter set
-        // and new one should be included instead
-        // the reason it's provided as an option is to make it possible to skip this field
-        // when creating transaction directly with nyxd
-        update_granter_set: Option<bool>,
-    },
-
-    /// Attempt to grant new allowance to the specified grantee
-    GrantAllowance {
-        grantee: String,
-        allowance: Box<Allowance>,
-    },
-
-    /// Attempt to revoke previously granted allowance
-    RevokeAllowance { grantee: String },
-
-    /// Attempt to use allowance
-    UseAllowance { recipients: Vec<TransferRecipient> },
-
-    /// Attempt to withdraw the specified amount into the grantee's account
-    WithdrawAllowance { amount: Coin },
-
-    /// Attempt to lock part of existing allowance for future use
-    LockAllowance { amount: Coin },
-
-    /// Attempt to unlock previously locked allowance
-    UnlockAllowance { amount: Coin },
-
-    /// Attempt to use part of the locked allowance
-    UseLockedAllowance { recipients: Vec<TransferRecipient> },
-
-    /// Attempt to withdraw the specified amount of locked tokens into the grantee's account
-    WithdrawLockedAllowance { amount: Coin },
-
-    /// Attempt to add a new account to the permitted set of grant granters
-    AddNewGranter { granter: String },
-
-    /// Revoke the provided account from the permitted set of granters
-    RevokeGranter { granter: String },
-
-    /// Attempt to remove expired grant from the storage and unlock (if any) locked tokens
-    RemoveExpiredGrant { grantee: String },
-}
-
-#[cw_serde]
-#[cfg_attr(feature = "schema", derive(cosmwasm_schema::QueryResponses))]
-pub enum QueryMsg {
-    #[cfg_attr(feature = "schema", returns(cw_controllers::AdminResponse))]
-    Admin {},
-
-    #[cfg_attr(feature = "schema", returns(AvailableTokensResponse))]
-    GetAvailableTokens {},
-
-    #[cfg_attr(feature = "schema", returns(TotalLockedTokensResponse))]
-    GetTotalLockedTokens {},
-
-    #[cfg_attr(feature = "schema", returns(LockedTokensResponse))]
-    GetLockedTokens { grantee: String },
-
-    #[cfg_attr(feature = "schema", returns(GrantResponse))]
-    GetGrant { grantee: String },
-
-    #[cfg_attr(feature = "schema", returns(GranterResponse))]
-    GetGranter { granter: String },
-
-    #[cfg_attr(feature = "schema", returns(LockedTokensPagedResponse))]
-    GetLockedTokensPaged {
-        /// Controls the maximum number of entries returned by the query. Note that too large values will be overwritten by a saner default.
-        limit: Option<u32>,
-
-        /// Pagination control for the values returned by the query. Note that the provided value itself will **not** be used for the response.
-        start_after: Option<String>,
-    },
-
-    #[cfg_attr(feature = "schema", returns(GrantersPagedResponse))]
-    GetGrantersPaged {
-        /// Controls the maximum number of entries returned by the query. Note that too large values will be overwritten by a saner default.
-        limit: Option<u32>,
-
-        /// Pagination control for the values returned by the query. Note that the provided value itself will **not** be used for the response.
-        start_after: Option<String>,
-    },
-
-    #[cfg_attr(feature = "schema", returns(GrantsPagedResponse))]
-    GetGrantsPaged {
-        /// Controls the maximum number of entries returned by the query. Note that too large values will be overwritten by a saner default.
-        limit: Option<u32>,
-
-        /// Pagination control for the values returned by the query. Note that the provided value itself will **not** be used for the response.
-        start_after: Option<String>,
-    },
-}
-
-#[cw_serde]
-pub struct MigrateMsg {
-    //
-}

common/cosmwasm-smart-contracts/nym-pool-contract/src/utils.rs

@@ -1,77 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::NymPoolContractError;
-use cosmwasm_std::Env;
-
-pub fn ensure_unix_timestamp_not_in_the_past(
-    unix_timestamp: u64,
-    env: &Env,
-) -> Result<(), NymPoolContractError> {
-    if unix_timestamp < env.block.time.seconds() {
-        return Err(NymPoolContractError::TimestampInThePast {
-            timestamp: unix_timestamp,
-            current_block_timestamp: env.block.time.seconds(),
-        });
-    }
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use cosmwasm_std::testing::mock_env;
-    use cosmwasm_std::Timestamp;
-    use time::macros::datetime;
-
-    #[test]
-    fn ensuring_unix_timestamp_not_in_the_past() {
-        let unix_epoch = 0;
-
-        let date_in_the_past = datetime!(1984-01-02 3:45 UTC);
-        let sane_block_time = datetime!(2025-01-28 12:15 UTC);
-
-        let before_block = datetime!(2025-01-28 12:00 UTC);
-        let after_block = datetime!(2025-01-28 12:30 UTC);
-
-        let mut env = mock_env();
-        env.block.time = Timestamp::from_seconds(sane_block_time.unix_timestamp() as u64);
-
-        let res = ensure_unix_timestamp_not_in_the_past(unix_epoch, &env).unwrap_err();
-        assert_eq!(
-            NymPoolContractError::TimestampInThePast {
-                timestamp: unix_epoch,
-                current_block_timestamp: env.block.time.seconds(),
-            },
-            res
-        );
-
-        let res =
-            ensure_unix_timestamp_not_in_the_past(date_in_the_past.unix_timestamp() as u64, &env)
-                .unwrap_err();
-        assert_eq!(
-            NymPoolContractError::TimestampInThePast {
-                timestamp: date_in_the_past.unix_timestamp() as u64,
-                current_block_timestamp: env.block.time.seconds(),
-            },
-            res
-        );
-
-        let res = ensure_unix_timestamp_not_in_the_past(before_block.unix_timestamp() as u64, &env)
-            .unwrap_err();
-        assert_eq!(
-            NymPoolContractError::TimestampInThePast {
-                timestamp: before_block.unix_timestamp() as u64,
-                current_block_timestamp: env.block.time.seconds(),
-            },
-            res
-        );
-
-        let res =
-            ensure_unix_timestamp_not_in_the_past(sane_block_time.unix_timestamp() as u64, &env);
-        assert!(res.is_ok());
-
-        let res = ensure_unix_timestamp_not_in_the_past(after_block.unix_timestamp() as u64, &env);
-        assert!(res.is_ok());
-    }
-}

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

@@ -55,8 +55,8 @@ impl PersistentStorage {
     /// * `database_path`: path to the database.
     pub async fn init<P: AsRef<Path>>(database_path: P) -> Result<Self, StorageError> {
         debug!(
-            "Attempting to connect to database {}",
-            database_path.as_ref().display()
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
         );
 
         let opts = sqlx::sqlite::SqliteConnectOptions::new()

common/credential-verification/src/bandwidth_storage_manager.rs

@@ -40,10 +40,6 @@ impl BandwidthStorageManager {
         }
     }
 
-    pub fn client_bandwidth(&self) -> ClientBandwidth {
-        self.client_bandwidth.clone()
-    }
-
     pub async fn available_bandwidth(&self) -> i64 {
         self.client_bandwidth.available().await
     }

common/credential-verification/src/client_bandwidth.rs

@@ -73,7 +73,7 @@ impl ClientBandwidth {
         false
     }
 
-    pub async fn available(&self) -> i64 {
+    pub(crate) async fn available(&self) -> i64 {
         self.inner.read().await.bandwidth.bytes
     }
 

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

@@ -218,12 +218,6 @@ impl From<PublicKey> for x25519_dalek::PublicKey {
     }
 }
 
-impl AsRef<[u8]> for PublicKey {
-    fn as_ref(&self) -> &[u8] {
-        self.0.as_ref()
-    }
-}
-
 #[derive(Zeroize, ZeroizeOnDrop)]
 pub struct PrivateKey(x25519_dalek::StaticSecret);
 
@@ -254,10 +248,6 @@ impl PrivateKey {
         PrivateKey(x25519_secret)
     }
 
-    pub fn inner(&self) -> &x25519_dalek::StaticSecret {
-        &self.0
-    }
-
     pub fn public_key(&self) -> PublicKey {
         self.into()
     }
@@ -266,10 +256,6 @@ impl PrivateKey {
         self.0.to_bytes()
     }
 
-    pub fn as_bytes(&self) -> &[u8; PRIVATE_KEY_SIZE] {
-        self.0.as_bytes()
-    }
-
     pub fn from_bytes(b: &[u8]) -> Result<Self, KeyRecoveryError> {
         if b.len() != PRIVATE_KEY_SIZE {
             return Err(KeyRecoveryError::InvalidSizePrivateKey {
@@ -349,12 +335,6 @@ impl AsRef<x25519_dalek::StaticSecret> for PrivateKey {
     }
 }
 
-impl AsRef<[u8]> for PrivateKey {
-    fn as_ref(&self) -> &[u8] {
-        self.0.as_ref()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

common/gateway-requests/src/lib.rs

@@ -19,7 +19,7 @@ pub use shared_key::{
     SharedGatewayKey, SharedKeyConversionError, SharedKeyUsageError, SharedSymmetricKey,
 };
 
-pub const CURRENT_PROTOCOL_VERSION: u8 = EMBEDDED_KEY_ROTATION_INFO_VERSION;
+pub const CURRENT_PROTOCOL_VERSION: u8 = AUTHENTICATE_V2_PROTOCOL_VERSION;
 
 /// Defines the current version of the communication protocol between gateway and clients.
 /// It has to be incremented for any breaking change.
@@ -28,12 +28,10 @@ pub const CURRENT_PROTOCOL_VERSION: u8 = EMBEDDED_KEY_ROTATION_INFO_VERSION;
 // 2 - changes to client credentials structure
 // 3 - change to AES-GCM-SIV and non-zero IVs
 // 4 - introduction of v2 authentication protocol to prevent reply attacks
-// 5 - add key rotation information to the serialised mix packet
 pub const INITIAL_PROTOCOL_VERSION: u8 = 1;
 pub const CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION: u8 = 2;
 pub const AES_GCM_SIV_PROTOCOL_VERSION: u8 = 3;
 pub const AUTHENTICATE_V2_PROTOCOL_VERSION: u8 = 4;
-pub const EMBEDDED_KEY_ROTATION_INFO_VERSION: u8 = 5;
 
 // TODO: could using `Mac` trait here for OutputSize backfire?
 // Should hmac itself be exposed, imported and used instead?
@@ -42,7 +40,6 @@ pub type LegacyGatewayMacSize = <GatewayIntegrityHmacAlgorithm as OutputSizeUser
 pub trait GatewayProtocolVersionExt {
     fn supports_aes256_gcm_siv(&self) -> bool;
     fn supports_authenticate_v2(&self) -> bool;
-    fn supports_key_rotation_packet(&self) -> bool;
 }
 
 impl GatewayProtocolVersionExt for Option<u8> {
@@ -55,9 +52,4 @@ impl GatewayProtocolVersionExt for Option<u8> {
         let Some(protocol) = *self else { return false };
         protocol >= AUTHENTICATE_V2_PROTOCOL_VERSION
     }
-
-    fn supports_key_rotation_packet(&self) -> bool {
-        let Some(protocol) = *self else { return false };
-        protocol >= EMBEDDED_KEY_ROTATION_INFO_VERSION
-    }
 }

common/gateway-requests/src/types/binary_request.rs

@@ -11,9 +11,6 @@ use tungstenite::Message;
 #[non_exhaustive]
 pub enum BinaryRequest {
     ForwardSphinx { packet: MixPacket },
-
-    // identical to `ForwardSphinx`, but also contains information about sphinx key rotation used
-    ForwardSphinxV2 { packet: MixPacket },
 }
 
 #[repr(u8)]
@@ -21,9 +18,6 @@ pub enum BinaryRequest {
 #[non_exhaustive]
 pub enum BinaryRequestKind {
     ForwardSphinx = 1,
-
-    // identical to `ForwardSphinx`, but also contains information about sphinx key rotation used
-    ForwardSphinxV2 = 2,
 }
 
 // Right now the only valid `BinaryRequest` is a request to forward a sphinx packet.
@@ -35,7 +29,6 @@ impl BinaryRequest {
     pub fn kind(&self) -> BinaryRequestKind {
         match self {
             BinaryRequest::ForwardSphinx { .. } => BinaryRequestKind::ForwardSphinx,
-            BinaryRequest::ForwardSphinxV2 { .. } => BinaryRequestKind::ForwardSphinxV2,
         }
     }
 
@@ -45,13 +38,9 @@ impl BinaryRequest {
     ) -> Result<Self, GatewayRequestsError> {
         match kind {
             BinaryRequestKind::ForwardSphinx => {
-                let packet = MixPacket::try_from_v1_bytes(plaintext)?;
+                let packet = MixPacket::try_from_bytes(plaintext)?;
                 Ok(BinaryRequest::ForwardSphinx { packet })
             }
-            BinaryRequestKind::ForwardSphinxV2 => {
-                let packet = MixPacket::try_from_v2_bytes(plaintext)?;
-                Ok(BinaryRequest::ForwardSphinxV2 { packet })
-            }
         }
     }
 
@@ -69,8 +58,7 @@ impl BinaryRequest {
         let kind = self.kind();
 
         let plaintext = match self {
-            BinaryRequest::ForwardSphinx { packet } => packet.into_v1_bytes()?,
-            BinaryRequest::ForwardSphinxV2 { packet } => packet.into_v2_bytes()?,
+            BinaryRequest::ForwardSphinx { packet } => packet.into_bytes()?,
         };
 
         BinaryData::make_encrypted_blob(kind as u8, &plaintext, shared_key)
@@ -82,9 +70,7 @@ impl BinaryRequest {
     ) -> Result<Message, GatewayRequestsError> {
         // all variants are currently encrypted
         let blob = match self {
-            BinaryRequest::ForwardSphinx { .. } | BinaryRequest::ForwardSphinxV2 { .. } => {
-                self.into_encrypted_tagged_bytes(shared_key)?
-            }
+            BinaryRequest::ForwardSphinx { .. } => self.into_encrypted_tagged_bytes(shared_key)?,
         };
 
         Ok(Message::Binary(blob))

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

@@ -33,8 +33,8 @@ impl PersistentStatsStorage {
     /// * `database_path`: path to the database.
     pub async fn init<P: AsRef<Path> + Send>(database_path: P) -> Result<Self, StatsStorageError> {
         debug!(
-            "Attempting to connect to database {}",
-            database_path.as_ref().display()
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
         );
 
         // TODO: we can inject here more stuff based on our gateway global config
@@ -193,7 +193,7 @@ impl PersistentStatsStorage {
     pub async fn get_started_sessions_count(
         &self,
         start_date: Date,
-    ) -> Result<i64, StatsStorageError> {
+    ) -> Result<i32, StatsStorageError> {
         Ok(self
             .session_manager
             .get_started_sessions_count(start_date)

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

@@ -160,7 +160,7 @@ impl SessionManager {
             .await
     }
 
-    pub(crate) async fn get_started_sessions_count(&self, start_date: Date) -> Result<i64> {
+    pub(crate) async fn get_started_sessions_count(&self, start_date: Date) -> Result<i32> {
         Ok(sqlx::query!(
             "SELECT COUNT(*) as count FROM sessions_active WHERE date(start_time) = ?",
             start_date

common/gateway-storage/.sqlx/query-03fe56298a6d60cdd5304a2953811a533d59b4f1f0e4efecd32c09256b657e24.json

@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                    SELECT \n                        id as \"id!\",\n                        client_address_bs58 as \"client_address_bs58!\",\n                        content as \"content!\" \n                    FROM message_store \n                    WHERE client_address_bs58 = ? AND id > ?\n                    ORDER BY id ASC\n                    LIMIT ?;\n                ",
+  "describe": {
+    "columns": [
+      {
+        "name": "id!",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "client_address_bs58!",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "content!",
+        "ordinal": 2,
+        "type_info": "Blob"
+      }
+    ],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "03fe56298a6d60cdd5304a2953811a533d59b4f1f0e4efecd32c09256b657e24"
+}

common/gateway-storage/.sqlx/query-071fbde5277c0806ed47fa15a9c6288609379049828a94008f854b3daeed21d1.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "DELETE FROM message_store WHERE timestamp < ?",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 1
-    },
-    "nullable": []
-  },
-  "hash": "071fbde5277c0806ed47fa15a9c6288609379049828a94008f854b3daeed21d1"
-}

common/gateway-storage/.sqlx/query-2a55441d4e6134975b2c75f0b43491e9cf7bb52f41644d45c92e4b83f60b65cc.json

@@ -16,7 +16,7 @@
       {
         "name": "protocol_version",
         "ordinal": 2,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "endpoint",
@@ -31,17 +31,17 @@
       {
         "name": "tx_bytes",
         "ordinal": 5,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "rx_bytes",
         "ordinal": 6,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "persistent_keepalive_interval",
         "ordinal": 7,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "allowed_ips",
@@ -51,7 +51,7 @@
       {
         "name": "client_id",
         "ordinal": 9,
-        "type_info": "Integer"
+        "type_info": "Int64"
       }
     ],
     "parameters": {

common/gateway-storage/.sqlx/query-36b5b40e6466b67f6027257068438e4e45dd6506d806a25ce3a4c69723216fd3.json

@@ -6,7 +6,7 @@
       {
         "name": "signer_id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       }
     ],
     "parameters": {

common/gateway-storage/.sqlx/query-451158af8f5602e30445986a8de22d2e065c4e9dce4e7463a875ca8c21ac97c1.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "UPDATE shared_keys SET last_used_authentication = ? WHERE client_id = ?;",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 2
-    },
-    "nullable": []
-  },
-  "hash": "451158af8f5602e30445986a8de22d2e065c4e9dce4e7463a875ca8c21ac97c1"
-}

common/gateway-storage/.sqlx/query-564c7da81081fab34754b76eeeedd48f3bc18842c03ef5a5c331bbee4c41c71c.json

@@ -0,0 +1,38 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT * FROM shared_keys WHERE client_address_bs58 = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "client_id",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "client_address_bs58",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "derived_aes128_ctr_blake3_hmac_keys_bs58",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "derived_aes256_gcm_siv_key",
+        "ordinal": 3,
+        "type_info": "Blob"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "564c7da81081fab34754b76eeeedd48f3bc18842c03ef5a5c331bbee4c41c71c"
+}

common/gateway-storage/.sqlx/query-5ee58c3050595614d550558879f54696dfcbddfb1b8575f5cc9690c4c2bffe25.json

@@ -6,7 +6,7 @@
       {
         "name": "client_id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       }
     ],
     "parameters": {

common/gateway-storage/.sqlx/query-72b268030ca7409c86806d6b5b253272629a3ebda7b89feacf8ed07ecf2e2c13.json

@@ -6,7 +6,7 @@
       {
         "name": "id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "client_type: ClientType",

common/gateway-storage/.sqlx/query-73e111225be2ce63d05f1a439a1fc9cc0359a960fe17a135a1d7f8975ebe38ef.json

@@ -6,7 +6,7 @@
       {
         "name": "ticket_id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "data!",

common/gateway-storage/.sqlx/query-7f8af0799d7ae5f751b9964e9566589bf768e7079079f584beb0c1ba16d43a5c.json

@@ -6,14 +6,14 @@
       {
         "name": "exists",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int"
       }
     ],
     "parameters": {
       "Right": 1
     },
     "nullable": [
-      false
+      null
     ]
   },
   "hash": "7f8af0799d7ae5f751b9964e9566589bf768e7079079f584beb0c1ba16d43a5c"

common/gateway-storage/.sqlx/query-870e426955cf3d0e297522552a87af82979545975f9df3ac3584fd1bf56a46cd.json

@@ -6,7 +6,7 @@
       {
         "name": "signer_id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       }
     ],
     "parameters": {

common/gateway-storage/.sqlx/query-9450b5f34620ec901e555f418eec6e0f489ed72d6b4f2b70ae1d905b4c46f0df.json

@@ -6,7 +6,7 @@
       {
         "name": "available",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       }
     ],
     "parameters": {

common/gateway-storage/.sqlx/query-af2a80cb05c0bff096e6eb830598fbb8ba0a69e0d7079e4600ff47db786e6642.json

@@ -6,7 +6,7 @@
       {
         "name": "ticket_id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "serial_number",

common/gateway-storage/.sqlx/query-be36bdf12b8f2145cefca3111f146c71205167f1edcaef624b2f80d30bf269cc.json

@@ -6,7 +6,7 @@
       {
         "name": "ticket_id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "serial_number",

common/gateway-storage/.sqlx/query-d968d8662a2327918b311d4017bf4c73f9e6f3b1be8ff81c1aebdf3791d59d4d.json

@@ -16,7 +16,7 @@
       {
         "name": "protocol_version",
         "ordinal": 2,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "endpoint",
@@ -31,17 +31,17 @@
       {
         "name": "tx_bytes",
         "ordinal": 5,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "rx_bytes",
         "ordinal": 6,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "persistent_keepalive_interval",
         "ordinal": 7,
-        "type_info": "Integer"
+        "type_info": "Int64"
       },
       {
         "name": "allowed_ips",
@@ -51,7 +51,7 @@
       {
         "name": "client_id",
         "ordinal": 9,
-        "type_info": "Integer"
+        "type_info": "Int64"
       }
     ],
     "parameters": {

common/gateway-storage/.sqlx/query-e3860c0c31ca03cc0b22ca34cef5f535a94c78d3491d44d7c8bf1b34a840839d.json

@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                   SELECT \n                        id as \"id!\",\n                        client_address_bs58 as \"client_address_bs58!\",\n                        content as \"content!\"\n                    FROM message_store\n                    WHERE client_address_bs58 = ?\n                    ORDER BY id ASC\n                    LIMIT ?;\n                ",
+  "describe": {
+    "columns": [
+      {
+        "name": "id!",
+        "ordinal": 0,
+        "type_info": "Int64"
+      },
+      {
+        "name": "client_address_bs58!",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "content!",
+        "ordinal": 2,
+        "type_info": "Blob"
+      }
+    ],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "e3860c0c31ca03cc0b22ca34cef5f535a94c78d3491d44d7c8bf1b34a840839d"
+}

common/gateway-storage/.sqlx/query-ff485c6b7e02423511b1fa55d5dd81d6c2f7228daf031c4621937e47804ce5b3.json

@@ -6,7 +6,7 @@
       {
         "name": "proposal_id",
         "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int64"
       }
     ],
     "parameters": {

common/gateway-storage/src/lib.rs

@@ -82,8 +82,8 @@ impl GatewayStorage {
         message_retrieval_limit: i64,
     ) -> Result<Self, GatewayStorageError> {
         debug!(
-            "Attempting to connect to database {}",
-            database_path.as_ref().display()
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
         );
 
         // TODO: we can inject here more stuff based on our gateway global config

common/gateway-storage/src/models.rs

@@ -1,8 +1,6 @@
 // Copyright 2021-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
-use std::time::SystemTime;
-
 use crate::error::GatewayStorageError;
 use nym_credentials_interface::{AvailableBandwidth, ClientTicket, CredentialSpendingData};
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
@@ -115,7 +113,7 @@ pub struct WireguardPeer {
     pub preshared_key: Option<String>,
     pub protocol_version: Option<i64>,
     pub endpoint: Option<String>,
-    pub last_handshake: Option<OffsetDateTime>,
+    pub last_handshake: Option<sqlx::types::chrono::NaiveDateTime>,
     pub tx_bytes: i64,
     pub rx_bytes: i64,
     pub persistent_keepalive_interval: Option<i64>,
@@ -130,7 +128,18 @@ impl From<defguard_wireguard_rs::host::Peer> for WireguardPeer {
             preshared_key: value.preshared_key.as_ref().map(|k| k.to_string()),
             protocol_version: value.protocol_version.map(|v| v as i64),
             endpoint: value.endpoint.map(|e| e.to_string()),
-            last_handshake: value.last_handshake.map(OffsetDateTime::from),
+            last_handshake: value.last_handshake.and_then(|t| {
+                if let Ok(d) = t.duration_since(std::time::UNIX_EPOCH) {
+                    if let Ok(millis) = d.as_millis().try_into() {
+                        sqlx::types::chrono::DateTime::from_timestamp_millis(millis)
+                            .map(|d| d.naive_utc())
+                    } else {
+                        None
+                    }
+                } else {
+                    None
+                }
+            }),
             tx_bytes: value.tx_bytes as i64,
             rx_bytes: value.rx_bytes as i64,
             persistent_keepalive_interval: value.persistent_keepalive_interval.map(|v| v as i64),
@@ -171,7 +180,15 @@ impl TryFrom<WireguardPeer> for defguard_wireguard_rs::host::Peer {
                 .map(|e| e.parse())
                 .transpose()
                 .map_err(|e| Self::Error::TypeConversion(format!("endpoint {e}")))?,
-            last_handshake: value.last_handshake.map(SystemTime::from),
+            last_handshake: value.last_handshake.and_then(|t| {
+                let unix_time = std::time::UNIX_EPOCH;
+                if let Ok(millis) = t.and_utc().timestamp_millis().try_into() {
+                    let duration = std::time::Duration::from_millis(millis);
+                    unix_time.checked_add(duration)
+                } else {
+                    None
+                }
+            }),
             tx_bytes: value
                 .tx_bytes
                 .try_into()

common/gateway-storage/src/tickets.rs

@@ -92,7 +92,7 @@ impl TicketStorageManager {
         )
         .fetch_one(&self.connection_pool)
         .await
-        .map(|result| result.exists == 1)
+        .map(|result| result.exists == Some(1))
     }
 
     pub(crate) async fn remove_binary_ticket_data(

common/http-api-client/Cargo.toml

@@ -10,14 +10,10 @@ license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[features]
-default=["tunneling"]
-tunneling=[]
-
 [dependencies]
 async-trait = { workspace = true }
 bincode = { workspace = true }
-reqwest = { workspace = true, features = ["json", "gzip", "deflate", "brotli", "zstd", "rustls-tls"] }
+reqwest = { workspace = true, features = ["json", "gzip", "deflate", "brotli", "zstd"] }
 http.workspace = true
 url = { workspace = true }
 once_cell = { workspace = true }
@@ -25,7 +21,6 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-itertools = { workspace = true }
 
 # used for decoding text responses (they were already implicitly included)
 bytes = { workspace = true }

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

@@ -1,118 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-//! Utilities for and implementation of request tunneling
-
-use std::sync::atomic::{AtomicBool, Ordering};
-use tracing::warn;
-
-use crate::ClientBuilder;
-
-// #[cfg(feature = "tunneling")]
-#[derive(Debug)]
-pub(crate) struct Front {
-    pub(crate) policy: FrontPolicy,
-    enabled: AtomicBool,
-}
-
-impl Clone for Front {
-    fn clone(&self) -> Self {
-        Self {
-            policy: self.policy.clone(),
-            enabled: AtomicBool::new(self.enabled.load(Ordering::Relaxed)),
-        }
-    }
-}
-
-impl Front {
-    pub(crate) fn new(policy: FrontPolicy) -> Self {
-        Self {
-            enabled: AtomicBool::new(policy == FrontPolicy::Always),
-            policy,
-        }
-    }
-
-    pub(crate) fn is_enabled(&self) -> bool {
-        match self.policy {
-            FrontPolicy::Off => false,
-            FrontPolicy::OnRetry => self.enabled.load(Ordering::Relaxed),
-            FrontPolicy::Always => true,
-        }
-    }
-
-    // Used to indicate that the client hit an error that should trigger the retry policy
-    // to enable fronting.
-    pub(crate) fn retry_enable(&self) {
-        if self.is_enabled() {
-            return;
-        }
-        if matches!(self.policy, FrontPolicy::OnRetry) {
-            self.enabled.store(true, Ordering::Relaxed);
-        }
-    }
-}
-
-#[derive(Debug, Default, PartialEq, Clone)]
-#[cfg(feature = "tunneling")]
-pub enum FrontPolicy {
-    Always,
-    OnRetry,
-    #[default]
-    Off,
-}
-
-impl ClientBuilder {
-    /// Enable and configure request tunneling for API requests.
-    #[cfg(feature = "tunneling")]
-    pub fn with_fronting(mut self, policy: FrontPolicy) -> Self {
-        let front = Front::new(policy);
-
-        // Check if any of the supplied urls even support fronting
-        if !self.urls.iter().any(|url| url.has_front()) {
-            warn!("fronting is enabled, but none of the supplied urls have configured fronting domains");
-        }
-
-        self.front = Some(front);
-
-        self
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{ApiClientCore, Url, NO_PARAMS};
-
-    #[tokio::test]
-    async fn nym_api_works() {
-        let url1 = Url::new(
-            "https://validator.global.ssl.fastly.net",
-            Some(vec!["https://yelp.global.ssl.fastly.net"]),
-        )
-        .unwrap(); // fastly
-
-        // let url2 = Url::new(
-        //     "https://validator.nymtech.net",
-        //     Some(vec!["https://cdn77.com"]),
-        // ).unwrap(); // cdn77
-
-        let client = ClientBuilder::new::<_, &str>(url1)
-            .expect("bad url")
-            .with_fronting(FrontPolicy::Always)
-            .build::<&str>()
-            .expect("failed to build client");
-
-        let response = client
-            .send_request::<_, (), &str, &str, &str>(
-                reqwest::Method::GET,
-                &["api", "v1", "network", "details"],
-                NO_PARAMS,
-                None,
-            )
-            .await
-            .expect("failed get request");
-
-        // println!("{response:?}");
-        assert_eq!(response.status(), 200);
-    }
-}

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

@@ -136,33 +136,29 @@
 //! ```
 #![warn(missing_docs)]
 
-pub use reqwest::StatusCode;
+pub use reqwest::{IntoUrl, StatusCode};
 
 use crate::path::RequestPath;
 use async_trait::async_trait;
 use bytes::Bytes;
 use http::header::CONTENT_TYPE;
 use http::HeaderMap;
-use itertools::Itertools;
 use mime::Mime;
 use reqwest::header::HeaderValue;
 use reqwest::{RequestBuilder, Response};
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
 use thiserror::Error;
 use tracing::{debug, instrument, warn};
+use url::Url;
 
 #[cfg(not(target_arch = "wasm32"))]
 use std::net::SocketAddr;
+#[cfg(not(target_arch = "wasm32"))]
 use std::sync::Arc;
 
-#[cfg(feature = "tunneling")]
-mod fronted;
-mod url;
-pub use url::{IntoUrl, Url};
 mod user_agent;
 pub use user_agent::UserAgent;
 
@@ -251,6 +247,207 @@ impl HttpClientError {
     }
 }
 
+/// A `ClientBuilder` can be used to create a [`Client`] with custom configuration applied consistently
+/// and state tracked across subsequent requests.
+pub struct ClientBuilder {
+    url: Url,
+    timeout: Option<Duration>,
+    custom_user_agent: bool,
+    reqwest_client_builder: reqwest::ClientBuilder,
+    #[allow(dead_code)] // not dead code, just unused in wasm
+    use_secure_dns: bool,
+}
+
+impl ClientBuilder {
+    /// Constructs a new `ClientBuilder`.
+    ///
+    /// This is the same as `Client::builder()`.
+    pub fn new<U, E>(url: U) -> Result<Self, HttpClientError<E>>
+    where
+        U: IntoUrl,
+        E: Display,
+    {
+        let str_url = url.as_str();
+
+        // a naive check: if the provided URL does not start with http(s), add that scheme
+        if !str_url.starts_with("http") {
+            let alt = format!("http://{str_url}");
+            warn!("the provided url ('{str_url}') does not contain scheme information. Changing it to '{alt}' ...");
+            // TODO: or should we maybe default to https?
+            Self::new(alt)
+        } else {
+            Ok(Self::new_with_url(url.into_url()?))
+        }
+    }
+
+    /// Constructs a new http `ClientBuilder` from a valid url.
+    pub fn new_with_url(url: Url) -> Self {
+        if !url.scheme().starts_with("http") {
+            warn!("the provided url ('{url}') does not use HTTP / HTTPS scheme");
+        }
+
+        #[cfg(target_arch = "wasm32")]
+        let reqwest_client_builder = reqwest::ClientBuilder::new();
+
+        #[cfg(not(target_arch = "wasm32"))]
+        let reqwest_client_builder = {
+            // Note: I believe the manual enable calls for the compression methods are extra
+            // as the various compression features for `reqwest` crate should be enabled
+            // just by including the feature which:
+            // `"Enable[s] auto decompression by checking the Content-Encoding response header."`
+            //
+            // I am going to leave these here anyways so that removing a decompression method
+            // from the features list will throw an error if it is not also removed here.
+            reqwest::ClientBuilder::new()
+                .gzip(true)
+                .deflate(true)
+                .brotli(true)
+                .zstd(true)
+        };
+
+        ClientBuilder {
+            url,
+            timeout: None,
+            custom_user_agent: false,
+            reqwest_client_builder,
+            use_secure_dns: true,
+        }
+    }
+
+    /// Enables a total request timeout other than the default.
+    ///
+    /// The timeout is applied from when the request starts connecting until the response body has finished. Also considered a total deadline.
+    ///
+    /// Default is [`DEFAULT_TIMEOUT`].
+    pub fn with_timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(timeout);
+        self
+    }
+
+    /// Provide a pre-configured [`reqwest::ClientBuilder`]
+    pub fn with_reqwest_builder(mut self, reqwest_builder: reqwest::ClientBuilder) -> Self {
+        self.reqwest_client_builder = reqwest_builder;
+        self
+    }
+
+    /// Sets the `User-Agent` header to be used by this client.
+    pub fn with_user_agent<V>(mut self, value: V) -> Self
+    where
+        V: TryInto<HeaderValue>,
+        V::Error: Into<http::Error>,
+    {
+        self.custom_user_agent = true;
+        self.reqwest_client_builder = self.reqwest_client_builder.user_agent(value);
+        self
+    }
+
+    /// Override DNS resolution for specific domains to particular IP addresses.
+    ///
+    /// Set the port to `0` to use the conventional port for the given scheme (e.g. 80 for http).
+    /// Ports in the URL itself will always be used instead of the port in the overridden addr.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn resolve_to_addrs(mut self, domain: &str, addrs: &[SocketAddr]) -> ClientBuilder {
+        self.reqwest_client_builder = self.reqwest_client_builder.resolve_to_addrs(domain, addrs);
+        self
+    }
+
+    /// Returns a Client that uses this ClientBuilder configuration.
+    pub fn build<E>(self) -> Result<Client, HttpClientError<E>>
+    where
+        E: Display,
+    {
+        #[cfg(target_arch = "wasm32")]
+        let reqwest_client = self.reqwest_client_builder.build()?;
+
+        // TODO: we should probably be propagating the error rather than panicking,
+        // but that'd break bunch of things due to type changes
+        #[cfg(not(target_arch = "wasm32"))]
+        let reqwest_client = {
+            let mut builder = self
+                .reqwest_client_builder
+                .timeout(self.timeout.unwrap_or(DEFAULT_TIMEOUT));
+
+            // if no custom user agent was set, use a default
+            if !self.custom_user_agent {
+                builder =
+                    builder.user_agent(format!("nym-http-api-client/{}", env!("CARGO_PKG_VERSION")))
+            }
+
+            // unless explicitly disabled use the DoT/DoH enabled resolver
+            if self.use_secure_dns {
+                builder = builder.dns_resolver(Arc::new(HickoryDnsResolver::default()));
+            }
+
+            builder.build()?
+        };
+
+        Ok(Client {
+            base_url: self.url,
+            reqwest_client,
+
+            #[cfg(target_arch = "wasm32")]
+            request_timeout: self.timeout.unwrap_or(DEFAULT_TIMEOUT),
+        })
+    }
+}
+
+/// A simple extendable client wrapper for http request with extra url sanitization.
+#[derive(Debug, Clone)]
+pub struct Client {
+    base_url: Url,
+    reqwest_client: reqwest::Client,
+
+    #[cfg(target_arch = "wasm32")]
+    request_timeout: Duration,
+}
+
+impl Client {
+    /// Create a new http `Client`
+    // no timeout until https://github.com/seanmonstar/reqwest/issues/1135 is fixed
+    //
+    // In order to prevent interference in API requests at the DNS phase we default to a resolver
+    // that uses DoT and DoH.
+    pub fn new(base_url: Url, timeout: Option<Duration>) -> Self {
+        Self::new_url::<_, String>(base_url, timeout).expect(
+            "we provided valid url and we were unwrapping previous construction errors anyway",
+        )
+    }
+
+    /// Attempt to create a new http client from a something that can be converted to a URL
+    pub fn new_url<U, E>(url: U, timeout: Option<Duration>) -> Result<Self, HttpClientError<E>>
+    where
+        U: IntoUrl,
+        E: Display,
+    {
+        let builder = Self::builder(url)?;
+        match timeout {
+            Some(timeout) => builder.with_timeout(timeout).build(),
+            None => builder.build(),
+        }
+    }
+
+    /// Creates a [`ClientBuilder`] to configure a [`Client`].
+    ///
+    /// This is the same as [`ClientBuilder::new()`].
+    pub fn builder<U, E>(url: U) -> Result<ClientBuilder, HttpClientError<E>>
+    where
+        U: IntoUrl,
+        E: Display,
+    {
+        ClientBuilder::new(url)
+    }
+
+    /// Update the host that this client uses when sending API requests.
+    pub fn change_base_url(&mut self, new_url: Url) {
+        self.base_url = new_url
+    }
+
+    /// Get the currently configured host that this client uses when sending API requests.
+    pub fn current_url(&self) -> &Url {
+        &self.base_url
+    }
+}
+
 /// Core functionality required for types acting as API clients.
 ///
 /// This trait defines the "skinny waist" of behaviors that are required by an API client. More
@@ -351,366 +548,6 @@ pub trait ApiClientCore {
     }
 }
 
-/// A `ClientBuilder` can be used to create a [`Client`] with custom configuration applied consistently
-/// and state tracked across subsequent requests.
-pub struct ClientBuilder {
-    urls: Vec<Url>,
-
-    timeout: Option<Duration>,
-    custom_user_agent: bool,
-    reqwest_client_builder: reqwest::ClientBuilder,
-    #[allow(dead_code)] // not dead code, just unused in wasm
-    use_secure_dns: bool,
-
-    #[cfg(feature = "tunneling")]
-    front: Option<fronted::Front>,
-
-    retry_limit: usize,
-}
-
-impl ClientBuilder {
-    /// Constructs a new `ClientBuilder`.
-    ///
-    /// This is the same as `Client::builder()`.
-    pub fn new<U, E>(url: U) -> Result<Self, HttpClientError<E>>
-    where
-        U: IntoUrl,
-        E: Display,
-    {
-        let str_url = url.as_str();
-
-        // a naive check: if the provided URL does not start with http(s), add that scheme
-        if !str_url.starts_with("http") {
-            let alt = format!("http://{str_url}");
-            warn!("the provided url ('{str_url}') does not contain scheme information. Changing it to '{alt}' ...");
-            // TODO: or should we maybe default to https?
-            Self::new(alt)
-        } else {
-            let url = url.to_url()?;
-            Ok(Self::new_with_urls(vec![url]))
-        }
-    }
-
-    /// Constructs a new http `ClientBuilder` from a valid url.
-    pub fn new_with_urls(urls: Vec<Url>) -> Self {
-        let urls = Self::check_urls(urls);
-
-        #[cfg(target_arch = "wasm32")]
-        let reqwest_client_builder = reqwest::ClientBuilder::new();
-
-        #[cfg(not(target_arch = "wasm32"))]
-        let reqwest_client_builder = {
-            // Note: I believe the manual enable calls for the compression methods are extra
-            // as the various compression features for `reqwest` crate should be enabled
-            // just by including the feature which:
-            // `"Enable[s] auto decompression by checking the Content-Encoding response header."`
-            //
-            // I am going to leave these here anyways so that removing a decompression method
-            // from the features list will throw an error if it is not also removed here.
-            reqwest::ClientBuilder::new()
-                .gzip(true)
-                .deflate(true)
-                .brotli(true)
-                .zstd(true)
-        };
-
-        ClientBuilder {
-            urls,
-            timeout: None,
-            custom_user_agent: false,
-            reqwest_client_builder,
-            use_secure_dns: true,
-            #[cfg(feature = "tunneling")]
-            front: None,
-
-            retry_limit: 0,
-        }
-    }
-
-    /// Add an additional URL to the set usable by this constructed `Client`
-    pub fn add_url(mut self, url: Url) -> Self {
-        self.urls.push(url);
-        self
-    }
-
-    fn check_urls(mut urls: Vec<Url>) -> Vec<Url> {
-        // remove any duplicate URLs
-        urls = urls.into_iter().unique().collect();
-
-        // warn about any invalid URLs
-        urls.iter()
-            .filter(|url| !url.scheme().contains("http") && !url.scheme().contains("https"))
-            .for_each(|url| {
-                warn!("the provided url ('{url}') does not use HTTP / HTTPS scheme");
-            });
-
-        urls
-    }
-
-    /// Enables a total request timeout other than the default.
-    ///
-    /// The timeout is applied from when the request starts connecting until the response body has finished. Also considered a total deadline.
-    ///
-    /// Default is [`DEFAULT_TIMEOUT`].
-    pub fn with_timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = Some(timeout);
-        self
-    }
-
-    /// Sets the maximum number of retries for a request. This defaults to 0, indicating no retries.
-    ///
-    /// Note that setting a retry limit of 3 (for example) will result in 4 attempts to send the
-    /// request in the case that all are unsuccessful.
-    ///
-    /// If multiple urls (or fronting configurations if enabled) are available, retried requests
-    /// will be sent to the next URL in the list.
-    pub fn with_retries(mut self, retry_limit: usize) -> Self {
-        self.retry_limit = retry_limit;
-        self
-    }
-
-    /// Provide a pre-configured [`reqwest::ClientBuilder`]
-    pub fn with_reqwest_builder(mut self, reqwest_builder: reqwest::ClientBuilder) -> Self {
-        self.reqwest_client_builder = reqwest_builder;
-        self
-    }
-
-    /// Sets the `User-Agent` header to be used by this client.
-    pub fn with_user_agent<V>(mut self, value: V) -> Self
-    where
-        V: TryInto<HeaderValue>,
-        V::Error: Into<http::Error>,
-    {
-        self.custom_user_agent = true;
-        self.reqwest_client_builder = self.reqwest_client_builder.user_agent(value);
-        self
-    }
-
-    /// Override DNS resolution for specific domains to particular IP addresses.
-    ///
-    /// Set the port to `0` to use the conventional port for the given scheme (e.g. 80 for http).
-    /// Ports in the URL itself will always be used instead of the port in the overridden addr.
-    #[cfg(not(target_arch = "wasm32"))]
-    pub fn resolve_to_addrs(mut self, domain: &str, addrs: &[SocketAddr]) -> ClientBuilder {
-        self.reqwest_client_builder = self.reqwest_client_builder.resolve_to_addrs(domain, addrs);
-        self
-    }
-
-    /// Returns a Client that uses this ClientBuilder configuration.
-    pub fn build<E>(self) -> Result<Client, HttpClientError<E>>
-    where
-        E: Display,
-    {
-        #[cfg(target_arch = "wasm32")]
-        let reqwest_client = self.reqwest_client_builder.build()?;
-
-        // TODO: we should probably be propagating the error rather than panicking,
-        // but that'd break bunch of things due to type changes
-        #[cfg(not(target_arch = "wasm32"))]
-        let reqwest_client = {
-            let mut builder = self
-                .reqwest_client_builder
-                .timeout(self.timeout.unwrap_or(DEFAULT_TIMEOUT));
-
-            // if no custom user agent was set, use a default
-            if !self.custom_user_agent {
-                builder =
-                    builder.user_agent(format!("nym-http-api-client/{}", env!("CARGO_PKG_VERSION")))
-            }
-
-            // unless explicitly disabled use the DoT/DoH enabled resolver
-            if self.use_secure_dns {
-                builder = builder.dns_resolver(Arc::new(HickoryDnsResolver::default()));
-            }
-
-            builder.build()?
-        };
-
-        let client = Client {
-            base_urls: self.urls,
-            current_idx: Arc::new(AtomicUsize::new(0)),
-            reqwest_client,
-
-            #[cfg(feature = "tunneling")]
-            front: self.front,
-
-            #[cfg(target_arch = "wasm32")]
-            request_timeout: self.timeout.unwrap_or(DEFAULT_TIMEOUT),
-            retry_limit: self.retry_limit,
-        };
-
-        Ok(client)
-    }
-}
-
-/// A simple extendable client wrapper for http request with extra url sanitization.
-#[derive(Debug, Clone)]
-pub struct Client {
-    base_urls: Vec<Url>,
-    current_idx: Arc<AtomicUsize>,
-    reqwest_client: reqwest::Client,
-
-    #[cfg(feature = "tunneling")]
-    front: Option<fronted::Front>,
-
-    #[cfg(target_arch = "wasm32")]
-    request_timeout: Duration,
-
-    retry_limit: usize,
-}
-
-impl Client {
-    /// Create a new http `Client`
-    // no timeout until https://github.com/seanmonstar/reqwest/issues/1135 is fixed
-    //
-    // In order to prevent interference in API requests at the DNS phase we default to a resolver
-    // that uses DoT and DoH.
-    pub fn new(base_url: ::url::Url, timeout: Option<Duration>) -> Self {
-        Self::new_url::<_, String>(base_url, timeout).expect(
-            "we provided valid url and we were unwrapping previous construction errors anyway",
-        )
-    }
-
-    /// Attempt to create a new http client from a something that can be converted to a URL
-    pub fn new_url<U, E>(url: U, timeout: Option<Duration>) -> Result<Self, HttpClientError<E>>
-    where
-        U: IntoUrl,
-        E: Display,
-    {
-        let builder = Self::builder(url)?;
-        match timeout {
-            Some(timeout) => builder.with_timeout(timeout).build(),
-            None => builder.build(),
-        }
-    }
-
-    /// Creates a [`ClientBuilder`] to configure a [`Client`].
-    ///
-    /// This is the same as [`ClientBuilder::new()`].
-    pub fn builder<U, E>(url: U) -> Result<ClientBuilder, HttpClientError<E>>
-    where
-        U: IntoUrl,
-        E: Display,
-    {
-        ClientBuilder::new(url)
-    }
-
-    /// Update the set of hosts that this client uses when sending API requests.
-    pub fn change_base_urls(&mut self, new_urls: Vec<Url>) {
-        self.current_idx.store(0, Ordering::Relaxed);
-        self.base_urls = new_urls
-    }
-
-    /// Create new instance of `Client` using the provided base url and existing client config
-    pub fn clone_with_new_url(&self, new_url: Url) -> Self {
-        Client {
-            base_urls: vec![new_url],
-            current_idx: Arc::new(Default::default()),
-            reqwest_client: self.reqwest_client.clone(),
-
-            front: self.front.clone(),
-            retry_limit: self.retry_limit,
-
-            #[cfg(target_arch = "wasm32")]
-            request_timeout: self.request_timeout,
-        }
-    }
-
-    /// Get the currently configured host that this client uses when sending API requests.
-    pub fn current_url(&self) -> &Url {
-        &self.base_urls[self.current_idx.load(std::sync::atomic::Ordering::Relaxed)]
-    }
-
-    /// Get the currently configured host that this client uses when sending API requests.
-    pub fn base_urls(&self) -> &[Url] {
-        &self.base_urls
-    }
-
-    /// Get a mutable reference to the hosts that this client uses when sending API requests.
-    pub fn base_urls_mut(&mut self) -> &mut [Url] {
-        &mut self.base_urls
-    }
-
-    /// Change the currently configured limit on the number of retries for a request.
-    pub fn change_retry_limit(&mut self, limit: usize) {
-        self.retry_limit = limit;
-    }
-
-    /// If multiple base urls are available rotate to next (e.g. when the current one resulted in an error)
-    fn update_host(&self) {
-        #[cfg(feature = "tunneling")]
-        if let Some(ref front) = self.front {
-            if front.is_enabled() {
-                // if we are using fronting, try updating to the next front
-                let url = self.current_url();
-
-                // try to update the current host to use a next front, if one is available, otherwise
-                // we move on and try the next base url (if one is available)
-                if url.has_front() && !url.update() {
-                    // we swapped to the next front for the current host
-                    return;
-                }
-            }
-        }
-
-        if self.base_urls.len() > 1 {
-            let orig = self.current_idx.load(Ordering::Relaxed);
-            let mut next = (orig + 1) % self.base_urls.len();
-
-            // if fronting is enabled we want to update to a host that has fronts configured
-            #[cfg(feature = "tunneling")]
-            if let Some(ref front) = self.front {
-                if front.is_enabled() {
-                    while next != orig {
-                        if self.base_urls[next].has_front() {
-                            // we have a front for the next host, so we can use it
-                            break;
-                        }
-
-                        next = (next + 1) % self.base_urls.len();
-                    }
-                }
-            }
-
-            self.current_idx.store(next, Ordering::Relaxed);
-        }
-    }
-
-    /// Make modifications to the request to apply the current state of this client i.e. the
-    /// currently configured host. This is required as a caller may use this client to create a
-    /// request, but then have the state of the client change before the caller uses the client to
-    /// send their request.
-    ///
-    /// This enures that the outgoing requests benefit from the configured fallback mechanisms, even
-    /// for requests that were created before the state of the client changed.
-    ///
-    /// This method assumes that any updates to the state of the client are made before the call to
-    /// this method. For example, if the client is configured to rotate hosts after each error, this
-    /// method should be called after the host has been updated -- i.e. as part of the subsequent
-    /// send.
-    fn apply_hosts_to_req(&self, r: &mut reqwest::Request) {
-        let url = self.current_url();
-        r.url_mut().set_host(url.host_str()).unwrap();
-
-        #[cfg(feature = "tunneling")]
-        if let Some(ref front) = self.front {
-            if front.is_enabled() {
-                // this should never fail as we are transplanting the host from one url to another
-                r.url_mut().set_host(url.front_str()).unwrap();
-
-                let actual_host: HeaderValue = url
-                    .host_str()
-                    .unwrap_or("")
-                    .parse()
-                    .unwrap_or(HeaderValue::from_static(""));
-                // If the map did have this key present, the new value is associated with the key
-                // and all previous values are removed. (reqwest HeaderMap docs)
-                _ = r.headers_mut().insert(reqwest::header::HOST, actual_host);
-            }
-        }
-    }
-}
-
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl ApiClientCore for Client {
@@ -728,77 +565,33 @@ impl ApiClientCore for Client {
         K: AsRef<str>,
         V: AsRef<str>,
     {
-        let url = self.current_url();
-        let url = sanitize_url(url, path, params);
+        let url = sanitize_url(&self.base_url, path, params);
 
-        let mut req = reqwest::Request::new(method, url.into());
-
-        self.apply_hosts_to_req(&mut req);
-
-        let mut rb = RequestBuilder::from_parts(self.reqwest_client.clone(), req);
+        let mut request = self.reqwest_client.request(method.clone(), url);
 
         if let Some(body) = json_body {
-            rb = rb.json(body);
+            request = request.json(body);
         }
 
-        rb
+        request
     }
 
     async fn send<E>(&self, request: RequestBuilder) -> Result<Response, HttpClientError<E>>
     where
         E: Display,
     {
-        let mut attempts = 0;
-        loop {
-            // try_clone may fail if the body is a stream in which case using retries is not advised.
-            let r = request
-                .try_clone()
-                .ok_or(HttpClientError::GenericRequestFailure(
-                    "failed to send request".to_string(),
-                ))?;
+        #[cfg(target_arch = "wasm32")]
+        {
+            Ok(
+                wasmtimer::tokio::timeout(self.request_timeout, request.send())
+                    .await
+                    .map_err(|_timeout| HttpClientError::RequestTimeout)??,
+            )
+        }
 
-            // apply any changes based on the current state of the client wrt. hosts,
-            // fronting domains, etc.
-            let mut req = r.build()?;
-            self.apply_hosts_to_req(&mut req);
-
-            #[cfg(target_arch = "wasm32")]
-            let response: Result<Response, HttpClientError<E>> = {
-                Ok(wasmtimer::tokio::timeout(
-                    self.request_timeout,
-                    self.reqwest_client.execute(req),
-                )
-                .await
-                .map_err(|_timeout| HttpClientError::RequestTimeout)??)
-            };
-
-            #[cfg(not(target_arch = "wasm32"))]
-            let response = self.reqwest_client.execute(req).await;
-
-            match response {
-                Ok(resp) => return Ok(resp),
-                Err(e) => {
-                    // if we have multiple urls, update to the next
-                    self.update_host();
-
-                    #[cfg(feature = "tunneling")]
-                    if let Some(ref front) = self.front {
-                        // If fronting is set to be enabled on error, enable domain fronting as we
-                        // have encountered an error.
-                        front.retry_enable();
-                    }
-
-                    if attempts < self.retry_limit {
-                        warn!("Retrying request due to http error: {}", e);
-                        attempts += 1;
-                        continue;
-                    }
-
-                    // if we have exhausted our attempts, return the error
-                    #[allow(clippy::useless_conversion)] // conversion considered useless in wasm
-                    return Err(e.into());
-                }
-            }
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            Ok(request.send().await?)
         }
     }
 }
@@ -1256,4 +1049,88 @@ fn try_get_mime_type(headers: &HeaderMap) -> Option<Mime> {
 }
 
 #[cfg(test)]
-mod tests;
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sanitizing_urls() {
+        let base_url: Url = "http://foomp.com".parse().unwrap();
+
+        // works with a full string
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, "/foo//bar/", NO_PARAMS).as_str()
+        );
+
+        // (and leading slash doesn't matter)
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, "foo//bar/", NO_PARAMS).as_str()
+        );
+
+        // works with 1 segment
+        assert_eq!(
+            "http://foomp.com/foo",
+            sanitize_url(&base_url, &["foo"], NO_PARAMS).as_str()
+        );
+
+        // works with 2 segments
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, &["foo", "bar"], NO_PARAMS).as_str()
+        );
+
+        // works with leading slash
+        assert_eq!(
+            "http://foomp.com/foo",
+            sanitize_url(&base_url, &["/foo"], NO_PARAMS).as_str()
+        );
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, &["/foo", "bar"], NO_PARAMS).as_str()
+        );
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, &["foo", "/bar"], NO_PARAMS).as_str()
+        );
+
+        // works with trailing slash
+        assert_eq!(
+            "http://foomp.com/foo",
+            sanitize_url(&base_url, &["foo/"], NO_PARAMS).as_str()
+        );
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, &["foo/", "bar"], NO_PARAMS).as_str()
+        );
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, &["foo", "bar/"], NO_PARAMS).as_str()
+        );
+
+        // works with both leading and trailing slash
+        assert_eq!(
+            "http://foomp.com/foo",
+            sanitize_url(&base_url, &["/foo/"], NO_PARAMS).as_str()
+        );
+        assert_eq!(
+            "http://foomp.com/foo/bar",
+            sanitize_url(&base_url, &["/foo/", "/bar/"], NO_PARAMS).as_str()
+        );
+
+        // adds params
+        assert_eq!(
+            "http://foomp.com/foo/bar?foomp=baz",
+            sanitize_url(&base_url, &["foo", "bar"], &[("foomp", "baz")]).as_str()
+        );
+        assert_eq!(
+            "http://foomp.com/foo/bar?arg1=val1&arg2=val2",
+            sanitize_url(
+                &base_url,
+                &["/foo/", "/bar/"],
+                &[("arg1", "val1"), ("arg2", "val2")]
+            )
+            .as_str()
+        );
+    }
+}

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

@@ -1,224 +0,0 @@
-use super::*;
-
-#[test]
-fn sanitizing_urls() {
-    let base_url: Url = "http://foomp.com".parse().unwrap();
-
-    // works with a full string
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, "/foo//bar/", NO_PARAMS).as_str()
-    );
-
-    // (and leading slash doesn't matter)
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, "foo//bar/", NO_PARAMS).as_str()
-    );
-
-    // works with 1 segment
-    assert_eq!(
-        "http://foomp.com/foo",
-        sanitize_url(&base_url, &["foo"], NO_PARAMS).as_str()
-    );
-
-    // works with 2 segments
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, &["foo", "bar"], NO_PARAMS).as_str()
-    );
-
-    // works with leading slash
-    assert_eq!(
-        "http://foomp.com/foo",
-        sanitize_url(&base_url, &["/foo"], NO_PARAMS).as_str()
-    );
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, &["/foo", "bar"], NO_PARAMS).as_str()
-    );
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, &["foo", "/bar"], NO_PARAMS).as_str()
-    );
-
-    // works with trailing slash
-    assert_eq!(
-        "http://foomp.com/foo",
-        sanitize_url(&base_url, &["foo/"], NO_PARAMS).as_str()
-    );
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, &["foo/", "bar"], NO_PARAMS).as_str()
-    );
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, &["foo", "bar/"], NO_PARAMS).as_str()
-    );
-
-    // works with both leading and trailing slash
-    assert_eq!(
-        "http://foomp.com/foo",
-        sanitize_url(&base_url, &["/foo/"], NO_PARAMS).as_str()
-    );
-    assert_eq!(
-        "http://foomp.com/foo/bar",
-        sanitize_url(&base_url, &["/foo/", "/bar/"], NO_PARAMS).as_str()
-    );
-
-    // adds params
-    assert_eq!(
-        "http://foomp.com/foo/bar?foomp=baz",
-        sanitize_url(&base_url, &["foo", "bar"], &[("foomp", "baz")]).as_str()
-    );
-    assert_eq!(
-        "http://foomp.com/foo/bar?arg1=val1&arg2=val2",
-        sanitize_url(
-            &base_url,
-            &["/foo/", "/bar/"],
-            &[("arg1", "val1"), ("arg2", "val2")]
-        )
-        .as_str()
-    );
-}
-
-// - Do the retries work
-// - Do we use fallback urls on retry if multiple are provided
-// - Do we use the next front on retry if multiple are provided
-// - If we have more retries than urls, do we wrap back to the first one again
-// - on error without retries is where we have multiple urls, is the url updated?
-
-#[tokio::test]
-async fn api_client_retry() -> Result<(), Box<dyn std::error::Error>> {
-    let client = ClientBuilder::new_with_urls(vec![
-        "http://broken.nym.badurl".parse()?,
-        "http://example.com/".parse()?,
-    ])
-    .with_retries(3)
-    .build::<HttpClientError>()?;
-
-    let req = client.create_get_request(&["/"], NO_PARAMS);
-    let resp = client.send::<HttpClientError>(req).await?;
-
-    assert_eq!(resp.status(), 200);
-
-    // check that the url was updated
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
-
-    Ok(())
-}
-
-#[test]
-fn host_updating() {
-    let url = Url::new("http://example.com", None).unwrap();
-    let mut client = ClientBuilder::new::<_, &str>(url)
-        .unwrap()
-        .build::<&str>()
-        .unwrap();
-
-    // check that the url is set correctly
-    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), None);
-
-    // update the url
-    client.update_host();
-
-    // check that the url is still the same since there is one URL
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
-
-    // =======================================
-    // we rotate through urls when available
-
-    let new_urls = vec![
-        Url::new("http://example.com", None).unwrap(),
-        Url::new("http://example.org", None).unwrap(),
-    ];
-    client.change_base_urls(new_urls);
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
-
-    client.update_host();
-
-    // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://example.org/");
-    assert_eq!(client.current_url().front_str(), None);
-
-    client.update_host();
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
-
-    // =======================================
-    // we rotate through urls when available if fronting is disabled
-
-    let new_urls = vec![
-        Url::new(
-            "http://example.com",
-            Some(vec!["http://front1.com", "http://front2.com"]),
-        )
-        .unwrap(),
-        Url::new("http://example.org", None).unwrap(),
-    ];
-    client.change_base_urls(new_urls);
-
-    assert_eq!(client.current_url().as_str(), "http://example.com/");
-
-    client.update_host();
-
-    // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://example.org/");
-}
-
-#[test]
-#[cfg(feature = "tunneling")]
-fn fronted_host_updating() {
-    let url = Url::new("http://example.com", Some(vec!["http://front1.com"])).unwrap();
-    let mut client = ClientBuilder::new::<_, &str>(url)
-        .unwrap()
-        .with_fronting(crate::fronted::FrontPolicy::Always)
-        .build::<&str>()
-        .unwrap();
-
-    // check that the url is set correctly
-    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
-
-    // update the url
-    client.update_host();
-
-    // check that the url is still the same since there is one URL and one front
-    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
-
-    // =======================================
-    // we rotate through front urls when available if fronting is enabled
-
-    let new_urls = vec![
-        Url::new(
-            "http://example.com",
-            Some(vec!["http://front1.com", "http://front2.com"]),
-        )
-        .unwrap(),
-        Url::new("http://example.org", None).unwrap(),
-    ];
-    client.change_base_urls(new_urls);
-
-    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
-
-    // update the url - this should keep the same host but change the front
-    client.update_host();
-
-    let current_url = client.current_url();
-    // check that the url is still the same since there is one URL
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front2.com"));
-
-    // update the url - this should wrap around to the first front as the second url is not fronted
-    client.update_host();
-
-    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://example.com/");
-    assert_eq!(current_url.front_str(), Some("front1.com"));
-}

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

@@ -1,291 +0,0 @@
-//! Url handling for the HTTP API client.
-//!
-//! This module provides a `Url` struct that wraps around the `url::Url` type and adds
-//! functionality for handling front domains, which are used for reverse proxying.
-
-use std::fmt::Display;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
-
-use itertools::Itertools;
-use url::form_urlencoded;
-pub use url::ParseError;
-
-/// A trait to try to convert some type into a `Url`.
-pub trait IntoUrl {
-    /// Parse as a valid `Url`
-    fn to_url(self) -> Result<Url, ParseError>;
-
-    /// Returns the string representation of the URL.
-    fn as_str(&self) -> &str;
-}
-
-impl IntoUrl for &str {
-    fn to_url(self) -> Result<Url, ParseError> {
-        let url = url::Url::parse(self)?;
-        Ok(url.into())
-    }
-
-    fn as_str(&self) -> &str {
-        self
-    }
-}
-
-impl IntoUrl for String {
-    fn to_url(self) -> Result<Url, ParseError> {
-        let url = url::Url::parse(&self)?;
-        Ok(url.into())
-    }
-
-    fn as_str(&self) -> &str {
-        self
-    }
-}
-
-impl IntoUrl for reqwest::Url {
-    fn to_url(self) -> Result<Url, ParseError> {
-        Ok(self.into())
-    }
-
-    fn as_str(&self) -> &str {
-        self.as_str()
-    }
-}
-
-/// When configuring fronting, some configurations will require a specific backend host
-/// to be used for the request to be properly reverse proxied.
-#[derive(Debug, Clone)]
-pub struct Url {
-    url: url::Url,
-    fronts: Option<Vec<url::Url>>,
-    current_front: Arc<AtomicUsize>,
-}
-
-impl IntoUrl for Url {
-    fn to_url(self) -> Result<Url, ParseError> {
-        Ok(self)
-    }
-
-    fn as_str(&self) -> &str {
-        self.url.as_str()
-    }
-}
-
-impl PartialEq for Url {
-    fn eq(&self, other: &Self) -> bool {
-        let current = self.current_front.load(Ordering::Relaxed);
-        let other_current = other.current_front.load(Ordering::Relaxed);
-
-        self.fronts == other.fronts && self.url == other.url && current == other_current
-    }
-}
-
-impl Eq for Url {}
-
-impl std::hash::Hash for Url {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        let current = self.current_front.load(Ordering::Relaxed);
-        self.fronts.hash(state);
-        self.url.hash(state);
-        current.hash(state);
-    }
-}
-
-impl Display for Url {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.fronts {
-            Some(ref fronts) => {
-                let current = self.current_front.load(Ordering::Relaxed);
-                if let Some(front) = fronts.get(current) {
-                    write!(f, "{front}=>{}", self.url)
-                } else {
-                    write!(f, "{}", self.url)
-                }
-            }
-            None => write!(f, "{}", self.url),
-        }
-    }
-}
-
-impl From<Url> for url::Url {
-    fn from(val: Url) -> Self {
-        val.url
-    }
-}
-
-impl From<reqwest::Url> for Url {
-    fn from(url: url::Url) -> Self {
-        Self {
-            url,
-            fronts: None,
-            current_front: Arc::new(AtomicUsize::new(0)),
-        }
-    }
-}
-
-impl AsRef<url::Url> for Url {
-    fn as_ref(&self) -> &url::Url {
-        &self.url
-    }
-}
-
-impl AsMut<url::Url> for Url {
-    fn as_mut(&mut self) -> &mut url::Url {
-        &mut self.url
-    }
-}
-
-impl std::str::FromStr for Url {
-    type Err = url::ParseError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let url = url::Url::parse(s)?;
-        Ok(Self {
-            url,
-            fronts: None,
-            current_front: Arc::new(AtomicUsize::new(0)),
-        })
-    }
-}
-
-impl Url {
-    /// Create a new `Url` instance with the given something that can be parsed as a  URL and
-    /// optional tunneling domains
-    pub fn new<U: reqwest::IntoUrl>(
-        url: U,
-        fronts: Option<Vec<U>>,
-    ) -> Result<Self, reqwest::Error> {
-        let mut url = Self {
-            url: url.into_url()?,
-            fronts: None,
-            current_front: Arc::new(AtomicUsize::new(0)),
-        };
-
-        // ensure that the provided URLs are valid
-        if let Some(front_domains) = fronts {
-            let f: Vec<reqwest::Url> = front_domains
-                .into_iter()
-                .map(|front| front.into_url())
-                .try_collect()?;
-            url.fronts = Some(f);
-        }
-
-        Ok(url)
-    }
-
-    /// Parse an absolute URL from a string.
-    pub fn parse(s: &str) -> Result<Self, ParseError> {
-        let url = url::Url::parse(s)?;
-        Ok(Self {
-            url,
-            fronts: None,
-            current_front: Arc::new(AtomicUsize::new(0)),
-        })
-    }
-
-    /// Returns true if the URL has a front domain set
-    pub fn has_front(&self) -> bool {
-        if let Some(fronts) = &self.fronts {
-            return !fronts.is_empty();
-        }
-        false
-    }
-
-    /// Return the string representation of the current front host (domain or IP address) for this
-    /// URL, if any.
-    pub fn front_str(&self) -> Option<&str> {
-        let current = self.current_front.load(Ordering::Relaxed);
-        self.fronts
-            .as_ref()
-            .and_then(|fronts| fronts.get(current))
-            .and_then(|url| url.host_str())
-    }
-
-    /// Return the string representation of the host (domain or IP address) for this URL, if any.
-    pub fn host_str(&self) -> Option<&str> {
-        self.url.host_str()
-    }
-
-    /// Return the serialization of this URL.
-    ///
-    /// This is fast since that serialization is already stored in the inner url::Url struct.
-    pub fn as_str(&self) -> &str {
-        self.url.as_str()
-    }
-
-    /// Returns true if updating the front wraps back to the first front, or if no fronts are set
-    pub fn update(&self) -> bool {
-        if let Some(fronts) = &self.fronts {
-            if fronts.len() > 1 {
-                let current = self.current_front.load(Ordering::Relaxed);
-                let next = (current + 1) % fronts.len();
-                self.current_front.store(next, Ordering::Relaxed);
-                return next == 0;
-            }
-        }
-        true
-    }
-
-    /// Return the scheme of this URL, lower-cased, as an ASCII string without the ‘:’ delimiter.
-    pub fn scheme(&self) -> &str {
-        self.url.scheme()
-    }
-
-    /// Parse the URL’s query string, if any, as application/x-www-form-urlencoded and return an
-    /// iterator of (key, value) pairs.
-    pub fn query_pairs(&self) -> form_urlencoded::Parse<'_> {
-        self.url.query_pairs()
-    }
-
-    /// Manipulate this URL’s query string, viewed as a sequence of name/value pairs in
-    /// application/x-www-form-urlencoded syntax.
-    pub fn query_pairs_mut(&mut self) -> form_urlencoded::Serializer<'_, ::url::UrlQuery<'_>> {
-        self.url.query_pairs_mut()
-    }
-
-    /// Change this URL’s query string. If `query` is `None`, this URL’s query string will be cleared.
-    pub fn set_query(&mut self, query: Option<&str>) {
-        self.url.set_query(query);
-    }
-
-    /// Change this URL’s path.
-    pub fn set_path(&mut self, path: &str) {
-        self.url.set_path(path);
-    }
-
-    /// Change this URL’s scheme.
-    pub fn set_scheme(&mut self, scheme: &str) {
-        self.url.set_scheme(scheme).unwrap();
-    }
-
-    /// Change this URL’s host.
-    ///
-    /// Removing the host (calling this with None) will also remove any username, password, and port number.
-    pub fn set_host(&mut self, host: &str) {
-        self.url.set_host(Some(host)).unwrap();
-    }
-
-    /// Change this URL’s port number.
-    ///
-    /// Note that default port numbers are not reflected in the serialization.
-    ///
-    /// If this URL is cannot-be-a-base, does not have a host, or has the `file` scheme; do nothing and return `Err`.
-    pub fn set_port(&mut self, port: u16) {
-        self.url.set_port(Some(port)).unwrap();
-    }
-
-    /// Return an object with methods to manipulate this URL’s path segments.
-    ///
-    /// Return Err(()) if this URL is cannot-be-a-base.
-    pub fn path_segments(&self) -> Option<std::str::Split<'_, char>> {
-        self.url.path_segments()
-    }
-
-    /// Return an object with methods to manipulate this URL’s path segments.
-    ///
-    /// Return Err(()) if this URL is cannot-be-a-base.
-    #[allow(clippy::result_unit_err)]
-    pub fn path_segments_mut(&mut self) -> Result<::url::PathSegmentsMut<'_>, ()> {
-        self.url.path_segments_mut()
-    }
-}

common/http-api-common/src/response/bincode.rs

@@ -30,10 +30,6 @@ impl<T> Bincode<T> {
         self.0.headers.insert(name, value.into());
         self
     }
-
-    pub(crate) fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Bincode<U> {
-        Bincode(self.0.map(op))
-    }
 }
 
 impl<T> IntoResponse for Bincode<T>

common/http-api-common/src/response/json.rs

@@ -32,10 +32,6 @@ impl<T> Json<T> {
         self.0.headers.insert(name, value.into());
         self
     }
-
-    pub(crate) fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Json<U> {
-        Json(self.0.map(op))
-    }
 }
 
 impl<T> IntoResponse for Json<T>

common/http-api-common/src/response/mod.rs

@@ -14,10 +14,11 @@ pub mod bincode;
 pub mod json;
 pub mod yaml;
 
-pub use bincode::Bincode;
 pub use json::Json;
 pub use yaml::Yaml;
 
+pub use bincode::Bincode;
+
 #[derive(Debug, Clone, Default)]
 pub(crate) struct ResponseWrapper<T> {
     data: T,
@@ -32,13 +33,6 @@ impl<T> ResponseWrapper<T> {
         }
     }
 
-    pub(crate) fn map<U, F: FnOnce(T) -> U>(self, op: F) -> ResponseWrapper<U> {
-        ResponseWrapper {
-            data: op(self.data),
-            headers: self.headers,
-        }
-    }
-
     #[must_use]
     pub(crate) fn with_header(
         mut self,
@@ -66,14 +60,6 @@ impl<T> FormattedResponse<T> {
         }
     }
 
-    pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> FormattedResponse<U> {
-        match self {
-            FormattedResponse::Json(inner) => FormattedResponse::Json(inner.map(op)),
-            FormattedResponse::Yaml(inner) => FormattedResponse::Yaml(inner.map(op)),
-            FormattedResponse::Bincode(inner) => FormattedResponse::Bincode(inner.map(op)),
-        }
-    }
-
     #[must_use]
     pub fn with_header(
         self,

common/http-api-common/src/response/yaml.rs

@@ -30,10 +30,6 @@ impl<T> Yaml<T> {
         self.0.headers.insert(name, value.into());
         self
     }
-
-    pub(crate) fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Yaml<U> {
-        Yaml(self.0.map(op))
-    }
 }
 
 impl<T> IntoResponse for Yaml<T>

common/network-defaults/src/mainnet.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #[cfg(feature = "network")]
-use crate::{ApiUrlConst, DenomDetails, ValidatorDetails};
+use crate::{DenomDetails, ValidatorDetails};
 
 pub const NETWORK_NAME: &str = "mainnet";
 
@@ -29,36 +29,10 @@ pub const COCONUT_DKG_CONTRACT_ADDRESS: &str =
 pub const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy";
 
 pub const NYXD_URL: &str = "https://rpc.nymtech.net";
+pub const NYM_API: &str = "https://validator.nymtech.net/api/";
 pub const NYXD_WS: &str = "wss://rpc.nymtech.net/websocket";
 pub const EXPLORER_API: &str = "https://explorer.nymtech.net/api/";
-pub const NYM_API: &str = "https://validator.nymtech.net/api/";
-#[cfg(feature = "network")]
-pub const NYM_APIS: &[ApiUrlConst] = &[
-    ApiUrlConst {
-        url: NYM_API,
-        front_hosts: None,
-    },
-    ApiUrlConst {
-        url: "https://nym-fronntdoor.vercel.app/api/",
-        front_hosts: Some(&["vercel.app", "vercel.com"]),
-    },
-    ApiUrlConst {
-        url: "https://nym-frontdoor.global.ssl.fastly.net/api/",
-        front_hosts: Some(&["yelp.global.ssl.fastly.net"]),
-    },
-];
 pub const NYM_VPN_API: &str = "https://nymvpn.com/api/";
-#[cfg(feature = "network")]
-pub const NYM_VPN_APIS: &[ApiUrlConst] = &[
-    ApiUrlConst {
-        url: NYM_VPN_API,
-        front_hosts: Some(&["vercel.app", "vercel.com"]),
-    },
-    ApiUrlConst {
-        url: "https://nymvpn-frontdoor.global.ssl.fastly.net/api/",
-        front_hosts: Some(&["yelp.global.ssl.fastly.net"]),
-    },
-];
 
 // I'm making clippy mad on purpose, because that url HAS TO be updated and deployed before merging
 pub const EXIT_POLICY_URL: &str =

common/network-defaults/src/network.rs

@@ -37,37 +37,6 @@ pub struct NymNetworkDetails {
     pub contracts: NymContracts,
     pub explorer_api: Option<String>,
     pub nym_vpn_api_url: Option<String>,
-    pub nym_api_urls: Option<Vec<ApiUrl>>,
-    pub nym_vpn_api_urls: Option<Vec<ApiUrl>>,
-}
-
-#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize, JsonSchema)]
-#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
-pub struct ApiUrl {
-    /// Expects a string formatted Url
-    ///
-    /// see https://docs.rs/url/latest/url/struct.Url.html
-    pub url: String,
-    /// Optional alternative equivalent hostnames. Each entry must parse as valid Host
-    ///
-    /// see https://docs.rs/url/latest/url/enum.Host.html
-    pub front_hosts: Option<Vec<String>>,
-}
-
-pub struct ApiUrlConst<'a> {
-    pub url: &'a str,
-    pub front_hosts: Option<&'a [&'a str]>,
-}
-
-impl From<ApiUrlConst<'_>> for ApiUrl {
-    fn from(value: ApiUrlConst) -> Self {
-        ApiUrl {
-            url: value.url.to_string(),
-            front_hosts: value
-                .front_hosts
-                .map(|slice| slice.iter().map(|s| s.to_string()).collect()),
-        }
-    }
 }
 
 // by default we assume the same defaults as mainnet, i.e. same prefixes and denoms
@@ -98,8 +67,6 @@ impl NymNetworkDetails {
             contracts: Default::default(),
             explorer_api: Default::default(),
             nym_vpn_api_url: Default::default(),
-            nym_api_urls: Default::default(),
-            nym_vpn_api_urls: Default::default(),
         }
     }
 
@@ -187,8 +154,6 @@ impl NymNetworkDetails {
             },
             explorer_api: parse_optional_str(mainnet::EXPLORER_API),
             nym_vpn_api_url: parse_optional_str(mainnet::NYM_VPN_API),
-            nym_api_urls: None,
-            nym_vpn_api_urls: None,
         }
     }
 

common/nym-psq-kkt/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-name = "nym-psq-kkt"
-version = "0.1.0"
-authors = ["Georgio Nicolas <georgio@nymtech.net>"]
-edition = "2021"
-license.workspace = true
-
-[dependencies]
-arc-swap = { workspace = true }
-bytes = { workspace = true }
-futures = { workspace = true }
-tracing = { workspace = true }
-pin-project = { workspace = true }
-sha2 = { workspace = true }
-snow = { workspace = true }
-strum = { workspace = true, features = ["derive"] }
-thiserror = { workspace = true }
-tokio = { workspace = true, features = ["full"] }
-tokio-util = { workspace = true, features = ["codec"] }
-
-# internal
-nym-crypto = { path = "../crypto", features = ["asymmetric", "serde"]}
-
-libcrux-traits = { git = "https://github.com/cryspen/libcrux" }
-libcrux-kem = { git = "https://github.com/cryspen/libcrux" }
-libcrux-psq = { git = "https://github.com/cryspen/libcrux", features = ["test-utils"] }
-rand = "0.9.1"
-
-[dev-dependencies]
-criterion = {workspace = true}
-
-[[bench]]
-name = "benches"
-harness = false
-
-[lints]
-workspace = true

common/nym-psq-kkt/benches/benches.rs

@@ -1,135 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use criterion::{criterion_group, criterion_main, Criterion};
-use libcrux_psq::impls::MlKem768;
-use nym_crypto::asymmetric::ed25519;
-use nym_psq_kkt::kkt::{
-    KKTInitiator, KKTResponder, KKT_REQ_LEN, KKT_RES_LEN_MLKEM768, KKT_TAG_LEN,
-};
-use rand::prelude::*;
-
-pub fn gen_ed25519_keypair(c: &mut Criterion) {
-    c.bench_function("Generate Ed25519 Keypair", |b| {
-        b.iter(|| {
-            let mut s: [u8; 32] = [0u8; 32];
-            rand::rng().fill_bytes(&mut s);
-            ed25519::KeyPair::from_secret(s, 0)
-        });
-    });
-}
-
-pub fn gen_mlkem768_keypair(c: &mut Criterion) {
-    c.bench_function("Generate MlKem768 Keypair", |b| {
-        b.iter(|| {
-            libcrux_kem::key_gen(libcrux_kem::Algorithm::MlKem768, &mut rand::rng()).unwrap()
-        });
-    });
-}
-
-pub fn kkt_benchmark(c: &mut Criterion) {
-    // generate ed25519 keys
-    let mut secret_initiator: [u8; 32] = [0u8; 32];
-    rand::rng().fill_bytes(&mut secret_initiator);
-    let initiator_ed25519_keypair = ed25519::KeyPair::from_secret(secret_initiator, 0);
-
-    let mut secret_responder: [u8; 32] = [0u8; 32];
-    rand::rng().fill_bytes(&mut secret_responder);
-    let responder_ed25519_keypair = ed25519::KeyPair::from_secret(secret_responder, 1);
-
-    // generate kem keypair
-    let (_, responder_kem_public_key) =
-        libcrux_kem::key_gen(libcrux_kem::Algorithm::MlKem768, &mut rand::rng()).unwrap();
-
-    // initialize parties
-    let initiator: KKTInitiator<MlKem768> =
-        KKTInitiator::init(initiator_ed25519_keypair.private_key());
-
-    c.bench_function("Initialize Initiator", |b| {
-        b.iter(|| KKTInitiator::<MlKem768>::init(initiator_ed25519_keypair.private_key()));
-    });
-
-    let responder: KKTResponder<MlKem768> = KKTResponder::init(
-        responder_ed25519_keypair.private_key(),
-        &responder_kem_public_key,
-    );
-
-    c.bench_function("Initialize Responder", |b| {
-        b.iter(|| {
-            KKTResponder::init(
-                responder_ed25519_keypair.private_key(),
-                &responder_kem_public_key,
-            )
-        });
-    });
-
-    // create buffers
-    let mut request_buffer: [u8; KKT_REQ_LEN] = [0u8; KKT_REQ_LEN];
-    let mut response_buffer: [u8; KKT_RES_LEN_MLKEM768] = [0u8; KKT_RES_LEN_MLKEM768];
-    let mut tag_buffer: [u8; KKT_TAG_LEN] = [0u8; KKT_TAG_LEN];
-
-    c.bench_function("Initiator: Generate Request", |b| {
-        b.iter(|| {
-            initiator.request_kem_pk(&mut request_buffer, &mut tag_buffer);
-        });
-    });
-
-    // generate request
-    initiator.request_kem_pk(&mut request_buffer, &mut tag_buffer);
-
-    c.bench_function("Responder: Ingest Request and Generate Response", |b| {
-        b.iter(|| {
-            responder
-                .respond_kem_pk(
-                    &mut response_buffer,
-                    initiator_ed25519_keypair.public_key(),
-                    &request_buffer,
-                )
-                .unwrap();
-        });
-    });
-
-    // ingest request, generate response
-    responder
-        .respond_kem_pk(
-            &mut response_buffer,
-            initiator_ed25519_keypair.public_key(),
-            &request_buffer,
-        )
-        .unwrap();
-
-    c.bench_function("Initiator: Ingest Response and Store Key", |b| {
-        b.iter(|| {
-            let _ = initiator
-                .ingest_response_kem_pk::<MlKem768>(
-                    &response_buffer,
-                    &tag_buffer,
-                    responder_ed25519_keypair.public_key(),
-                )
-                .unwrap();
-        });
-    });
-
-    // ingest response
-    let received_responder_key = initiator
-        .ingest_response_kem_pk::<MlKem768>(
-            &response_buffer,
-            &tag_buffer,
-            responder_ed25519_keypair.public_key(),
-        )
-        .unwrap();
-
-    // check if the public key received is the same one that we generated at the start
-    assert_eq!(
-        responder_kem_public_key.encode(),
-        received_responder_key.encode()
-    );
-}
-
-criterion_group!(
-    benches,
-    gen_ed25519_keypair,
-    gen_mlkem768_keypair,
-    kkt_benchmark
-);
-criterion_main!(benches);

common/nym-psq-kkt/src/error.rs

@@ -1,66 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::io;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum PSQError {
-    #[error("encountered a decryption error")]
-    DecryptionError,
-
-    #[error("encountered a KEM error")]
-    KEMError,
-
-    #[error("encountered a PSQ error")]
-    PSQError,
-
-    #[error("encountered an IO error: {0}")]
-    IoError(#[from] io::Error),
-
-    #[error("Incorrect state")]
-    IncorrectStateError,
-
-    #[error("Handshake did not complete")]
-    HandshakeError,
-
-    #[error("Unknown noise version")]
-    UnknownVersion,
-
-    #[error("Handshake timeout")]
-    HandshakeTimeout(#[from] tokio::time::error::Elapsed),
-}
-
-impl From<libcrux_kem::Error> for PSQError {
-    fn from(err: libcrux_kem::Error) -> Self {
-        match err {
-            // Error::Decrypt => PSQError::DecryptionError,
-            err => PSQError::KEMError,
-        }
-    }
-}
-impl From<libcrux_psq::Error> for PSQError {
-    fn from(err: libcrux_psq::Error) -> Self {
-        match err {
-            // Error::Decrypt => PSQError::DecryptionError,
-            err => PSQError::PSQError,
-        }
-    }
-}
-
-#[derive(Error, Debug)]
-pub enum KKTError {
-    #[error("Signature constructor error")]
-    SigConstructorError,
-
-    #[error("Signature verification error")]
-    SigVerifError,
-    // #[error("Protocol did not complete")]
-    // ProtocolError,
-
-    // #[error("encountered an IO error: {0}")]
-    // IoError(#[from] io::Error),
-
-    // #[error("Handshake timeout")]
-    // HandshakeTimeout(#[from] tokio::time::error::Elapsed),
-}