place-holder attempting compatibility

keep details provided by topology instead of just a url
2025-12-05 17:09:43 -07:00 · 2025-12-05 13:39:34 -07:00
153 changed files with 2851 additions and 2540 deletions
@@ -27,10 +27,10 @@ jobs:
      - uses: actions/setup-node@v4
        with:
          node-version: 20
-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
@@ -43,10 +43,10 @@ jobs:
        run: sudo apt-get update && sudo apt-get -y install jq vim libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
        continue-on-error: true

-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable

      - name: Branch name
        run: echo running on branch ${GITHUB_REF##*/}
@@ -46,10 +46,10 @@ jobs:
        run: |
          echo "RUSTFLAGS=--cfg tokio_unstable" >> $GITHUB_ENV
          echo "CARGO_FEATURES=--features tokio-console" >> $GITHUB_ENV
-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable

      - name: Build all binaries
        uses: actions-rs/cargo@v1
@@ -21,7 +21,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          target: wasm32-unknown-unknown
          override: true
          components: rustfmt, clippy
@@ -60,7 +60,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          override: true
          components: rustfmt, clippy

@@ -10,7 +10,7 @@ env:

 jobs:
  check-if-tag-exists:
-    runs-on: arc-linux-latest-dind
+    runs-on: arc-ubuntu-22.04-dind
    steps:
      - name: Checkout repo
        uses: actions/checkout@v4
@@ -21,7 +21,7 @@ jobs:
      - name: Install Rust toolchain
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable

      - name: Generate the schema
        run: make contract-schema
@@ -34,10 +34,10 @@ jobs:
      - uses: actions/setup-node@v4
        with:
          node-version: 20
-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
      - name: Build all binaries
        uses: actions-rs/cargo@v1
        with:
@@ -27,10 +27,10 @@ jobs:
      - name: Setup yarn
        run: npm install -g yarn

-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable

      - name: Install wasm-pack
        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
@@ -31,7 +31,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          override: true
          components: rustfmt, clippy

@@ -8,7 +8,7 @@ on:

 jobs:
  build:
-    runs-on: arc-linux-latest-dind
+    runs-on: arc-linux-latest
    steps:
      - uses: actions/checkout@v4

@@ -25,10 +25,10 @@ jobs:
      - name: Setup yarn
        run: npm install -g yarn

-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable

      - name: Install wasm-pack
        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
@@ -25,7 +25,7 @@ jobs:
      - uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          target: wasm32-unknown-unknown
          override: true
          components: rustfmt, clippy
@@ -8,6 +8,6 @@ jobs:
    steps:
    - uses: actions/first-interaction@v3
      with:
-        repo_token: ${{ secrets.GITHUB_TOKEN }}
-        issue_message: 'Thank you for raising this issue'
-        pr_message: 'Thank you for making this first PR'
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        issue-message: 'Thank you for raising this issue'
+        pr-message: 'Thank you for making this first PR'
@@ -28,7 +28,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          override: true
          components: rustfmt, clippy

@@ -12,7 +12,7 @@ jobs:
      - name: Install rust toolchain
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
      - name: Install cargo deny
        run: cargo install --locked cargo-deny
      - name: Run cargo deny
@@ -20,7 +20,7 @@ jobs:
      - name: Install Rust
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          override: true

      - name: Install dependencies
@@ -53,10 +53,10 @@ jobs:
          echo 'RUSTFLAGS="--cfg tokio_unstable"' >> $GITHUB_ENV
        if: github.event_name == 'workflow_dispatch' && inputs.add_tokio_unstable == true

-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: 1.88.0
          override: true

      - name: Build all binaries
@@ -11,10 +11,9 @@ jobs:
    steps:
      - uses: actions/checkout@v4

-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
          target: wasm32-unknown-unknown
          override: true

@@ -28,10 +28,10 @@ jobs:
        with:
          node-version: 21
          
-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          
      - name: Add Rust target for x86_64-apple-darwin
        run: rustup target add x86_64-apple-darwin
@@ -33,10 +33,10 @@ jobs:
          node-version: 21
          cache: 'yarn'
      
-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
      
      - name: Install project dependencies
        shell: bash
@@ -29,10 +29,10 @@ jobs:
    steps:
      - uses: actions/checkout@v4

-      - name: Install Rust toolchain
+      - name: Install Rust stable
        uses: dtolnay/rust-toolchain@stable
        with:
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable

      - name: Setup MSBuild.exe
        uses: microsoft/setup-msbuild@v2
@@ -21,7 +21,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: ${{ vars.REQUIRED_RUSTC_VERSION }}
+          toolchain: stable
          override: true
          components: rustfmt, clippy

@@ -5251,10 +5251,12 @@ version = "0.1.0"
 dependencies = [
 "anyhow",
 "async-trait",
+ "cosmrs",
 "nym-crypto",
- "nym-gateway-client",
 "nym-gateway-requests",
+ "nym-topology",
 "serde",
+ "serde_json",
 "sqlx",
 "thiserror 2.0.12",
 "time",
@@ -5866,12 +5868,12 @@ dependencies = [
 "nym-credentials-interface",
 "nym-crypto",
 "nym-gateway-requests",
- "nym-http-api-client",
 "nym-network-defaults",
 "nym-pemstore",
 "nym-sphinx",
 "nym-statistics-common",
 "nym-task",
+ "nym-topology",
 "nym-validator-client",
 "rand 0.8.5",
 "serde",
@@ -7200,7 +7202,7 @@ dependencies = [

 [[package]]
 name = "nym-statistics-api"
-version = "0.3.1"
+version = "0.2.1"
 dependencies = [
 "anyhow",
 "axum",
@@ -7214,6 +7216,7 @@ dependencies = [
 "nym-statistics-common",
 "nym-task",
 "nym-validator-client",
+ "serde",
 "serde_json",
 "sqlx",
 "time",
@@ -7400,7 +7403,6 @@ dependencies = [
 name = "nym-validator-client"
 version = "0.1.0"
 dependencies = [
- "anyhow",
 "async-trait",
 "base64 0.22.1",
 "bip32",
@@ -6,14 +6,14 @@
      {
        "name": "exists",
        "ordinal": 0,
-        "type_info": "Integer"
+        "type_info": "Int"
      }
    ],
    "parameters": {
      "Right": 1
    },
    "nullable": [
-      false
+      null
    ]
  },
  "hash": "06e743d143fcc4be20ca2af5e99b19f15d22fff72490473587a14cdc046fda32"
@@ -0,0 +1,44 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT * FROM remote_gateway_details WHERE gateway_id_bs58 = ?",
+  "describe": {
+    "columns": [
+      {
+        "name": "gateway_id_bs58",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "gateway_owner_address",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "gateway_listener",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "derived_aes128_ctr_blake3_hmac_keys_bs58",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "derived_aes256_gcm_siv_key",
+        "ordinal": 4,
+        "type_info": "Blob"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      true,
+      false,
+      true,
+      true
+    ]
+  },
+  "hash": "0e85ec18da67cf4e3df04ad80136571f6e920eb2290f20b1b8c5b0ab4b489985"
+}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                UPDATE remote_gateway_details\n                SET\n                    derived_aes128_ctr_blake3_hmac_keys_bs58 = ?,\n                    derived_aes256_gcm_siv_key = ?\n                WHERE gateway_id_bs58 = ?\n            ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "0f1dfb89f1eb39f4a58787af0f53a7a93afb7e4d2e54e2d38fd79d31c8575a54"
+}
@@ -1,38 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "SELECT\n                rgd.gateway_id_bs58,\n                derived_aes256_gcm_siv_key,\n                gateway_listener,\n                fallback_listener\n            FROM\n                remote_gateway_details AS rgd\n            INNER JOIN\n                remote_gateway_shared_keys AS rgsk\n            ON\n                rgd.gateway_id_bs58 = rgsk.gateway_id_bs58\n            WHERE\n                rgd.gateway_id_bs58 = ?",
-  "describe": {
-    "columns": [
-      {
-        "name": "gateway_id_bs58",
-        "ordinal": 0,
-        "type_info": "Text"
-      },
-      {
-        "name": "derived_aes256_gcm_siv_key",
-        "ordinal": 1,
-        "type_info": "Blob"
-      },
-      {
-        "name": "gateway_listener",
-        "ordinal": 2,
-        "type_info": "Text"
-      },
-      {
-        "name": "fallback_listener",
-        "ordinal": 3,
-        "type_info": "Text"
-      }
-    ],
-    "parameters": {
-      "Right": 1
-    },
-    "nullable": [
-      false,
-      false,
-      false,
-      true
-    ]
-  },
-  "hash": "4b739e12ea8d917cb17580337caeabb05f0e3ddbec04fdfa111d0fc86ba75505"
-}
@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n                INSERT INTO remote_gateway_shared_keys(gateway_id_bs58, derived_aes256_gcm_siv_key)\n                VALUES (?, ?)\n            ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 2
-    },
-    "nullable": []
-  },
-  "hash": "700a75acbcd90c74baa7823c40739a8ff8a26400c1d2bd45a689970bf1ba0e66"
-}
@@ -1,6 +1,6 @@
 {
  "db_name": "SQLite",
-  "query": "\n                INSERT INTO registered_gateway(gateway_id_bs58, registration_timestamp, gateway_type)\n                VALUES (?, ?, ?)\n            ",
+  "query": "\n                INSERT INTO registered_gateway(gateway_id_bs58, registration_timestamp, gateway_type) \n                VALUES (?, ?, ?)\n            ",
  "describe": {
    "columns": [],
    "parameters": {
@@ -8,5 +8,5 @@
    },
    "nullable": []
  },
-  "hash": "727598e516090da6d26e36d09062b60ccb76d6468f359891428c0bfb96ddd7ef"
+  "hash": "8909fd329e7e5fb16c4989b15b3d3a12bba1569520e01f6f074178e23d6ee89e"
 }
@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n                INSERT INTO remote_gateway_details(gateway_id_bs58, gateway_listener, fallback_listener)\n                VALUES (?, ?, ?)\n            ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 3
-    },
-    "nullable": []
-  },
-  "hash": "a64a557ba87d4b2c7457857afa7ebc7d4f895fc4991da18ec02c9e250bea0fe0"
-}
@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                INSERT INTO remote_gateway_details(gateway_id_bs58, derived_aes128_ctr_blake3_hmac_keys_bs58, derived_aes256_gcm_siv_key, gateway_owner_address, gateway_listener)\n                VALUES (?, ?, ?, ?, ?)\n            ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 5
+    },
+    "nullable": []
+  },
+  "hash": "a6939bea03b10cde810a9a099bd597b4f51092e30a41c4085a8f8668f039f7c0"
+}
@@ -1,6 +1,6 @@
 {
  "db_name": "SQLite",
-  "query": "\n                INSERT INTO custom_gateway_details(gateway_id_bs58, data)\n                VALUES (?, ?)\n            ",
+  "query": "\n                INSERT INTO custom_gateway_details(gateway_id_bs58, data) \n                VALUES (?, ?)\n            ",
  "describe": {
    "columns": [],
    "parameters": {
@@ -8,5 +8,5 @@
    },
    "nullable": []
  },
-  "hash": "2c113b37864f9fec7e64c0f8fdd38edcdf149acfd38c56a4db3bbf97bdb13210"
+  "hash": "b059bc3688b6b7f83f47048db9897720fd4e6f3211bf74030a9638f7bf6738e4"
 }
@@ -9,7 +9,9 @@ rust-version.workspace = true

 [dependencies]
 async-trait.workspace = true
+cosmrs.workspace = true
 serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
 thiserror.workspace = true
 time.workspace = true
 tokio = { workspace = true, features = ["sync"] }
@@ -19,7 +21,7 @@ zeroize = { workspace = true, features = ["zeroize_derive"] }

 nym-crypto = { path = "../../crypto", features = ["asymmetric"] }
 nym-gateway-requests = { path = "../../gateway-requests" }
-nym-gateway-client = { path = "../../client-libs/gateway-client" }
+nym-topology = { path = "../../topology", features = ["persistence"] }

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 workspace = true
@@ -1,22 +0,0 @@
-/*
- * Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-CREATE TABLE remote_gateway_details_temp
-(
-    gateway_id_bs58                          TEXT NOT NULL UNIQUE PRIMARY KEY REFERENCES registered_gateway (gateway_id_bs58),
-    derived_aes256_gcm_siv_key               BLOB NOT NULL,
-    gateway_listener                         TEXT NOT NULL,
-    fallback_listener                        TEXT,
-    expiration_timestamp                     DATETIME NOT NULL
-);
-
-- keep only registrations with a non null aes256 key
-INSERT INTO remote_gateway_details_temp SELECT gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_listener, NULL, datetime(0, 'unixepoch') FROM remote_gateway_details WHERE derived_aes256_gcm_siv_key IS NOT NULL;
-
-DROP TABLE remote_gateway_details;
-ALTER TABLE remote_gateway_details_temp RENAME TO remote_gateway_details;
-
-- delete registrations with no key
-DELETE FROM registered_gateway WHERE gateway_id_bs58 NOT IN ( SELECT gateway_id_bs58 FROM remote_gateway_details);
@@ -6,7 +6,6 @@ use crate::{
    types::{
        RawActiveGateway, RawCustomGatewayDetails, RawRegisteredGateway, RawRemoteGatewayDetails,
    },
-    RawGatewayPublishedData,
 };
 use sqlx::{
    sqlite::{SqliteAutoVacuum, SqliteSynchronous},
@@ -145,11 +144,13 @@ impl StorageManager {
        &self,
        gateway_id: &str,
    ) -> Result<RawRemoteGatewayDetails, sqlx::Error> {
-        // query_as! macro doesn't use fromRow
-        sqlx::query_as("SELECT * FROM remote_gateway_details WHERE gateway_id_bs58 = ?")
-            .bind(gateway_id)
-            .fetch_one(&self.connection_pool)
-            .await
+        sqlx::query_as!(
+            RawRemoteGatewayDetails,
+            "SELECT * FROM remote_gateway_details WHERE gateway_id_bs58 = ?",
+            gateway_id
+        )
+        .fetch_one(&self.connection_pool)
+        .await
    }

    pub(crate) async fn set_remote_gateway_details(
@@ -158,36 +159,41 @@ impl StorageManager {
    ) -> Result<(), sqlx::Error> {
        sqlx::query!(
            r#"
-                INSERT INTO remote_gateway_details(gateway_id_bs58, derived_aes256_gcm_siv_key, gateway_listener, fallback_listener, expiration_timestamp)
+                INSERT INTO remote_gateway_details(gateway_id_bs58, derived_aes128_ctr_blake3_hmac_keys_bs58, derived_aes256_gcm_siv_key, gateway_owner_address, gateway_listener)
                VALUES (?, ?, ?, ?, ?)
            "#,
            remote.gateway_id_bs58,
+            remote.derived_aes128_ctr_blake3_hmac_keys_bs58,
            remote.derived_aes256_gcm_siv_key,
-            remote.published_data.gateway_listener,
-            remote.published_data.fallback_listener,
-            remote.published_data.expiration_timestamp
+            remote.gateway_owner_address,
+            remote.gateway_listener,
        )
            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }

-    pub(crate) async fn update_remote_gateway_published_data(
+    pub(crate) async fn update_remote_gateway_key(
        &self,
        gateway_id_bs58: &str,
-        published_data: &RawGatewayPublishedData,
+        derived_aes128_ctr_blake3_hmac_keys_bs58: Option<&str>,
+        derived_aes256_gcm_siv_key: Option<&[u8]>,
    ) -> Result<(), sqlx::Error> {
        sqlx::query!(
            r#"
-                UPDATE remote_gateway_details SET gateway_listener = ?, fallback_listener = ?, expiration_timestamp = ? WHERE gateway_id_bs58 = ?
+                UPDATE remote_gateway_details
+                SET
+                    derived_aes128_ctr_blake3_hmac_keys_bs58 = ?,
+                    derived_aes256_gcm_siv_key = ?
+                WHERE gateway_id_bs58 = ?
            "#,
-            published_data.gateway_listener,
-            published_data.fallback_listener,
-            published_data.expiration_timestamp,
+            derived_aes128_ctr_blake3_hmac_keys_bs58,
+            derived_aes256_gcm_siv_key,
            gateway_id_bs58
        )
-            .execute(&self.connection_pool)
-            .await?;
+        .execute(&self.connection_pool)
+        .await?;
+
        Ok(())
    }

@@ -2,16 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::{
-    ActiveGateway, BadGateway, GatewayDetails, GatewayPublishedData, GatewayRegistration,
-    GatewayType, GatewaysDetailsStore, StorageError,
+    ActiveGateway, BadGateway, GatewayDetails, GatewayRegistration, GatewayType,
+    GatewaysDetailsStore, StorageError,
 };
 use async_trait::async_trait;
 use manager::StorageManager;
 use nym_crypto::asymmetric::ed25519;
+use nym_gateway_requests::SharedSymmetricKey;
 use std::path::Path;

 pub mod error;
 mod manager;
+mod models;

 #[derive(Clone)]
 pub struct OnDiskGatewaysDetails {
@@ -132,15 +134,16 @@ impl GatewaysDetailsStore for OnDiskGatewaysDetails {
        Ok(())
    }

-    async fn update_gateway_published_data(
+    async fn upgrade_stored_remote_gateway_key(
        &self,
-        gateway_id: &ed25519::PublicKey,
-        published_data: &GatewayPublishedData,
+        gateway_id: ed25519::PublicKey,
+        updated_key: &SharedSymmetricKey,
    ) -> Result<(), Self::StorageError> {
        self.manager
-            .update_remote_gateway_published_data(
+            .update_remote_gateway_key(
                &gateway_id.to_base58_string(),
-                &published_data.into(),
+                None,
+                Some(updated_key.as_bytes()),
            )
            .await?;
        Ok(())
@@ -0,0 +1,2 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::types::{ActiveGateway, GatewayRegistration};
-use crate::{BadGateway, GatewayDetails, GatewayPublishedData, GatewaysDetailsStore};
+use crate::{BadGateway, GatewayDetails, GatewaysDetailsStore};
 use async_trait::async_trait;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::ed25519::PublicKey;
+use nym_gateway_requests::{SharedGatewayKey, SharedSymmetricKey};
 use std::collections::HashMap;
 use std::sync::Arc;
 use thiserror::Error;
@@ -95,17 +96,26 @@ impl GatewaysDetailsStore for InMemGatewaysDetails {
        Ok(())
    }

-    async fn update_gateway_published_data(
+    async fn upgrade_stored_remote_gateway_key(
        &self,
-        gateway_id: &ed25519::PublicKey,
-        published_data: &GatewayPublishedData,
+        gateway_id: PublicKey,
+        updated_key: &SharedSymmetricKey,
    ) -> Result<(), Self::StorageError> {
        let mut guard = self.inner.write().await;
-        if let Some(gateway) = guard.gateways.get_mut(&gateway_id.to_base58_string()) {
-            if let GatewayDetails::Remote(ref mut remote_details) = gateway.details {
-                remote_details.published_data = published_data.clone();
-            }
+
+        #[allow(clippy::unwrap_used)]
+        if let Some(target) = guard.gateways.get_mut(&gateway_id.to_string()) {
+            let GatewayDetails::Remote(details) = &mut target.details else {
+                return Ok(());
+            };
+            assert_eq!(Arc::strong_count(&details.shared_key), 1);
+
+            // eh. that's nasty, but it's only ever used for ephemeral clients so should be fine for now...
+            details.shared_key = Arc::new(SharedGatewayKey::Current(
+                SharedSymmetricKey::try_from_bytes(updated_key.as_bytes()).unwrap(),
+            ))
        }
+
        Ok(())
    }

@@ -18,6 +18,16 @@ pub enum BadGateway {
        source: Ed25519RecoveryError,
    },

+    #[error("the account owner of gateway {gateway_id} ({raw_owner}) is malformed: {source}")]
+    MalformedGatewayOwnerAccountAddress {
+        gateway_id: String,
+
+        raw_owner: String,
+
+        #[source]
+        source: cosmrs::ErrorReport,
+    },
+
    #[error("the shared keys provided for gateway {gateway_id} are malformed: {source}")]
    MalformedSharedKeys {
        gateway_id: String,
@@ -38,14 +48,6 @@ pub enum BadGateway {
        raw_listener: String,

        #[source]
-        source: url::ParseError,
-    },
-
-    #[error("the listening address ({raw_listener}) is malformed: {source}")]
-    MalformedListenerNoId {
-        raw_listener: String,
-
-        #[source]
-        source: url::ParseError,
+        source: serde_json::Error,
    },
 }
@@ -6,6 +6,7 @@

 use async_trait::async_trait;
 use nym_crypto::asymmetric::ed25519;
+use nym_gateway_requests::SharedSymmetricKey;
 use std::error::Error;

 pub mod backend;
@@ -59,11 +60,10 @@ pub trait GatewaysDetailsStore {
        details: &GatewayRegistration,
    ) -> Result<(), Self::StorageError>;

-    /// Update the gateway details
-    async fn update_gateway_published_data(
+    async fn upgrade_stored_remote_gateway_key(
        &self,
-        gateway_id: &ed25519::PublicKey,
-        published_data: &GatewayPublishedData,
+        gateway_id: ed25519::PublicKey,
+        updated_key: &SharedSymmetricKey,
    ) -> Result<(), Self::StorageError>;

    /// Remove given gateway details from the underlying store.
@@ -2,21 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::BadGateway;
+use cosmrs::AccountId;
 use nym_crypto::asymmetric::ed25519;
-use nym_gateway_client::client::GatewayListeners;
-use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
+use nym_topology::EntryDetails;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
+use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::Arc;
-use time::Duration;
 use time::OffsetDateTime;
-use url::Url;
 use zeroize::{Zeroize, ZeroizeOnDrop};

 pub const REMOTE_GATEWAY_TYPE: &str = "remote";
 pub const CUSTOM_GATEWAY_TYPE: &str = "custom";
-const GATEWAY_DETAILS_TTL: Duration = Duration::days(7);

 #[derive(Debug, Clone, Default)]
 pub struct ActiveGateway {
@@ -66,13 +65,15 @@ impl From<GatewayDetails> for GatewayRegistration {
 impl GatewayDetails {
    pub fn new_remote(
        gateway_id: ed25519::PublicKey,
-        shared_key: Arc<SharedSymmetricKey>,
-        published_data: GatewayPublishedData,
+        shared_key: Arc<SharedGatewayKey>,
+        gateway_owner_address: Option<AccountId>,
+        gateway_listener: EntryDetails,
    ) -> Self {
        GatewayDetails::Remote(RemoteGatewayDetails {
            gateway_id,
            shared_key,
-            published_data,
+            gateway_owner_address,
+            gateway_listener,
        })
    }

@@ -87,20 +88,13 @@ impl GatewayDetails {
        }
    }

-    pub fn shared_key(&self) -> Option<&SharedSymmetricKey> {
+    pub fn shared_key(&self) -> Option<&SharedGatewayKey> {
        match self {
            GatewayDetails::Remote(details) => Some(&details.shared_key),
            GatewayDetails::Custom(_) => None,
        }
    }

-    pub fn details_exipration(&self) -> Option<OffsetDateTime> {
-        match self {
-            GatewayDetails::Remote(details) => Some(details.published_data.expiration_timestamp),
-            GatewayDetails::Custom(_) => None,
-        }
-    }
-
    pub fn is_custom(&self) -> bool {
        matches!(self, GatewayDetails::Custom(..))
    }
@@ -170,80 +164,25 @@ pub struct RegisteredGateway {
    pub gateway_type: GatewayType,
 }

-#[derive(Debug, Clone)]
-pub struct GatewayPublishedData {
-    pub listeners: GatewayListeners,
-    pub expiration_timestamp: OffsetDateTime,
-}
-
-impl GatewayPublishedData {
-    pub fn new(listeners: GatewayListeners) -> GatewayPublishedData {
-        GatewayPublishedData {
-            listeners,
-            expiration_timestamp: OffsetDateTime::now_utc() + GATEWAY_DETAILS_TTL,
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
-pub struct RawGatewayPublishedData {
-    pub gateway_listener: String,
-    pub fallback_listener: Option<String>,
-    pub expiration_timestamp: OffsetDateTime,
-}
-
-impl<'a> From<&'a GatewayPublishedData> for RawGatewayPublishedData {
-    fn from(value: &'a GatewayPublishedData) -> Self {
-        Self {
-            gateway_listener: value.listeners.primary.to_string(),
-            fallback_listener: value.listeners.fallback.as_ref().map(|uri| uri.to_string()),
-            expiration_timestamp: value.expiration_timestamp,
-        }
-    }
-}
-
-impl TryFrom<RawGatewayPublishedData> for GatewayPublishedData {
-    type Error = BadGateway;
-
-    fn try_from(value: RawGatewayPublishedData) -> Result<Self, Self::Error> {
-        let gateway_listener: Url = Url::parse(&value.gateway_listener).map_err(|source| {
-            BadGateway::MalformedListenerNoId {
-                raw_listener: value.gateway_listener.clone(),
-                source,
-            }
-        })?;
-        let fallback_listener = value
-            .fallback_listener
-            .as_ref()
-            .map(|uri| {
-                Url::parse(uri).map_err(|source| BadGateway::MalformedListenerNoId {
-                    raw_listener: uri.to_owned(),
-                    source,
-                })
-            })
-            .transpose()?;
-
-        Ok(GatewayPublishedData {
-            listeners: GatewayListeners {
-                primary: gateway_listener,
-                fallback: fallback_listener,
-            },
-            expiration_timestamp: value.expiration_timestamp,
-        })
-    }
-}
-
-#[derive(Debug, Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
-#[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct RawRemoteGatewayDetails {
    pub gateway_id_bs58: String,
-    pub derived_aes256_gcm_siv_key: Vec<u8>,
-    #[zeroize(skip)]
-    #[cfg_attr(feature = "sqlx", sqlx(flatten))]
-    pub published_data: RawGatewayPublishedData,
+    pub derived_aes128_ctr_blake3_hmac_keys_bs58: Option<String>,
+    pub derived_aes256_gcm_siv_key: Option<Vec<u8>>,
+    pub gateway_owner_address: Option<String>,
+    pub gateway_listener: String,
 }

+impl Zeroize for RawRemoteGatewayDetails {
+    fn zeroize(&mut self) {
+        self.gateway_id_bs58.zeroize();
+        self.derived_aes128_ctr_blake3_hmac_keys_bs58.zeroize();
+        self.derived_aes256_gcm_siv_key.zeroize();
+        self.gateway_owner_address.zeroize();
+    }
+}
+impl ZeroizeOnDrop for RawRemoteGatewayDetails {}
+
 impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {
    type Error = BadGateway;

@@ -256,26 +195,85 @@ impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {
                }
            })?;

-        let shared_key = SharedSymmetricKey::try_from_bytes(&value.derived_aes256_gcm_siv_key)
-            .map_err(|source| BadGateway::MalformedSharedKeys {
+        let shared_key =
+            match (
+                &value.derived_aes256_gcm_siv_key,
+                &value.derived_aes128_ctr_blake3_hmac_keys_bs58,
+            ) {
+                (None, None) => {
+                    return Err(BadGateway::MissingSharedKey {
+                        gateway_id: value.gateway_id_bs58.clone(),
+                    })
+                }
+                (Some(aes256gcm_siv), _) => {
+                    let current_key =
+                        SharedSymmetricKey::try_from_bytes(aes256gcm_siv).map_err(|source| {
+                            BadGateway::MalformedSharedKeys {
+                                gateway_id: value.gateway_id_bs58.clone(),
+                                source,
+                            }
+                        })?;
+                    SharedGatewayKey::Current(current_key)
+                }
+                (None, Some(aes128ctr_hmac)) => {
+                    let legacy_key = LegacySharedKeys::try_from_base58_string(aes128ctr_hmac)
+                        .map_err(|source| BadGateway::MalformedSharedKeys {
+                            gateway_id: value.gateway_id_bs58.clone(),
+                            source,
+                        })?;
+                    SharedGatewayKey::Legacy(legacy_key)
+                }
+            };
+
+        let gateway_owner_address = value
+            .gateway_owner_address
+            .as_ref()
+            .map(|raw_owner| {
+                AccountId::from_str(raw_owner).map_err(|source| {
+                    BadGateway::MalformedGatewayOwnerAccountAddress {
+                        gateway_id: value.gateway_id_bs58.clone(),
+                        raw_owner: raw_owner.clone(),
+                        source,
+                    }
+                })
+            })
+            .transpose()?;
+
+        let gateway_listener = serde_json::from_str(&value.gateway_listener).map_err(|source| {
+            BadGateway::MalformedListener {
                gateway_id: value.gateway_id_bs58.clone(),
+                raw_listener: value.gateway_listener.clone(),
                source,
-            })?;
+            }
+        })?;

        Ok(RemoteGatewayDetails {
            gateway_id,
            shared_key: Arc::new(shared_key),
-            published_data: value.published_data.clone().try_into()?,
+            gateway_owner_address,
+            gateway_listener,
        })
    }
 }

 impl<'a> From<&'a RemoteGatewayDetails> for RawRemoteGatewayDetails {
    fn from(value: &'a RemoteGatewayDetails) -> Self {
+        let (derived_aes128_ctr_blake3_hmac_keys_bs58, derived_aes256_gcm_siv_key) =
+            match value.shared_key.deref() {
+                SharedGatewayKey::Current(key) => (None, Some(key.to_bytes())),
+                SharedGatewayKey::Legacy(key) => (Some(key.to_base58_string()), None),
+            };
+
+        #[allow(clippy::expect_used)]
+        let gateway_listener = serde_json::to_string(&value.gateway_listener)
+            .expect("serialize for gateway details should never fail");
+
        RawRemoteGatewayDetails {
            gateway_id_bs58: value.gateway_id.to_base58_string(),
-            derived_aes256_gcm_siv_key: value.shared_key.to_bytes(),
-            published_data: (&value.published_data).into(),
+            derived_aes128_ctr_blake3_hmac_keys_bs58,
+            derived_aes256_gcm_siv_key,
+            gateway_owner_address: value.gateway_owner_address.as_ref().map(|o| o.to_string()),
+            gateway_listener,
        }
    }
 }
@@ -284,9 +282,11 @@ impl<'a> From<&'a RemoteGatewayDetails> for RawRemoteGatewayDetails {
 pub struct RemoteGatewayDetails {
    pub gateway_id: ed25519::PublicKey,

-    pub shared_key: Arc<SharedSymmetricKey>,
+    pub shared_key: Arc<SharedGatewayKey>,

-    pub published_data: GatewayPublishedData,
+    pub gateway_owner_address: Option<AccountId>,
+
+    pub gateway_listener: EntryDetails,
 }

 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -87,7 +87,6 @@ where
        user_chosen_gateway_id.map(|id| id.to_base58_string()),
        Some(common_args.latency_based_selection),
        common_args.force_tls_gateway,
-        false,
    );
    tracing::debug!("Gateway selection specification: {selection_spec:?}");

@@ -168,7 +167,6 @@ where
        identity: gateway_details.gateway_id,
        active: common_args.set_active,
        typ: gateway_registration.details.typ().to_string(),
-        endpoint: Some(gateway_details.published_data.listeners.primary.clone()),
-        fallback_endpoint: gateway_details.published_data.listeners.fallback.clone(),
+        endpoint: Some(gateway_details.gateway_listener.clone()),
    })
 }
@@ -136,7 +136,6 @@ where
        user_chosen_gateway_id.map(|id| id.to_base58_string()),
        Some(common_args.latency_based_selection),
        common_args.force_tls_gateway,
-        false,
    );
    tracing::debug!("Gateway selection specification: {selection_spec:?}");

@@ -56,8 +56,7 @@ where
                identity: remote_details.gateway_id,
                active: active_gateway == Some(remote_details.gateway_id),
                typ: GatewayType::Remote.to_string(),
-                endpoint: Some(remote_details.published_data.listeners.primary.clone()),
-                fallback_endpoint: remote_details.published_data.listeners.fallback.clone(),
+                endpoint: Some(remote_details.gateway_listener),
            }),
            GatewayDetails::Custom(_) => info.push(GatewayInfo {
                registration: gateway.registration_timestamp,
@@ -65,7 +64,6 @@ where
                active: active_gateway == Some(gateway.details.gateway_id()),
                typ: gateway.details.typ().to_string(),
                endpoint: None,
-                fallback_endpoint: None,
            }),
        };
    }
@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 use nym_crypto::asymmetric::ed25519;
+use nym_topology::EntryDetails;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 use time::OffsetDateTime;
-use url::Url;

 #[derive(Serialize, Deserialize)]
 pub struct GatewayInfo {
@@ -14,8 +14,7 @@ pub struct GatewayInfo {
    pub active: bool,

    pub typ: String,
-    pub endpoint: Option<Url>,
-    pub fallback_endpoint: Option<Url>,
+    pub endpoint: Option<EntryDetails>,
 }

 impl Display for GatewayInfo {
@@ -31,9 +30,6 @@ impl Display for GatewayInfo {
        if let Some(endpoint) = &self.endpoint {
            write!(f, " endpoint: {endpoint}")?;
        }
-        if let Some(fallback_endpoint) = &self.fallback_endpoint {
-            write!(f, " fallback: {fallback_endpoint}")?;
-        }
        Ok(())
    }
 }
@@ -529,6 +529,7 @@ where
        config: &Config,
        initialisation_result: InitialisationResult,
        bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
+        details_store: &S::GatewaysDetailsStore,
        packet_router: PacketRouter,
        stats_reporter: ClientStatsSender,
        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
@@ -554,7 +555,14 @@ where
                    shutdown_tracker.clone_shutdown_token(),
                )
            } else {
-                let cfg = GatewayConfig::new(details.gateway_id, details.published_data.listeners);
+                let cfg = GatewayConfig::new(
+                    details.gateway_id,
+                    details
+                        .gateway_owner_address
+                        .as_ref()
+                        .map(|o| o.to_string()),
+                    details.gateway_listener,
+                );
                GatewayClient::new(
                    GatewayClientConfig::new_default()
                        .with_disabled_credentials_mode(config.client.disabled_credentials_mode)
@@ -584,13 +592,32 @@ where
        // the gateway client startup procedure is slightly more complicated now
        // we need to:
        // - perform handshake (reg or auth)
+        // - check for key upgrade
+        // - maybe perform another upgrade handshake
        // - check for bandwidth
        // - start background tasks
-        let _ = gateway_client
+        let auth_res = gateway_client
            .perform_initial_authentication()
            .await
            .map_err(gateway_failure)?;

+        if auth_res.requires_key_upgrade {
+            // drop the shared_key arc because we don't need it and we can't hold it for the purposes of upgrade
+            drop(auth_res);
+
+            let updated_key = gateway_client
+                .upgrade_key_authenticated()
+                .await
+                .map_err(gateway_failure)?;
+
+            details_store
+                .upgrade_stored_remote_gateway_key(gateway_client.gateway_identity(), &updated_key)
+                .await.map_err(|err| {
+                tracing::error!("failed to store upgraded gateway key! this connection might be forever broken now: {err}");
+                ClientCoreError::GatewaysDetailsStoreError { source: Box::new(err) }
+            })?
+        }
+
        gateway_client
            .claim_initial_bandwidth()
            .await
@@ -609,6 +636,7 @@ where
        config: &Config,
        initialisation_result: InitialisationResult,
        bandwidth_controller: Option<BandwidthController<C, S::CredentialStore>>,
+        details_store: &S::GatewaysDetailsStore,
        packet_router: PacketRouter,
        stats_reporter: ClientStatsSender,
        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
@@ -639,6 +667,7 @@ where
            config,
            initialisation_result,
            bandwidth_controller,
+            details_store,
            packet_router,
            stats_reporter,
            #[cfg(unix)]
@@ -946,7 +975,8 @@ where
        )
        .await?;

-        let (reply_storage_backend, credential_store, _) = self.client_store.into_runtime_stores();
+        let (reply_storage_backend, credential_store, details_store) =
+            self.client_store.into_runtime_stores();

        // channels for inter-component communication
        // TODO: make the channels be internally created by the relevant components
@@ -1039,6 +1069,7 @@ where
            &self.config,
            init_res,
            bandwidth_controller,
+            &details_store,
            gateway_packet_router,
            stats_reporter.clone(),
            #[cfg(unix)]
@@ -4,9 +4,7 @@
 use crate::client::key_manager::persistence::KeyStore;
 use crate::client::key_manager::ClientKeys;
 use crate::error::ClientCoreError;
-use nym_client_core_gateways_storage::{
-    ActiveGateway, GatewayPublishedData, GatewayRegistration, GatewaysDetailsStore,
-};
+use nym_client_core_gateways_storage::{ActiveGateway, GatewayRegistration, GatewaysDetailsStore};
 use nym_crypto::asymmetric::ed25519;

 // helpers for error wrapping
@@ -87,23 +85,6 @@ where
        })
 }

-pub async fn update_stored_published_data_gateway<D>(
-    details_store: &D,
-    gateway_id: &ed25519::PublicKey,
-    published_data: &GatewayPublishedData,
-) -> Result<(), ClientCoreError>
-where
-    D: GatewaysDetailsStore,
-    D::StorageError: Send + Sync + 'static,
-{
-    details_store
-        .update_gateway_published_data(gateway_id, published_data)
-        .await
-        .map_err(|source| ClientCoreError::GatewaysDetailsStoreError {
-            source: Box::new(source),
-        })
-}
-
 pub async fn load_active_gateway_details<D>(
    details_store: &D,
 ) -> Result<ActiveGateway, ClientCoreError>
@@ -2,18 +2,210 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod v1_1_33 {
+    use crate::client::base_client::{
+        non_wasm_helpers::setup_fs_gateways_storage,
+        storage::helpers::{set_active_gateway, store_gateway_details},
+    };
    use crate::config::disk_persistence::old_v1_1_33::CommonClientPathsV1_1_33;
    use crate::config::disk_persistence::CommonClientPaths;
    use crate::config::old_config_v1_1_33::OldGatewayEndpointConfigV1_1_33;
    use crate::error::ClientCoreError;
+    use nym_client_core_gateways_storage::{
+        CustomGatewayDetails, GatewayDetails, GatewayRegistration, RemoteGatewayDetails,
+    };
+    use nym_gateway_requests::shared_key::LegacySharedKeys;
+    use serde::{Deserialize, Serialize};
+    use sha2::{digest::Digest, Sha256};
+    use std::ops::Deref;
+    use std::path::Path;
+    use std::sync::Arc;
+    use zeroize::Zeroizing;
+
+    mod base64 {
+        use base64::{engine::general_purpose::STANDARD, Engine as _};
+        use serde::{Deserialize, Deserializer, Serializer};
+
+        pub fn serialize<S: Serializer>(bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> {
+            serializer.serialize_str(&STANDARD.encode(bytes))
+        }
+
+        pub fn deserialize<'de, D: Deserializer<'de>>(
+            deserializer: D,
+        ) -> Result<Vec<u8>, D::Error> {
+            let s = <String>::deserialize(deserializer)?;
+            STANDARD.decode(s).map_err(serde::de::Error::custom)
+        }
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    #[serde(untagged)]
+    enum PersistedGatewayDetails {
+        /// Standard details of a remote gateway
+        Default(PersistedGatewayConfig),
+
+        /// Custom gateway setup, such as for a client embedded inside gateway itself
+        Custom(PersistedCustomGatewayDetails),
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+    struct PersistedGatewayConfig {
+        /// The hash of the shared keys to ensure the correct ones are used with those gateway details.
+        #[serde(with = "base64")]
+        key_hash: Vec<u8>,
+
+        /// Actual gateway details being persisted.
+        details: OldGatewayEndpointConfigV1_1_33,
+    }
+
+    impl PersistedGatewayConfig {
+        fn verify(&self, shared_key: &LegacySharedKeys) -> bool {
+            let key_bytes = Zeroizing::new(shared_key.to_bytes());
+
+            let mut key_hasher = Sha256::new();
+            key_hasher.update(&key_bytes);
+            let key_hash = key_hasher.finalize();
+
+            self.key_hash == key_hash.deref()
+        }
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    struct PersistedCustomGatewayDetails {
+        gateway_id: String,
+    }
+
+    fn load_shared_key<P: AsRef<Path>>(path: P) -> Result<LegacySharedKeys, ClientCoreError> {
+        // the shared key was a simple pem file
+        Ok(nym_pemstore::load_key(path)?)
+    }
+
+    fn gateway_details_from_raw(
+        gateway_id: String,
+        gateway_owner: String,
+        gateway_listener: String,
+        gateway_shared_key: LegacySharedKeys,
+    ) -> Result<GatewayDetails, ClientCoreError> {
+        Ok(GatewayDetails::Remote(RemoteGatewayDetails {
+            gateway_id: gateway_id
+                .parse()
+                .map_err(|err| ClientCoreError::UpgradeFailure {
+                    message: format!("the stored gateway id was malformed: {err}"),
+                })?,
+            shared_key: Arc::new(gateway_shared_key.into()),
+            gateway_owner_address: Some(gateway_owner.parse().map_err(|err| {
+                ClientCoreError::UpgradeFailure {
+                    message: format!("the stored gateway owner address was malformed: {err}"),
+                }
+            })?),
+            gateway_listener: gateway_listener.parse().map_err(|err| {
+                ClientCoreError::UpgradeFailure {
+                    message: format!("the stored gateway listener address was malformed: {err}"),
+                }
+            })?,
+        }))
+    }
+
+    // helper to extract shared key and gateway details into the new GatewayRegistration
+    fn extract_gateway_registration(
+        storage_paths: &CommonClientPathsV1_1_33,
+    ) -> Result<GatewayRegistration, ClientCoreError> {
+        let details_file = std::fs::File::open(&storage_paths.gateway_details).map_err(|err| {
+            ClientCoreError::UpgradeFailure {
+                message: format!(
+                    "failed to open gateway details file at {}: {err}",
+                    storage_paths.gateway_details.display()
+                ),
+            }
+        })?;
+
+        // in v1.1.33 of the clients, the gateway details struct was saved as json
+        let details: PersistedGatewayDetails =
+            serde_json::from_reader(details_file).map_err(|err| {
+                ClientCoreError::UpgradeFailure {
+                    message: format!(
+                        "failed to deserialize gateway details from {}: {err}",
+                        storage_paths.gateway_details.display()
+                    ),
+                }
+            })?;
+
+        let details = match details {
+            PersistedGatewayDetails::Default(config) => {
+                let gateway_shared_key =
+                    load_shared_key(&storage_paths.keys.gateway_shared_key_file)?;
+                if !config.verify(&gateway_shared_key) {
+                    return Err(ClientCoreError::UpgradeFailure {
+                        message: "failed to verify consistency of the existing gateway details"
+                            .to_string(),
+                    });
+                }
+                gateway_details_from_raw(
+                    config.details.gateway_id,
+                    config.details.gateway_owner,
+                    config.details.gateway_listener,
+                    gateway_shared_key,
+                )?
+            }
+            PersistedGatewayDetails::Custom(custom) => {
+                GatewayDetails::Custom(CustomGatewayDetails {
+                    gateway_id: custom.gateway_id.parse().map_err(|err| {
+                        ClientCoreError::UpgradeFailure {
+                            message: format!("the stored gateway id was malformed: {err}"),
+                        }
+                    })?,
+                    data: None,
+                })
+            }
+        };
+
+        Ok(details.into())
+    }
+
+    // it's responsibility of the caller to ensure this is called **after** new registration has already been saved
+    fn remove_old_gateway_details(storage_paths: &CommonClientPathsV1_1_33) -> std::io::Result<()> {
+        std::fs::remove_file(&storage_paths.gateway_details)?;
+
+        if storage_paths.keys.gateway_shared_key_file.exists() {
+            std::fs::remove_file(&storage_paths.keys.gateway_shared_key_file)?;
+        }
+        Ok(())
+    }

    pub async fn migrate_gateway_details(
-        _old_storage_paths: &CommonClientPathsV1_1_33,
-        _new_storage_paths: &CommonClientPaths,
-        _preloaded_config: Option<OldGatewayEndpointConfigV1_1_33>,
+        old_storage_paths: &CommonClientPathsV1_1_33,
+        new_storage_paths: &CommonClientPaths,
+        preloaded_config: Option<OldGatewayEndpointConfigV1_1_33>,
    ) -> Result<(), ClientCoreError> {
-        Err(ClientCoreError::UnsupportedMigration(
-            "migration of legacy keys has been removed and is no longer supported".into(),
-        ))
+        let gateway_registration = match preloaded_config {
+            Some(config) => {
+                let gateway_shared_key =
+                    load_shared_key(&old_storage_paths.keys.gateway_shared_key_file)?;
+                gateway_details_from_raw(
+                    config.gateway_id,
+                    config.gateway_owner,
+                    config.gateway_listener,
+                    gateway_shared_key,
+                )?
+                .into()
+            }
+            None => extract_gateway_registration(old_storage_paths)?,
+        };
+
+        // since we're migrating to a brand new store, the store should be empty
+        // and thus set the 'new' gateway as the active one
+        let details_store =
+            setup_fs_gateways_storage(&new_storage_paths.gateway_registrations).await?;
+        store_gateway_details(&details_store, &gateway_registration).await?;
+        set_active_gateway(
+            &details_store,
+            &gateway_registration.details.gateway_id().to_base58_string(),
+        )
+        .await?;
+
+        remove_old_gateway_details(old_storage_paths).map_err(|err| {
+            ClientCoreError::UpgradeFailure {
+                message: format!("failed to remove old data: {err}"),
+            }
+        })
    }
 }
@@ -32,12 +32,9 @@ where
    /// Key used to encrypt and decrypt content of an ACK packet.
    ack_key: Arc<AckKey>,

-    /// Average delay an acknowledgement packet is going to get delayed at a single mixnode.
+    /// Average delay an acknowledgement packet is going to get delay at a single mixnode.
    average_ack_delay: Duration,

-    /// Average delay a forward packet is going to get delayed at a single mixnode.
-    average_packet_delay: Duration,
-
    /// Defines configuration options related to cover traffic.
    cover_traffic: config::CoverTraffic,

@@ -125,7 +122,6 @@ impl LoopCoverTrafficStream<OsRng> {
        LoopCoverTrafficStream {
            ack_key,
            average_ack_delay,
-            average_packet_delay: traffic_config.average_packet_delay,
            cover_traffic: cover_config,
            next_delay,
            mix_tx,
@@ -191,7 +187,7 @@ impl LoopCoverTrafficStream<OsRng> {
            &self.ack_key,
            &self.our_full_destination,
            self.average_ack_delay,
-            self.average_packet_delay,
+            self.cover_traffic.loop_cover_traffic_average_delay,
            cover_traffic_packet_size,
            self.packet_type,
        ) {
@@ -6,7 +6,7 @@ use nym_crypto::{
    asymmetric::{ed25519, x25519},
    hkdf::{DerivationMaterial, InvalidLength},
 };
-use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use nym_sphinx::acknowledgements::AckKey;
 use rand::{CryptoRng, RngCore};
 use std::sync::Arc;
@@ -106,5 +106,7 @@ fn _assert_keys_zeroize_on_drop() {
    _assert_zeroize_on_drop::<ed25519::KeyPair>();
    _assert_zeroize_on_drop::<x25519::KeyPair>();
    _assert_zeroize_on_drop::<AckKey>();
+    _assert_zeroize_on_drop::<LegacySharedKeys>();
    _assert_zeroize_on_drop::<SharedSymmetricKey>();
+    _assert_zeroize_on_drop::<SharedGatewayKey>();
 }
@@ -13,7 +13,7 @@ use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::fmt::Debug;
 use std::os::raw::c_int as RawFd;
 use thiserror::Error;
-use tracing::debug;
+use tracing::{debug, error};

 #[cfg(not(target_arch = "wasm32"))]
 use futures::channel::oneshot;
@@ -436,7 +436,7 @@ where
            }
        }

-        if let Some(ref mut next_delay) = &mut self.next_delay {
+        if let Some(next_delay) = &mut self.next_delay {
            // it is not yet time to return a message
            if next_delay.as_mut().poll(cx).is_pending() {
                return Poll::Pending;
@@ -8,6 +8,7 @@ use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::anonymous_replies::ReplySurbWithKeyRotation;
 use nym_task::connections::{ConnectionId, TransmissionLane};
 use std::sync::Weak;
+use tracing::error;

 pub(crate) fn new_control_channels() -> (ReplyControllerSender, ReplyControllerReceiver) {
    let (tx, rx) = mpsc::unbounded();
@@ -16,9 +16,6 @@ use std::path::PathBuf;

 #[derive(thiserror::Error, Debug)]
 pub enum ClientCoreError {
-    #[error("could not perform the state migration: {0}")]
-    UnsupportedMigration(String),
-
    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),

@@ -43,15 +40,8 @@ pub enum ClientCoreError {
    #[error("no gateway with id: {0}")]
    NoGatewayWithId(String),

-    #[error("Invalid URL: {0}")]
-    InvalidUrl(String),
-
-    #[error("node doesn't advertise ip addresses : {0}")]
-    MissingIpAddress(String),
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[error("resolution failed: {0}")]
-    ResolutionFailed(#[from] nym_http_api_client::ResolveError),
+    #[error("Invalid Endpoint: {0}")]
+    InvalidEndpoint(String),

    #[error("no gateways on network")]
    NoGatewaysOnNetwork,
@@ -169,9 +159,6 @@ pub enum ClientCoreError {
    #[error("custom selection of gateway was expected")]
    CustomGatewaySelectionExpected,

-    #[error("custom selection of gateway was unexpected")]
-    UnexpectedCustomGatewaySelection,
-
    #[error("the persisted gateway details were set for a custom setup")]
    UnexpectedPersistedCustomGatewayDetails,

@@ -5,7 +5,6 @@ use crate::error::ClientCoreError;
 use crate::init::types::RegistrationResult;
 use futures::{SinkExt, StreamExt};
 use nym_crypto::asymmetric::ed25519;
-use nym_gateway_client::client::GatewayListeners;
 use nym_gateway_client::GatewayClient;
 use nym_topology::node::RoutingNode;
 use nym_validator_client::client::{IdentityKeyRef, NymApiClientExt};
@@ -22,7 +21,7 @@ use url::Url;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::init::websockets::connect_async;

-use nym_topology::NodeId;
+use nym_topology::{EntryDetails, NodeId};
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::net::TcpStream;
 #[cfg(not(target_arch = "wasm32"))]
@@ -56,7 +55,7 @@ const PING_TIMEOUT: Duration = Duration::from_millis(1000);
 pub trait ConnectableGateway {
    fn node_id(&self) -> NodeId;
    fn identity(&self) -> ed25519::PublicKey;
-    fn clients_address(&self, prefer_ipv6: bool) -> Option<String>;
+    fn endpoint_details(&self) -> Option<EntryDetails>;
    fn is_wss(&self) -> bool;
 }

@@ -69,8 +68,8 @@ impl ConnectableGateway for RoutingNode {
        self.identity_key
    }

-    fn clients_address(&self, prefer_ipv6: bool) -> Option<String> {
-        self.ws_entry_address(prefer_ipv6)
+    fn endpoint_details(&self) -> Option<EntryDetails> {
+        self.entry.clone()
    }

    fn is_wss(&self) -> bool {
@@ -192,7 +191,7 @@ pub async fn gateways_for_init(
 }

 #[cfg(not(target_arch = "wasm32"))]
-async fn connect(endpoint: &str) -> Result<WsConn, ClientCoreError> {
+async fn connect(endpoint: &EntryDetails) -> Result<WsConn, ClientCoreError> {
    match tokio::time::timeout(CONN_TIMEOUT, connect_async(endpoint)).await {
        Err(_elapsed) => Err(ClientCoreError::GatewayConnectionTimeout),
        Ok(Err(conn_failure)) => Err(conn_failure),
@@ -209,17 +208,17 @@ async fn measure_latency<G>(gateway: &G) -> Result<GatewayWithLatency<'_, G>, Cl
 where
    G: ConnectableGateway,
 {
-    let Some(addr) = gateway.clients_address(false) else {
+    let Some(endpoint) = gateway.endpoint_details() else {
        return Err(ClientCoreError::UnsupportedEntry {
            id: gateway.node_id(),
            identity: gateway.identity().to_string(),
        });
    };
    trace!(
-        "establishing connection to {} ({addr})...",
+        "establishing connection to {} ({endpoint})...",
        gateway.identity(),
    );
-    let mut stream = connect(&addr).await?;
+    let mut stream = connect(&endpoint).await?;

    let mut results = Vec::new();
    for _ in 0..MEASUREMENTS {
@@ -380,12 +379,12 @@ pub(super) fn get_specified_gateway(

 pub(super) async fn register_with_gateway(
    gateway_id: ed25519::PublicKey,
-    gateway_listeners: GatewayListeners,
+    gateway_listener: EntryDetails,
    our_identity: Arc<ed25519::KeyPair>,
    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
 ) -> Result<RegistrationResult, ClientCoreError> {
    let mut gateway_client = GatewayClient::new_init(
-        gateway_listeners,
+        gateway_listener,
        gateway_id,
        our_identity.clone(),
        #[cfg(unix)]
@@ -410,6 +409,14 @@ pub(super) async fn register_with_gateway(
            }
        })?;

+    // this should NEVER happen, if it did, it means the function was misused,
+    // because for any fresh **registration**, the derived key is always up to date
+    if auth_response.requires_key_upgrade {
+        return Err(ClientCoreError::UnexpectedKeyUpgrade {
+            gateway_id: gateway_id.to_base58_string(),
+        });
+    }
+
    Ok(RegistrationResult {
        shared_keys: auth_response.initial_shared_key,
        authenticated_ephemeral_client: gateway_client,
@@ -5,7 +5,7 @@

 use crate::client::base_client::storage::helpers::{
    has_gateway_details, load_active_gateway_details, load_client_keys, load_gateway_details,
-    store_gateway_details, update_stored_published_data_gateway,
+    store_gateway_details,
 };
 use crate::client::key_manager::persistence::KeyStore;
 use crate::client::key_manager::ClientKeys;
@@ -16,8 +16,8 @@ use crate::init::helpers::{
 use crate::init::types::{
    GatewaySelectionSpecification, GatewaySetup, InitialisationResult, SelectedGateway,
 };
+use nym_client_core_gateways_storage::GatewaysDetailsStore;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewayRegistration};
-use nym_client_core_gateways_storage::{GatewayPublishedData, GatewaysDetailsStore};
 use nym_gateway_client::client::InitGatewayClient;
 use nym_topology::node::RoutingNode;
 use rand::rngs::OsRng;
@@ -71,28 +71,21 @@ where
    let mut rng = OsRng;

    let selected_gateway = match selection_specification {
-        GatewaySelectionSpecification::UniformRemote {
-            must_use_tls,
-            no_hostname,
-        } => {
+        GatewaySelectionSpecification::UniformRemote { must_use_tls } => {
            let gateway = uniformly_random_gateway(&mut rng, &available_gateways, must_use_tls)?;
-            SelectedGateway::from_topology_node(gateway, must_use_tls, no_hostname)?
+            SelectedGateway::from_topology_node(gateway, must_use_tls)?
        }
-        GatewaySelectionSpecification::RemoteByLatency {
-            must_use_tls,
-            no_hostname,
-        } => {
+        GatewaySelectionSpecification::RemoteByLatency { must_use_tls } => {
            let gateway =
                choose_gateway_by_latency(&mut rng, &available_gateways, must_use_tls).await?;
-            SelectedGateway::from_topology_node(gateway, must_use_tls, no_hostname)?
+            SelectedGateway::from_topology_node(gateway, must_use_tls)?
        }
        GatewaySelectionSpecification::Specified {
            must_use_tls,
-            no_hostname,
            identity,
        } => {
            let gateway = get_specified_gateway(&identity, &available_gateways, must_use_tls)?;
-            SelectedGateway::from_topology_node(gateway, must_use_tls, no_hostname)?
+            SelectedGateway::from_topology_node(gateway, must_use_tls)?
        }
        GatewaySelectionSpecification::Custom {
            gateway_identity,
@@ -112,15 +105,15 @@ where
    let (gateway_details, authenticated_ephemeral_client) = match selected_gateway {
        SelectedGateway::Remote {
            gateway_id,
-
-            gateway_listeners,
+            gateway_owner_address,
+            gateway_listener,
        } => {
            // if we're using a 'normal' gateway setup, do register
            let our_identity = client_keys.identity_keypair();

            let registration = helpers::register_with_gateway(
                gateway_id,
-                gateway_listeners.clone(),
+                gateway_listener.clone(),
                our_identity,
                #[cfg(unix)]
                connection_fd_callback,
@@ -130,7 +123,8 @@ where
                GatewayDetails::new_remote(
                    gateway_id,
                    registration.shared_keys,
-                    GatewayPublishedData::new(gateway_listeners),
+                    gateway_owner_address,
+                    gateway_listener,
                ),
                Some(registration.authenticated_ephemeral_client),
            )
@@ -156,46 +150,6 @@ where
    })
 }

-pub async fn refresh_gateway_published_data<D>(
-    details_store: &D,
-    registration: GatewayRegistration,
-    available_gateways: Vec<RoutingNode>,
-    must_use_tls: bool,
-    no_hostname: bool,
-) -> Result<(), ClientCoreError>
-where
-    D: GatewaysDetailsStore,
-    D::StorageError: Send + Sync + 'static,
-{
-    let gateway_id = registration.gateway_id().to_base58_string();
-    tracing::trace!("Updating gateway details : {gateway_id}");
-
-    let gateway = get_specified_gateway(&gateway_id, &available_gateways, must_use_tls)?;
-    let selected_gateway = SelectedGateway::from_topology_node(gateway, must_use_tls, no_hostname)?;
-
-    let new_gateway_listeners = match selected_gateway {
-        SelectedGateway::Remote {
-            gateway_listeners, ..
-        } => gateway_listeners,
-        SelectedGateway::Custom { .. } => {
-            // this should not happen, as `from_topology_node` returns a Remote
-            Err(ClientCoreError::UnexpectedCustomGatewaySelection)?
-        }
-    };
-
-    let new_published_data = GatewayPublishedData::new(new_gateway_listeners);
-
-    // update gateway details
-    update_stored_published_data_gateway(
-        details_store,
-        &registration.gateway_id(),
-        &new_published_data,
-    )
-    .await?;
-
-    Ok(())
-}
-
 async fn use_loaded_gateway_details<K, D>(
    key_store: &K,
    details_store: &D,
@@ -10,24 +10,27 @@ use nym_client_core_gateways_storage::{
    GatewayRegistration, GatewaysDetailsStore, RemoteGatewayDetails,
 };
 use nym_crypto::asymmetric::ed25519;
-use nym_gateway_client::client::{GatewayListeners, InitGatewayClient};
-use nym_gateway_client::SharedSymmetricKey;
+use nym_gateway_client::client::InitGatewayClient;
+use nym_gateway_requests::shared_key::SharedGatewayKey;
 use nym_sphinx::addressing::clients::Recipient;
 use nym_topology::node::RoutingNode;
+use nym_topology::EntryDetails;
 use nym_validator_client::client::IdentityKey;
+use nym_validator_client::nyxd::AccountId;
 use serde::Serialize;
 use std::fmt::{Debug, Display};
 #[cfg(unix)]
 use std::os::fd::RawFd;
 use std::sync::Arc;
 use time::OffsetDateTime;
-use url::Url;

 pub enum SelectedGateway {
    Remote {
        gateway_id: ed25519::PublicKey,

-        gateway_listeners: GatewayListeners,
+        gateway_owner_address: Option<AccountId>,
+
+        gateway_listener: EntryDetails,
    },
    Custom {
        gateway_id: ed25519::PublicKey,
@@ -39,52 +42,34 @@ impl SelectedGateway {
    pub fn from_topology_node(
        node: RoutingNode,
        must_use_tls: bool,
-        no_hostname: bool,
    ) -> Result<Self, ClientCoreError> {
        // for now, let's use 'old' behaviour, if you want to change it, you can pass it up the enum stack yourself : )
        let prefer_ipv6 = false;

-        let (gateway_listener, fallback_listener) = if must_use_tls {
-            // WSS main, no fallback
-            let primary =
-                node.ws_entry_address_tls()
-                    .ok_or(ClientCoreError::UnsupportedWssProtocol {
-                        gateway: node.identity_key.to_base58_string(),
-                    })?;
-            (primary, None)
-        } else {
-            let (maybe_primary, fallback) =
-                node.ws_entry_address_with_fallback(prefer_ipv6, no_hostname);
-            (
-                maybe_primary.ok_or(ClientCoreError::UnsupportedEntry {
-                    id: node.node_id,
-                    identity: node.identity_key.to_base58_string(),
-                })?,
-                fallback,
-            )
-        };
+        let gateway_listener = node.entry.ok_or(ClientCoreError::UnsupportedEntry {
+            id: node.node_id,
+            identity: node.identity_key.to_base58_string(),
+        })?;

-        let fallback_listener_url = fallback_listener.and_then(|address| {
-            Url::parse(&address)
-                .inspect_err(|err| {
-                    tracing::warn!("Malformed fallback listener, none will be used : {err}")
-                })
-                .ok()
-        });
+        if must_use_tls
+            && (gateway_listener.hostname.is_none() || gateway_listener.clients_wss_port.is_none())
+        {
+            return Err(ClientCoreError::UnsupportedWssProtocol {
+                gateway: node.identity_key.to_base58_string(),
+            });
+        }

-        let gateway_listener_url =
-            Url::parse(&gateway_listener).map_err(|source| ClientCoreError::MalformedListener {
-                gateway_id: node.identity_key.to_base58_string(),
-                raw_listener: gateway_listener,
-                source,
-            })?;
+        if prefer_ipv6 && gateway_listener.ip_addresses.iter().all(|i| i.is_ipv4()) {
+            return Err(ClientCoreError::UnsupportedEntry {
+                id: node.node_id,
+                identity: node.identity_key.to_base58_string(),
+            });
+        }

        Ok(SelectedGateway::Remote {
            gateway_id: node.identity_key,
-            gateway_listeners: GatewayListeners {
-                primary: gateway_listener_url,
-                fallback: fallback_listener_url,
-            },
+            gateway_owner_address: None,
+            gateway_listener,
        })
    }

@@ -113,7 +98,7 @@ impl SelectedGateway {
 /// - shared keys derived between ourselves and the node
 /// - an authenticated handle of an ephemeral handle created for the purposes of registration
 pub struct RegistrationResult {
-    pub shared_keys: Arc<SharedSymmetricKey>,
+    pub shared_keys: Arc<SharedGatewayKey>,
    pub authenticated_ephemeral_client: InitGatewayClient,
 }

@@ -160,36 +145,20 @@ impl InitialisationResult {
    pub fn gateway_id(&self) -> ed25519::PublicKey {
        self.gateway_registration.details.gateway_id()
    }
-
-    // indicates if the remote gateway details TTL has expired
-    pub fn exipred_details(&self) -> bool {
-        if let Some(expiration_timestamp) = self.gateway_registration.details.details_exipration() {
-            OffsetDateTime::now_utc() > expiration_timestamp
-        } else {
-            false
-        }
-    }
 }

 #[derive(Clone, Debug)]
 pub enum GatewaySelectionSpecification {
    /// Uniformly choose a random remote gateway.
-    UniformRemote {
-        must_use_tls: bool,
-        no_hostname: bool,
-    },
+    UniformRemote { must_use_tls: bool },

    /// Should the new, remote, gateway be selected based on latency.
-    RemoteByLatency {
-        must_use_tls: bool,
-        no_hostname: bool,
-    },
+    RemoteByLatency { must_use_tls: bool },

    /// Gateway with this specific identity should be chosen.
    // JS: I don't really like the name of this enum variant but couldn't think of anything better at the time
    Specified {
        must_use_tls: bool,
-        no_hostname: bool,
        identity: IdentityKey,
    },

@@ -205,7 +174,6 @@ impl Default for GatewaySelectionSpecification {
    fn default() -> Self {
        GatewaySelectionSpecification::UniformRemote {
            must_use_tls: false,
-            no_hostname: false,
        }
    }
 }
@@ -215,24 +183,16 @@ impl GatewaySelectionSpecification {
        gateway_identity: Option<String>,
        latency_based_selection: Option<bool>,
        must_use_tls: bool,
-        no_hostname: bool,
    ) -> Self {
        if let Some(identity) = gateway_identity {
            GatewaySelectionSpecification::Specified {
                identity,
                must_use_tls,
-                no_hostname,
            }
        } else if let Some(true) = latency_based_selection {
-            GatewaySelectionSpecification::RemoteByLatency {
-                must_use_tls,
-                no_hostname,
-            }
+            GatewaySelectionSpecification::RemoteByLatency { must_use_tls }
        } else {
-            GatewaySelectionSpecification::UniformRemote {
-                must_use_tls,
-                no_hostname,
-            }
+            GatewaySelectionSpecification::UniformRemote { must_use_tls }
        }
    }
 }
@@ -355,7 +315,6 @@ pub struct InitResults {
    pub encryption_key: String,
    pub gateway_id: String,
    pub gateway_listener: String,
-    pub fallback_listener: Option<String>,
    pub gateway_registration: OffsetDateTime,
    pub address: Recipient,
 }
@@ -373,13 +332,7 @@ impl InitResults {
            identity_key: address.identity().to_base58_string(),
            encryption_key: address.encryption_key().to_base58_string(),
            gateway_id: gateway.gateway_id.to_base58_string(),
-            gateway_listener: gateway.published_data.listeners.primary.to_string(),
-            fallback_listener: gateway
-                .published_data
-                .listeners
-                .fallback
-                .as_ref()
-                .map(|uri| uri.to_string()),
+            gateway_listener: gateway.gateway_listener.to_string(),
            gateway_registration: registration,
            address,
        }
@@ -1,43 +1,60 @@
 use crate::error::ClientCoreError;

-use nym_http_api_client::HickoryDnsResolver;
+#[cfg(not(target_arch = "wasm32"))]
+use nym_topology::EntryDetails;
 use tokio::net::TcpStream;
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 use tungstenite::handshake::client::Response;
-use url::{Host, Url};
+use url::Url;

 use std::net::SocketAddr;

 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn connect_async(
-    endpoint: &str,
+    endpoint: &EntryDetails,
 ) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), ClientCoreError> {
-    let resolver = HickoryDnsResolver::default();
-    let uri = Url::parse(endpoint).map_err(|_| ClientCoreError::InvalidUrl(endpoint.to_owned()))?;
+    let uri = ws_entry_address(endpoint, false)
+        .ok_or(ClientCoreError::InvalidEndpoint(endpoint.to_string()))?;
    let port: u16 = uri.port_or_known_default().unwrap_or(443);

-    let host = uri
-        .host()
-        .ok_or(ClientCoreError::InvalidUrl(endpoint.to_owned()))?;
-
-    // Get address for tcp connection, if a domain is provided use our preferred resolver rather than
-    // the default std resolve
-    let sock_addrs: Vec<SocketAddr> = match host {
-        Host::Ipv4(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Ipv6(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Domain(domain) => {
-            // Do a DNS lookup for the domain using our custom DNS resolver
-            resolver
-                .resolve_str(domain)
-                .await?
-                .map(|a| SocketAddr::new(a, port))
-                .collect()
-        }
-    };
+    let sock_addrs: Vec<SocketAddr> = endpoint
+        .ip_addresses
+        .iter()
+        .map(|addr| SocketAddr::new(addr.clone(), port))
+        .collect();

    let stream = TcpStream::connect(&sock_addrs[..]).await?;

-    tokio_tungstenite::client_async_tls(endpoint, stream)
+    tokio_tungstenite::client_async_tls(uri.to_string(), stream)
        .await
        .map_err(Into::into)
 }
+
+pub fn ws_entry_address_tls(entry: &EntryDetails) -> Option<Url> {
+    let hostname = entry.hostname.as_ref()?;
+    let wss_port = entry.clients_wss_port?;
+
+    Url::parse(&format!("wss://{hostname}:{wss_port}")).ok()
+}
+
+pub fn ws_entry_address_no_tls(entry: &EntryDetails, prefer_ipv6: bool) -> Option<Url> {
+    if let Some(hostname) = entry.hostname.as_ref() {
+        return Url::parse(&format!("ws://{hostname}:{}", entry.clients_ws_port)).ok();
+    }
+
+    if prefer_ipv6 {
+        if let Some(ipv6) = entry.ip_addresses.iter().find(|ip| ip.is_ipv6()) {
+            return Url::parse(&format!("ws://{ipv6}:{}", entry.clients_ws_port)).ok();
+        }
+    }
+
+    let any_ip = entry.ip_addresses.first()?;
+    Url::parse(&format!("ws://{any_ip}:{}", entry.clients_ws_port)).ok()
+}
+
+pub fn ws_entry_address(entry: &EntryDetails, prefer_ipv6: bool) -> Option<Url> {
+    if let Some(tls) = ws_entry_address_tls(entry) {
+        return Some(tls);
+    }
+    ws_entry_address_no_tls(entry, prefer_ipv6)
+}
@@ -27,11 +27,11 @@ nym-credential-storage = { path = "../../credential-storage" }
 nym-credentials-interface = { path = "../../credentials-interface" }
 nym-crypto = { path = "../../crypto" }
 nym-gateway-requests = { path = "../../gateway-requests" }
-nym-http-api-client = { path = "../../http-api-client" }
 nym-network-defaults = { path = "../../network-defaults" }
 nym-sphinx = { path = "../../nymsphinx" }
 nym-statistics-common = { path = "../../statistics" }
 nym-pemstore = { path = "../../pemstore" }
+nym-topology = { path = "../../topology", features = ["persistence"] }
 nym-validator-client = { path = "../validator-client", default-features = false }
 nym-task = { path = "../../task" }
 serde = { workspace = true, features = ["derive"] }
@@ -20,21 +20,21 @@ use nym_credentials_interface::TicketType;
 use nym_crypto::asymmetric::ed25519;
 use nym_gateway_requests::registration::handshake::client_handshake;
 use nym_gateway_requests::{
-    BinaryRequest, ClientControlRequest, ClientRequest, GatewayProtocolVersion,
-    GatewayProtocolVersionExt, GatewayRequestsError, ServerResponse, SharedSymmetricKey,
-    CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION, CURRENT_PROTOCOL_VERSION,
+    BinaryRequest, ClientControlRequest, ClientRequest, GatewayProtocolVersionExt,
+    GatewayRequestsError, 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;
 use nym_statistics_common::clients::ClientStatsSender;
 use nym_task::ShutdownToken;
+use nym_topology::EntryDetails;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use rand::rngs::OsRng;
 use std::sync::Arc;
 use tracing::instrument;
 use tracing::*;
 use tungstenite::protocol::Message;
-use url::Url;

 #[cfg(unix)]
 use std::os::fd::RawFd;
@@ -47,39 +47,43 @@ use std::os::raw::c_int as RawFd;
 use wasm_utils::websocket::JSWebsocket;
 #[cfg(target_arch = "wasm32")]
 use wasmtimer::tokio::sleep;
+use zeroize::Zeroizing;

 pub mod config;

 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) mod websockets;
 #[cfg(not(target_arch = "wasm32"))]
-use crate::client::websockets::connect_async_with_fallback;
+use websockets::connect_async;

 pub struct GatewayConfig {
    pub gateway_identity: ed25519::PublicKey,

-    pub gateway_listeners: GatewayListeners,
+    // currently a dead field
+    pub gateway_owner: Option<String>,
+
+    pub gateway_listener: EntryDetails,
 }

 impl GatewayConfig {
-    pub fn new(gateway_identity: ed25519::PublicKey, gateway_listeners: GatewayListeners) -> Self {
+    pub fn new(
+        gateway_identity: ed25519::PublicKey,
+        gateway_owner: Option<String>,
+        gateway_listener: EntryDetails,
+    ) -> Self {
        GatewayConfig {
            gateway_identity,
-            gateway_listeners,
+            gateway_owner,
+            gateway_listener,
        }
    }
 }

-#[derive(Debug, Clone)]
-pub struct GatewayListeners {
-    pub primary: Url,
-    pub fallback: Option<Url>,
-}
-
 #[must_use]
 #[derive(Debug)]
 pub struct AuthenticationResponse {
-    pub initial_shared_key: Arc<SharedSymmetricKey>,
+    pub initial_shared_key: Arc<SharedGatewayKey>,
+    pub requires_key_upgrade: bool,
 }

 // TODO: this should be refactored into a state machine that keeps track of its authentication state
@@ -88,16 +92,17 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {

    authenticated: bool,
    bandwidth: ClientBandwidth,
-    gateway_addresses: GatewayListeners,
+    gateway_address: EntryDetails,
    gateway_identity: ed25519::PublicKey,
    local_identity: Arc<ed25519::KeyPair>,
-    shared_key: Option<Arc<SharedSymmetricKey>>,
+    shared_key: Option<Arc<SharedGatewayKey>>,
    connection: SocketState,
    packet_router: PacketRouter,
    bandwidth_controller: Option<BandwidthController<C, St>>,
    stats_reporter: ClientStatsSender,

-    negotiated_protocol: Option<GatewayProtocolVersion>,
+    // currently unused (but populated)
+    negotiated_protocol: Option<u8>,

    // Callback on the fd as soon as the connection has been established
    #[cfg(unix)]
@@ -114,7 +119,7 @@ impl<C, St> GatewayClient<C, St> {
        gateway_config: GatewayConfig,
        local_identity: Arc<ed25519::KeyPair>,
        // TODO: make it mandatory. if you don't want to pass it, use `new_init`
-        shared_key: Option<Arc<SharedSymmetricKey>>,
+        shared_key: Option<Arc<SharedGatewayKey>>,
        packet_router: PacketRouter,
        bandwidth_controller: Option<BandwidthController<C, St>>,
        stats_reporter: ClientStatsSender,
@@ -125,7 +130,7 @@ impl<C, St> GatewayClient<C, St> {
            cfg,
            authenticated: false,
            bandwidth: ClientBandwidth::new_empty(),
-            gateway_addresses: gateway_config.gateway_listeners,
+            gateway_address: gateway_config.gateway_listener,
            gateway_identity: gateway_config.gateway_identity,
            local_identity,
            shared_key,
@@ -144,7 +149,7 @@ impl<C, St> GatewayClient<C, St> {
        self.gateway_identity
    }

-    pub fn shared_key(&self) -> Option<Arc<SharedSymmetricKey>> {
+    pub fn shared_key(&self) -> Option<Arc<SharedGatewayKey>> {
        self.shared_key.clone()
    }

@@ -161,12 +166,10 @@ impl<C, St> GatewayClient<C, St> {
    }

    #[cfg(not(target_arch = "wasm32"))]
-    #[allow(clippy::unreachable)]
    async fn _close_connection(&mut self) -> Result<(), GatewayClientError> {
        match std::mem::replace(&mut self.connection, SocketState::NotConnected) {
            SocketState::Available(mut socket) => Ok((*socket).close(None).await?),
            SocketState::PartiallyDelegated(_) => {
-                // SAFETY: this is only called after the caller has already recovered the connection
                unreachable!("this branch should have never been reached!")
            }
            _ => Ok(()), // no need to do anything in those cases
@@ -174,7 +177,6 @@ impl<C, St> GatewayClient<C, St> {
    }

    #[cfg(target_arch = "wasm32")]
-    #[allow(clippy::unreachable)]
    async fn _close_connection(&mut self) -> Result<(), GatewayClientError> {
        match std::mem::replace(&mut self.connection, SocketState::NotConnected) {
            SocketState::Available(socket) => {
@@ -182,7 +184,6 @@ impl<C, St> GatewayClient<C, St> {
                Ok(())
            }
            SocketState::PartiallyDelegated(_) => {
-                // SAFETY: this is only called after the caller has already recovered the connection
                unreachable!("this branch should have never been reached!")
            }
            _ => Ok(()), // no need to do anything in those cases
@@ -199,19 +200,12 @@ impl<C, St> GatewayClient<C, St> {

    #[cfg(not(target_arch = "wasm32"))]
    pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
-        if let Some(fallback_url) = &self.gateway_addresses.fallback {
-            debug!(
-                "Attempting to establish connection to gateway at: {}, with fallback at: {fallback_url}",
-                self.gateway_addresses.primary
-            );
-        } else {
-            debug!(
-                "Attempting to establish connection to gateway at: {}",
-                self.gateway_addresses.primary
-            );
-        }
-        let (ws_stream, _) = connect_async_with_fallback(
-            &self.gateway_addresses,
+        debug!(
+            "Attempting to establish connection to gateway at: {:?}",
+            self.gateway_address
+        );
+        let (ws_stream, _) = connect_async(
+            &self.gateway_address,
            #[cfg(unix)]
            self.connection_fd_callback.clone(),
        )
@@ -224,7 +218,7 @@ impl<C, St> GatewayClient<C, St> {

    #[cfg(target_arch = "wasm32")]
    pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
-        let ws_stream = match JSWebsocket::new(self.gateway_addresses.primary.as_ref()) {
+        let ws_stream = match JSWebsocket::new(&self.gateway_address) {
            Ok(ws_stream) => ws_stream,
            Err(e) => {
                return Err(GatewayClientError::NetworkErrorWasm(e));
@@ -277,7 +271,7 @@ impl<C, St> GatewayClient<C, St> {
        message: ClientRequest,
    ) -> Result<(), GatewayClientError> {
        if let Some(shared_key) = self.shared_key() {
-            let encrypted = message.encrypt(&shared_key)?;
+            let encrypted = message.encrypt(&*shared_key)?;
            Box::pin(self.send_websocket_message_without_response(encrypted)).await?;
            Ok(())
        } else {
@@ -464,28 +458,65 @@ impl<C, St> GatewayClient<C, St> {
        }
    }

+    fn check_gateway_protocol(
+        &self,
+        gateway_protocol: Option<u8>,
+    ) -> Result<(), GatewayClientError> {
+        debug!("gateway protocol: {gateway_protocol:?}, ours: {CURRENT_PROTOCOL_VERSION}");
+
+        // right now there are no failure cases here, but this might change in the future
+        match gateway_protocol {
+            None => {
+                warn!(
+                    "the gateway we're connected to has not specified its protocol version. It's probably running version < 1.1.X, but that's still fine for now. It will become a hard error in 1.2.0"
+                );
+                // note: in +1.2.0 we will have to return a hard error here
+                Ok(())
+            }
+            Some(v) if v > CURRENT_PROTOCOL_VERSION => {
+                let err = GatewayClientError::IncompatibleProtocol {
+                    gateway: Some(v),
+                    current: CURRENT_PROTOCOL_VERSION,
+                };
+                error!("{err}");
+                Err(err)
+            }
+
+            Some(_) => {
+                debug!(
+                    "the gateway is using exactly the same (or older) protocol version as we are. We're good to continue!"
+                );
+                Ok(())
+            }
+        }
+    }
+
    async fn register(
        &mut self,
-        supported_gateway_protocol: GatewayProtocolVersion,
+        derive_aes256_gcm_siv_key: bool,
    ) -> Result<(), GatewayClientError> {
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
        }

        debug_assert!(self.connection.is_available());
-        log::debug!("registering with gateway");
+        log::debug!(
+            "registering with gateway. using legacy key derivation: {}",
+            !derive_aes256_gcm_siv_key
+        );

        // it's fine to instantiate it here as it's only used once (during authentication or registration)
        // and putting it into the GatewayClient struct would be a hassle
        let mut rng = OsRng;

-        let handshake_result = match &mut self.connection {
+        let shared_key = match &mut self.connection {
            SocketState::Available(ws_stream) => client_handshake(
                &mut rng,
                ws_stream,
                self.local_identity.as_ref(),
                self.gateway_identity,
-                supported_gateway_protocol,
+                self.cfg.bandwidth.require_tickets,
+                derive_aes256_gcm_siv_key,
                #[cfg(not(target_arch = "wasm32"))]
                self.shutdown_token.clone(),
            )
@@ -494,26 +525,99 @@ impl<C, St> GatewayClient<C, St> {
            _ => return Err(GatewayClientError::ConnectionInInvalidState),
        }?;

-        let authentication_status = match self.read_control_response().await? {
-            ServerResponse::Register { status, .. } => status,
+        let (authentication_status, gateway_protocol) = match self.read_control_response().await? {
+            ServerResponse::Register {
+                protocol_version,
+                status,
+            } => (status, protocol_version),
            ServerResponse::Error { message } => {
-                return Err(GatewayClientError::GatewayError(message))
+                return Err(GatewayClientError::GatewayError(message));
            }
            other => return Err(GatewayClientError::UnexpectedResponse { name: other.name() }),
        };

+        self.check_gateway_protocol(gateway_protocol)?;
        self.authenticated = authentication_status;

        if self.authenticated {
-            self.shared_key = Some(Arc::new(handshake_result.derived_key));
+            self.shared_key = Some(Arc::new(shared_key));
        }

        // populate the negotiated protocol for future uses
-        self.negotiated_protocol = Some(handshake_result.negotiated_protocol);
+        self.negotiated_protocol = gateway_protocol;

        Ok(())
    }

+    pub async fn upgrade_key_authenticated(
+        &mut self,
+    ) -> Result<Zeroizing<SharedSymmetricKey>, GatewayClientError> {
+        info!("*** STARTING AES128CTR-HMAC KEY UPGRADE INTO AES256GCM-SIV***");
+
+        if !self.connection.is_established() {
+            return Err(GatewayClientError::ConnectionNotEstablished);
+        }
+
+        if !self.authenticated {
+            return Err(GatewayClientError::NotAuthenticated);
+        }
+
+        let Some(shared_key) = self.shared_key.as_ref() else {
+            return Err(GatewayClientError::NoSharedKeyAvailable);
+        };
+
+        if !shared_key.is_legacy() {
+            return Err(GatewayClientError::KeyAlreadyUpgraded);
+        }
+
+        // make sure we have the only reference, so we could safely swap it
+        if Arc::strong_count(shared_key) != 1 {
+            return Err(GatewayClientError::KeyAlreadyInUse);
+        }
+
+        assert!(shared_key.is_legacy());
+        let legacy_key = shared_key.unwrap_legacy();
+        let (updated_key, hkdf_salt) = legacy_key.upgrade();
+        let derived_key_digest = updated_key.digest();
+
+        let upgrade_request = ClientRequest::UpgradeKey {
+            hkdf_salt,
+            derived_key_digest,
+        }
+        .encrypt(legacy_key)?;
+
+        info!("sending upgrade request and awaiting the acknowledgement back");
+        let (ciphertext, nonce) = match self
+            .send_websocket_message_with_response(upgrade_request)
+            .await?
+        {
+            ServerResponse::EncryptedResponse { ciphertext, nonce } => (ciphertext, nonce),
+            ServerResponse::Error { message } => {
+                return Err(GatewayClientError::GatewayError(message));
+            }
+            other => return Err(GatewayClientError::UnexpectedResponse { name: other.name() }),
+        };
+
+        // attempt to decrypt it using NEW key
+        let Ok(response) = SensitiveServerResponse::decrypt(&ciphertext, &nonce, &updated_key)
+        else {
+            return Err(GatewayClientError::FatalKeyUpgradeFailure);
+        };
+
+        match response {
+            SensitiveServerResponse::KeyUpgradeAck { .. } => {
+                info!("received key upgrade acknowledgement")
+            }
+            _ => return Err(GatewayClientError::FatalKeyUpgradeFailure),
+        }
+
+        // perform in memory swap and make a copy for updating storage
+        let zeroizing_updated_key = updated_key.zeroizing_clone();
+        self.shared_key = Some(Arc::new(updated_key.into()));
+
+        Ok(zeroizing_updated_key)
+    }
+
    async fn send_authenticate_request_and_handle_response(
        &mut self,
        msg: ClientControlRequest,
@@ -524,14 +628,11 @@ impl<C, St> GatewayClient<C, St> {
                status,
                bandwidth_remaining,
            } => {
-                if protocol_version.is_future_version() {
-                    error!("the gateway insists on using v{protocol_version} protocol which is not supported by this client");
-                    return Err(GatewayClientError::AuthenticationFailure);
-                }
+                self.check_gateway_protocol(protocol_version)?;
                self.authenticated = status;
                self.bandwidth.update_and_maybe_log(bandwidth_remaining);

-                self.negotiated_protocol = Some(protocol_version);
+                self.negotiated_protocol = protocol_version;
                log::debug!("authenticated: {status}, bandwidth remaining: {bandwidth_remaining}");

                Ok(())
@@ -541,42 +642,56 @@ impl<C, St> GatewayClient<C, St> {
        }
    }

-    async fn authenticate_v2(
-        &mut self,
-        requested_protocol_version: GatewayProtocolVersion,
-    ) -> Result<(), GatewayClientError> {
-        debug!("using v2 authentication");
+    async fn authenticate_v1(&mut self) -> Result<(), GatewayClientError> {
+        debug!("using v1 authentication");
+
        let Some(shared_key) = self.shared_key.as_ref() else {
            return Err(GatewayClientError::NoSharedKeyAvailable);
        };

-        let msg = ClientControlRequest::new_authenticate_v2(
+        let self_address = self
+            .local_identity
+            .public_key()
+            .derive_destination_address();
+
+        let msg = ClientControlRequest::new_authenticate(
+            self_address,
            shared_key,
-            &self.local_identity,
-            requested_protocol_version,
+            self.cfg.bandwidth.require_tickets,
        )?;
        self.send_authenticate_request_and_handle_response(msg)
            .await
    }

-    async fn authenticate(
-        &mut self,
-        requested_protocol_version: GatewayProtocolVersion,
-    ) -> Result<(), GatewayClientError> {
+    async fn authenticate_v2(&mut self) -> Result<(), GatewayClientError> {
+        debug!("using v2 authentication");
+        let Some(shared_key) = self.shared_key.as_ref() else {
+            return Err(GatewayClientError::NoSharedKeyAvailable);
+        };
+
+        let msg = ClientControlRequest::new_authenticate_v2(shared_key, &self.local_identity)?;
+        self.send_authenticate_request_and_handle_response(msg)
+            .await
+    }
+
+    async fn authenticate(&mut self, use_v2: bool) -> Result<(), GatewayClientError> {
        if !self.connection.is_established() {
            return Err(GatewayClientError::ConnectionNotEstablished);
        }
        debug!("authenticating with gateway");

-        // use the highest possible protocol version the gateway has announced support for
-        self.authenticate_v2(requested_protocol_version).await
+        if use_v2 {
+            self.authenticate_v2().await
+        } else {
+            self.authenticate_v1().await
+        }
    }

    /// Helper method to either call register or authenticate based on self.shared_key value
    #[instrument(skip_all,
        fields(
            gateway = %self.gateway_identity,
-            gateway_address = %self.gateway_addresses.primary
+            gateway_address = %self.gateway_address
        )
    )]
    pub async fn perform_initial_authentication(
@@ -587,11 +702,15 @@ impl<C, St> GatewayClient<C, St> {
        }

        // 1. check gateway's protocol version
-        // if we failed to get this request resolved, it means the gateway is on an old version
-        // that definitely does not support auth v2 or aes256gcm, so we bail
-        let gw_protocol = self.get_gateway_protocol().await?;
-
-        debug!("supported gateway protocol: {gw_protocol:?}");
+        let gw_protocol = match self.get_gateway_protocol().await {
+            Ok(protocol) => Some(protocol),
+            Err(_) => {
+                // if we failed to send the request, it means the gateway is running the old binary,
+                // so it has reset our connection - we have to reconnect
+                self.establish_connection().await?;
+                None
+            }
+        };

        let supports_aes_gcm_siv = gw_protocol.supports_aes256_gcm_siv();
        let supports_auth_v2 = gw_protocol.supports_authenticate_v2();
@@ -603,32 +722,16 @@ impl<C, St> GatewayClient<C, St> {
        if !supports_auth_v2 {
            warn!("this gateway is on an old version that doesn't support authentication v2")
        }
-
-        // Dropping v1 support
-        if !supports_auth_v2 || !supports_aes_gcm_siv {
-            // we can't continue
-            return Err(GatewayClientError::IncompatibleProtocol {
-                gateway: gw_protocol,
-                current: CURRENT_PROTOCOL_VERSION,
-            });
-        }
-
        if !supports_key_rotation_info {
            warn!("this gateway is on an old version that doesn't support key rotation packets")
        }

-        let gw_protocol = if gw_protocol.is_future_version() {
-            warn!("we're running outdated software as gateway is announcing protocol {gw_protocol:?} whilst we're using {}. we're going to attempt to downgrade", GatewayProtocolVersion::CURRENT);
-            GatewayProtocolVersion::CURRENT
-        } else {
-            gw_protocol
-        };
-
        if self.authenticated {
            debug!("Already authenticated");
            return if let Some(shared_key) = &self.shared_key {
                Ok(AuthenticationResponse {
                    initial_shared_key: Arc::clone(shared_key),
+                    requires_key_upgrade: shared_key.is_legacy() && supports_aes_gcm_siv,
                })
            } else {
                Err(GatewayClientError::AuthenticationFailureWithPreexistingSharedKey)
@@ -636,30 +739,32 @@ impl<C, St> GatewayClient<C, St> {
        }

        if self.shared_key.is_some() {
-            self.authenticate(gw_protocol).await?;
+            self.authenticate(supports_auth_v2).await?;

            if self.authenticated {
                // if we are authenticated it means we MUST have an associated shared_key
-                #[allow(clippy::unwrap_used)]
                let shared_key = self.shared_key.as_ref().unwrap();

+                let requires_key_upgrade = shared_key.is_legacy() && supports_aes_gcm_siv;
+
                Ok(AuthenticationResponse {
                    initial_shared_key: Arc::clone(shared_key),
+                    requires_key_upgrade,
                })
            } else {
                Err(GatewayClientError::AuthenticationFailure)
            }
        } else {
-            self.register(gw_protocol).await?;
+            self.register(supports_aes_gcm_siv).await?;

            // if registration didn't return an error, we MUST have an associated shared key
-            #[allow(clippy::unwrap_used)]
            let shared_key = self.shared_key.as_ref().unwrap();

            // we're always registering with the highest supported protocol,
            // so no upgrades are required
            Ok(AuthenticationResponse {
                initial_shared_key: Arc::clone(shared_key),
+                requires_key_upgrade: false,
            })
        }
    }
@@ -727,8 +832,6 @@ impl<C, St> GatewayClient<C, St> {
    }

    fn unchecked_bandwidth_controller(&self) -> &BandwidthController<C, St> {
-        // this is an unchecked method
-        #[allow(clippy::unwrap_used)]
        self.bandwidth_controller.as_ref().unwrap()
    }

@@ -759,7 +862,9 @@ impl<C, St> GatewayClient<C, St> {

        warn!("Not enough bandwidth. Trying to get more bandwidth, this might take a while");
        if !self.cfg.bandwidth.require_tickets {
-            info!("The client is running in disabled credentials mode - attempting to claim bandwidth without a credential");
+            info!(
+                "The client is running in disabled credentials mode - attempting to claim bandwidth without a credential"
+            );
            return self.try_claim_testnet_bandwidth().await;
        }

@@ -797,7 +902,9 @@ impl<C, St> GatewayClient<C, St> {
            Err(err) => {
                error!("failed to claim ecash bandwidth with the gateway...: {err}");
                if err.is_ticket_replay() {
-                    warn!("this was due to our ticket being replayed! have you messed with the database file?")
+                    warn!(
+                        "this was due to our ticket being replayed! have you messed with the database file?"
+                    )
                } else {
                    // TODO: tracing span
                    info!("attempting to revert ticket withdrawal...");
@@ -820,7 +927,6 @@ impl<C, St> GatewayClient<C, St> {
            BinaryRequest::ForwardSphinx { packet }
        };

-        #[allow(clippy::expect_used)]
        req.into_ws_message(
            self.shared_key
                .as_ref()
@@ -927,8 +1033,6 @@ impl<C, St> GatewayClient<C, St> {
        self.send_with_reconnection_on_failure(msg).await
    }

-    // SAFETY: this method is only called when the connection is in `PartiallyDelegated` state
-    #[allow(clippy::unreachable)]
    async fn recover_socket_connection(&mut self) -> Result<(), GatewayClientError> {
        if self.connection.is_available() {
            return Ok(());
@@ -958,7 +1062,6 @@ impl<C, St> GatewayClient<C, St> {
            return Err(GatewayClientError::ConnectionInInvalidState);
        }

-        #[allow(clippy::expect_used)]
        let partially_delegated =
            match std::mem::replace(&mut self.connection, SocketState::Invalid) {
                SocketState::Available(conn) => {
@@ -974,13 +1077,7 @@ impl<C, St> GatewayClient<C, St> {
                        self.shutdown_token.clone(),
                    )
                }
-                other => {
-                    error!(
-                        "attempted to start mixnet listener whilst the connection is in {} state!",
-                        other.name()
-                    );
-                    return Err(GatewayClientError::ConnectionInInvalidState);
-                }
+                _ => unreachable!(),
            };

        self.connection = SocketState::PartiallyDelegated(partially_delegated);
@@ -993,12 +1090,8 @@ impl<C, St> GatewayClient<C, St> {
        }

        // if we're reconnecting, because we lost connection, we need to re-authenticate the connection
-        if let Some(negotiated_protocol) = self.negotiated_protocol {
-            self.authenticate(negotiated_protocol).await?;
-        } else {
-            // This should never happen, because it would mean we're not registered
-            return Err(GatewayClientError::NotRegistered);
-        }
+        self.authenticate(self.negotiated_protocol.supports_authenticate_v2())
+            .await?;

        // this call is NON-blocking
        self.start_listening_for_mixnet_messages()?;
@@ -1027,7 +1120,9 @@ impl<C, St> GatewayClient<C, St> {
            self.cfg
                .bandwidth
                .ensure_above_cutoff(bandwidth_remaining)?;
-            info!("Claiming more bandwidth with existing credentials. Stop the process now if you don't want that to happen.");
+            info!(
+                "Claiming more bandwidth with existing credentials. Stop the process now if you don't want that to happen."
+            );
            self.claim_bandwidth().await?;
        }
        Ok(())
@@ -1043,7 +1138,7 @@ pub struct InitOnly;
 impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
    // for initialisation we do not need credential storage. Though it's still a bit weird we have to set the generic...
    pub fn new_init(
-        gateway_listeners: GatewayListeners,
+        gateway_listener: EntryDetails,
        gateway_identity: ed25519::PublicKey,
        local_identity: Arc<ed25519::KeyPair>,
        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
@@ -1062,7 +1157,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
            cfg: GatewayClientConfig::default().with_disabled_credentials_mode(true),
            authenticated: false,
            bandwidth: ClientBandwidth::new_empty(),
-            gateway_addresses: gateway_listeners,
+            gateway_address: gateway_listener.clone(),
            gateway_identity,
            local_identity,
            shared_key: None,
@@ -1094,7 +1189,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
            cfg: self.cfg,
            authenticated: self.authenticated,
            bandwidth: self.bandwidth,
-            gateway_addresses: self.gateway_addresses,
+            gateway_address: self.gateway_address,
            gateway_identity: self.gateway_identity,
            local_identity: self.local_identity,
            shared_key: self.shared_key,
@@ -1,53 +1,37 @@
-#[cfg(not(target_arch = "wasm32"))]
-use crate::client::GatewayListeners;
 use crate::error::GatewayClientError;

-use nym_http_api_client::HickoryDnsResolver;
+#[cfg(not(target_arch = "wasm32"))]
+use nym_topology::EntryDetails;
 #[cfg(unix)]
 use std::{
    os::fd::{AsRawFd, RawFd},
    sync::Arc,
 };
+use tokio::net::TcpSocket;
 use tokio::net::TcpStream;
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 use tungstenite::handshake::client::Response;
-use url::{Host, Url};
+use url::Url;

 use std::net::SocketAddr;

 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn connect_async(
-    endpoint: &str,
+    endpoint: &EntryDetails,
    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
 ) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), GatewayClientError> {
-    use tokio::net::TcpSocket;
-
-    let resolver = HickoryDnsResolver::default();
-    let uri =
-        Url::parse(endpoint).map_err(|_| GatewayClientError::InvalidUrl(endpoint.to_owned()))?;
+    let uri = ws_entry_address(endpoint, false)
+        .ok_or(GatewayClientError::InvalidEndpoint(endpoint.to_string()))?;
    let port: u16 = uri.port_or_known_default().unwrap_or(443);

-    let host = uri
-        .host()
-        .ok_or(GatewayClientError::InvalidUrl(endpoint.to_owned()))?;
-
-    // Get address for tcp connection, if a domain is provided use our preferred resolver rather than
-    // the default std resolve
-    let sock_addrs: Vec<SocketAddr> = match host {
-        Host::Ipv4(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Ipv6(addr) => vec![SocketAddr::new(addr.into(), port)],
-        Host::Domain(domain) => {
-            // Do a DNS lookup for the domain using our custom DNS resolver
-            resolver
-                .resolve_str(domain)
-                .await?
-                .map(|a| SocketAddr::new(a, port))
-                .collect()
-        }
-    };
+    let sock_addrs = endpoint
+        .ip_addresses
+        .iter()
+        .map(|addr| SocketAddr::new(*addr, port));
+    let uri_str = uri.to_string();

    let mut stream = Err(GatewayClientError::NoEndpointForConnection {
-        address: endpoint.to_owned(),
+        address: uri_str.clone(),
    });
    for sock_addr in sock_addrs {
        let socket = if sock_addr.is_ipv4() {
@@ -56,7 +40,7 @@ pub(crate) async fn connect_async(
            TcpSocket::new_v6()
        }
        .map_err(|err| GatewayClientError::NetworkConnectionFailed {
-            address: endpoint.to_owned(),
+            address: uri_str.clone(),
            source: Box::new(tungstenite::Error::from(err)),
        })?;

@@ -72,7 +56,7 @@ pub(crate) async fn connect_async(
            }
            Err(err) => {
                stream = Err(GatewayClientError::NetworkConnectionFailed {
-                    address: endpoint.to_owned(),
+                    address: uri_str.clone(),
                    source: Box::new(tungstenite::Error::from(err)),
                });
                continue;
@@ -80,42 +64,39 @@ pub(crate) async fn connect_async(
        }
    }

-    tokio_tungstenite::client_async_tls(endpoint, stream?)
+    tokio_tungstenite::client_async_tls(uri.clone(), stream?)
        .await
        .map_err(|error| GatewayClientError::NetworkConnectionFailed {
-            address: endpoint.to_owned(),
+            address: uri_str.clone(),
            source: Box::new(error),
        })
 }

-#[cfg(not(target_arch = "wasm32"))]
-pub(crate) async fn connect_async_with_fallback(
-    endpoints: &GatewayListeners,
-    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
-) -> Result<(WebSocketStream<MaybeTlsStream<TcpStream>>, Response), GatewayClientError> {
-    match connect_async(
-        endpoints.primary.as_ref(),
-        #[cfg(unix)]
-        connection_fd_callback.clone(),
-    )
-    .await
-    {
-        Ok(inner) => Ok(inner),
-        Err(e) => {
-            if let Some(fallback) = &endpoints.fallback {
-                tracing::warn!(
-                    "Main endpoint failed {} : {e}, trying fallback : {fallback}",
-                    endpoints.primary
-                );
-                connect_async(
-                    fallback.as_ref(),
-                    #[cfg(unix)]
-                    connection_fd_callback,
-                )
-                .await
-            } else {
-                Err(e)
-            }
+pub fn ws_entry_address_tls(entry: &EntryDetails) -> Option<Url> {
+    let hostname = entry.hostname.as_ref()?;
+    let wss_port = entry.clients_wss_port?;
+
+    Url::parse(&format!("wss://{hostname}:{wss_port}")).ok()
+}
+
+pub fn ws_entry_address_no_tls(entry: &EntryDetails, prefer_ipv6: bool) -> Option<Url> {
+    if let Some(hostname) = entry.hostname.as_ref() {
+        return Url::parse(&format!("ws://{hostname}:{}", entry.clients_ws_port)).ok();
+    }
+
+    if prefer_ipv6 {
+        if let Some(ipv6) = entry.ip_addresses.iter().find(|ip| ip.is_ipv6()) {
+            return Url::parse(&format!("ws://{ipv6}:{}", entry.clients_ws_port)).ok();
        }
    }
+
+    let any_ip = entry.ip_addresses.first()?;
+    Url::parse(&format!("ws://{any_ip}:{}", entry.clients_ws_port)).ok()
+}
+
+pub fn ws_entry_address(entry: &EntryDetails, prefer_ipv6: bool) -> Option<Url> {
+    if let Some(tls) = ws_entry_address_tls(entry) {
+        return Some(tls);
+    }
+    ws_entry_address_no_tls(entry, prefer_ipv6)
 }
@@ -49,12 +49,8 @@ pub enum GatewayClientError {
    #[error("no socket address for endpoint: {address}")]
    NoEndpointForConnection { address: String },

-    #[error("Invalid URL: {0}")]
-    InvalidUrl(String),
-
-    #[cfg(not(target_arch = "wasm32"))]
-    #[error("resolution failed: {0}")]
-    ResolutionFailed(#[from] nym_http_api_client::ResolveError),
+    #[error("Invalid Endpoint: {0}")]
+    InvalidEndpoint(String),

    #[error("No shared key was provided or obtained")]
    NoSharedKeyAvailable,
@@ -83,9 +79,6 @@ pub enum GatewayClientError {
    #[error("Client is not authenticated")]
    NotAuthenticated,

-    #[error("Client is not registered")]
-    NotRegistered,
-
    #[error("Client does not have enough bandwidth: estimated {0}, remaining: {1}")]
    NotEnoughBandwidth(i64, i64),

@@ -119,8 +112,8 @@ pub enum GatewayClientError {
    #[error("Failed to send mixnet message")]
    MixnetMsgSenderFailedToSend,

-    #[error("Attempted to negotiate connection with gateway using incompatible protocol version. Ours is {current} and the gateway reports {gateway}")]
-    IncompatibleProtocol { gateway: u8, current: u8 },
+    #[error("Attempted to negotiate connection with gateway using incompatible protocol version. Ours is {current} and the gateway reports {gateway:?}")]
+    IncompatibleProtocol { gateway: Option<u8>, current: u8 },

    #[error(
        "The packet router hasn't been set - are you sure you started up the client correctly?"
@@ -7,7 +7,9 @@ use tracing::{error, warn};
 use tungstenite::{protocol::Message, Error as WsError};

 pub use client::{config::GatewayClientConfig, GatewayClient, GatewayConfig};
-pub use nym_gateway_requests::shared_key::SharedSymmetricKey;
+pub use nym_gateway_requests::shared_key::{
+    LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey,
+};
 pub use packet_router::{
    AcknowledgementReceiver, AcknowledgementSender, MixnetMessageReceiver, MixnetMessageSender,
    PacketRouter,
@@ -45,7 +47,7 @@ pub(crate) fn cleanup_socket_messages(

 pub(crate) fn try_decrypt_binary_message(
    bin_msg: Vec<u8>,
-    shared_keys: &SharedSymmetricKey,
+    shared_keys: &SharedGatewayKey,
 ) -> Option<Vec<u8>> {
    match BinaryResponse::try_from_encrypted_tagged_bytes(bin_msg, shared_keys) {
        Ok(bin_response) => match bin_response {
@@ -9,7 +9,7 @@ use crate::{cleanup_socket_messages, try_decrypt_binary_message};
 use futures::channel::oneshot;
 use futures::stream::{SplitSink, SplitStream};
 use futures::{SinkExt, StreamExt};
-use nym_gateway_requests::shared_key::SharedSymmetricKey;
+use nym_gateway_requests::shared_key::SharedGatewayKey;
 use nym_gateway_requests::{SensitiveServerResponse, ServerResponse, SimpleGatewayRequestsError};
 use nym_task::ShutdownToken;
 use si_scale::helpers::bibytes2;
@@ -63,7 +63,7 @@ pub(crate) struct PartiallyDelegatedHandle {

 struct PartiallyDelegatedRouter {
    packet_router: PacketRouter,
-    shared_key: Arc<SharedSymmetricKey>,
+    shared_key: Arc<SharedGatewayKey>,
    client_bandwidth: ClientBandwidth,

    stream_return: SplitStreamSender,
@@ -73,7 +73,7 @@ struct PartiallyDelegatedRouter {
 impl PartiallyDelegatedRouter {
    fn new(
        packet_router: PacketRouter,
-        shared_key: Arc<SharedSymmetricKey>,
+        shared_key: Arc<SharedGatewayKey>,
        client_bandwidth: ClientBandwidth,
        stream_return: SplitStreamSender,
        stream_return_requester: oneshot::Receiver<()>,
@@ -197,6 +197,11 @@ impl PartiallyDelegatedRouter {
                        SensitiveServerResponse::RememberMeAck {} => {
                            info!("received remember me acknowledgement");
                        }
+                        SensitiveServerResponse::KeyUpgradeAck {} => {
+                            warn!(
+                                    "received illegal key upgrade acknowledgement in an authenticated client"
+                                );
+                        }
                        _ => {
                            warn!("received unknown SensitiveServerResponse");
                        }
@@ -272,7 +277,7 @@ impl PartiallyDelegatedHandle {
    pub(crate) fn split_and_listen_for_mixnet_messages(
        conn: WsConn,
        packet_router: PacketRouter,
-        shared_key: Arc<SharedSymmetricKey>,
+        shared_key: Arc<SharedGatewayKey>,
        client_bandwidth: ClientBandwidth,
        shutdown: ShutdownToken,
    ) -> Self {
@@ -322,7 +327,6 @@ impl PartiallyDelegatedHandle {
        Ok(self.sink_half.send_all(&mut send_stream).await?)
    }

-    #[allow(clippy::panic)]
    pub(crate) async fn merge(self) -> Result<WsConn, GatewayClientError> {
        let (mut stream_receiver, notify) = self.delegated_stream;

@@ -351,10 +355,8 @@ impl PartiallyDelegatedHandle {
            // in receive_res
            .map_err(|_| GatewayClientError::ConnectionAbruptlyClosed)?;
        let stream = stream_results?;
-
        // the error is thrown when trying to reunite sink and stream that did not originate
        // from the same split which is impossible to happen here
-        #[allow(clippy::unwrap_used)]
        Ok(self.sink_half.reunite(stream).unwrap())
    }
 }
@@ -385,13 +387,4 @@ impl SocketState {
            SocketState::Available(_) | SocketState::PartiallyDelegated(_)
        )
    }
-
-    pub(crate) fn name(&self) -> &'static str {
-        match self {
-            SocketState::Available(_) => "available",
-            SocketState::PartiallyDelegated(_) => "partially delegated",
-            SocketState::NotConnected => "not connected",
-            SocketState::Invalid => "invalid",
-        }
-    }
 }
@@ -75,7 +75,6 @@ workspace = true
 features = ["json", "rustls-tls"]

 [dev-dependencies]
-anyhow = { workspace = true }
 bip39 = { workspace = true }
 cosmrs = { workspace = true, features = ["bip32"] }
 ts-rs = { workspace = true }
@@ -7,7 +7,6 @@ use cosmrs::{tx, AccountId, Coin, Denom};
 use nym_validator_client::http_client;
 use nym_validator_client::nyxd::CosmWasmClient;
 use nym_validator_client::signing::direct_wallet::DirectSecp256k1HdWallet;
-use nym_validator_client::signing::signer::OfflineSigner;
 use nym_validator_client::signing::tx_signer::TxSigner;
 use nym_validator_client::signing::SignerData;

@@ -20,8 +19,8 @@ async fn main() {
    let validator = "https://rpc.sandbox.nymtech.net";
    let to_address: AccountId = "n1pefc2utwpy5w78p2kqdsfmpjxfwmn9d39k5mqa".parse().unwrap();

-    let signer = DirectSecp256k1HdWallet::checked_from_mnemonic(prefix, signer_mnemonic).unwrap();
-    let signer_address = signer.signer_addresses()[0].clone();
+    let signer = DirectSecp256k1HdWallet::from_mnemonic(prefix, signer_mnemonic);
+    let signer_address = signer.try_derive_accounts().unwrap()[0].address().clone();

    // local 'client' ONLY signing messages
    let tx_signer = signer;
@@ -58,15 +57,9 @@ async fn main() {
        100000u32,
    );

-    let tx_raw = TxSigner::sign_direct(
-        &tx_signer,
-        &signer_address,
-        vec![send_msg],
-        fee,
-        memo,
-        signer_data,
-    )
-    .unwrap();
+    let tx_raw = tx_signer
+        .sign_direct(&signer_address, vec![send_msg], fee, memo, signer_data)
+        .unwrap();
    let tx_bytes = tx_raw.to_bytes().unwrap();

    // compare balances from before and after the tx
@@ -5,7 +5,8 @@ use crate::nyxd::{self, NyxdClient};
 use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 use crate::signing::signer::{NoSigner, OfflineSigner};
 use crate::{
-    DirectSigningReqwestRpcValidatorClient, QueryReqwestRpcValidatorClient, ValidatorClientError,
+    DirectSigningReqwestRpcValidatorClient, QueryReqwestRpcValidatorClient, ReqwestRpcClient,
+    ValidatorClientError,
 };
 use nym_api_requests::ecash::models::{
    AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
@@ -163,7 +164,7 @@ impl Client<HttpRpcClient, DirectSecp256k1HdWallet> {
    ) -> Result<DirectSigningHttpRpcValidatorClient, ValidatorClientError> {
        let rpc_client = http_client(config.nyxd_url.as_str())?;
        let prefix = &config.nyxd_config.chain_details.bech32_account_prefix;
-        let wallet = DirectSecp256k1HdWallet::checked_from_mnemonic(prefix, mnemonic)?;
+        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);

        Ok(Self::new_signing_with_rpc_client(
            config, rpc_client, wallet,
@@ -176,13 +177,12 @@ impl Client<HttpRpcClient, DirectSecp256k1HdWallet> {
    }
 }

-#[allow(deprecated)]
-impl Client<crate::ReqwestRpcClient, DirectSecp256k1HdWallet> {
+impl Client<ReqwestRpcClient, DirectSecp256k1HdWallet> {
    pub fn new_reqwest_signing(
        config: Config,
        mnemonic: bip39::Mnemonic,
    ) -> DirectSigningReqwestRpcValidatorClient {
-        let rpc_client = crate::ReqwestRpcClient::new(config.nyxd_url.clone());
+        let rpc_client = ReqwestRpcClient::new(config.nyxd_url.clone());
        let prefix = &config.nyxd_config.chain_details.bech32_account_prefix;
        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);

@@ -203,10 +203,9 @@ impl Client<HttpRpcClient> {
    }
 }

-#[allow(deprecated)]
-impl Client<crate::ReqwestRpcClient> {
+impl Client<ReqwestRpcClient> {
    pub fn new_reqwest_query(config: Config) -> QueryReqwestRpcValidatorClient {
-        let rpc_client = crate::ReqwestRpcClient::new(config.nyxd_url.clone());
+        let rpc_client = ReqwestRpcClient::new(config.nyxd_url.clone());
        Self::new_with_rpc_client(config, rpc_client)
    }
 }
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::nym_api;
-use crate::signing::direct_wallet::DirectSecp256k1HdWalletError;
 pub use tendermint_rpc::error::Error as TendermintRpcError;
 use thiserror::Error;

@@ -27,12 +26,6 @@ pub enum ValidatorClientError {

    #[error("No validator API url has been provided")]
    NoAPIUrlAvailable,
-
-    #[error("failed to derive signing accounts: {source}")]
-    AccountDerivationFailure {
-        #[from]
-        source: DirectSecp256k1HdWalletError,
-    },
 }

 impl From<nym_api::error::NymAPIError> for ValidatorClientError {
@@ -12,7 +12,6 @@ pub mod rpc;
 pub mod signing;

 pub use crate::error::ValidatorClientError;
-#[allow(deprecated)]
 pub use crate::rpc::reqwest::ReqwestRpcClient;
 pub use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 pub use client::{Client, Config, EcashApiClient};
@@ -39,13 +38,9 @@ pub type DirectSigningHttpRpcValidatorClient = Client<HttpRpcClient, DirectSecp2
 #[cfg(feature = "http-client")]
 pub type DirectSigningHttpRpcNyxdClient = nyxd::NyxdClient<HttpRpcClient, DirectSecp256k1HdWallet>;

-#[allow(deprecated)]
 pub type QueryReqwestRpcValidatorClient = Client<ReqwestRpcClient>;
-#[allow(deprecated)]
 pub type QueryReqwestRpcNyxdClient = nyxd::NyxdClient<ReqwestRpcClient>;

-#[allow(deprecated)]
 pub type DirectSigningReqwestRpcValidatorClient = Client<ReqwestRpcClient, DirectSecp256k1HdWallet>;
-#[allow(deprecated)]
 pub type DirectSigningReqwestRpcNyxdClient =
    nyxd::NyxdClient<ReqwestRpcClient, DirectSecp256k1HdWallet>;
@@ -178,7 +178,7 @@ where
            .ok_or_else(|| NyxdError::unavailable_contract_address("dkg contract"))?;

        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let signer_address = &self.signer_addresses()[0];
+        let signer_address = &self.signer_addresses()?[0];

        self.execute(signer_address, dkg_contract_address, &msg, fee, memo, funds)
            .await
@@ -99,7 +99,7 @@ where
            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;

        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let signer_address = &self.signer_addresses()[0];
+        let signer_address = &self.signer_addresses()?[0];

        self.execute(
            signer_address,
@@ -95,7 +95,7 @@ where

        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));

-        let signer_address = &self.signer_addresses()[0];
+        let signer_address = &self.signer_addresses()?[0];
        self.execute(
            signer_address,
            group_contract_address,
@@ -667,7 +667,7 @@ where
        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
        let memo = msg.default_memo();

-        let signer_address = &self.signer_addresses()[0];
+        let signer_address = &self.signer_addresses()?[0];
        self.execute(
            signer_address,
            mixnet_contract_address,
@@ -133,7 +133,7 @@ where

        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));

-        let signer_address = &self.signer_addresses()[0];
+        let signer_address = &self.signer_addresses()?[0];
        self.execute(
            signer_address,
            multisig_contract_address,
@@ -165,7 +165,7 @@ where

        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));

-        let signer_address = &self.signer_addresses()[0];
+        let signer_address = &self.signer_addresses()?[0];
        self.execute(
            signer_address,
            performance_contract_address,
@@ -375,7 +375,7 @@ where
        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
        let memo = msg.name().to_string();

-        let signer_address = &self.signer_addresses()[0];
+        let signer_address = &self.signer_addresses()?[0];
        self.execute(
            signer_address,
            vesting_contract_address,
@@ -324,7 +324,7 @@ where
 {
    type Error = S::Error;

-    fn get_accounts(&self) -> &[AccountData] {
+    fn get_accounts(&self) -> Result<Vec<AccountData>, Self::Error> {
        self.signer.get_accounts()
    }

@@ -19,7 +19,7 @@ use crate::signing::signer::NoSigner;
 use crate::signing::signer::OfflineSigner;
 use crate::signing::tx_signer::TxSigner;
 use crate::signing::AccountData;
-use crate::{DirectSigningReqwestRpcNyxdClient, QueryReqwestRpcNyxdClient};
+use crate::{DirectSigningReqwestRpcNyxdClient, QueryReqwestRpcNyxdClient, ReqwestRpcClient};
 use async_trait::async_trait;
 use cosmrs::tendermint::{abci, evidence::Evidence, Genesis};
 use cosmrs::tx::{Raw, SignDoc};
@@ -158,13 +158,12 @@ impl NyxdClient<HttpClient> {
    }
 }

-#[allow(deprecated)]
-impl NyxdClient<crate::ReqwestRpcClient> {
+impl NyxdClient<ReqwestRpcClient> {
    pub fn connect_reqwest(
        config: Config,
        endpoint: Url,
    ) -> Result<QueryReqwestRpcNyxdClient, NyxdError> {
-        let client = crate::ReqwestRpcClient::new(endpoint);
+        let client = ReqwestRpcClient::new(endpoint);

        Ok(NyxdClient {
            client: MaybeSigningClient::new(client, (&config).into()),
@@ -196,19 +195,18 @@ impl NyxdClient<HttpClient, DirectSecp256k1HdWallet> {
        let client = http_client(endpoint)?;

        let prefix = &config.chain_details.bech32_account_prefix;
-        let wallet = DirectSecp256k1HdWallet::checked_from_mnemonic(prefix, mnemonic)?;
+        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
        Ok(Self::connect_with_signer(config, client, wallet))
    }
 }

-#[allow(deprecated)]
-impl NyxdClient<crate::ReqwestRpcClient, DirectSecp256k1HdWallet> {
+impl NyxdClient<ReqwestRpcClient, DirectSecp256k1HdWallet> {
    pub fn connect_reqwest_with_mnemonic(
        config: Config,
        endpoint: Url,
        mnemonic: bip39::Mnemonic,
    ) -> DirectSigningReqwestRpcNyxdClient {
-        let client = crate::ReqwestRpcClient::new(endpoint);
+        let client = ReqwestRpcClient::new(endpoint);

        let prefix = &config.chain_details.bech32_account_prefix;
        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
@@ -393,12 +391,17 @@ where
    S: OfflineSigner + Send + Sync,
    NyxdError: From<<S as OfflineSigner>::Error>,
 {
-    pub fn signing_account(&self) -> Result<&AccountData, NyxdError> {
+    pub fn signing_account(&self) -> Result<AccountData, NyxdError> {
        Ok(self.find_account(&self.address())?)
    }

    pub fn address(&self) -> AccountId {
-        self.client.signer_addresses()[0].clone()
+        match self.client.signer_addresses() {
+            Ok(addresses) => addresses[0].clone(),
+            Err(_) => {
+                panic!("key derivation failure")
+            }
+        }
    }

    pub fn mix_coin(&self, amount: u128) -> Coin {
@@ -864,7 +867,7 @@ where
 {
    type Error = S::Error;

-    fn get_accounts(&self) -> &[AccountData] {
+    fn get_accounts(&self) -> Result<Vec<AccountData>, Self::Error> {
        self.client.get_accounts()
    }

@@ -42,15 +42,12 @@ macro_rules! perform_with_compat {
    }};
 }

-// the separate implementation is now completely redundant
-#[deprecated(note = "use HttpClient directly instead")]
 pub struct ReqwestRpcClient {
    compat: CompatMode,
    inner: reqwest::Client,
    url: Url,
 }

-#[allow(deprecated)]
 impl ReqwestRpcClient {
    pub fn new(url: Url) -> Self {
        ReqwestRpcClient {
@@ -134,7 +131,6 @@ impl TendermintRpcErrorMap for reqwest::Error {
    }
 }

-#[allow(deprecated)]
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl TendermintRpcClient for ReqwestRpcClient {
@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::signing::signer::{OfflineSigner, SigningError};
-use crate::signing::{
-    derive_extended_private_key, derive_keypair, AccountData, Secp256k1Derivation, Secp256k1Keypair,
-};
-use bip32::XPrv;
-use cosmrs::bip32::DerivationPath;
+use crate::signing::{AccountData, Secp256k1Derivation};
+use cosmrs::bip32::{DerivationPath, XPrv};
+use cosmrs::crypto::secp256k1::SigningKey;
+use cosmrs::crypto::PublicKey;
 use cosmrs::tx;
 use cosmrs::tx::SignDoc;
 use nym_config::defaults;
-use std::borrow::Cow;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};

+type Secp256k1Keypair = (SigningKey, PublicKey);
+
 #[derive(Debug, Error)]
 pub enum DirectSecp256k1HdWalletError {
    #[error(transparent)]
@@ -36,22 +36,28 @@ pub enum DirectSecp256k1HdWalletError {
 }

 // TODO: maybe lock this one behind feature flag?
-#[derive(Zeroize, ZeroizeOnDrop)]
+#[derive(Debug, Clone, Zeroize, ZeroizeOnDrop)]
 pub struct DirectSecp256k1HdWallet {
    /// Base secret
    secret: bip39::Mnemonic,

-    /// Derived accounts
+    /// BIP39 seed
+    seed: [u8; 64],
+
+    // An unfortunate result of immature rust async story is that async traits (only available in the separate package)
+    // can't yet figure out everything and if we stored our derived account data on the struct,
+    // that would include the secret key which is a dyn EcdsaSigner and hence not Sync making the wallet
+    // not Sync and if used on the signing client in an async trait, it wouldn't be Send
+    /// Derivation instructions
    #[zeroize(skip)]
-    // unfortunately `dyn EcdsaSigner` does not guarantee Zeroize
-    accounts: Vec<AccountData>,
+    accounts: Vec<Secp256k1Derivation>,
 }

 impl OfflineSigner for DirectSecp256k1HdWallet {
    type Error = DirectSecp256k1HdWalletError;

-    fn get_accounts(&self) -> &[AccountData] {
-        &self.accounts
+    fn get_accounts(&self) -> Result<Vec<AccountData>, Self::Error> {
+        self.try_derive_accounts()
    }

    fn sign_direct_with_account(
@@ -71,27 +77,55 @@ impl DirectSecp256k1HdWallet {
    }

    /// Restores a wallet from the given BIP39 mnemonic using default options.
-    #[deprecated(
-        note = "this function can potentially panic if accounts can't be derived correctly. please use .checked_from_mnemonic() instead"
-    )]
    pub fn from_mnemonic(prefix: &str, mnemonic: bip39::Mnemonic) -> Self {
-        // unfortunately due to backwards compatibility requirements,
-        // we can't change signature of this method
-        #[allow(deprecated)]
        DirectSecp256k1HdWalletBuilder::new(prefix).build(mnemonic)
    }

-    /// Restores a wallet from the given BIP39 mnemonic using default options.
-    pub fn checked_from_mnemonic(
-        prefix: &str,
-        mnemonic: bip39::Mnemonic,
-    ) -> Result<Self, DirectSecp256k1HdWalletError> {
-        DirectSecp256k1HdWalletBuilder::new(prefix).try_build(mnemonic)
-    }
-
    pub fn generate(prefix: &str, word_count: usize) -> Result<Self, DirectSecp256k1HdWalletError> {
        let mneomonic = bip39::Mnemonic::generate(word_count)?;
-        Self::checked_from_mnemonic(prefix, mneomonic)
+        Ok(Self::from_mnemonic(prefix, mneomonic))
+    }
+
+    fn derive_keypair(
+        &self,
+        hd_path: &DerivationPath,
+    ) -> Result<Secp256k1Keypair, DirectSecp256k1HdWalletError> {
+        let extended_private_key = XPrv::derive_from_path(self.seed, hd_path)?;
+
+        let private_key: SigningKey = extended_private_key.into();
+        let public_key = private_key.public_key();
+
+        Ok((private_key, public_key))
+    }
+
+    pub fn derive_extended_private_key(
+        &self,
+        hd_path: &DerivationPath,
+    ) -> Result<XPrv, DirectSecp256k1HdWalletError> {
+        Ok(XPrv::derive_from_path(self.seed, hd_path)?)
+    }
+
+    pub fn try_derive_accounts(&self) -> Result<Vec<AccountData>, DirectSecp256k1HdWalletError> {
+        let mut accounts = Vec::with_capacity(self.accounts.len());
+        for derivation_info in &self.accounts {
+            let keypair = self.derive_keypair(&derivation_info.hd_path)?;
+
+            // it seems this can only fail if the provided account prefix is invalid
+            let address = keypair
+                .1
+                .account_id(&derivation_info.prefix)
+                .map_err(
+                    |source| DirectSecp256k1HdWalletError::AccountDerivationError { source },
+                )?;
+
+            accounts.push(AccountData {
+                address,
+                public_key: keypair.1,
+                private_key: keypair.0,
+            })
+        }
+
+        Ok(accounts)
    }

    pub fn secret(&self) -> &bip39::Mnemonic {
@@ -108,43 +142,6 @@ impl DirectSecp256k1HdWallet {
    pub fn mnemonic_string(&self) -> Zeroizing<String> {
        Zeroizing::new(self.secret.to_string())
    }
-
-    pub fn account_seed<'a, P: Into<Cow<'a, str>>>(
-        &self,
-        bip39_password: P,
-    ) -> Zeroizing<[u8; 64]> {
-        Zeroizing::new(self.secret.to_seed(bip39_password))
-    }
-
-    /// Derive an extended private key from the stored account secret assuming no bip39 password
-    #[deprecated(
-        note = "use derive_extended_private_key_with_password to ensure correct derivation if used bip39 password"
-    )]
-    pub fn derive_extended_private_key(
-        &self,
-        hd_path: &DerivationPath,
-    ) -> Result<XPrv, DirectSecp256k1HdWalletError> {
-        let seed = self.account_seed("");
-        derive_extended_private_key(seed, hd_path)
-    }
-
-    pub fn derive_keypair<'a, P: Into<Cow<'a, str>>>(
-        &self,
-        hd_path: &DerivationPath,
-        bip39_password: P,
-    ) -> Result<Secp256k1Keypair, DirectSecp256k1HdWalletError> {
-        let seed = self.account_seed(bip39_password);
-        derive_keypair(seed, hd_path)
-    }
-
-    pub fn derive_extended_private_key_with_password<'a, P: Into<Cow<'a, str>>>(
-        &self,
-        hd_path: &DerivationPath,
-        bip39_password: P,
-    ) -> Result<XPrv, DirectSecp256k1HdWalletError> {
-        let seed = self.account_seed(bip39_password);
-        derive_extended_private_key(seed, hd_path)
-    }
 }

 #[must_use]
@@ -191,39 +188,23 @@ impl DirectSecp256k1HdWalletBuilder {
        self
    }

-    #[deprecated(
-        note = "this function can potentially panic if accounts can't be derived correctly. please use .try_build() instead"
-    )]
    pub fn build(self, mnemonic: bip39::Mnemonic) -> DirectSecp256k1HdWallet {
-        // unfortunately due to backwards compatibility requirements,
-        // we can't change signature of this method
-        #[allow(clippy::expect_used)]
-        self.try_build(mnemonic)
-            .expect("account derivation failure")
-    }
-
-    pub fn try_build(
-        self,
-        mnemonic: bip39::Mnemonic,
-    ) -> Result<DirectSecp256k1HdWallet, DirectSecp256k1HdWalletError> {
-        let seed = Zeroizing::new(mnemonic.to_seed(&self.bip39_password));
+        let seed = mnemonic.to_seed(&self.bip39_password);
        let prefix = self.prefix.clone();
        let accounts = self
            .hd_paths
            .iter()
-            .map(|hd_path| {
-                Secp256k1Derivation {
-                    hd_path: hd_path.clone(),
-                    prefix: prefix.clone(),
-                }
-                .try_derive_account(&seed)
+            .map(|hd_path| Secp256k1Derivation {
+                hd_path: hd_path.clone(),
+                prefix: prefix.clone(),
            })
-            .collect::<Result<_, _>>()?;
+            .collect();

-        Ok(DirectSecp256k1HdWallet {
+        DirectSecp256k1HdWallet {
            accounts,
+            seed,
            secret: mnemonic,
-        })
+        }
    }
 }

@@ -234,7 +215,7 @@ mod tests {
    use super::*;

    #[test]
-    fn generating_account_addresses() -> anyhow::Result<()> {
+    fn generating_account_addresses() {
        // test vectors produced from our js wallet
        let mnemonics = ["crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove",
            "acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel",
@@ -249,10 +230,11 @@ mod tests {
            "n17n9flp6jflljg6fp05dsy07wcprf2uuu8g40rf",
        ];
        for (idx, mnemonic) in mnemonics.iter().enumerate() {
-            let wallet =
-                DirectSecp256k1HdWallet::checked_from_mnemonic(&prefix, mnemonic.parse()?)?;
-            assert_eq!(wallet.signer_addresses()[0], addrs[idx].parse().unwrap());
+            let wallet = DirectSecp256k1HdWallet::from_mnemonic(&prefix, mnemonic.parse().unwrap());
+            assert_eq!(
+                wallet.try_derive_accounts().unwrap()[0].address,
+                addrs[idx].parse().unwrap()
+            )
        }
-        Ok(())
    }
 }
@@ -1,8 +1,6 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::signing::direct_wallet::DirectSecp256k1HdWalletError;
-use bip32::XPrv;
 use cosmrs::bip32::DerivationPath;
 use cosmrs::crypto::secp256k1::SigningKey;
 use cosmrs::crypto::PublicKey;
@@ -14,64 +12,14 @@ pub mod direct_wallet;
 pub mod signer;
 pub mod tx_signer;

-pub(crate) type Secp256k1Keypair = (SigningKey, PublicKey);
-
 /// Derivation information required to derive a keypair and an address from a mnemonic.
 #[derive(Debug, Clone)]
-pub(crate) struct Secp256k1Derivation {
+struct Secp256k1Derivation {
    hd_path: DerivationPath,
    prefix: String,
 }

-impl Secp256k1Derivation {
-    pub(crate) fn try_derive_account<S>(
-        &self,
-        seed: S,
-    ) -> Result<AccountData, DirectSecp256k1HdWalletError>
-    where
-        S: AsRef<[u8]>,
-    {
-        let keypair = derive_keypair(seed, &self.hd_path)?;
-
-        // it seems this can only fail if the provided account prefix is invalid
-        let address = keypair
-            .1
-            .account_id(&self.prefix)
-            .map_err(|source| DirectSecp256k1HdWalletError::AccountDerivationError { source })?;
-
-        Ok(AccountData {
-            address,
-            public_key: keypair.1,
-            private_key: keypair.0,
-        })
-    }
-}
-
-pub fn derive_keypair<S>(
-    seed: S,
-    hd_path: &DerivationPath,
-) -> Result<Secp256k1Keypair, DirectSecp256k1HdWalletError>
-where
-    S: AsRef<[u8]>,
-{
-    let extended_private_key = derive_extended_private_key(seed, hd_path)?;
-
-    let private_key: SigningKey = extended_private_key.into();
-    let public_key = private_key.public_key();
-
-    Ok((private_key, public_key))
-}
-
-pub fn derive_extended_private_key<S>(
-    seed: S,
-    hd_path: &DerivationPath,
-) -> Result<XPrv, DirectSecp256k1HdWalletError>
-where
-    S: AsRef<[u8]>,
-{
-    Ok(XPrv::derive_from_path(seed, hd_path)?)
-}
-
+// TODO: is this struct going to be derivable with other signer types?
 pub struct AccountData {
    pub address: AccountId,

@@ -33,18 +33,23 @@ pub enum SignerType {
 pub trait OfflineSigner {
    type Error: From<SigningError>;

-    fn signer_addresses(&self) -> Vec<AccountId> {
-        self.get_accounts()
-            .iter()
-            .map(|account| account.address.clone())
-            .collect()
+    // I really dislike existence of this function because it makes you re-derive your key **twice** for each contract transaction
+    fn signer_addresses(&self) -> Result<Vec<AccountId>, Self::Error> {
+        let derived_addresses = self
+            .get_accounts()?
+            .into_iter()
+            .map(|account| account.address)
+            .collect();
+        Ok(derived_addresses)
    }

-    fn get_accounts(&self) -> &[AccountData];
+    fn get_accounts(&self) -> Result<Vec<AccountData>, Self::Error>;

-    fn find_account(&self, signer_address: &AccountId) -> Result<&AccountData, Self::Error> {
-        self.get_accounts()
-            .iter()
+    fn find_account(&self, signer_address: &AccountId) -> Result<AccountData, Self::Error> {
+        // TODO: we could really use some zeroize action here
+        let accounts = self.get_accounts()?;
+        accounts
+            .into_iter()
            .find(|account| &account.address == signer_address)
            .ok_or_else(|| {
                SigningError::AccountNotFound {
@@ -71,7 +76,7 @@ pub trait OfflineSigner {
        message: M,
    ) -> Result<Signature, Self::Error> {
        let signer = self.find_account(signer_address)?;
-        self.sign_raw_with_account(signer, message)
+        self.sign_raw_with_account(&signer, message)
    }

    fn sign_direct(
@@ -80,7 +85,7 @@ pub trait OfflineSigner {
        sign_doc: SignDoc,
    ) -> Result<tx::Raw, Self::Error> {
        let signer = self.find_account(signer_address)?;
-        self.sign_direct_with_account(signer, sign_doc)
+        self.sign_direct_with_account(&signer, sign_doc)
    }

    // unless explicitly defined, each signing method is unsupported
@@ -117,7 +122,7 @@ pub struct NoSigner;
 // impl OfflineSigner for NoSigner {
 //     type Error = SignerUnavailable;
 //
-//     fn get_accounts(&self) -> &[AccountData] {
+//     fn get_accounts(&self) -> Result<Vec<AccountData>, Self::Error> {
 //         return Err(SignerUnavailable);
 //     }
 // }
@@ -50,7 +50,7 @@ pub trait TxSigner: OfflineSigner {
        )
        .map_err(|source| SigningError::SignDocFailure { source })?;

-        self.sign_direct_with_account(account_from_signer, sign_doc)
+        self.sign_direct_with_account(&account_from_signer, sign_doc)
    }
 }

@@ -3,7 +3,6 @@

 use clap::Parser;
 use nym_validator_client::signing::direct_wallet::DirectSecp256k1HdWallet;
-use nym_validator_client::signing::signer::OfflineSigner;

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -16,10 +15,9 @@ pub fn create_account(args: Args, prefix: &str) {
    let word_count = args.word_count.unwrap_or(24);
    let mnemonic = bip39::Mnemonic::generate(word_count).expect("failed to generate mnemonic!");

-    let wallet = DirectSecp256k1HdWallet::checked_from_mnemonic(prefix, mnemonic)
-        .expect("failed to derive accounts!");
+    let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);

    // Output address and mnemonics into separate lines for easier parsing
    println!("{}", wallet.mnemonic_string().as_str());
-    println!("{}", wallet.signer_addresses()[0]);
+    println!("{}", wallet.try_derive_accounts().unwrap()[0].address());
 }
@@ -1,13 +1,13 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::context::QueryClient;
-use crate::utils::show_error;
 use clap::Parser;
 use log::{error, info};
 use nym_validator_client::nyxd::{AccountId, CosmWasmClient};
 use nym_validator_client::signing::direct_wallet::DirectSecp256k1HdWallet;
-use nym_validator_client::signing::signer::OfflineSigner;
+
+use crate::context::QueryClient;
+use crate::utils::show_error;

 #[derive(Debug, Parser)]
 pub struct Args {
@@ -50,19 +50,20 @@ pub async fn get_pubkey(
 }

 pub fn get_pubkey_from_mnemonic(address: AccountId, prefix: &str, mnemonic: bip39::Mnemonic) {
-    let wallet = match DirectSecp256k1HdWallet::checked_from_mnemonic(prefix, mnemonic) {
-        Ok(wallet) => wallet,
-        Err(err) => {
-            error!("Failed to derive accounts. {err}");
-            return;
+    let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
+    match wallet.try_derive_accounts() {
+        Ok(accounts) => match accounts.iter().find(|a| *a.address() == address) {
+            Some(account) => {
+                println!("{}", account.public_key().to_string());
+            }
+            None => {
+                error!("Could not derive key that matches {address}")
+            }
+        },
+        Err(e) => {
+            error!("Failed to derive accounts. {e}");
        }
-    };
-
-    let Ok(account) = wallet.find_account(&address) else {
-        error!("Could not derive key that matches {address}");
-        return;
-    };
-    println!("{}", account.public_key().to_string());
+    }
 }

 pub async fn get_pubkey_from_chain(address: AccountId, client: &QueryClient) {
@@ -36,35 +36,32 @@ pub fn sign(args: Args, prefix: &str, mnemonic: Option<bip39::Mnemonic>) {
        return;
    }

-    let wallet = match DirectSecp256k1HdWallet::checked_from_mnemonic(
-        prefix,
-        mnemonic.expect("mnemonic not set"),
-    ) {
-        Ok(wallet) => wallet,
-        Err(err) => {
-            error!("Could not derive an account key from the mnemonic: {err}");
-            return;
-        }
-    };
-    match wallet.get_accounts().first() {
-        Some(account) => {
-            let msg = args.message.into_bytes();
-            match wallet.sign_raw_with_account(account, msg) {
-                Ok(signature) => {
-                    let output = SignatureOutputJson {
-                        account_id: account.address().to_string(),
-                        public_key: account.public_key(),
-                        signature_as_hex: signature.to_string(),
-                    };
-                    println!("{}", json!(output));
-                }
-                Err(e) => {
-                    error!("Failed to sign message. {e}");
+    let wallet =
+        DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic.expect("mnemonic not set"));
+    match wallet.try_derive_accounts() {
+        Ok(accounts) => match accounts.first() {
+            Some(account) => {
+                let msg = args.message.into_bytes();
+                match wallet.sign_raw_with_account(account, msg) {
+                    Ok(signature) => {
+                        let output = SignatureOutputJson {
+                            account_id: account.address().to_string(),
+                            public_key: account.public_key(),
+                            signature_as_hex: signature.to_string(),
+                        };
+                        println!("{}", json!(output));
+                    }
+                    Err(e) => {
+                        error!("Failed to sign message. {e}");
+                    }
                }
            }
-        }
-        None => {
-            error!("Could not derive an account key from the mnemonic",)
+            None => {
+                error!("Could not derive an account key from the mnemonic",)
+            }
+        },
+        Err(e) => {
+            error!("Failed to derive accounts. {e}");
        }
    }
 }
@@ -39,11 +39,8 @@ impl SqliteEcashTicketbookManager {
        Ok(())
    }

-    /// Starts a write (IMMEDIATE) transaction, to prevent issue when upgrading from a read one to a write one
-    pub(crate) async fn begin_storage_write_tx(
-        &self,
-    ) -> Result<Transaction<'_, Sqlite>, sqlx::Error> {
-        self.connection_pool.begin_with("BEGIN IMMEDIATE").await
+    pub(crate) async fn begin_storage_tx(&self) -> Result<Transaction<'_, Sqlite>, sqlx::Error> {
+        self.connection_pool.begin().await
    }

    pub(crate) async fn insert_pending_ticketbook(
@@ -243,7 +243,7 @@ impl Storage for PersistentStorage {
        tickets: u32,
    ) -> Result<Option<RetrievedTicketbook>, Self::StorageError> {
        let deadline = ecash_today().ecash_date();
-        let mut tx = self.storage_manager.begin_storage_write_tx().await?;
+        let mut tx = self.storage_manager.begin_storage_tx().await?;

        // we don't want ticketbooks with expiration in the past
        let Some(raw) =
@@ -0,0 +1,73 @@
+// Copyright 2020-2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::shared_key::{SharedGatewayKey, SharedKeyUsageError};
+use nym_sphinx::DestinationAddressBytes;
+use thiserror::Error;
+
+/// Replacement for what used to be an `AuthToken`.
+///
+/// Replacement for what used to be an `AuthToken`. We used to be generating an `AuthToken` based on
+/// local secret and remote address in order to allow for authentication. Due to changes in registration
+/// and the fact we are deriving a shared key, we are encrypting remote's address with the previously
+/// derived shared key. If the value is as expected, then authentication is successful.
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+// this is no longer constant size due to the differences in ciphertext between aes128ctr and aes256gcm-siv (inclusion of tag)
+pub struct EncryptedAddressBytes(Vec<u8>);
+
+impl From<Vec<u8>> for EncryptedAddressBytes {
+    fn from(encrypted_address: Vec<u8>) -> Self {
+        EncryptedAddressBytes(encrypted_address)
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum EncryptedAddressConversionError {
+    #[error("Failed to decode the encrypted address - {0}")]
+    DecodeError(#[from] bs58::decode::Error),
+}
+
+impl EncryptedAddressBytes {
+    pub fn new(
+        address: &DestinationAddressBytes,
+        key: &SharedGatewayKey,
+        nonce: &[u8],
+    ) -> Result<Self, SharedKeyUsageError> {
+        let ciphertext = key.encrypt_naive(address.as_bytes_ref(), Some(nonce))?;
+
+        Ok(EncryptedAddressBytes(ciphertext))
+    }
+
+    pub fn verify(
+        &self,
+        address: &DestinationAddressBytes,
+        key: &SharedGatewayKey,
+        nonce: &[u8],
+    ) -> bool {
+        let Ok(reconstructed) = Self::new(address, key, nonce) else {
+            return false;
+        };
+        self == &reconstructed
+    }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+
+    pub fn try_from_base58_string<S: Into<String>>(
+        val: S,
+    ) -> Result<Self, EncryptedAddressConversionError> {
+        let decoded = bs58::decode(val.into()).into_vec()?;
+        Ok(EncryptedAddressBytes(decoded))
+    }
+
+    pub fn to_base58_string(self) -> String {
+        bs58::encode(self.0).into_string()
+    }
+}
+
+impl From<EncryptedAddressBytes> for String {
+    fn from(val: EncryptedAddressBytes) -> Self {
+        val.to_base58_string()
+    }
+}
@@ -0,0 +1,4 @@
+// Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod encrypted_address;
@@ -7,14 +7,17 @@ use nym_sphinx::params::GatewayIntegrityHmacAlgorithm;

 pub use types::*;

+pub mod authentication;
 pub mod models;
 pub mod registration;
 pub mod shared_key;
 pub mod types;

-pub use shared_key::{SharedKeyConversionError, SharedKeyUsageError, SharedSymmetricKey};
-
-pub type GatewayProtocolVersion = u8;
+pub use shared_key::helpers::SymmetricKey;
+pub use shared_key::legacy::{LegacySharedKeySize, LegacySharedKeys};
+pub use shared_key::{
+    SharedGatewayKey, SharedKeyConversionError, SharedKeyUsageError, SharedSymmetricKey,
+};

 pub const CURRENT_PROTOCOL_VERSION: u8 = EMBEDDED_KEY_ROTATION_INFO_VERSION;

@@ -24,7 +27,7 @@ pub const CURRENT_PROTOCOL_VERSION: u8 = EMBEDDED_KEY_ROTATION_INFO_VERSION;
 // 1 - initial release
 // 2 - changes to client credentials structure
 // 3 - change to AES-GCM-SIV and non-zero IVs
-// 4 - introduction of v2 authentication protocol to prevent replay attacks
+// 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;
@@ -37,50 +40,24 @@ pub const EMBEDDED_KEY_ROTATION_INFO_VERSION: u8 = 5;
 pub type LegacyGatewayMacSize = <GatewayIntegrityHmacAlgorithm as OutputSizeUser>::OutputSize;

 pub trait GatewayProtocolVersionExt {
-    const CURRENT: GatewayProtocolVersion = CURRENT_PROTOCOL_VERSION;
-
    fn supports_aes256_gcm_siv(&self) -> bool;
    fn supports_authenticate_v2(&self) -> bool;
    fn supports_key_rotation_packet(&self) -> bool;
-    fn is_future_version(&self) -> bool;
 }

-impl GatewayProtocolVersionExt for Option<GatewayProtocolVersion> {
+impl GatewayProtocolVersionExt for Option<u8> {
    fn supports_aes256_gcm_siv(&self) -> bool {
-        let Some(protocol) = self else { return false };
-        protocol.supports_aes256_gcm_siv()
+        let Some(protocol) = *self else { return false };
+        protocol >= AES_GCM_SIV_PROTOCOL_VERSION
    }

    fn supports_authenticate_v2(&self) -> bool {
-        let Some(protocol) = self else { return false };
-        protocol.supports_authenticate_v2()
+        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.supports_key_rotation_packet()
-    }
-
-    fn is_future_version(&self) -> bool {
-        let Some(protocol) = self else { return false };
-        protocol.is_future_version()
-    }
-}
-
-impl GatewayProtocolVersionExt for GatewayProtocolVersion {
-    fn supports_aes256_gcm_siv(&self) -> bool {
-        *self >= AES_GCM_SIV_PROTOCOL_VERSION
-    }
-
-    fn supports_authenticate_v2(&self) -> bool {
-        *self >= AUTHENTICATE_V2_PROTOCOL_VERSION
-    }
-
-    fn supports_key_rotation_packet(&self) -> bool {
-        *self >= EMBEDDED_KEY_ROTATION_INFO_VERSION
-    }
-
-    fn is_future_version(&self) -> bool {
-        *self > CURRENT_PROTOCOL_VERSION
+        let Some(protocol) = *self else { return false };
+        protocol >= EMBEDDED_KEY_ROTATION_INFO_VERSION
    }
 }
@@ -3,12 +3,10 @@

 use crate::registration::handshake::messages::{Finalization, GatewayMaterialExchange};
 use crate::registration::handshake::state::State;
-use crate::registration::handshake::HandshakeResult;
+use crate::registration::handshake::SharedGatewayKey;
 use crate::registration::handshake::{error::HandshakeError, WsItem};
-use crate::GatewayProtocolVersionExt;
 use futures::{Sink, Stream};
 use rand::{CryptoRng, RngCore};
-use tracing::info;
 use tungstenite::Message as WsMessage;

 impl<S, R> State<'_, S, R> {
@@ -18,35 +16,22 @@ impl<S, R> State<'_, S, R> {
        R: CryptoRng + RngCore,
    {
        // 1. if we're using non-legacy, i.e. aes256gcm-siv derivation, generate initiator salt for kdf
-        let hkdf_salt = self.generate_initiator_salt();
+        let maybe_hkdf_salt = self.maybe_generate_initiator_salt();

        // 1. send ed25519 pubkey alongside ephemeral x25519 pubkey and a hkdf salt if we're using non-legacy client
-        // LOCAL_ID_PUBKEY || EPHEMERAL_KEY || SALT
-        let init_message = self.init_message(hkdf_salt.clone());
+        // LOCAL_ID_PUBKEY || EPHEMERAL_KEY || MAYBE_SALT
+        let init_message = self.init_message(maybe_hkdf_salt.clone());
        self.send_handshake_data(init_message).await?;

        // 2. wait for response with remote x25519 pubkey as well as encrypted signature
        // <- g^y || AES(k, sig(gate_priv, (g^y || g^x)) || MAYBE_NONCE
-        let (mid_res, gateway_protocol) = self
+        let mid_res = self
            .receive_handshake_message::<GatewayMaterialExchange>()
            .await?;

-        // NEGOTIATE PROTOCOL
-        if gateway_protocol.is_future_version() {
-            return Err(HandshakeError::UnsupportedProtocol {
-                version: gateway_protocol,
-            });
-        }
-
-        // that should never happen, but we're fine with that outcome
-        if gateway_protocol != self.proposed_protocol_version() {
-            info!("the gateway insists on protocol version different from the one we suggested. it wants {gateway_protocol} whilst we wanted {:?}, however, we can support it", self.proposed_protocol_version());
-            self.set_protocol_version(gateway_protocol);
-        }
-
        // 3. derive shared keys locally
        // hkdf::<blake3>::(g^xy)
-        self.derive_shared_key(&mid_res.ephemeral_dh, &hkdf_salt);
+        self.derive_shared_key(&mid_res.ephemeral_dh, maybe_hkdf_salt.as_deref());

        // 4. verify the received signature using the locally derived keys
        self.verify_remote_key_material(&mid_res.materials, &mid_res.ephemeral_dh)?;
@@ -57,14 +42,14 @@ impl<S, R> State<'_, S, R> {
        self.send_handshake_data(materials).await?;

        // 6. wait for remote confirmation of finalizing the handshake
-        let (finalization, _) = self.receive_handshake_message::<Finalization>().await?;
+        let finalization = self.receive_handshake_message::<Finalization>().await?;
        finalization.ensure_success()?;
        Ok(())
    }

    pub(crate) async fn perform_client_handshake(
        mut self,
-    ) -> Result<HandshakeResult, HandshakeError>
+    ) -> Result<SharedGatewayKey, HandshakeError>
    where
        S: Stream<Item = WsItem> + Sink<WsMessage> + Unpin,
        R: CryptoRng + RngCore,
@@ -2,8 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::shared_key::SharedKeyUsageError;
-use crate::GatewayProtocolVersion;
-use crate::GatewayProtocolVersionExt;
 use thiserror::Error;

 #[derive(Debug, Error)]
@@ -36,10 +34,4 @@ pub enum HandshakeError {

    #[error("timed out waiting for a handshake message")]
    Timeout,
-
-    #[error("Connection is in an invalid state - please send a bug report")]
-    ConnectionInInvalidState,
-
-    #[error("the gateway requests protocol version that's not supported by this client. it wants to use v{version} whilst we only understand up to v{}", GatewayProtocolVersion::CURRENT)]
-    UnsupportedProtocol { version: GatewayProtocolVersion },
 }
@@ -5,11 +5,9 @@ use crate::registration::handshake::messages::{
    HandshakeMessage, Initialisation, MaterialExchange,
 };
 use crate::registration::handshake::state::State;
-use crate::registration::handshake::HandshakeResult;
+use crate::registration::handshake::SharedGatewayKey;
 use crate::registration::handshake::{error::HandshakeError, WsItem};
-use crate::{GatewayProtocolVersion, GatewayProtocolVersionExt};
 use futures::{Sink, Stream};
-use tracing::{debug, warn};
 use tungstenite::Message as WsMessage;

 impl<S, R> State<'_, S, R> {
@@ -20,43 +18,18 @@ impl<S, R> State<'_, S, R> {
    where
        S: Stream<Item = WsItem> + Sink<WsMessage> + Unpin,
    {
-        // NEGOTIATE PROTOCOL
-        // old clients were sending protocol version as defined by the following:
-        /*
-          fn request_protocol_version(&self) -> u8 {
-               if self.derive_aes256_gcm_siv_key {
-                   AES_GCM_SIV_PROTOCOL_VERSION
-               } else if self.expects_credential_usage {
-                   CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION
-               } else {
-                   INITIAL_PROTOCOL_VERSION
-               }
-           }
-        */
-        // meaning the highest possible value they could have sent was `4` (AUTHENTICATE_V2_PROTOCOL_VERSION)
-        // so if we received anything higher than that, it means they understand negotiation.
-        // currently not strictly needed as we just blindly accept what they proposed,
-        // but will be needed in the future.
-        if self.proposed_protocol_version().is_future_version() {
-            // this should never happen in a non-malicious client as it should use at most whatever version this gateway has announced
-            self.set_protocol_version(GatewayProtocolVersion::CURRENT)
-        } else {
-            // currently we accept all protocols, i.e. legacy keys, aes128, etc. so we downgrade to whatever
-            // the client has proposed. this will change in the future
-            debug!(
-                "using the protocol version proposed by the client: {:?}",
-                self.proposed_protocol_version()
-            )
-        }
-
        // 1. receive remote ed25519 pubkey alongside ephemeral x25519 pubkey and maybe a flag indicating non-legacy client
        // LOCAL_ID_PUBKEY || EPHEMERAL_KEY || MAYBE_NON_LEGACY
        let init_message = Initialisation::try_from_bytes(&raw_init_message)?;
        self.update_remote_identity(init_message.identity);
+        self.set_aes256_gcm_siv_key_derivation(!init_message.is_legacy());

        // 2. derive shared keys locally
        // hkdf::<blake3>::(g^xy)
-        self.derive_shared_key(&init_message.ephemeral_dh, &init_message.initiator_salt);
+        self.derive_shared_key(
+            &init_message.ephemeral_dh,
+            init_message.initiator_salt.as_deref(),
+        );

        // 3. send ephemeral x25519 pubkey alongside the encrypted signature
        // g^y || AES(k, sig(gate_priv, (g^y || g^x))
@@ -66,12 +39,7 @@ impl<S, R> State<'_, S, R> {
        self.send_handshake_data(material).await?;

        // 4. wait for the remote response with their own encrypted signature
-        let (materials, client_protocol) =
-            self.receive_handshake_message::<MaterialExchange>().await?;
-        if client_protocol != self.proposed_protocol_version() {
-            warn!("the client hasn't accepted our proposed protocol version. we suggested {:?} while it returned {client_protocol:?}", self.proposed_protocol_version());
-            // TBD what to do here
-        }
+        let materials = self.receive_handshake_message::<MaterialExchange>().await?;

        // 5. verify the received signature using the locally derived keys
        self.verify_remote_key_material(&materials, &init_message.ephemeral_dh)?;
@@ -86,7 +54,7 @@ impl<S, R> State<'_, S, R> {
    pub(crate) async fn perform_gateway_handshake(
        mut self,
        raw_init_message: Vec<u8>,
-    ) -> Result<HandshakeResult, HandshakeError>
+    ) -> Result<SharedGatewayKey, HandshakeError>
    where
        S: Stream<Item = WsItem> + Sink<WsMessage> + Unpin,
    {
@@ -4,7 +4,7 @@
 use crate::registration::handshake::error::HandshakeError;
 use crate::registration::handshake::KDF_SALT_LENGTH;
 use nym_crypto::asymmetric::{ed25519, x25519};
-use nym_crypto::symmetric::aead::{nonce_size, tag_size, Nonce};
+use nym_crypto::symmetric::aead::{nonce_size, tag_size};
 use nym_sphinx::params::GatewayEncryptionAlgorithm;

 // it is vital nobody changes the serialisation implementation unless you have an EXTREMELY good reason,
@@ -21,13 +21,20 @@ pub trait HandshakeMessage {
 pub struct Initialisation {
    pub identity: ed25519::PublicKey,
    pub ephemeral_dh: x25519::PublicKey,
-    pub initiator_salt: Vec<u8>,
+    pub initiator_salt: Option<Vec<u8>>,
+}
+
+impl Initialisation {
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn is_legacy(&self) -> bool {
+        self.initiator_salt.is_none()
+    }
 }

 #[derive(Debug)]
 pub struct MaterialExchange {
    pub signature_ciphertext: Vec<u8>,
-    pub nonce: Nonce<GatewayEncryptionAlgorithm>,
+    pub nonce: Option<Vec<u8>>,
 }

 impl MaterialExchange {
@@ -61,16 +68,21 @@ impl Finalization {
 }

 impl HandshakeMessage for Initialisation {
-    // LOCAL_ID_PUBKEY || EPHEMERAL_KEY || SALT
+    // LOCAL_ID_PUBKEY || EPHEMERAL_KEY || MAYBE_SALT
    // Eventually the ID_PUBKEY prefix will get removed and recipient will know
    // initializer's identity from another source.
    fn into_bytes(self) -> Vec<u8> {
-        self.identity
+        let bytes = self
+            .identity
            .to_bytes()
            .into_iter()
-            .chain(self.ephemeral_dh.to_bytes())
-            .chain(self.initiator_salt)
-            .collect()
+            .chain(self.ephemeral_dh.to_bytes());
+
+        if let Some(salt) = self.initiator_salt {
+            bytes.chain(salt).collect()
+        } else {
+            bytes.collect()
+        }
    }

    // this will need to be adjusted when REMOTE_ID_PUBKEY is removed
@@ -78,24 +90,25 @@ impl HandshakeMessage for Initialisation {
    where
        Self: Sized,
    {
-        let current_len = ed25519::PUBLIC_KEY_LENGTH + x25519::PUBLIC_KEY_SIZE + KDF_SALT_LENGTH;
-        if bytes.len() != current_len {
+        let legacy_len = ed25519::PUBLIC_KEY_LENGTH + x25519::PUBLIC_KEY_SIZE;
+        let current_len = legacy_len + KDF_SALT_LENGTH;
+        if bytes.len() != legacy_len && bytes.len() != current_len {
            return Err(HandshakeError::MalformedRequest);
        }

        let identity = ed25519::PublicKey::from_bytes(&bytes[..ed25519::PUBLIC_KEY_LENGTH])
            .map_err(|_| HandshakeError::MalformedRequest)?;

-        // SAFETY: this can only fail if the provided bytes have len different from encryption::PUBLIC_KEY_SIZE
+        // this can only fail if the provided bytes have len different from encryption::PUBLIC_KEY_SIZE
        // which is impossible
-        #[allow(clippy::unwrap_used)]
-        let ephemeral_dh = x25519::PublicKey::from_bytes(
-            &bytes
-                [ed25519::PUBLIC_KEY_LENGTH..ed25519::PUBLIC_KEY_LENGTH + x25519::PUBLIC_KEY_SIZE],
-        )
-        .unwrap();
+        let ephemeral_dh =
+            x25519::PublicKey::from_bytes(&bytes[ed25519::PUBLIC_KEY_LENGTH..legacy_len]).unwrap();

-        let initiator_salt = bytes[ed25519::PUBLIC_KEY_LENGTH + x25519::PUBLIC_KEY_SIZE..].to_vec();
+        let initiator_salt = if bytes.len() == legacy_len {
+            None
+        } else {
+            Some(bytes[legacy_len..].to_vec())
+        };

        Ok(Initialisation {
            identity,
@@ -108,31 +121,43 @@ impl HandshakeMessage for Initialisation {
 impl HandshakeMessage for MaterialExchange {
    // AES(k, SIG(PRIV_GATE, G^y || G^x))
    fn into_bytes(self) -> Vec<u8> {
-        self.signature_ciphertext
-            .iter()
-            .cloned()
-            .chain(self.nonce)
-            .collect()
+        if let Some(nonce) = self.nonce {
+            self.signature_ciphertext
+                .iter()
+                .cloned()
+                .chain(nonce)
+                .collect()
+        } else {
+            self.signature_ciphertext.to_vec()
+        }
    }

    fn try_from_bytes(bytes: &[u8]) -> Result<Self, HandshakeError>
    where
        Self: Sized,
    {
+        // we expect to receive either:
+        // LEGACY: ed25519 signature ciphertext (64 bytes)
        // CURRENT: ed25519 signature ciphertext (+ tag) + AES256-GCM-SIV nonce (76 bytes)
-        let current_len = ed25519::SIGNATURE_LENGTH
+        let legacy_len = ed25519::SIGNATURE_LENGTH;
+        let current_len = legacy_len
            + tag_size::<GatewayEncryptionAlgorithm>()
            + nonce_size::<GatewayEncryptionAlgorithm>();

-        if bytes.len() != current_len {
+        if bytes.len() != legacy_len && bytes.len() != current_len {
            return Err(HandshakeError::MalformedResponse);
        }

-        let ciphertext_len = ed25519::SIGNATURE_LENGTH + tag_size::<GatewayEncryptionAlgorithm>();
-        let signature_ciphertext = bytes[..ciphertext_len].to_vec();
-
-        // SAFETY: we know the bytes have correct length
-        let nonce = Nonce::<GatewayEncryptionAlgorithm>::clone_from_slice(&bytes[ciphertext_len..]);
+        let (signature_ciphertext, nonce) = if bytes.len() == current_len {
+            let ciphertext_len =
+                ed25519::SIGNATURE_LENGTH + tag_size::<GatewayEncryptionAlgorithm>();
+            (
+                bytes[..ciphertext_len].to_vec(),
+                Some(bytes[ciphertext_len..].to_vec()),
+            )
+        } else {
+            (bytes.to_vec(), None)
+        };

        Ok(MaterialExchange {
            signature_ciphertext,
@@ -169,7 +194,6 @@ impl HandshakeMessage for GatewayMaterialExchange {

        // this can only fail if the provided bytes have len different from PUBLIC_KEY_SIZE
        // which is impossible
-        #[allow(clippy::unwrap_used)]
        let ephemeral_dh =
            x25519::PublicKey::from_bytes(&bytes[..x25519::PUBLIC_KEY_SIZE]).unwrap();
        let materials = MaterialExchange::try_from_bytes(&bytes[x25519::PUBLIC_KEY_SIZE..])?;
@@ -3,7 +3,7 @@

 use self::error::HandshakeError;
 use crate::registration::handshake::state::State;
-use crate::{GatewayProtocolVersion, SharedSymmetricKey};
+use crate::SharedGatewayKey;
 use futures::future::BoxFuture;
 use futures::{Sink, Stream};
 use nym_crypto::asymmetric::ed25519;
@@ -34,29 +34,24 @@ pub const KDF_SALT_LENGTH: usize = 16;
 // we do not need to worry about that.

 pub struct GatewayHandshake<'a> {
-    handshake_future: BoxFuture<'a, Result<HandshakeResult, HandshakeError>>,
+    handshake_future: BoxFuture<'a, Result<SharedGatewayKey, HandshakeError>>,
 }

 impl Future for GatewayHandshake<'_> {
-    type Output = Result<HandshakeResult, HandshakeError>;
+    type Output = Result<SharedGatewayKey, HandshakeError>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        Pin::new(&mut self.handshake_future).poll(cx)
    }
 }

-#[derive(Debug, PartialEq)]
-pub struct HandshakeResult {
-    pub negotiated_protocol: GatewayProtocolVersion,
-    pub derived_key: SharedSymmetricKey,
-}
-
 pub fn client_handshake<'a, S, R>(
    rng: &'a mut R,
    ws_stream: &'a mut S,
    identity: &'a ed25519::KeyPair,
    gateway_pubkey: ed25519::PublicKey,
-    gateway_protocol: GatewayProtocolVersion,
+    expects_credential_usage: bool,
+    derive_aes256_gcm_siv_key: bool,
    #[cfg(not(target_arch = "wasm32"))] shutdown_token: ShutdownToken,
 ) -> GatewayHandshake<'a>
 where
@@ -68,10 +63,11 @@ where
        ws_stream,
        identity,
        Some(gateway_pubkey),
-        gateway_protocol,
        #[cfg(not(target_arch = "wasm32"))]
        shutdown_token,
-    );
+    )
+    .with_credential_usage(expects_credential_usage)
+    .with_aes256_gcm_siv_key(derive_aes256_gcm_siv_key);

    GatewayHandshake {
        handshake_future: Box::pin(state.perform_client_handshake()),
@@ -84,21 +80,13 @@ pub fn gateway_handshake<'a, S, R>(
    ws_stream: &'a mut S,
    identity: &'a ed25519::KeyPair,
    received_init_payload: Vec<u8>,
-    requested_client_protocol: GatewayProtocolVersion,
    shutdown_token: ShutdownToken,
 ) -> GatewayHandshake<'a>
 where
    S: Stream<Item = WsItem> + Sink<WsMessage> + Unpin + Send + 'a,
    R: CryptoRng + RngCore + Send,
 {
-    let state = State::new(
-        rng,
-        ws_stream,
-        identity,
-        None,
-        requested_client_protocol,
-        shutdown_token,
-    );
+    let state = State::new(rng, ws_stream, identity, None, shutdown_token);
    GatewayHandshake {
        handshake_future: Box::pin(state.perform_gateway_handshake(received_init_payload)),
    }
@@ -125,8 +113,7 @@ DONE(status)
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::{ClientControlRequest, CURRENT_PROTOCOL_VERSION};
-    use anyhow::{bail, Context};
+    use crate::ClientControlRequest;
    use futures::StreamExt;
    use nym_test_utils::helpers::u64_seeded_rng;
    use nym_test_utils::mocks::stream_sink::mock_streams;
@@ -134,53 +121,10 @@ mod tests {
    use tokio::join;
    use tungstenite::Message;

-    trait ClientControlRequestExt {
-        async fn get_handshake_init_data(&mut self) -> anyhow::Result<Vec<u8>> {
-            let ClientControlRequest::RegisterHandshakeInitRequest {
-                protocol_version: _,
-                data,
-            } = self.get_control_request().await?
-            else {
-                bail!("unexpected ClientControlRequest")
-            };
-            Ok(data)
-        }
-        async fn get_control_request(&mut self) -> anyhow::Result<ClientControlRequest>;
-    }
+    #[tokio::test]
+    async fn basic_handshake() -> anyhow::Result<()> {
+        use anyhow::Context as _;

-    impl<T> ClientControlRequestExt for T
-    where
-        T: Stream<Item = WsItem> + Unpin,
-    {
-        async fn get_control_request(&mut self) -> anyhow::Result<ClientControlRequest> {
-            let msg = self
-                .next()
-                .timeboxed()
-                .await
-                .context("timeout")?
-                .context("no message!")??
-                .into_text()?
-                .parse::<ClientControlRequest>()?;
-            Ok(msg)
-        }
-    }
-
-    struct Party<R: 'static, S: 'static> {
-        rng: &'static mut R,
-        keys: &'static mut ed25519::KeyPair,
-        socket: &'static mut S,
-    }
-
-    fn setup() -> (
-        Party<
-            impl CryptoRng + RngCore + Send,
-            impl Stream<Item = WsItem> + Sink<WsMessage> + Unpin,
-        >,
-        Party<
-            impl CryptoRng + RngCore + Send,
-            impl Stream<Item = WsItem> + Sink<WsMessage> + Unpin,
-        >,
-    ) {
        // solve the lifetime issue by just leaking the contents of the boxes
        // which is perfectly fine in test
        let client_rng = u64_seeded_rng(42).leak();
@@ -198,97 +142,51 @@ mod tests {
        let client_ws = client_ws.leak();
        let gateway_ws = gateway_ws.leak();

-        (
-            Party {
-                rng: client_rng,
-                keys: client_keys,
-                socket: client_ws,
-            },
-            Party {
-                rng: gateway_rng,
-                keys: gateway_keys,
-                socket: gateway_ws,
-            },
-        )
-    }
-
-    #[tokio::test]
-    async fn basic_handshake() -> anyhow::Result<()> {
-        let (client, gateway) = setup();
-
        let handshake_client = client_handshake(
-            client.rng,
-            client.socket,
-            client.keys,
-            *gateway.keys.public_key(),
-            CURRENT_PROTOCOL_VERSION,
+            client_rng,
+            client_ws,
+            client_keys,
+            *gateway_keys.public_key(),
+            false,
+            true,
            ShutdownToken::default(),
        );

        let client_fut = handshake_client.spawn_timeboxed();

        // we need to receive the first message so that it could be propagated to the gateway side of the handshake
-        let init_msg = gateway.socket.get_handshake_init_data().await?;
+        let ClientControlRequest::RegisterHandshakeInitRequest {
+            protocol_version: _,
+            data,
+        } = (gateway_ws.next())
+            .timeboxed()
+            .await
+            .context("timeout")?
+            .context("no message!")??
+            .into_text()?
+            .parse::<ClientControlRequest>()?
+        else {
+            panic!("bad message")
+        };
+
+        let init_msg = data;

        let handshake_gateway = gateway_handshake(
-            gateway.rng,
-            gateway.socket,
-            gateway.keys,
+            gateway_rng,
+            gateway_ws,
+            gateway_keys,
            init_msg,
-            CURRENT_PROTOCOL_VERSION,
            ShutdownToken::default(),
        );

        let gateway_fut = handshake_gateway.spawn_timeboxed();
        let (client, gateway) = join!(client_fut, gateway_fut);

-        let client_res = client???;
-        let gateway_res = gateway???;
+        let client_key = client???;
+        let gateway_key = gateway???;

        // ensure the created keys are the same
-        assert_eq!(client_res, gateway_res);
-        assert_eq!(client_res.negotiated_protocol, CURRENT_PROTOCOL_VERSION);
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn protocol_downgrade() -> anyhow::Result<()> {
-        let (client, gateway) = setup();
-
-        let handshake_client = client_handshake(
-            client.rng,
-            client.socket,
-            client.keys,
-            *gateway.keys.public_key(),
-            CURRENT_PROTOCOL_VERSION + 42,
-            ShutdownToken::default(),
-        );
-
-        let client_fut = handshake_client.spawn_timeboxed();
-        // we need to receive the first message so that it could be propagated to the gateway side of the handshake
-        let init_msg = gateway.socket.get_handshake_init_data().await?;
-
-        let handshake_gateway = gateway_handshake(
-            gateway.rng,
-            gateway.socket,
-            gateway.keys,
-            init_msg,
-            CURRENT_PROTOCOL_VERSION + 42,
-            ShutdownToken::default(),
-        );
-
-        let gateway_fut = handshake_gateway.spawn_timeboxed();
-        let (client, gateway) = join!(client_fut, gateway_fut);
-
-        let client_res = client???;
-        let gateway_res = gateway???;
-
-        // ensure the created keys are the same
-        assert_eq!(client_res, gateway_res);
-
-        // and the protocol got downgraded for both parties
-        assert_eq!(client_res.negotiated_protocol, CURRENT_PROTOCOL_VERSION);
+        assert_eq!(client_key, gateway_key);

        Ok(())
    }
@@ -5,11 +5,12 @@ use crate::registration::handshake::error::HandshakeError;
 use crate::registration::handshake::messages::{
    HandshakeMessage, Initialisation, MaterialExchange,
 };
-use crate::registration::handshake::{
-    HandshakeResult, SharedSymmetricKey, WsItem, KDF_SALT_LENGTH,
-};
+use crate::registration::handshake::{SharedGatewayKey, WsItem, KDF_SALT_LENGTH};
 use crate::shared_key::SharedKeySize;
-use crate::{types, GatewayProtocolVersion};
+use crate::{
+    types, LegacySharedKeySize, LegacySharedKeys, SharedSymmetricKey, AES_GCM_SIV_PROTOCOL_VERSION,
+    CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION, INITIAL_PROTOCOL_VERSION,
+};
 use futures::{Sink, SinkExt, Stream, StreamExt};
 use nym_crypto::asymmetric::{ed25519, x25519};
 use nym_crypto::symmetric::aead::random_nonce;
@@ -47,15 +48,18 @@ pub(crate) struct State<'a, S, R> {
    ephemeral_keypair: x25519::KeyPair,

    /// The derived shared key using the ephemeral keys of both parties.
-    derived_shared_keys: Option<SharedSymmetricKey>,
+    derived_shared_keys: Option<SharedGatewayKey>,

    /// The known or received public identity key of the remote.
    /// Ideally it would always be known before the handshake was initiated.
    remote_pubkey: Option<ed25519::PublicKey>,

-    /// Version of the protocol to use during the handshake that also implicitly specifies
-    /// additional features
-    protocol_version: GatewayProtocolVersion,
+    // this field is really out of place here, however, we need to propagate this information somehow
+    // in order to establish correct protocol for backwards compatibility reasons
+    expects_credential_usage: bool,
+
+    /// Specifies whether the end product should be an AES128Ctr + blake3 HMAC keys (legacy) or AES256-GCM-SIV (current)
+    derive_aes256_gcm_siv_key: bool,

    // channel to receive shutdown signal
    #[cfg(not(target_arch = "wasm32"))]
@@ -68,7 +72,6 @@ impl<'a, S, R> State<'a, S, R> {
        ws_stream: &'a mut S,
        identity: &'a ed25519::KeyPair,
        remote_pubkey: Option<ed25519::PublicKey>,
-        protocol_version: GatewayProtocolVersion,
        #[cfg(not(target_arch = "wasm32"))] shutdown_token: ShutdownToken,
    ) -> Self
    where
@@ -81,39 +84,52 @@ impl<'a, S, R> State<'a, S, R> {
            ephemeral_keypair,
            identity,
            remote_pubkey,
-            protocol_version,
            derived_shared_keys: None,
+            // later on this should become the default
+            expects_credential_usage: false,
+            derive_aes256_gcm_siv_key: false,
            #[cfg(not(target_arch = "wasm32"))]
            shutdown_token,
        }
    }

+    pub(crate) fn with_credential_usage(mut self, expects_credential_usage: bool) -> Self {
+        self.expects_credential_usage = expects_credential_usage;
+        self
+    }
+
+    pub(crate) fn with_aes256_gcm_siv_key(mut self, derive_aes256_gcm_siv_key: bool) -> Self {
+        self.derive_aes256_gcm_siv_key = derive_aes256_gcm_siv_key;
+        self
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(crate) fn set_aes256_gcm_siv_key_derivation(&mut self, derive_aes256_gcm_siv_key: bool) {
+        self.derive_aes256_gcm_siv_key = derive_aes256_gcm_siv_key;
+    }
+
    #[cfg(not(target_arch = "wasm32"))]
    pub(crate) fn local_ephemeral_key(&self) -> &x25519::PublicKey {
        self.ephemeral_keypair.public_key()
    }

-    pub(crate) fn proposed_protocol_version(&self) -> GatewayProtocolVersion {
-        self.protocol_version
-    }
-
-    pub(crate) fn set_protocol_version(&mut self, protocol_version: GatewayProtocolVersion) {
-        self.protocol_version = protocol_version;
-    }
-
-    pub(crate) fn generate_initiator_salt(&mut self) -> Vec<u8>
+    pub(crate) fn maybe_generate_initiator_salt(&mut self) -> Option<Vec<u8>>
    where
        R: CryptoRng + RngCore,
    {
-        let mut salt = vec![0u8; KDF_SALT_LENGTH];
-        self.rng.fill_bytes(&mut salt);
-        salt
+        if self.derive_aes256_gcm_siv_key {
+            let mut salt = vec![0u8; KDF_SALT_LENGTH];
+            self.rng.fill_bytes(&mut salt);
+            Some(salt)
+        } else {
+            None
+        }
    }

-    // LOCAL_ID_PUBKEY || EPHEMERAL_KEY || SALT
+    // LOCAL_ID_PUBKEY || EPHEMERAL_KEY || MAYBE_SALT
    // Eventually the ID_PUBKEY prefix will get removed and recipient will know
    // initializer's identity from another source.
-    pub(crate) fn init_message(&self, initiator_salt: Vec<u8>) -> Initialisation {
+    pub(crate) fn init_message(&self, initiator_salt: Option<Vec<u8>>) -> Initialisation {
        Initialisation {
            identity: *self.identity.public_key(),
            ephemeral_dh: *self.ephemeral_keypair.public_key(),
@@ -131,30 +147,37 @@ impl<'a, S, R> State<'a, S, R> {
    pub(crate) fn derive_shared_key(
        &mut self,
        remote_ephemeral_key: &x25519::PublicKey,
-        initiator_salt: &[u8],
+        initiator_salt: Option<&[u8]>,
    ) {
        let dh_result = self
            .ephemeral_keypair
            .private_key()
            .diffie_hellman(remote_ephemeral_key);

-        let key_size = SharedKeySize::to_usize();
+        let key_size = if self.derive_aes256_gcm_siv_key {
+            SharedKeySize::to_usize()
+        } else {
+            LegacySharedKeySize::to_usize()
+        };

-        // SAFETY: there is no reason for this to fail as our okm is expected to be only 16 bytes
-        #[allow(clippy::expect_used)]
+        // there is no reason for this to fail as our okm is expected to be only 16 bytes
        let okm = hkdf::extract_then_expand::<GatewaySharedKeyHkdfAlgorithm>(
-            Some(initiator_salt),
+            initiator_salt,
            &dh_result,
            None,
            key_size,
        )
        .expect("somehow too long okm was provided");

-        // SAFETY: the okm has been expanded to the length expected by the corresponding keys
-        #[allow(clippy::expect_used)]
-        let shared_key = SharedSymmetricKey::try_from_bytes(&okm)
-            .expect("okm was expanded to incorrect length!");
-
+        let shared_key = if self.derive_aes256_gcm_siv_key {
+            let current_key = SharedSymmetricKey::try_from_bytes(&okm)
+                .expect("okm was expanded to incorrect length!");
+            SharedGatewayKey::Current(current_key)
+        } else {
+            let legacy_key = LegacySharedKeys::try_from_bytes(&okm)
+                .expect("okm was expanded to incorrect length!");
+            SharedGatewayKey::Legacy(legacy_key)
+        };
        self.derived_shared_keys = Some(shared_key)
    }

@@ -173,16 +196,19 @@ impl<'a, S, R> State<'a, S, R> {
            .collect();
        let signature = self.identity.private_key().sign(plaintext);

-        let mut rng = thread_rng();
-        let nonce = random_nonce::<GatewayEncryptionAlgorithm, _>(&mut rng);
+        let nonce = if self.derive_aes256_gcm_siv_key {
+            let mut rng = thread_rng();
+            Some(random_nonce::<GatewayEncryptionAlgorithm, _>(&mut rng).to_vec())
+        } else {
+            None
+        };

        // SAFETY: this function is only called after the local key has already been derived
-        #[allow(clippy::expect_used)]
        let signature_ciphertext = self
            .derived_shared_keys
            .as_ref()
            .expect("shared key was not derived!")
-            .encrypt(&signature.to_bytes(), &nonce)?;
+            .encrypt_naive(&signature.to_bytes(), nonce.as_deref())?;

        Ok(MaterialExchange {
            signature_ciphertext,
@@ -196,16 +222,20 @@ impl<'a, S, R> State<'a, S, R> {
        remote_ephemeral_key: &x25519::PublicKey,
    ) -> Result<(), HandshakeError> {
        // SAFETY: this function is only called after the local key has already been derived
-        #[allow(clippy::expect_used)]
        let derived_shared_key = self
            .derived_shared_keys
            .as_ref()
            .expect("shared key was not derived!");

+        // if the [client] init message contained non-legacy flag, the associated nonce MUST be present
+        if self.derive_aes256_gcm_siv_key && remote_response.nonce.is_none() {
+            return Err(HandshakeError::MissingNonceForCurrentKey);
+        }
+
        // first decrypt received data
-        let decrypted_signature = derived_shared_key.decrypt(
+        let decrypted_signature = derived_shared_key.decrypt_naive(
            &remote_response.signature_ciphertext,
-            &remote_response.nonce,
+            remote_response.nonce.as_deref(),
        )?;

        // now verify signature itself
@@ -219,7 +249,6 @@ impl<'a, S, R> State<'a, S, R> {
            .chain(self.ephemeral_keypair.public_key().to_bytes())
            .collect();

-        #[allow(clippy::unwrap_used)]
        self.remote_pubkey
            .as_ref()
            .unwrap()
@@ -232,10 +261,7 @@ impl<'a, S, R> State<'a, S, R> {
        self.remote_pubkey = Some(remote_pubkey)
    }

-    #[allow(clippy::complexity)]
-    fn on_wg_msg(
-        msg: Option<WsItem>,
-    ) -> Result<Option<(Vec<u8>, GatewayProtocolVersion)>, HandshakeError> {
+    fn on_wg_msg(msg: Option<WsItem>) -> Result<Option<Vec<u8>>, HandshakeError> {
        let Some(msg) = msg else {
            return Err(HandshakeError::ClosedStream);
        };
@@ -251,10 +277,9 @@ impl<'a, S, R> State<'a, S, R> {
                            // hehe, that's a bit disgusting that the type system requires we explicitly ignore the
                            // protocol_version field that we actually never attach at this point
                            // yet another reason for the overdue refactor
-                            types::RegistrationHandshake::HandshakePayload {
-                                protocol_version,
-                                data,
-                            } => Ok(Some((data, protocol_version))),
+                            types::RegistrationHandshake::HandshakePayload { data, .. } => {
+                                Ok(Some(data))
+                            }
                            types::RegistrationHandshake::HandshakeError { message } => {
                                Err(HandshakeError::RemoteError(message))
                            }
@@ -274,9 +299,7 @@ impl<'a, S, R> State<'a, S, R> {
    }

    #[cfg(not(target_arch = "wasm32"))]
-    async fn _receive_handshake_message_bytes(
-        &mut self,
-    ) -> Result<(Vec<u8>, GatewayProtocolVersion), HandshakeError>
+    async fn _receive_handshake_message_bytes(&mut self) -> Result<Vec<u8>, HandshakeError>
    where
        S: Stream<Item = WsItem> + Unpin,
    {
@@ -295,9 +318,7 @@ impl<'a, S, R> State<'a, S, R> {
    }

    #[cfg(target_arch = "wasm32")]
-    async fn _receive_handshake_message_bytes(
-        &mut self,
-    ) -> Result<(Vec<u8>, GatewayProtocolVersion), HandshakeError>
+    async fn _receive_handshake_message_bytes(&mut self) -> Result<Vec<u8>, HandshakeError>
    where
        S: Stream<Item = WsItem> + Unpin,
    {
@@ -310,22 +331,20 @@ impl<'a, S, R> State<'a, S, R> {
        }
    }

-    pub(crate) async fn receive_handshake_message<M>(
-        &mut self,
-    ) -> Result<(M, GatewayProtocolVersion), HandshakeError>
+    pub(crate) async fn receive_handshake_message<M>(&mut self) -> Result<M, HandshakeError>
    where
        S: Stream<Item = WsItem> + Unpin,
        M: HandshakeMessage,
    {
        // TODO: make timeout duration configurable
-        let (bytes, protocol) = timeout(
+        let bytes = timeout(
            Duration::from_secs(5),
            self._receive_handshake_message_bytes(),
        )
        .await
        .map_err(|_| HandshakeError::Timeout)??;

-        M::try_from_bytes(&bytes).map(|msg| (msg, protocol))
+        M::try_from_bytes(&bytes)
    }

    // upon receiving this, the receiver should terminate the handshake
@@ -338,11 +357,21 @@ impl<'a, S, R> State<'a, S, R> {
    {
        let handshake_message = types::RegistrationHandshake::new_error(message);
        self.ws_stream
-            .send(WsMessage::Text(handshake_message.into()))
+            .send(WsMessage::Text(handshake_message.try_into().unwrap()))
            .await
            .map_err(|_| HandshakeError::ClosedStream)
    }

+    fn request_protocol_version(&self) -> u8 {
+        if self.derive_aes256_gcm_siv_key {
+            AES_GCM_SIV_PROTOCOL_VERSION
+        } else if self.expects_credential_usage {
+            CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION
+        } else {
+            INITIAL_PROTOCOL_VERSION
+        }
+    }
+
    pub(crate) async fn send_handshake_data<M>(
        &mut self,
        inner_message: M,
@@ -355,23 +384,18 @@ impl<'a, S, R> State<'a, S, R> {

        let handshake_message = types::RegistrationHandshake::new_payload(
            inner_message.into_bytes(),
-            self.protocol_version,
+            self.request_protocol_version(),
        );
        self.ws_stream
-            .send(WsMessage::Text(handshake_message.into()))
+            .send(WsMessage::Text(handshake_message.try_into().unwrap()))
            .await
            .map_err(|_| HandshakeError::ClosedStream)
    }

    /// Finish the handshake, yielding the derived shared key and implicitly dropping all borrowed
    /// values.
-    pub(crate) fn finalize_handshake(self) -> HandshakeResult {
-        // SAFETY: handshake can't be finalised without deriving the shared keys
-        #[allow(clippy::unwrap_used)]
-        HandshakeResult {
-            negotiated_protocol: self.proposed_protocol_version(),
-            derived_key: self.derived_shared_keys.unwrap(),
-        }
+    pub(crate) fn finalize_handshake(self) -> SharedGatewayKey {
+        self.derived_shared_keys.unwrap()
    }

    // If any step along the way failed (that are non-network related),
@@ -1,141 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_crypto::blake3;
-use nym_crypto::crypto_hash::compute_digest;
-use nym_crypto::generic_array::{typenum::Unsigned, GenericArray};
-use nym_crypto::symmetric::aead::{
-    self, nonce_size, random_nonce, AeadError, AeadKey, KeySizeUser, Nonce,
-};
-use nym_pemstore::traits::PemStorableKey;
-use nym_sphinx::params::GatewayEncryptionAlgorithm;
-use rand::thread_rng;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};
-
-pub type SharedKeySize = <GatewayEncryptionAlgorithm as KeySizeUser>::KeySize;
-
-#[derive(Debug, Error)]
-pub enum SharedKeyUsageError {
-    #[error("the request is too short")]
-    TooShortRequest,
-
-    #[error("provided MAC is invalid")]
-    InvalidMac,
-
-    #[error("the provided nonce (or legacy IV) did not have the expected length")]
-    MalformedNonce,
-
-    #[error("did not provide a valid nonce for aead encryption")]
-    MissingAeadNonce,
-
-    #[error("failed to either encrypt or decrypt provided message")]
-    AeadFailure(#[from] AeadError),
-}
-
-#[derive(Debug, PartialEq, Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]
-pub struct SharedSymmetricKey(AeadKey<GatewayEncryptionAlgorithm>);
-
-type KeySize = <GatewayEncryptionAlgorithm as KeySizeUser>::KeySize;
-
-#[derive(Debug, Clone, Copy, Error)]
-pub enum SharedKeyConversionError {
-    #[error("the string representation of the shared key was malformed: {0}")]
-    DecodeError(#[from] bs58::decode::Error),
-    #[error(
-        "the received shared keys had invalid size. Got: {received}, but expected: {expected}"
-    )]
-    InvalidSharedKeysSize { received: usize, expected: usize },
-}
-
-impl SharedSymmetricKey {
-    pub fn random_nonce(&self) -> Nonce<GatewayEncryptionAlgorithm> {
-        let mut rng = thread_rng();
-        random_nonce::<GatewayEncryptionAlgorithm, _>(&mut rng)
-    }
-
-    pub fn nonce_size(&self) -> usize {
-        nonce_size::<GatewayEncryptionAlgorithm>()
-    }
-
-    pub fn validate_aead_nonce(
-        raw: &[u8],
-    ) -> Result<Nonce<GatewayEncryptionAlgorithm>, SharedKeyUsageError> {
-        if raw.len() != nonce_size::<GatewayEncryptionAlgorithm>() {
-            return Err(SharedKeyUsageError::MalformedNonce);
-        }
-        Ok(Nonce::<GatewayEncryptionAlgorithm>::clone_from_slice(raw))
-    }
-    pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, SharedKeyConversionError> {
-        if bytes.len() != KeySize::to_usize() {
-            return Err(SharedKeyConversionError::InvalidSharedKeysSize {
-                received: bytes.len(),
-                expected: KeySize::to_usize(),
-            });
-        }
-
-        Ok(SharedSymmetricKey(GenericArray::clone_from_slice(bytes)))
-    }
-
-    pub fn zeroizing_clone(&self) -> Zeroizing<Self> {
-        Zeroizing::new(SharedSymmetricKey(self.0))
-    }
-
-    pub fn digest(&self) -> Vec<u8> {
-        compute_digest::<blake3::Hasher>(self.as_bytes()).to_vec()
-    }
-
-    pub fn as_bytes(&self) -> &[u8] {
-        self.0.as_slice()
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        self.0.iter().copied().collect()
-    }
-
-    pub fn try_from_base58_string<S: Into<String>>(
-        val: S,
-    ) -> Result<Self, SharedKeyConversionError> {
-        let bs58_str = Zeroizing::new(val.into());
-        let decoded = Zeroizing::new(bs58::decode(bs58_str).into_vec()?);
-        Self::try_from_bytes(&decoded)
-    }
-
-    pub fn to_base58_string(&self) -> String {
-        let bytes = Zeroizing::new(self.to_bytes());
-        bs58::encode(bytes).into_string()
-    }
-
-    pub fn encrypt(
-        &self,
-        plaintext: &[u8],
-        nonce: &Nonce<GatewayEncryptionAlgorithm>,
-    ) -> Result<Vec<u8>, SharedKeyUsageError> {
-        aead::encrypt::<GatewayEncryptionAlgorithm>(&self.0, nonce, plaintext).map_err(Into::into)
-    }
-
-    pub fn decrypt(
-        &self,
-        ciphertext: &[u8],
-        nonce: &Nonce<GatewayEncryptionAlgorithm>,
-    ) -> Result<Vec<u8>, SharedKeyUsageError> {
-        aead::decrypt::<GatewayEncryptionAlgorithm>(&self.0, nonce, ciphertext).map_err(Into::into)
-    }
-}
-
-impl PemStorableKey for SharedSymmetricKey {
-    type Error = SharedKeyConversionError;
-
-    fn pem_type() -> &'static str {
-        "AES-256-GCM-SIV GATEWAY SHARED KEY"
-    }
-
-    fn to_bytes(&self) -> Vec<u8> {
-        self.to_bytes()
-    }
-
-    fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error> {
-        Self::try_from_bytes(bytes)
-    }
-}
@@ -0,0 +1,98 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::{LegacySharedKeys, SharedGatewayKey, SharedKeyUsageError, SharedSymmetricKey};
+use nym_crypto::symmetric::aead::random_nonce;
+use nym_crypto::symmetric::stream_cipher::random_iv;
+use nym_sphinx::params::{GatewayEncryptionAlgorithm, LegacyGatewayEncryptionAlgorithm};
+use rand::thread_rng;
+
+pub trait SymmetricKey {
+    fn random_nonce_or_iv(&self) -> Vec<u8>;
+
+    fn encrypt(
+        &self,
+        plaintext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError>;
+
+    fn decrypt(
+        &self,
+        ciphertext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError>;
+}
+
+impl SymmetricKey for SharedGatewayKey {
+    fn random_nonce_or_iv(&self) -> Vec<u8> {
+        self.random_nonce_or_iv()
+    }
+
+    fn encrypt(
+        &self,
+        plaintext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        self.encrypt(plaintext, nonce)
+    }
+
+    fn decrypt(
+        &self,
+        ciphertext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        self.decrypt(ciphertext, nonce)
+    }
+}
+
+impl SymmetricKey for SharedSymmetricKey {
+    fn random_nonce_or_iv(&self) -> Vec<u8> {
+        let mut rng = thread_rng();
+
+        random_nonce::<GatewayEncryptionAlgorithm, _>(&mut rng).to_vec()
+    }
+
+    fn encrypt(
+        &self,
+        plaintext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        let nonce = SharedGatewayKey::validate_aead_nonce(nonce)?;
+        self.encrypt(plaintext, &nonce)
+    }
+
+    fn decrypt(
+        &self,
+        ciphertext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        let nonce = SharedGatewayKey::validate_aead_nonce(nonce)?;
+        self.decrypt(ciphertext, &nonce)
+    }
+}
+
+impl SymmetricKey for LegacySharedKeys {
+    fn random_nonce_or_iv(&self) -> Vec<u8> {
+        let mut rng = thread_rng();
+
+        random_iv::<LegacyGatewayEncryptionAlgorithm, _>(&mut rng).to_vec()
+    }
+
+    fn encrypt(
+        &self,
+        plaintext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        let iv = SharedGatewayKey::validate_cipher_iv(nonce)?;
+        Ok(self.encrypt_and_tag(plaintext, iv))
+    }
+
+    fn decrypt(
+        &self,
+        ciphertext: &[u8],
+        nonce: Option<&[u8]>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        let iv = SharedGatewayKey::validate_cipher_iv(nonce)?;
+        self.decrypt_tagged(ciphertext, iv)
+    }
+}
@@ -0,0 +1,241 @@
+// Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::registration::handshake::KDF_SALT_LENGTH;
+use crate::shared_key::SharedSymmetricKey;
+use crate::shared_key::{SharedKeyConversionError, SharedKeySize, SharedKeyUsageError};
+use crate::LegacyGatewayMacSize;
+use nym_crypto::generic_array::{
+    typenum::{Sum, Unsigned, U16},
+    GenericArray,
+};
+use nym_crypto::hkdf;
+use nym_crypto::hmac::{compute_keyed_hmac, recompute_keyed_hmac_and_verify_tag};
+use nym_crypto::symmetric::stream_cipher::{self, CipherKey, KeySizeUser, IV};
+use nym_pemstore::traits::PemStorableKey;
+use nym_sphinx::params::{
+    GatewayIntegrityHmacAlgorithm, GatewaySharedKeyHkdfAlgorithm, LegacyGatewayEncryptionAlgorithm,
+};
+use rand::{thread_rng, RngCore};
+use serde::{Deserialize, Serialize};
+use zeroize::{Zeroize, ZeroizeOnDrop, Zeroizing};
+
+// shared key is as long as the encryption key and the MAC key combined.
+pub type LegacySharedKeySize = Sum<EncryptionKeySize, MacKeySize>;
+
+// we're using 16 byte long key in sphinx, so let's use the same one here
+type MacKeySize = U16;
+type EncryptionKeySize = <LegacyGatewayEncryptionAlgorithm as KeySizeUser>::KeySize;
+
+/// Shared key used when computing MAC for messages exchanged between client and its gateway.
+pub type MacKey = GenericArray<u8, MacKeySize>;
+
+#[derive(Debug, PartialEq, Serialize, Deserialize, Zeroize, ZeroizeOnDrop)]
+pub struct LegacySharedKeys {
+    encryption_key: CipherKey<LegacyGatewayEncryptionAlgorithm>,
+    mac_key: MacKey,
+}
+
+impl LegacySharedKeys {
+    pub fn upgrade(&self) -> (SharedSymmetricKey, Vec<u8>) {
+        let mut rng = thread_rng();
+        let mut salt = vec![0u8; KDF_SALT_LENGTH];
+        rng.fill_bytes(&mut salt);
+
+        let legacy_bytes = Zeroizing::new(self.to_bytes());
+        let okm = hkdf::extract_then_expand::<GatewaySharedKeyHkdfAlgorithm>(
+            Some(&salt),
+            &legacy_bytes,
+            None,
+            SharedKeySize::to_usize(),
+        )
+        .expect("somehow too long okm was provided");
+
+        let key = SharedSymmetricKey::try_from_bytes(&okm)
+            .expect("okm was expanded to incorrect length!");
+        (key, salt)
+    }
+
+    pub fn upgrade_verify(
+        &self,
+        salt: &[u8],
+        expected_digest: &[u8],
+    ) -> Option<SharedSymmetricKey> {
+        let legacy_bytes = Zeroizing::new(self.to_bytes());
+        let okm = hkdf::extract_then_expand::<GatewaySharedKeyHkdfAlgorithm>(
+            Some(salt),
+            &legacy_bytes,
+            None,
+            SharedKeySize::to_usize(),
+        )
+        .expect("somehow too long okm was provided");
+        let key = SharedSymmetricKey::try_from_bytes(&okm)
+            .expect("okm was expanded to incorrect length!");
+        if key.digest() != expected_digest {
+            // no need to zeroize  that key since it's malformed and we won't be using it anyway
+            None
+        } else {
+            Some(key)
+        }
+    }
+
+    pub fn try_from_bytes(bytes: &[u8]) -> Result<Self, SharedKeyConversionError> {
+        if bytes.len() != LegacySharedKeySize::to_usize() {
+            return Err(SharedKeyConversionError::InvalidSharedKeysSize {
+                received: bytes.len(),
+                expected: LegacySharedKeySize::to_usize(),
+            });
+        }
+
+        let encryption_key =
+            GenericArray::clone_from_slice(&bytes[..EncryptionKeySize::to_usize()]);
+        let mac_key = GenericArray::clone_from_slice(&bytes[EncryptionKeySize::to_usize()..]);
+
+        Ok(LegacySharedKeys {
+            encryption_key,
+            mac_key,
+        })
+    }
+
+    /// Encrypts the provided data using the optionally provided initialisation vector,
+    /// or a 0 value if nothing was given.
+    /// It does **NOT** attach any integrity macs on the produced ciphertext
+    pub fn encrypt_without_tagging(
+        &self,
+        data: &[u8],
+        iv: Option<&IV<LegacyGatewayEncryptionAlgorithm>>,
+    ) -> Vec<u8> {
+        match iv {
+            Some(iv) => stream_cipher::encrypt::<LegacyGatewayEncryptionAlgorithm>(
+                self.encryption_key(),
+                iv,
+                data,
+            ),
+            None => {
+                let zero_iv = stream_cipher::zero_iv::<LegacyGatewayEncryptionAlgorithm>();
+                stream_cipher::encrypt::<LegacyGatewayEncryptionAlgorithm>(
+                    self.encryption_key(),
+                    &zero_iv,
+                    data,
+                )
+            }
+        }
+    }
+
+    /// Encrypts the provided data using the optionally provided initialisation vector,
+    /// or a 0 value if nothing was given. Then it computes an integrity mac and concatenates it
+    /// with the previously produced ciphertext.
+    pub fn encrypt_and_tag(
+        &self,
+        data: &[u8],
+        iv: Option<&IV<LegacyGatewayEncryptionAlgorithm>>,
+    ) -> Vec<u8> {
+        let ciphertext = self.encrypt_without_tagging(data, iv);
+        let mac = compute_keyed_hmac::<GatewayIntegrityHmacAlgorithm>(
+            self.mac_key().as_slice(),
+            &ciphertext,
+        );
+
+        mac.into_bytes().into_iter().chain(ciphertext).collect()
+    }
+
+    pub fn decrypt_without_tag(
+        &self,
+        ciphertext: &[u8],
+        iv: Option<&IV<LegacyGatewayEncryptionAlgorithm>>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        let zero_iv = stream_cipher::zero_iv::<LegacyGatewayEncryptionAlgorithm>();
+        let iv = iv.unwrap_or(&zero_iv);
+        Ok(stream_cipher::decrypt::<LegacyGatewayEncryptionAlgorithm>(
+            self.encryption_key(),
+            iv,
+            ciphertext,
+        ))
+    }
+
+    pub fn decrypt_tagged(
+        &self,
+        enc_data: &[u8],
+        iv: Option<&IV<LegacyGatewayEncryptionAlgorithm>>,
+    ) -> Result<Vec<u8>, SharedKeyUsageError> {
+        let mac_size = LegacyGatewayMacSize::to_usize();
+        if enc_data.len() < mac_size {
+            return Err(SharedKeyUsageError::TooShortRequest);
+        }
+
+        let mac_tag = &enc_data[..mac_size];
+        let message_bytes = &enc_data[mac_size..];
+
+        if !recompute_keyed_hmac_and_verify_tag::<GatewayIntegrityHmacAlgorithm>(
+            self.mac_key().as_slice(),
+            message_bytes,
+            mac_tag,
+        ) {
+            return Err(SharedKeyUsageError::InvalidMac);
+        }
+
+        // couldn't have made the first borrow mutable as you can't have an immutable borrow
+        // together with a mutable one
+        let mut message_bytes_mut = message_bytes.to_vec();
+
+        let zero_iv = stream_cipher::zero_iv::<LegacyGatewayEncryptionAlgorithm>();
+        let iv = iv.unwrap_or(&zero_iv);
+        stream_cipher::decrypt_in_place::<LegacyGatewayEncryptionAlgorithm>(
+            self.encryption_key(),
+            iv,
+            &mut message_bytes_mut,
+        );
+        Ok(message_bytes_mut)
+    }
+
+    pub fn encryption_key(&self) -> &CipherKey<LegacyGatewayEncryptionAlgorithm> {
+        &self.encryption_key
+    }
+
+    pub fn mac_key(&self) -> &MacKey {
+        &self.mac_key
+    }
+
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.encryption_key
+            .iter()
+            .copied()
+            .chain(self.mac_key.iter().copied())
+            .collect()
+    }
+
+    pub fn try_from_base58_string<S: Into<String>>(
+        val: S,
+    ) -> Result<Self, SharedKeyConversionError> {
+        let decoded = bs58::decode(val.into()).into_vec()?;
+        LegacySharedKeys::try_from_bytes(&decoded)
+    }
+
+    pub fn to_base58_string(&self) -> String {
+        bs58::encode(self.to_bytes()).into_string()
+    }
+}
+
+impl From<LegacySharedKeys> for String {
+    fn from(keys: LegacySharedKeys) -> Self {
+        keys.to_base58_string()
+    }
+}
+
+impl PemStorableKey for LegacySharedKeys {
+    type Error = SharedKeyConversionError;
+
+    fn pem_type() -> &'static str {
+        // TODO: If common\nymsphinx\params\src\lib::GatewayIntegrityHmacAlgorithm changes
+        // the pem type needs updating!
+        "AES-128-CTR + HMAC-BLAKE3 GATEWAY SHARED KEYS"
+    }
+
+    fn to_bytes(&self) -> Vec<u8> {
+        self.to_bytes()
+    }
+
+    fn from_bytes(bytes: &[u8]) -> Result<Self, Self::Error> {
+        Self::try_from_bytes(bytes)
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
jmwample	b90a75266f	place-holder attempting compatibility	2025-12-05 17:09:43 -07:00
jmwample	26b537e256	keep details provided by topology instead of just a url	2025-12-05 13:39:34 -07:00