add 10 recommended nodes

Yana/explorer caching

.github/workflows/cd-docs.yml

@@ -5,7 +5,7 @@ on:
 
 jobs:
   build:
-    runs-on: arc-ubuntu-20.04
+    runs-on: arc-ubuntu-22.04
     defaults:
       run:
         working-directory: documentation/docs
@@ -18,7 +18,7 @@ jobs:
       - name: Install Python3 modules
         run: sudo pip3 install pandas tabulate
       - name: Install rsync
-        run: sudo apt-get install rsync
+        run: sudo apt-get install -y rsync
       - uses: rlespinasse/github-slug-action@v3.x
       - name: Setup pnpm
         uses: pnpm/action-setup@v4.0.0

.github/workflows/ci-binary-config-checker.yml

@@ -33,7 +33,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [arc-ubuntu-20.04]
+        platform: [arc-ubuntu-22.04]
 
     runs-on: ${{ matrix.platform }}
     steps:

.github/workflows/ci-build-ts.yml

@@ -10,7 +10,7 @@ on:
 
 jobs:
   build:
-    runs-on: arc-ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
     - uses: actions/checkout@v4
     - name: Install rsync
@@ -19,7 +19,7 @@ jobs:
     - uses: rlespinasse/github-slug-action@v3.x
     - uses: actions/setup-node@v4
       with:
-        node-version: 18
+        node-version: 20
     - name: Setup yarn
       run: npm install -g yarn
     - name: Build

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

@@ -21,7 +21,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [ arc-ubuntu-20.04 ]
+        platform: [ arc-ubuntu-22.04 ]
 
     runs-on: ${{ matrix.platform }}
     env:

.github/workflows/ci-build.yml

@@ -38,7 +38,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ arc-ubuntu-20.04, custom-windows-11, custom-runner-mac-m1 ]
+        os: [ arc-ubuntu-22.04, custom-windows-11, custom-runner-mac-m1 ]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
@@ -102,6 +102,8 @@ jobs:
       - name: Run all tests
         if: contains(matrix.os, 'ubuntu')
         uses: actions-rs/cargo@v1
+        env:
+          NYM_API: https://sandbox-nym-api1.nymtech.net/api
         with:
           command: test
           args: --workspace

.github/workflows/ci-contracts-schema.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   check-schema:
     name: Generate and check schema
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     env:
       CARGO_TERM_COLOR: always
     steps:

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

@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [ arc-ubuntu-20.04 ]
+        platform: [ arc-ubuntu-22.04 ]
 
     runs-on: ${{ matrix.platform }}
     env:

.github/workflows/ci-contracts.yml

@@ -17,7 +17,7 @@ jobs:
   build:
     # since it's going to be compiled into wasm, there's absolutely
     # no point in running CI on different OS-es
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     env:
       CARGO_TERM_COLOR: always
     steps:

.github/workflows/ci-docs.yml

@@ -10,7 +10,7 @@ on:
 
 jobs:
   build:
-    runs-on: arc-ubuntu-20.04
+    runs-on: arc-ubuntu-22.04
     env:
       RUSTUP_PERMIT_COPY_RENAME: 1
     defaults:
@@ -25,7 +25,7 @@ jobs:
       - name: Install Python3 modules
         run: sudo pip3 install pandas tabulate
       - name: Install rsync
-        run: sudo apt-get install rsync
+        run: sudo apt-get install -y rsync
       - uses: rlespinasse/github-slug-action@v3.x
       - name: Setup pnpm
         uses: pnpm/action-setup@v4.0.0

.github/workflows/ci-lint-typescript.yml

@@ -15,7 +15,7 @@ on:
 
 jobs:
   build:
-    runs-on: arc-ubuntu-20.04
+    runs-on: ubuntu-22.04
     env:
       RUSTUP_PERMIT_COPY_RENAME: 1
     steps:
@@ -24,7 +24,7 @@ jobs:
 
       - uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: 20
       - name: Setup yarn
         run: npm install -g yarn
 

.github/workflows/ci-nym-network-explorer.yml

@@ -1,92 +0,0 @@
-name: ci-nym-network-explorer
-
-on:
-  workflow_dispatch:
-  push:
-    paths:
-      - 'explorer/**'
-      - '.github/workflows/ci-nym-network-explorer.yml'
-
-defaults:
-  run:
-    working-directory: explorer
-
-jobs:
-  build:
-    runs-on: custom-linux
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install rsync
-      run: sudo apt-get install rsync
-      continue-on-error: true
-    - uses: rlespinasse/github-slug-action@v3.x
-    - uses: actions/setup-node@v4
-      with:
-        node-version: 18
-    - name: Setup yarn
-      run: npm install -g yarn
-      continue-on-error: true
-    - name: Build shared packages
-      run: cd .. && yarn && yarn build
-    - name: Set environment from the example
-      run: cp .env.prod .env
-#    - run: yarn test
-#      continue-on-error: true
-    - run: yarn && yarn build
-      continue-on-error: true
-    - run: yarn storybook:build
-      name: Build storybook
-    - name: Deploy branch to CI www
-      continue-on-error: true
-      uses: easingthemes/ssh-deploy@main
-      env:
-        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-        ARGS: "-rltgoDzvO --delete"
-        SOURCE: "explorer/dist/"
-        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/network-explorer-${{ env.GITHUB_REF_SLUG }}
-        EXCLUDE: "/dist/, /node_modules/"
-    - name: Deploy storybook to CI www
-      continue-on-error: true
-      uses: easingthemes/ssh-deploy@main
-      env:
-        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-        ARGS: "-rltgoDzvO --delete"
-        SOURCE: "explorer/storybook-static/"
-        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ne-sb-${{ env.GITHUB_REF_SLUG }}
-        EXCLUDE: "/dist/, /node_modules/"
-    - name: Matrix - Node Install
-      run: npm install
-      working-directory: .github/workflows/support-files
-    - name: Matrix - Send Notification
-      env:
-        NYM_NOTIFICATION_KIND: network-explorer
-        NYM_PROJECT_NAME: "Network Explorer"
-        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-        NYM_CI_WWW_LOCATION: "network-explorer-${{ env.GITHUB_REF_SLUG }}"
-        NYM_CI_WWW_LOCATION_STORYBOOK: "ne-sb-${{ env.GITHUB_REF_SLUG }}"
-        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-        GIT_BRANCH: "${GITHUB_REF##*/}"
-        IS_SUCCESS: "${{ job.status == 'success' }}"
-        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
-        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-      uses: docker://keybaseio/client:stable-node
-      with:
-        args: .github/workflows/support-files/notifications/entry_point.sh
-    - name: Deploy
-      if: github.event_name == 'workflow_dispatch'
-      uses: easingthemes/ssh-deploy@main
-      env:
-        SSH_PRIVATE_KEY: ${{ secrets.CD_PROD_NE_SSH_PRIVATE_KEY }}
-        ARGS: "-rltgoDzvO --delete"
-        SOURCE: "explorer/dist/"
-        REMOTE_HOST: ${{ secrets.CD_PROD_NE_REMOTE_HOST }}
-        REMOTE_USER: ${{ secrets.CD_PROD_NE_REMOTE_USER }}
-        TARGET: ${{ secrets.CD_PROD_NE_REMOTE_TARGET }}
-        EXCLUDE: "/dist/, /node_modules/"

.github/workflows/ci-nym-wallet-rust.yml

@@ -11,13 +11,17 @@ on:
 
 jobs:
   build:
-    runs-on: arc-ubuntu-20.04
+    runs-on: arc-ubuntu-22.04
     env:
       CARGO_TERM_COLOR: always
       RUSTUP_PERMIT_COPY_RENAME: 1
     steps:
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y libdbus-1-dev libmnl-dev libnftnl-dev \
+            libwebkit2gtk-4.1-dev build-essential curl wget libssl-dev jq \
+            libgtk-3-dev squashfs-tools libayatana-appindicator3-dev make libfuse2 unzip librsvg2-dev file \
+            libsoup-3.0-dev libjavascriptcoregtk-4.1-dev
         continue-on-error: true
 
       - name: Check out repository code

.github/workflows/ci-sdk-wasm.yml

@@ -11,7 +11,7 @@ on:
 
 jobs:
   wasm:
-    runs-on: arc-ubuntu-20.04
+    runs-on: arc-ubuntu-22.04
     env:
       CARGO_TERM_COLOR: always
       RUSTUP_PERMIT_COPY_RENAME: 1
@@ -20,7 +20,7 @@ jobs:
 
       - uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: 20
 
       - uses: actions-rs/toolchain@v1
         with:

.github/workflows/nightly-build.yml

@@ -11,7 +11,7 @@ jobs:
       fail-fast: false
       matrix:
         rust: [stable, beta]
-        os: [ubuntu-20.04, windows-latest, macos-latest]
+        os: [ubuntu-22.04, windows-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
@@ -23,7 +23,7 @@ jobs:
 
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
 
       - name: Install Rust toolchain
         uses: actions-rs/toolchain@v1
@@ -59,7 +59,7 @@ jobs:
 
       # To avoid running out of disk space, skip generating debug symbols
       - name: Set debug to false (unix)
-        if: matrix.os == 'ubuntu-20.04' || matrix.os == 'macos-latest'
+        if: matrix.os == 'ubuntu-22.04' || matrix.os == 'macos-latest'
         run: |
           sed -i.bak 's/\[profile.dev\]/\[profile.dev\]\ndebug = false/' Cargo.toml
           git diff
@@ -106,7 +106,7 @@ jobs:
         uses: actions/setup-node@v4
         if: env.WORKFLOW_CONCLUSION == 'failure'
         with:
-          node-version: 18
+          node-version: 20
       - name: Matrix - Node Install
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install

.github/workflows/nightly-nym-wallet-build.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macos-latest, windows-latest]
+        os: [ubuntu-22.04, macos-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
@@ -22,7 +22,7 @@ jobs:
 
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
 
       - name: Install rust toolchain
         uses: actions-rs/toolchain@v1
@@ -68,7 +68,7 @@ jobs:
         uses: actions/setup-node@v4
         if: env.WORKFLOW_CONCLUSION == 'failure'
         with:
-          node-version: 18
+          node-version: 20
       - name: Matrix - Node Install
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install

.github/workflows/nightly-security-audit.yml

@@ -5,7 +5,7 @@ on:
     - cron: '5 9 * * *'
 jobs:
   cargo-deny:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout repository code
         uses: actions/checkout@v4
@@ -38,7 +38,7 @@ jobs:
       - name: install npm
         uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: 20
       - name: Matrix - Node Install
         run: npm install
         working-directory: .github/workflows/support-files

.github/workflows/nym-api-integration-tests.yml

@@ -0,0 +1,47 @@
+name: Integration Tests
+
+on:
+  pull_request:
+    paths:
+      - "nym-api/**"
+      - "tests/**"
+  workflow_dispatch:
+
+jobs:
+  integration-tests:
+    runs-on: ubuntu-latest
+    env:
+      API_BASE_URL: http://localhost:8000
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+
+      - name: Install dependencies
+        run: sudo apt-get update && sudo apt-get install -y pkg-config libssl-dev
+
+      - name: Build nym-api
+        run: cargo build --package nym-api
+
+      - name: Run nym-api in the background
+        run: |
+          ./target/debug/nym-api &
+
+      - name: Wait for nym-api to come alive
+        run: |
+          for i in {1..20}; do
+            curl -sSf http://localhost:8000/v1/status/config-score-details && break
+            echo "Waiting for nym-api to start..."
+            sleep 2
+          done
+
+      - name: Run integration tests
+        env:
+          NYM_API: https://sandbox-nym-api1.nymtech.net/api
+        run: cargo test --test public-api-tests -- --nocapture

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

@@ -20,7 +20,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [custom-ubuntu-20.04]
+        platform: [custom-ubuntu-22.04]
     runs-on: ${{ matrix.platform }}
 
     outputs:

.github/workflows/publish-nym-wallet-macos.yml

@@ -18,11 +18,7 @@ jobs:
     runs-on: ${{ matrix.platform }}
 
     outputs:
-      release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
-      version: ${{ steps.release-info.outputs.version }}
-      filename: ${{ steps.release-info.outputs.filename }}
-      file_hash: ${{ steps.release-info.outputs.file_hash }}
+      release_tag: ${{ github.ref_name }}
 
     steps:
       - uses: actions/checkout@v4
@@ -31,10 +27,18 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: 21
+          
       - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
+          
+      - name: Add Rust target for x86_64-apple-darwin
+        run: rustup target add x86_64-apple-darwin
+
+      - name: Set Cargo build target to x86_64
+        run: echo "CARGO_BUILD_TARGET=x86_64-apple-darwin" >> $GITHUB_ENV
+          
       - name: Install the Apple developer certificate for code signing
         env:
           APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
@@ -64,11 +68,19 @@ jobs:
           fileName: '.env'
           encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
 
+      - name: Yarn cache clean
+        shell: bash
+        run: cd .. && yarn cache clean
+
       - name: Install project dependencies
         shell: bash
         run: cd .. && yarn --network-timeout 100000
 
-      - name: Install app dependencies and build it
+      - name: Yarn build
+        shell: bash
+        run: cd .. && yarn build
+
+      - name: Install dependencies and build it
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
@@ -78,46 +90,48 @@ jobs:
           APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
           APPLE_ID: ${{ secrets.APPLE_ID }}
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-        run: yarn && yarn build
+          # Tauri v2 specific environment variables
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          TAURI_NOTARIZATION_USERNAME: ${{ secrets.APPLE_ID }}
+          TAURI_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          TAURI_NOTARIZATION_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          yarn build-macx86 
+
+      - name: Create app tarball
+        run: |
+          # Navigate to where the app bundle is and create the tarball
+          cd target/x86_64-apple-darwin/release/bundle/macos
+          echo "Creating tarball from app bundle"
+          tar -czf nym-wallet.app.tar.gz NymWallet.app
+          cd -
 
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         with:
           name: nym-wallet.app.tar.gz
-          path: nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz
+          path: nym-wallet/target/x86_64-apple-darwin/release/bundle/macos/nym-wallet.app.tar.gz
           retention-days: 5
 
       - name: Clean up keychain
         if: ${{ always() }}
         run: |
           security delete-keychain $RUNNER_TEMP/app-signing.keychain-db
+          
       - id: create-release
         name: Upload to release based on tag name
         uses: softprops/action-gh-release@v2
         if: github.event_name == 'release'
         with:
           files: |
-            nym-wallet/target/release/bundle/dmg/*.dmg
-            nym-wallet/target/release/bundle/macos/*.app.tar.gz*
-
-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"            
+            nym-wallet/target/x86_64-apple-darwin/release/bundle/dmg/*.dmg
+            nym-wallet/target/x86_64-apple-darwin/release/bundle/macos/*.app.tar.gz*
 
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
-      release_tag: ${{ github.ref_name }}
-    secrets: inherit
+      release_tag: ${{ needs.publish-tauri.outputs.release_tag || github.ref_name }}
+    secrets: inherit

.github/workflows/publish-nym-wallet-ubuntu.yml

@@ -3,71 +3,108 @@ on:
   workflow_dispatch:
   release:
     types: [created]
-
 defaults:
   run:
     working-directory: nym-wallet
-
 jobs:
   publish-tauri:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     strategy:
       fail-fast: false
       matrix:
-        platform: [custom-ubuntu-20.04]
+        platform: [ubuntu-22.04]
     runs-on: ${{ matrix.platform }}
-
     outputs:
-      release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
-      version: ${{ steps.release-info.outputs.version }}
-      filename: ${{ steps.release-info.outputs.filename }}
-      file_hash: ${{ steps.release-info.outputs.file_hash }}
-
+      release_tag: ${{ github.ref_name }}
+      
     steps:
       - uses: actions/checkout@v4
-
-      - name: Tauri dependencies
-        run: >
-          sudo apt-get update &&
-          sudo apt-get install -y webkit2gtk-4.0
-        continue-on-error: true
-
+      
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y libdbus-1-dev libmnl-dev libnftnl-dev \
+            libwebkit2gtk-4.1-dev build-essential curl wget libssl-dev jq \
+            libgtk-3-dev squashfs-tools libayatana-appindicator3-dev make libfuse2 unzip librsvg2-dev file \
+            libsoup-3.0-dev libjavascriptcoregtk-4.1-dev
+      
       - name: Node
         uses: actions/setup-node@v4
         with:
           node-version: 21
-
+          cache: 'yarn'
+      
       - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
+        uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
-
+      
       - name: Install project dependencies
         shell: bash
         run: cd .. && yarn --network-timeout 100000
-
+      
       - name: Install app dependencies
         run: yarn
+      
       - name: Create env file
         uses: timheuer/base64-to-file@v1.2
         with:
           fileName: '.env'
           encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
-
+      
       - name: Build app
         run: yarn build
         env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
           TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+      
+      - name: Check bundle directory
+        run: |
+          echo "Checking bundle directory structure"
+          ls -la target/release/bundle || echo "Bundle directory not found"
+          if [ -d "target/release/bundle/appimage" ]; then
+            echo "AppImage bundle directory exists, checking contents:"
+            ls -la target/release/bundle/appimage
+          else
+            echo "AppImage bundle directory not found, checking alternatives:"
+            find target/release/bundle -type d -name "*appimage*" -o -name "*AppImage*" || echo "No AppImage directories found"
+            find target/release/bundle -name "*.AppImage" -o -name "*.appimage" || echo "No AppImage files found"
+          fi
+      
+      - name: Create AppImage tarball if needed
+        run: |
+          # Find the AppImage file
+          APPIMAGE_FILE=$(find target/release/bundle -name "*.AppImage" | head -n 1)
+          if [ -n "$APPIMAGE_FILE" ]; then
+            echo "Found AppImage file: $APPIMAGE_FILE"
+            APPIMAGE_DIR=$(dirname "$APPIMAGE_FILE")
+            APPIMAGE_NAME=$(basename "$APPIMAGE_FILE")
+            
+            # Create tarball if it doesn't exist
+            if [ ! -f "${APPIMAGE_FILE}.tar.gz" ]; then
+              echo "Creating tarball for $APPIMAGE_NAME"
+              cd "$APPIMAGE_DIR"
+              tar -czf "${APPIMAGE_NAME}.tar.gz" "$APPIMAGE_NAME"
+              cd -
+              echo "Created tarball: ${APPIMAGE_FILE}.tar.gz"
+            else
+              echo "Tarball already exists: ${APPIMAGE_FILE}.tar.gz"
+            fi
+          else
+            echo "WARNING: No AppImage file found!"
+          fi
+      
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         with:
-          name: nym-wallet_1.0.0_amd64.AppImage.tar.gz
-          path: nym-wallet/target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz
+          name: nym-wallet-appimage.tar.gz
+          path: |
+            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz
+            nym-wallet/target/release/bundle/*/nym-wallet*.AppImage.tar.gz
           retention-days: 30
-
+      
       - id: create-release
         name: Upload to release based on tag name
         uses: softprops/action-gh-release@v2
@@ -75,24 +112,26 @@ jobs:
         with:
           files: |
             nym-wallet/target/release/bundle/appimage/*.AppImage
-            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz*
-
-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"               
-
+            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz
+            nym-wallet/target/release/bundle/*/nym-wallet*.AppImage
+            nym-wallet/target/release/bundle/*/nym-wallet*.AppImage.tar.gz
+      
+      - name: Find AppImage tarball path for deployment
+        id: find-appimage
+        run: |
+          APPIMAGE_TARBALL=$(find target/release/bundle -name "*.AppImage.tar.gz" | head -n 1)
+          if [ -n "$APPIMAGE_TARBALL" ]; then
+            echo "Found AppImage tarball: $APPIMAGE_TARBALL"
+            echo "appimage_path=$APPIMAGE_TARBALL" >> $GITHUB_OUTPUT
+          else
+            echo "WARNING: No AppImage tarball found for deployment!"
+            echo "appimage_path=target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz" >> $GITHUB_OUTPUT
+          fi
+      
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
-      release_tag: ${{ github.ref_name }}
-    secrets: inherit
+      release_tag: ${{ needs.publish-tauri.outputs.release_tag || github.ref_name }}
+    secrets: inherit

.github/workflows/publish-nym-wallet-win11.yml

@@ -1,6 +1,12 @@
 name: publish-nym-wallet-win11
 on:
   workflow_dispatch:
+    inputs:
+      sign:
+        description: "Sign this build using SSL.com. Signing is billed per signature so be careful"
+        required: false
+        type: boolean
+        default: true
   release:
     types: [created]
 
@@ -18,53 +24,61 @@ jobs:
     runs-on: ${{ matrix.platform }}
 
     outputs:
-      release_id: ${{ steps.create-release.outputs.id }}
-      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
-      version: ${{ steps.release-info.outputs.version }}
-      filename: ${{ steps.release-info.outputs.filename }}
-      file_hash: ${{ steps.release-info.outputs.file_hash }}
+      release_tag: ${{ github.ref_name }}
 
     steps:
-      - name: Clean up first
-        continue-on-error: true
-        working-directory: .
-        run: |
-          cd ..
-          del /s /q /A:H nym
-          rmdir /s /q nym
-
       - uses: actions/checkout@v4
 
-      - name: Import signing certificate
-        env:
-          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
-          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
-        run: |
-          New-Item -ItemType directory -Path certificate
-          Set-Content -Path certificate/tempCert.txt -Value $env:WINDOWS_CERTIFICATE
-          certutil -decode certificate/tempCert.txt certificate/certificate.pfx
-          Remove-Item -path certificate -include tempCert.txt
-          Import-PfxCertificate -FilePath certificate/certificate.pfx -CertStoreLocation Cert:\CurrentUser\My -Password (ConvertTo-SecureString -String $env:WINDOWS_CERTIFICATE_PASSWORD -Force -AsPlainText)
+      - name: Install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+
+      - name: Setup MSBuild.exe
+        uses: microsoft/setup-msbuild@v2
 
       - name: Node
         uses: actions/setup-node@v4
         with:
           node-version: 21
 
-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-
-      - name: Create env file
-        uses: timheuer/base64-to-file@v1.2
-        with:
-          fileName: '.env'
-          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
-
-      - name: Install Yarn
-        run: npm install -g yarn
-
+      - name: Download EV CodeSignTool from ssl.com
+        working-directory: nym-wallet/src-tauri
+        if: ${{ inputs.sign }}
+        shell: bash
+        run: |
+          curl -L0 https://www.ssl.com/download/codesigntool-for-linux-and-macos/ -o codesigntool.zip
+          unzip codesigntool.zip
+      - name: Get EV certificate credential id
+        working-directory: nym-wallet/src-tauri
+        if: ${{ inputs.sign }}
+        id: get_credential_ids
+        shell: bash
+        run: |
+          echo "SSL_COM_CREDENTIAL_ID=$(./CodeSignTool.sh get_credential_ids -username=${{ secrets.SSL_COM_USERNAME }} -password=${{ secrets.SSL_COM_PASSWORD }} | sed -n '1!p' | sed 's/- //')" >> "$GITHUB_OUTPUT"
+      - name: Add custom sign command to tauri.conf.json
+        working-directory: nym-wallet/src-tauri
+        if: ${{ inputs.sign }}
+        shell: bash
+        run: |
+          yq eval --inplace '.bundle.windows +=
+          {
+            "signCommand": {
+              "cmd": "C:\Program Files\Git\bin\bash.EXE",
+              "args": [
+                "/c/actions-runner/_work/nym/nym/nym-wallet/src-tauri/CodeSignTool.sh",
+                "sign",
+                "-username ${{ secrets.SSL_COM_USERNAME }}",
+                "-password ${{ secrets.SSL_COM_PASSWORD }}",
+                "-credential_id ${{ steps.get_credential_ids.outputs.SSL_COM_CREDENTIAL_ID }}",
+                "-totp_secret ${{ secrets.SSL_COM_TOTP_SECRET }}",
+                "-program_name NymWallet",
+                "-input_file_path",
+                "%1",
+                "-override"
+              ]
+            }
+          }' tauri.conf.json
       - name: Install project dependencies
         shell: bash
         run: cd .. && yarn --network-timeout 100000
@@ -77,18 +91,50 @@ jobs:
         shell: bash
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          ENABLE_CODE_SIGNING: ${{ secrets.WINDOWS_CERTIFICATE }}
-          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
-          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
-          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-        run: yarn build
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+          SSL_COM_USERNAME: ${{ inputs.sign && secrets.SSL_COM_USERNAME }}
+          SSL_COM_PASSWORD: ${{ inputs.sign && secrets.SSL_COM_PASSWORD }}
+          SSL_COM_CREDENTIAL_ID: ${{ inputs.sign && steps.get_credential_ids.outputs.SSL_COM_CREDENTIAL_ID }}
+          SSL_COM_TOTP_SECRET: ${{ inputs.sign && secrets.SSL_COM_TOTP_SECRET }}
+        run: |
+          echo "Starting build process..."
+          yarn build
+
+      - name: Check bundle directory
+        shell: bash
+        run: |
+          echo "Checking bundle directory structure"
+          
+          # Check standard location
+          if [ -d "target/release/bundle" ]; then
+            echo "Found bundle directory at standard location"
+            ls -la target/release/bundle || echo "Failed to list bundle directory"
+          fi
+          
+          # Check src-tauri location
+          if [ -d "src-tauri/target/release/bundle" ]; then
+            echo "Found bundle directory in src-tauri"
+            ls -la src-tauri/target/release/bundle || echo "Failed to list src-tauri bundle directory"
+            
+            # Use this path for future steps
+            echo "BUNDLE_PATH=src-tauri/target/release/bundle" >> $GITHUB_ENV
+          else
+            echo "Using standard bundle path"
+            echo "BUNDLE_PATH=target/release/bundle" >> $GITHUB_ENV
+          fi
+          
+          # Check for MSI files in any location
+          find . -name "*.msi" -type f
 
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         with:
-          name: nym-wallet_1.0.0_x64_en-US.msi
-          path: nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi
+          name: nym-wallet.msi
+          path: |
+            nym-wallet/${{ env.BUNDLE_PATH }}/msi/*.msi
+            nym-wallet/${{ env.BUNDLE_PATH }}/*/nym-wallet*.msi
+            nym-wallet/src-tauri/target/release/bundle/msi/*.msi
           retention-days: 30
 
       - id: create-release
@@ -97,25 +143,28 @@ jobs:
         if: github.event_name == 'release'
         with:
           files: |
-            nym-wallet/target/release/bundle/msi/*.msi
-            nym-wallet/target/release/bundle/msi/*.msi.zip*
-
-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"            
+            nym-wallet/${{ env.BUNDLE_PATH }}/msi/*.msi
+            nym-wallet/${{ env.BUNDLE_PATH }}/msi/*.msi.zip*
+            nym-wallet/${{ env.BUNDLE_PATH }}/*/nym-wallet*.msi
+            nym-wallet/src-tauri/target/release/bundle/msi/*.msi
+          
+      - name: Find MSI path for deployment
+        id: find-msi
+        shell: bash
+        run: |
+          MSI_FILE=$(find . -name "*.msi" -type f | head -n 1)
+          if [ -n "$MSI_FILE" ]; then
+            echo "Found MSI file: $MSI_FILE"
+            echo "msi_path=$MSI_FILE" >> $GITHUB_OUTPUT
+          else
+            echo "WARNING: No MSI file found for deployment!"
+            echo "msi_path=${{ env.BUNDLE_PATH }}/msi/nym-wallet*.msi" >> $GITHUB_OUTPUT
+          fi
 
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
-      release_tag: ${{ github.ref_name }}
-    secrets: inherit
+      release_tag: ${{ needs.publish-tauri.outputs.release_tag || github.ref_name }}
+    secrets: inherit

.github/workflows/publish-nyms5-android-apk.yml

@@ -12,7 +12,7 @@ on:
 jobs:
   build:
     name: Build APK
-    runs-on: custom-ubuntu-20.04
+    runs-on: custom-ubuntu-22.04
     env:
       ANDROID_HOME: ${{ github.workspace }}/android-sdk
       NDK_VERSION: 25.2.9519653

.github/workflows/publish-sdk-npm.yml

@@ -4,14 +4,14 @@ on:
 
 jobs:
   publish:
-    runs-on: arc-ubuntu-20.04
+    runs-on: arc-ubuntu-22.04
     steps:
       - uses: actions/checkout@v4
 
       - name: Install Node
         uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: 20
           registry-url: "https://registry.npmjs.org"
 
       - name: Setup yarn

.github/workflows/release-calculate-hash.yml

@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@v4
       - uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: 20
       - uses: nymtech/nym/.github/actions/nym-hash-releases@develop
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Cargo.toml

@@ -39,7 +39,6 @@ members = [
     "common/cosmwasm-smart-contracts/mixnet-contract",
     "common/cosmwasm-smart-contracts/multisig-contract",
     "common/cosmwasm-smart-contracts/vesting-contract",
-    "common/country-group",
     "common/credential-storage",
     "common/credential-utils",
     "common/credential-verification",
@@ -97,9 +96,6 @@ members = [
     "common/wireguard",
     "common/wireguard-types",
     "documentation/autodoc",
-    # "explorer-api",
-    # "explorer-api/explorer-api-requests",
-    # "explorer-api/explorer-client",
     "gateway",
     "integrations/bity",
     "nym-api",
@@ -203,8 +199,8 @@ bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
 bit-vec = "0.7.0"                                     # can we unify those?
 bitvec = "1.0.0"
-blake3 = "1.6.1"
-bloomfilter = "1.0.14"
+blake3 = "1.7.0"
+bloomfilter = "3.0.1"
 bs58 = "0.5.1"
 bytecodec = "0.4.15"
 bytes = "1.10.1"
@@ -215,7 +211,7 @@ chacha20 = "0.9.0"
 chacha20poly1305 = "0.10.1"
 chrono = "0.4.40"
 cipher = "0.4.3"
-clap = "4.5.32"
+clap = "4.5.34"
 clap_complete = "4.5"
 clap_complete_fig = "4.5"
 colored = "2.2"
@@ -270,7 +266,6 @@ indicatif = "0.17.11"
 inquire = "0.6.2"
 ip_network = "0.4.1"
 ipnetwork = "0.20"
-isocountry = "0.3.2"
 itertools = "0.14.0"
 k256 = "0.13"
 lazy_static = "1.5.0"
@@ -283,7 +278,7 @@ moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
 okapi = "0.7.0"
-once_cell = "1.21.1"
+once_cell = "1.21.3"
 opentelemetry = "0.19.0"
 opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.3"
@@ -302,10 +297,7 @@ rand_pcg = "0.3.1"
 rand_seeder = "0.2.3"
 rayon = "1.5.1"
 regex = "1.10.6"
-reqwest = { version = "0.12.4", default-features = false }
-rocket = "0.5.0"
-rocket_cors = "0.6.0"
-rocket_okapi = "0.8.0"
+reqwest = { version = "0.12.15", default-features = false }
 rs_merkle = "1.5.0"
 safer-ffi = "0.1.13"
 schemars = "0.8.22"
@@ -320,7 +312,7 @@ serde_with = "3.9.0"
 serde_yaml = "0.9.25"
 sha2 = "0.10.8"
 si-scale = "0.2.3"
-sphinx-packet = "=0.3.2"
+sphinx-packet = "=0.6.0"
 sqlx = "0.7.4"
 strum = "0.26"
 strum_macros = "0.26"
@@ -331,7 +323,7 @@ tap = "1.0.1"
 tar = "0.4.44"
 tempfile = "3.19"
 thiserror = "2.0"
-time = "0.3.39"
+time = "0.3.41"
 tokio = "1.44"
 tokio-postgres = "0.7"
 tokio-stream = "0.1.17"
@@ -347,9 +339,10 @@ tracing-log = "0.2"
 tracing-opentelemetry = "0.19.0"
 tracing-subscriber = "0.3.19"
 tracing-tree = "0.2.2"
+tracing-indicatif = "0.3.9"
 ts-rs = "10.1.0"
 tungstenite = { version = "0.20.1", default-features = false }
-uniffi = "0.29.0"
+uniffi = "0.29.1"
 uniffi_build = "0.29.0"
 url = "2.5"
 utoipa = "5.2"
@@ -409,6 +402,11 @@ wasm-bindgen-futures = "0.4.49"
 wasmtimer = "0.4.1"
 web-sys = "0.3.76"
 
+
+# for local development:
+#[patch.crates-io]
+#sphinx-packet = { path = "../sphinx" }
+
 # Profile settings for individual crates
 
 # Compile-time verified queries do quite a bit of work at compile time. Incremental

Makefile

@@ -168,8 +168,9 @@ generate-typescript:
 	cd tools/ts-rs-cli && cargo run && cd ../..
 	yarn types:lint:fix
 
+# Run the integration tests for public nym-api endpoints
 run-api-tests:
-	cd nym-api/tests/functional_test && yarn test:qa
+	dotenv -f envs/sandbox.env -- cargo test --test public-api-tests
 
 # Build debian package, and update PPA
 deb-cli: build-nym-cli

clients/native/Cargo.toml

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

clients/socks5/Cargo.toml

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

clients/socks5/src/commands/init.rs

@@ -87,7 +87,6 @@ impl From<Init> for OverrideConfig {
             use_anonymous_replies: init_config.use_reply_surbs,
             fastmode: init_config.common_args.fastmode,
             no_cover: init_config.common_args.no_cover,
-            geo_routing: None,
             medium_toggle: false,
             nyxd_urls: init_config.common_args.nyxd_urls,
             enabled_credentials_mode: init_config.common_args.enabled_credentials_mode,

clients/socks5/src/commands/mod.rs

@@ -16,8 +16,7 @@ use nym_bin_common::bin_info;
 use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_client_core::cli_helpers::CliClient;
 use nym_client_core::client::base_client::storage::migration_helpers::v1_1_33;
-use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
-use nym_client_core::config::{ForgetMe, GroupBy, TopologyStructure};
+use nym_client_core::config::ForgetMe;
 use nym_config::OptionalSet;
 use nym_sphinx::addressing::Recipient;
 use nym_sphinx::params::{PacketSize, PacketType};
@@ -107,7 +106,6 @@ pub(crate) struct OverrideConfig {
     use_anonymous_replies: Option<bool>,
     fastmode: bool,
     no_cover: bool,
-    geo_routing: Option<CountryGroup>,
     medium_toggle: bool,
     nyxd_urls: Option<Vec<url::Url>>,
     enabled_credentials_mode: Option<bool>,
@@ -138,21 +136,6 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
     let secondary_packet_size = args.medium_toggle.then_some(PacketSize::ExtendedPacket16);
     let no_per_hop_delays = args.medium_toggle;
 
-    let topology_structure = if args.medium_toggle {
-        // Use the location of the network-requester
-        let address = config
-            .core
-            .socks5
-            .provider_mix_address
-            .parse()
-            .expect("failed to parse provider mix address");
-        TopologyStructure::GeoAware(GroupBy::NymAddress(address))
-    } else if let Some(code) = args.geo_routing {
-        TopologyStructure::GeoAware(GroupBy::CountryGroup(code))
-    } else {
-        TopologyStructure::default()
-    };
-
     let packet_type = if args.outfox {
         PacketType::Outfox
     } else {
@@ -176,10 +159,6 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
         // NOTE: see comment above about the order of the other disble cover traffic config
         .with_base(BaseClientConfig::with_disabled_cover_traffic, args.no_cover)
         .with_base(BaseClientConfig::with_packet_type, packet_type)
-        .with_base(
-            BaseClientConfig::with_topology_structure,
-            topology_structure,
-        )
         .with_base(BaseClientConfig::with_forget_me, args.forget_me)
         .with_optional(Config::with_anonymous_replies, args.use_anonymous_replies)
         .with_optional(Config::with_port, args.port)

clients/socks5/src/commands/run.rs

@@ -6,7 +6,6 @@ use crate::commands::{override_config, OverrideConfig};
 use clap::Args;
 use nym_client_core::cli_helpers::client_run::CommonClientRunArgs;
 use nym_client_core::client::base_client::storage::OnDiskPersistent;
-use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
 use nym_socks5_client_core::NymClient;
 use nym_sphinx::addressing::clients::Recipient;
 use std::net::IpAddr;
@@ -37,10 +36,6 @@ pub(crate) struct Run {
     #[clap(long)]
     host: Option<IpAddr>,
 
-    /// Set geo-aware mixnode selection when sending mixnet traffic, for experiments only.
-    #[clap(long, hide = true, value_parser = validate_country_group, group="routing")]
-    geo_routing: Option<CountryGroup>,
-
     /// Enable medium mixnet traffic, for experiments only.
     /// This includes things like disabling cover traffic, no per hop delays, etc.
     #[clap(long, hide = true)]
@@ -59,7 +54,6 @@ impl From<Run> for OverrideConfig {
             use_anonymous_replies: run_config.use_anonymous_replies,
             fastmode: run_config.common_args.fastmode,
             no_cover: run_config.common_args.no_cover,
-            geo_routing: run_config.geo_routing,
             medium_toggle: run_config.medium_toggle,
             nyxd_urls: run_config.common_args.nyxd_urls,
             enabled_credentials_mode: run_config.common_args.enabled_credentials_mode,
@@ -70,13 +64,6 @@ impl From<Run> for OverrideConfig {
     }
 }
 
-fn validate_country_group(s: &str) -> Result<CountryGroup, String> {
-    match s.parse() {
-        Ok(cg) => Ok(cg),
-        Err(_) => Err(format!("failed to parse country group: {}", s)),
-    }
-}
-
 pub(crate) async fn execute(args: Run) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
     eprintln!("Starting client {}...", args.common_args.id);
 

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

@@ -13,7 +13,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::encryption::PrivateKey;
+use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
 #[cfg(feature = "verify")]
 use sha2::Sha256;
 
@@ -82,16 +82,14 @@ impl GatewayClient {
         private_ip: IpAddr,
         nonce: u64,
     ) -> Self {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
-        let local_public: x25519_dalek::PublicKey = (&static_secret).into();
+        let local_public = PublicKey::from(local_secret);
+        let remote_public = PublicKey::from(remote_public);
 
-        let dh = static_secret.diffie_hellman(&remote_public);
+        let dh = local_secret.diffie_hellman(&remote_public);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
+        let mut mac = HmacSha256::new_from_slice(&dh[..])
             .expect("x25519 shared secret is always 32 bytes long");
 
         mac.update(local_public.as_bytes());
@@ -99,7 +97,7 @@ impl GatewayClient {
         mac.update(&nonce.to_le_bytes());
 
         GatewayClient {
-            pub_key: PeerPublicKey::new(local_public),
+            pub_key: PeerPublicKey::new(local_public.into()),
             private_ip,
             mac: ClientMac(mac.finalize().into_bytes().to_vec()),
         }
@@ -109,11 +107,8 @@ impl GatewayClient {
     // Client should perform this step when generating its payload, using its own WG PK
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
-
-        let dh = static_secret.diffie_hellman(&self.pub_key);
+        // use gateways key as a ref to an x25519_dalek key
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
@@ -195,15 +190,15 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nym_crypto::asymmetric::encryption;
+    use nym_crypto::asymmetric::x25519;
 
     #[test]
     #[cfg(feature = "verify")]
     fn client_request_roundtrip() {
         let mut rng = rand::thread_rng();
 
-        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
-        let client_key_pair = encryption::KeyPair::new(&mut rng);
+        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
+        let client_key_pair = x25519::KeyPair::new(&mut rng);
 
         let nonce = 1234567890;
 

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

@@ -14,7 +14,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::encryption::PrivateKey;
+use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
 #[cfg(feature = "verify")]
 use sha2::Sha256;
 
@@ -91,16 +91,14 @@ impl GatewayClient {
         private_ip: IpAddr,
         nonce: u64,
     ) -> Self {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
-        let local_public: x25519_dalek::PublicKey = (&static_secret).into();
+        let local_public = PublicKey::from(local_secret);
+        let remote_public = PublicKey::from(remote_public);
 
-        let dh = static_secret.diffie_hellman(&remote_public);
+        let dh = local_secret.diffie_hellman(&remote_public);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
+        let mut mac = HmacSha256::new_from_slice(&dh[..])
             .expect("x25519 shared secret is always 32 bytes long");
 
         mac.update(local_public.as_bytes());
@@ -108,7 +106,7 @@ impl GatewayClient {
         mac.update(&nonce.to_le_bytes());
 
         GatewayClient {
-            pub_key: PeerPublicKey::new(local_public),
+            pub_key: PeerPublicKey::new(local_public.into()),
             private_ip,
             mac: ClientMac(mac.finalize().into_bytes().to_vec()),
         }
@@ -118,11 +116,8 @@ impl GatewayClient {
     // Client should perform this step when generating its payload, using its own WG PK
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
-
-        let dh = static_secret.diffie_hellman(&self.pub_key);
+        // use gateways key as a ref to an x25519_dalek key
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
@@ -204,15 +199,15 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nym_crypto::asymmetric::encryption;
+    use nym_crypto::asymmetric::x25519;
 
     #[test]
     #[cfg(feature = "verify")]
     fn client_request_roundtrip() {
         let mut rng = rand::thread_rng();
 
-        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
-        let client_key_pair = encryption::KeyPair::new(&mut rng);
+        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
+        let client_key_pair = x25519::KeyPair::new(&mut rng);
 
         let nonce = 1234567890;
 

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

@@ -340,7 +340,7 @@ mod tests {
     use std::{net::IpAddr, str::FromStr};
 
     use nym_credentials_interface::CredentialSpendingData;
-    use nym_crypto::asymmetric::encryption::PrivateKey;
+    use nym_crypto::asymmetric::x25519::PrivateKey;
     use nym_sphinx::addressing::Recipient;
     use nym_wireguard_types::PeerPublicKey;
     use x25519_dalek::PublicKey;

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

@@ -14,7 +14,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::encryption::PrivateKey;
+use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
 #[cfg(feature = "verify")]
 use sha2::Sha256;
 
@@ -91,16 +91,14 @@ impl GatewayClient {
         private_ip: IpAddr,
         nonce: u64,
     ) -> Self {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
-        let local_public: x25519_dalek::PublicKey = (&static_secret).into();
+        let local_public = PublicKey::from(local_secret);
+        let remote_public = PublicKey::from(remote_public);
 
-        let dh = static_secret.diffie_hellman(&remote_public);
+        let dh = local_secret.diffie_hellman(&remote_public);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
+        let mut mac = HmacSha256::new_from_slice(&dh[..])
             .expect("x25519 shared secret is always 32 bytes long");
 
         mac.update(local_public.as_bytes());
@@ -108,7 +106,7 @@ impl GatewayClient {
         mac.update(&nonce.to_le_bytes());
 
         GatewayClient {
-            pub_key: PeerPublicKey::new(local_public),
+            pub_key: PeerPublicKey::new(local_public.into()),
             private_ip,
             mac: ClientMac(mac.finalize().into_bytes().to_vec()),
         }
@@ -118,11 +116,8 @@ impl GatewayClient {
     // Client should perform this step when generating its payload, using its own WG PK
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
-
-        let dh = static_secret.diffie_hellman(&self.pub_key);
+        // use gateways key as a ref to an x25519_dalek key
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
@@ -204,15 +199,15 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nym_crypto::asymmetric::encryption;
+    use nym_crypto::asymmetric::x25519;
 
     #[test]
     #[cfg(feature = "verify")]
     fn client_request_roundtrip() {
         let mut rng = rand::thread_rng();
 
-        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
-        let client_key_pair = encryption::KeyPair::new(&mut rng);
+        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
+        let client_key_pair = x25519::KeyPair::new(&mut rng);
 
         let nonce = 1234567890;
 

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

@@ -306,7 +306,7 @@ mod tests {
     };
 
     use nym_credentials_interface::CredentialSpendingData;
-    use nym_crypto::asymmetric::encryption::PrivateKey;
+    use nym_crypto::asymmetric::x25519::PrivateKey;
     use nym_sphinx::addressing::Recipient;
     use nym_wireguard_types::PeerPublicKey;
     use x25519_dalek::PublicKey;

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

@@ -15,7 +15,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::encryption::PrivateKey;
+use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
 #[cfg(feature = "verify")]
 use sha2::Sha256;
 
@@ -143,16 +143,14 @@ impl GatewayClient {
         private_ips: IpPair,
         nonce: u64,
     ) -> Self {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
-        let local_public: x25519_dalek::PublicKey = (&static_secret).into();
+        let local_public = PublicKey::from(local_secret);
+        let remote_public = PublicKey::from(remote_public);
 
-        let dh = static_secret.diffie_hellman(&remote_public);
+        let dh = local_secret.diffie_hellman(&remote_public);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
+        let mut mac = HmacSha256::new_from_slice(&dh[..])
             .expect("x25519 shared secret is always 32 bytes long");
 
         mac.update(local_public.as_bytes());
@@ -160,7 +158,7 @@ impl GatewayClient {
         mac.update(&nonce.to_le_bytes());
 
         GatewayClient {
-            pub_key: PeerPublicKey::new(local_public),
+            pub_key: PeerPublicKey::new(local_public.into()),
             private_ips,
             mac: ClientMac(mac.finalize().into_bytes().to_vec()),
         }
@@ -170,11 +168,8 @@ impl GatewayClient {
     // Client should perform this step when generating its payload, using its own WG PK
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
-
-        let dh = static_secret.diffie_hellman(&self.pub_key);
+        // use gateways key as a ref to an x25519_dalek key
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
@@ -256,7 +251,7 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nym_crypto::asymmetric::encryption;
+    use nym_crypto::asymmetric::x25519;
 
     #[test]
     fn create_ip_pair() {
@@ -271,8 +266,8 @@ mod tests {
     fn client_request_roundtrip() {
         let mut rng = rand::thread_rng();
 
-        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
-        let client_key_pair = encryption::KeyPair::new(&mut rng);
+        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
+        let client_key_pair = x25519::KeyPair::new(&mut rng);
 
         let nonce = 1234567890;
 

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

@@ -230,7 +230,7 @@ mod tests {
     };
 
     use nym_credentials_interface::CredentialSpendingData;
-    use nym_crypto::asymmetric::encryption::PrivateKey;
+    use nym_crypto::asymmetric::x25519::PrivateKey;
     use nym_sphinx::addressing::Recipient;
     use nym_wireguard_types::PeerPublicKey;
     use x25519_dalek::PublicKey;

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

@@ -15,7 +15,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::encryption::PrivateKey;
+use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
 #[cfg(feature = "verify")]
 use sha2::Sha256;
 
@@ -143,16 +143,14 @@ impl GatewayClient {
         private_ips: IpPair,
         nonce: u64,
     ) -> Self {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
-        let local_public: x25519_dalek::PublicKey = (&static_secret).into();
+        let local_public = PublicKey::from(local_secret);
+        let remote_public = PublicKey::from(remote_public);
 
-        let dh = static_secret.diffie_hellman(&remote_public);
+        let dh = local_secret.diffie_hellman(&remote_public);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
+        let mut mac = HmacSha256::new_from_slice(&dh[..])
             .expect("x25519 shared secret is always 32 bytes long");
 
         mac.update(local_public.as_bytes());
@@ -160,7 +158,7 @@ impl GatewayClient {
         mac.update(&nonce.to_le_bytes());
 
         GatewayClient {
-            pub_key: PeerPublicKey::new(local_public),
+            pub_key: PeerPublicKey::new(local_public.into()),
             private_ips,
             mac: ClientMac(mac.finalize().into_bytes().to_vec()),
         }
@@ -170,11 +168,8 @@ impl GatewayClient {
     // Client should perform this step when generating its payload, using its own WG PK
     #[cfg(feature = "verify")]
     pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
-        #[allow(clippy::expect_used)]
-        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
-
-        let dh = static_secret.diffie_hellman(&self.pub_key);
+        // use gateways key as a ref to an x25519_dalek key
+        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
 
         // TODO: change that to use our nym_crypto::hmac module instead
         #[allow(clippy::expect_used)]
@@ -256,7 +251,7 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use nym_crypto::asymmetric::encryption;
+    use nym_crypto::asymmetric::x25519;
 
     #[test]
     fn create_ip_pair() {
@@ -271,8 +266,8 @@ mod tests {
     fn client_request_roundtrip() {
         let mut rng = rand::thread_rng();
 
-        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
-        let client_key_pair = encryption::KeyPair::new(&mut rng);
+        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
+        let client_key_pair = x25519::KeyPair::new(&mut rng);
 
         let nonce = 1234567890;
 

common/bandwidth-controller/src/acquire/mod.rs

@@ -11,7 +11,7 @@ use nym_credentials::ecash::bandwidth::IssuanceTicketBook;
 use nym_credentials::ecash::utils::obtain_aggregate_wallet;
 use nym_credentials::IssuedTicketBook;
 use nym_credentials_interface::TicketType;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_ecash_time::{ecash_default_expiration_date, Date};
 use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nym_api::EpochId;
@@ -31,7 +31,7 @@ where
     C: EcashSigningClient + EcashQueryClient + Sync,
 {
     let mut rng = OsRng;
-    let signing_key = identity::PrivateKey::new(&mut rng);
+    let signing_key = ed25519::PrivateKey::new(&mut rng);
     let expiration = expiration.unwrap_or_else(ecash_default_expiration_date);
 
     let deposit_amount = client.get_required_deposit_amount().await?;

common/bandwidth-controller/src/error.rs

@@ -4,8 +4,8 @@
 use nym_credential_storage::error::StorageError;
 use nym_credentials::error::Error as CredentialsError;
 use nym_credentials_interface::CompactEcashError;
-use nym_crypto::asymmetric::encryption::KeyRecoveryError;
-use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
+use nym_crypto::asymmetric::x25519::KeyRecoveryError;
 use nym_validator_client::coconut::EcashApiError;
 use nym_validator_client::error::ValidatorClientError;
 use thiserror::Error;

common/bin-common/Cargo.toml

@@ -21,6 +21,7 @@ serde_json = { workspace = true, optional = true }
 ## tracing
 tracing-subscriber = { workspace = true, features = ["env-filter"], optional = true }
 tracing-tree = { workspace = true, optional = true }
+tracing = { workspace = true, optional = true }
 opentelemetry-jaeger = { workspace = true, features = ["rt-tokio", "collector_client", "isahc_collector_client"], optional = true }
 tracing-opentelemetry = { workspace = true, optional = true }
 utoipa = { workspace = true, optional = true }
@@ -35,7 +36,7 @@ default = []
 openapi = ["utoipa"]
 output_format = ["serde_json", "dep:clap"]
 bin_info_schema = ["schemars"]
-basic_tracing = ["tracing-subscriber"]
+basic_tracing = ["dep:tracing", "tracing-subscriber"]
 tracing = [
     "basic_tracing",
     "tracing-tree",

common/bin-common/src/logging/mod.rs

@@ -44,10 +44,38 @@ pub fn setup_logging() {
         .init();
 }
 
+// don't call init so that we could attach additional layers
 #[cfg(feature = "basic_tracing")]
-pub fn setup_tracing_logger() {
-    let log_builder = tracing_subscriber::fmt()
-        .with_writer(std::io::stderr)
+pub fn build_tracing_logger() -> impl tracing_subscriber::layer::SubscriberExt {
+    use tracing_subscriber::prelude::*;
+
+    tracing_subscriber::registry()
+        .with(default_tracing_fmt_layer(std::io::stderr))
+        .with(default_tracing_env_filter())
+}
+
+#[cfg(feature = "basic_tracing")]
+pub fn default_tracing_env_filter() -> tracing_subscriber::filter::EnvFilter {
+    if ::std::env::var("RUST_LOG").is_ok() {
+        tracing_subscriber::filter::EnvFilter::from_default_env()
+    } else {
+        // if the env value was not found, default to `INFO` level rather than `ERROR`
+        tracing_subscriber::filter::EnvFilter::builder()
+            .with_default_directive(tracing_subscriber::filter::LevelFilter::INFO.into())
+            .parse_lossy("")
+    }
+}
+
+#[cfg(feature = "basic_tracing")]
+pub fn default_tracing_fmt_layer<S, W>(
+    writer: W,
+) -> impl tracing_subscriber::Layer<S> + Sync + Send + 'static
+where
+    S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
+    W: for<'writer> tracing_subscriber::fmt::MakeWriter<'writer> + Sync + Send + 'static,
+{
+    tracing_subscriber::fmt::layer()
+        .with_writer(writer)
         // Use a more compact, abbreviated log format
         .compact()
         // Display source code file paths
@@ -55,18 +83,13 @@ pub fn setup_tracing_logger() {
         // Display source code line numbers
         .with_line_number(true)
         // Don't display the event's target (module path)
-        .with_target(false);
+        .with_target(false)
+}
 
-    if ::std::env::var("RUST_LOG").is_ok() {
-        log_builder
-            .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
-            .init()
-    } else {
-        // default to 'Info
-        log_builder
-            .with_max_level(tracing_subscriber::filter::LevelFilter::INFO)
-            .init()
-    }
+#[cfg(feature = "basic_tracing")]
+pub fn setup_tracing_logger() {
+    use tracing_subscriber::util::SubscriberInitExt;
+    build_tracing_logger().init()
 }
 
 // TODO: This has to be a macro, running it as a function does not work for the file_appender for some reason

common/client-core/Cargo.toml

@@ -12,7 +12,6 @@ license.workspace = true
 async-trait = { workspace = true }
 base64 = { workspace = true }
 bs58 = { workspace = true }
-cfg-if = { workspace = true }
 clap = { workspace = true, optional = true }
 comfy-table = { workspace = true, optional = true }
 futures = { workspace = true }
@@ -24,7 +23,6 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
 si-scale = { workspace = true }
-tap = { workspace = true }
 thiserror = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 tokio = { workspace = true, features = ["macros"] }
@@ -35,9 +33,7 @@ zeroize = { workspace = true }
 nym-id = { path = "../nym-id" }
 nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
-nym-country-group = { path = "../country-group" }
 nym-crypto = { path = "../crypto" }
-nym-explorer-client = { path = "../../explorer-api/explorer-client" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 nym-gateway-requests = { path = "../gateway-requests" }
 nym-http-api-client = { path = "../http-api-client" }

common/client-core/config-types/Cargo.toml

@@ -14,7 +14,6 @@ url = { workspace = true, features = ["serde"] }
 
 nym-config = { path = "../../config" }
 
-nym-country-group = { path = "../../country-group" }
 nym-pemstore = { path = "../../pemstore", optional = true }
 
 # those are pulling so many deps T.T

common/client-core/config-types/src/lib.rs

@@ -65,11 +65,10 @@ const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60
 
 // stats reporting related
 
-/// Time interval between reporting statistics to the given provider if it exist
+/// Time interval between reporting statistics to the given provider if it exists
 const STATS_REPORT_INTERVAL_SECS: Duration = Duration::from_secs(300);
 
 use crate::error::InvalidTrafficModeFailure;
-pub use nym_country_group::CountryGroup;
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
@@ -258,15 +257,6 @@ impl Config {
         self
     }
 
-    pub fn with_topology_structure(mut self, topology_structure: TopologyStructure) -> Self {
-        self.set_topology_structure(topology_structure);
-        self
-    }
-
-    pub fn set_topology_structure(&mut self, topology_structure: TopologyStructure) {
-        self.debug.topology.topology_structure = topology_structure;
-    }
-
     pub fn with_no_per_hop_delays(mut self, no_per_hop_delays: bool) -> Self {
         if no_per_hop_delays {
             self.set_no_per_hop_delays()
@@ -415,6 +405,14 @@ pub struct Traffic {
     /// Do not set it unless you understand the consequences of that change.
     pub secondary_packet_size: Option<PacketSize>,
 
+    /// Specify whether any constructed sphinx packets should use the legacy format,
+    /// where the payload keys are explicitly attached rather than using the seeds
+    /// this affects any forward packets, acks and reply surbs
+    /// this flag should remain disabled until sufficient number of nodes on the network has upgraded
+    /// and support updated format.
+    /// in the case of reply surbs, the recipient must also understand the new encoding
+    pub use_legacy_sphinx_format: bool,
+
     pub packet_type: PacketType,
 }
 
@@ -442,6 +440,10 @@ impl Default for Traffic {
             primary_packet_size: PacketSize::RegularPacket,
             secondary_packet_size: None,
             packet_type: PacketType::Mix,
+
+            // we should use the legacy format until sufficient number of nodes understand the
+            // improved encoding
+            use_legacy_sphinx_format: true,
         }
     }
 }
@@ -546,9 +548,6 @@ pub struct Topology {
     #[serde(with = "humantime_serde")]
     pub max_startup_gateway_waiting_period: Duration,
 
-    /// Specifies the mixnode topology to be used for sending packets.
-    pub topology_structure: TopologyStructure,
-
     /// Specifies a minimum performance of a mixnode that is used on route construction.
     /// This setting is only applicable when `NymApi` topology is used.
     pub minimum_mixnode_performance: u8,
@@ -570,30 +569,6 @@ pub struct Topology {
     pub ignore_ingress_epoch_role: bool,
 }
 
-#[allow(clippy::large_enum_variant)]
-#[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TopologyStructure {
-    #[default]
-    NymApi,
-    GeoAware(GroupBy),
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupBy {
-    CountryGroup(CountryGroup),
-    NymAddress(Recipient),
-}
-
-impl std::fmt::Display for GroupBy {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GroupBy::CountryGroup(group) => write!(f, "group: {group}"),
-            GroupBy::NymAddress(address) => write!(f, "address: {address}"),
-        }
-    }
-}
-
 impl Default for Topology {
     fn default() -> Self {
         Topology {
@@ -601,7 +576,6 @@ impl Default for Topology {
             topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
             disable_refreshing: false,
             max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
-            topology_structure: TopologyStructure::default(),
             minimum_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
             minimum_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
             use_extended_topology: false,

common/client-core/config-types/src/old/v4.rs

@@ -2,10 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::old::v5::{
-    AcknowledgementsV5, ClientV5, ConfigV5, CoverTrafficV5, DebugConfigV5, GatewayConnectionV5,
-    GroupByV5, ReplySurbsV5, TopologyStructureV5, TopologyV5, TrafficV5,
+    AcknowledgementsV5, ClientV5, ConfigV5, CountryGroupV5, CoverTrafficV5, DebugConfigV5,
+    GatewayConnectionV5, GroupByV5, ReplySurbsV5, TopologyStructureV5, TopologyV5, TrafficV5,
 };
-use crate::CountryGroup;
 use nym_sphinx_addressing::Recipient;
 use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
@@ -369,31 +368,47 @@ impl From<TopologyStructureV4> for TopologyStructureV5 {
     }
 }
 
+#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
+pub enum CountryGroupV4 {
+    Europe,
+    NorthAmerica,
+    SouthAmerica,
+    Oceania,
+    Asia,
+    Africa,
+    Unknown,
+}
+
+impl From<CountryGroupV4> for CountryGroupV5 {
+    fn from(value: CountryGroupV4) -> Self {
+        match value {
+            CountryGroupV4::Europe => CountryGroupV5::Europe,
+            CountryGroupV4::NorthAmerica => CountryGroupV5::NorthAmerica,
+            CountryGroupV4::SouthAmerica => CountryGroupV5::SouthAmerica,
+            CountryGroupV4::Oceania => CountryGroupV5::Oceania,
+            CountryGroupV4::Asia => CountryGroupV5::Asia,
+            CountryGroupV4::Africa => CountryGroupV5::Africa,
+            CountryGroupV4::Unknown => CountryGroupV5::Unknown,
+        }
+    }
+}
+
 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum GroupByV4 {
-    CountryGroup(CountryGroup),
+    CountryGroup(CountryGroupV4),
     NymAddress(Recipient),
 }
 
 impl From<GroupByV4> for GroupByV5 {
     fn from(value: GroupByV4) -> Self {
         match value {
-            GroupByV4::CountryGroup(country) => GroupByV5::CountryGroup(country),
+            GroupByV4::CountryGroup(country) => GroupByV5::CountryGroup(country.into()),
             GroupByV4::NymAddress(addr) => GroupByV5::NymAddress(addr),
         }
     }
 }
 
-impl std::fmt::Display for GroupByV4 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GroupByV4::CountryGroup(group) => write!(f, "group: {}", group),
-            GroupByV4::NymAddress(address) => write!(f, "address: {}", address),
-        }
-    }
-}
-
 impl Default for TopologyV4 {
     fn default() -> Self {
         TopologyV4 {

common/client-core/config-types/src/old/v5.rs

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::{
-    Acknowledgements, Client, Config, CountryGroup, CoverTraffic, DebugConfig, GatewayConnection,
-    GroupBy, ReplySurbs, Topology, TopologyStructure, Traffic,
+    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, GatewayConnection, ReplySurbs,
+    Topology, Traffic,
 };
 use nym_sphinx_addressing::Recipient;
 use nym_sphinx_params::{PacketSize, PacketType};
@@ -146,7 +146,6 @@ impl From<ConfigV5> for Config {
                         .debug
                         .topology
                         .max_startup_gateway_waiting_period,
-                    topology_structure: value.debug.topology.topology_structure.into(),
                     ..Default::default()
                 },
                 reply_surbs: ReplySurbs {
@@ -372,40 +371,24 @@ pub enum TopologyStructureV5 {
     GeoAware(GroupByV5),
 }
 
-impl From<TopologyStructureV5> for TopologyStructure {
-    fn from(value: TopologyStructureV5) -> Self {
-        match value {
-            TopologyStructureV5::NymApi => TopologyStructure::NymApi,
-            TopologyStructureV5::GeoAware(group_by) => TopologyStructure::GeoAware(group_by.into()),
-        }
-    }
+#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
+pub enum CountryGroupV5 {
+    Europe,
+    NorthAmerica,
+    SouthAmerica,
+    Oceania,
+    Asia,
+    Africa,
+    Unknown,
 }
 
 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum GroupByV5 {
-    CountryGroup(CountryGroup),
+    CountryGroup(CountryGroupV5),
     NymAddress(Recipient),
 }
 
-impl From<GroupByV5> for GroupBy {
-    fn from(value: GroupByV5) -> Self {
-        match value {
-            GroupByV5::CountryGroup(country) => GroupBy::CountryGroup(country),
-            GroupByV5::NymAddress(addr) => GroupBy::NymAddress(addr),
-        }
-    }
-}
-
-impl std::fmt::Display for GroupByV5 {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            GroupByV5::CountryGroup(group) => write!(f, "group: {}", group),
-            GroupByV5::NymAddress(address) => write!(f, "address: {}", address),
-        }
-    }
-}
-
 impl Default for TopologyV5 {
     fn default() -> Self {
         TopologyV5 {

common/client-core/gateways-storage/src/error.rs

@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
 use nym_gateway_requests::shared_key::SharedKeyConversionError;
 use thiserror::Error;
 

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

@@ -5,7 +5,7 @@
 #![warn(clippy::unwrap_used)]
 
 use async_trait::async_trait;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_gateway_requests::SharedSymmetricKey;
 use std::error::Error;
 
@@ -36,9 +36,7 @@ pub trait GatewaysDetailsStore {
     async fn all_gateways(&self) -> Result<Vec<GatewayRegistration>, Self::StorageError>;
 
     /// Return identity keys of all registered gateways.
-    async fn all_gateways_identities(
-        &self,
-    ) -> Result<Vec<identity::PublicKey>, Self::StorageError> {
+    async fn all_gateways_identities(&self) -> Result<Vec<ed25519::PublicKey>, Self::StorageError> {
         Ok(self
             .all_gateways()
             .await?
@@ -64,7 +62,7 @@ pub trait GatewaysDetailsStore {
 
     async fn upgrade_stored_remote_gateway_key(
         &self,
-        gateway_id: identity::PublicKey,
+        gateway_id: ed25519::PublicKey,
         updated_key: &SharedSymmetricKey,
     ) -> Result<(), Self::StorageError>;
 

common/client-core/gateways-storage/src/types.rs

@@ -3,7 +3,7 @@
 
 use crate::BadGateway;
 use cosmrs::AccountId;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
@@ -29,7 +29,7 @@ pub struct GatewayRegistration {
 }
 
 impl GatewayRegistration {
-    pub fn gateway_id(&self) -> identity::PublicKey {
+    pub fn gateway_id(&self) -> ed25519::PublicKey {
         self.details.gateway_id()
     }
 }
@@ -64,7 +64,7 @@ impl From<GatewayDetails> for GatewayRegistration {
 
 impl GatewayDetails {
     pub fn new_remote(
-        gateway_id: identity::PublicKey,
+        gateway_id: ed25519::PublicKey,
         shared_key: Arc<SharedGatewayKey>,
         gateway_owner_address: Option<AccountId>,
         gateway_listener: Url,
@@ -77,11 +77,11 @@ impl GatewayDetails {
         })
     }
 
-    pub fn new_custom(gateway_id: identity::PublicKey, data: Option<Vec<u8>>) -> Self {
+    pub fn new_custom(gateway_id: ed25519::PublicKey, data: Option<Vec<u8>>) -> Self {
         GatewayDetails::Custom(CustomGatewayDetails { gateway_id, data })
     }
 
-    pub fn gateway_id(&self) -> identity::PublicKey {
+    pub fn gateway_id(&self) -> ed25519::PublicKey {
         match self {
             GatewayDetails::Remote(details) => details.gateway_id,
             GatewayDetails::Custom(details) => details.gateway_id,
@@ -157,7 +157,7 @@ pub struct RawRegisteredGateway {
 
 #[derive(Debug, Clone, Copy)]
 pub struct RegisteredGateway {
-    pub gateway_id: identity::PublicKey,
+    pub gateway_id: ed25519::PublicKey,
 
     pub registration_timestamp: OffsetDateTime,
 
@@ -179,7 +179,7 @@ impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {
 
     fn try_from(value: RawRemoteGatewayDetails) -> Result<Self, Self::Error> {
         let gateway_id =
-            identity::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
+            ed25519::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
                 BadGateway::MalformedGatewayIdentity {
                     gateway_id: value.gateway_id_bs58.clone(),
                     source,
@@ -267,7 +267,7 @@ impl<'a> From<&'a RemoteGatewayDetails> for RawRemoteGatewayDetails {
 
 #[derive(Debug, Clone)]
 pub struct RemoteGatewayDetails {
-    pub gateway_id: identity::PublicKey,
+    pub gateway_id: ed25519::PublicKey,
 
     pub shared_key: Arc<SharedGatewayKey>,
 
@@ -288,7 +288,7 @@ impl TryFrom<RawCustomGatewayDetails> for CustomGatewayDetails {
 
     fn try_from(value: RawCustomGatewayDetails) -> Result<Self, Self::Error> {
         let gateway_id =
-            identity::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
+            ed25519::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
                 BadGateway::MalformedGatewayIdentity {
                     gateway_id: value.gateway_id_bs58.clone(),
                     source,
@@ -314,12 +314,12 @@ impl<'a> From<&'a CustomGatewayDetails> for RawCustomGatewayDetails {
 
 #[derive(Debug, Clone)]
 pub struct CustomGatewayDetails {
-    pub gateway_id: identity::PublicKey,
+    pub gateway_id: ed25519::PublicKey,
     pub data: Option<Vec<u8>>,
 }
 
 impl CustomGatewayDetails {
-    pub fn new(gateway_id: identity::PublicKey) -> CustomGatewayDetails {
+    pub fn new(gateway_id: ed25519::PublicKey) -> CustomGatewayDetails {
         Self {
             gateway_id,
             data: None,

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

@@ -14,7 +14,7 @@ use crate::{
 };
 use log::info;
 use nym_client_core_gateways_storage::GatewayDetails;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_topology::NymTopology;
 use nym_validator_client::UserAgent;
 use std::path::PathBuf;
@@ -29,7 +29,7 @@ pub struct CommonClientAddGatewayArgs {
     /// Explicitly specify id of the gateway to register with.
     /// If unspecified, a random gateway will be chosen instead.
     #[cfg_attr(feature = "cli", clap(long, alias = "gateway"))]
-    pub gateway_id: Option<identity::PublicKey>,
+    pub gateway_id: Option<ed25519::PublicKey>,
 
     /// Specifies whether the client will attempt to enforce tls connection to the desired gateway.
     #[cfg_attr(feature = "cli", clap(long))]

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

@@ -14,7 +14,7 @@ use crate::{
 };
 use log::info;
 use nym_client_core_gateways_storage::GatewayDetails;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_sphinx::addressing::Recipient;
 use nym_topology::NymTopology;
 use nym_validator_client::UserAgent;
@@ -42,7 +42,7 @@ pub struct CommonClientInitArgs {
 
     /// Id of the gateway we are going to connect to.
     #[cfg_attr(feature = "cli", clap(long))]
-    pub gateway: Option<identity::PublicKey>,
+    pub gateway: Option<ed25519::PublicKey>,
 
     /// Specifies whether the client will attempt to enforce tls connection to the desired gateway.
     #[cfg_attr(feature = "cli", clap(long))]

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

@@ -1,7 +1,7 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_sphinx::addressing::Recipient;
 use std::path::PathBuf;
 
@@ -15,7 +15,7 @@ pub struct CommonClientRunArgs {
     /// Id of the gateway we want to connect to. If overridden, it is user's responsibility to
     /// ensure prior registration happened
     #[cfg_attr(feature = "cli", clap(long))]
-    pub gateway: Option<identity::PublicKey>,
+    pub gateway: Option<ed25519::PublicKey>,
 
     /// Comma separated list of rest endpoints of the nyxd validators
     #[cfg_attr(

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

@@ -4,7 +4,7 @@
 use crate::cli_helpers::{CliClient, CliClientConfig};
 use crate::client::base_client::non_wasm_helpers::setup_fs_gateways_storage;
 use crate::client::base_client::storage::helpers::set_active_gateway;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 
 #[cfg_attr(feature = "cli", derive(clap::Args))]
 #[derive(Debug, Clone)]
@@ -15,7 +15,7 @@ pub struct CommonClientSwitchGatewaysArgs {
 
     /// Id of the gateway we want to switch to.
     #[cfg_attr(feature = "cli", clap(long))]
-    pub gateway_id: identity::PublicKey,
+    pub gateway_id: ed25519::PublicKey,
 }
 
 pub async fn switch_gateway<C, A>(args: A) -> Result<(), C::Error>

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

@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 use time::OffsetDateTime;
@@ -10,7 +10,7 @@ use url::Url;
 #[derive(Serialize, Deserialize)]
 pub struct GatewayInfo {
     pub registration: OffsetDateTime,
-    pub identity: identity::PublicKey,
+    pub identity: ed25519::PublicKey,
     pub active: bool,
 
     pub typ: String,

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

@@ -39,7 +39,7 @@ use nym_bandwidth_controller::BandwidthController;
 use nym_client_core_config_types::ForgetMe;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewaysDetailsStore};
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::{encryption, identity};
+use nym_crypto::asymmetric::{ed25519, x25519};
 use nym_crypto::hkdf::DerivationMaterial;
 use nym_gateway_client::client::config::GatewayClientConfig;
 use nym_gateway_client::{
@@ -367,7 +367,7 @@ where
     // buffer controlling all messages fetched from provider
     // required so that other components would be able to use them (say the websocket)
     fn start_received_messages_buffer_controller(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
+        local_encryption_keypair: Arc<x25519::KeyPair>,
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_receiver: MixnetMessageReceiver,
         reply_key_storage: SentReplyKeys,
@@ -552,18 +552,12 @@ where
         user_agent: Option<UserAgent>,
     ) -> Box<dyn TopologyProvider + Send + Sync> {
         // if no custom provider was ... provided ..., create one using nym-api
-        custom_provider.unwrap_or_else(|| match config_topology.topology_structure {
-            config::TopologyStructure::NymApi => Box::new(NymApiTopologyProvider::new(
+        custom_provider.unwrap_or_else(|| {
+            Box::new(NymApiTopologyProvider::new(
                 config_topology,
                 nym_api_urls,
                 user_agent,
-            )),
-            config::TopologyStructure::GeoAware(group_by) => {
-                warn!("using deprecated 'GeoAware' topology provider - this option will be removed very soon");
-
-                #[allow(deprecated)]
-                Box::new(crate::client::topology_control::GeoAwareTopologyProvider::new(nym_api_urls, group_by))
-            }
+            ))
         })
     }
 
@@ -942,7 +936,7 @@ where
 
 pub struct BaseClient {
     pub address: Recipient,
-    pub identity_keys: Arc<identity::KeyPair>,
+    pub identity_keys: Arc<ed25519::KeyPair>,
     pub client_input: ClientInputStatus,
     pub client_output: ClientOutputStatus,
     pub client_state: ClientState,

common/client-core/src/client/base_client/storage/helpers.rs

@@ -5,7 +5,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, GatewayRegistration, GatewaysDetailsStore};
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 
 // helpers for error wrapping
 pub async fn set_active_gateway<D>(
@@ -26,7 +26,7 @@ where
 
 pub async fn get_active_gateway_identity<D>(
     details_store: &D,
-) -> Result<Option<identity::PublicKey>, ClientCoreError>
+) -> Result<Option<ed25519::PublicKey>, ClientCoreError>
 where
     D: GatewaysDetailsStore,
     D::StorageError: Send + Sync + 'static,
@@ -42,7 +42,7 @@ where
 
 pub async fn get_all_registered_identities<D>(
     details_store: &D,
-) -> Result<Vec<identity::PublicKey>, ClientCoreError>
+) -> Result<Vec<ed25519::PublicKey>, ClientCoreError>
 where
     D: GatewaysDetailsStore + Sync,
     D::StorageError: Send + Sync + 'static,

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

@@ -62,6 +62,10 @@ where
     /// Optional secondary predefined packet size used for the loop cover messages.
     secondary_packet_size: Option<PacketSize>,
 
+    /// Specify whether any constructed packets should use the legacy format,
+    /// where the payload keys are explicitly attached rather than using the seeds
+    use_legacy_sphinx_format: bool,
+
     packet_type: PacketType,
 
     stats_tx: ClientStatsSender,
@@ -130,6 +134,7 @@ impl LoopCoverTrafficStream<OsRng> {
             topology_access,
             primary_packet_size: traffic_config.primary_packet_size,
             secondary_packet_size: traffic_config.secondary_packet_size,
+            use_legacy_sphinx_format: traffic_config.use_legacy_sphinx_format,
             packet_type: traffic_config.packet_type,
             stats_tx,
             task_client,
@@ -182,6 +187,7 @@ impl LoopCoverTrafficStream<OsRng> {
 
         let cover_message = match generate_loop_cover_packet(
             &mut self.rng,
+            self.use_legacy_sphinx_format,
             topology_ref,
             &self.ack_key,
             &self.our_full_destination,

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

@@ -3,7 +3,7 @@
 
 use crate::client::key_manager::persistence::KeyStore;
 use nym_crypto::{
-    asymmetric::{encryption, identity},
+    asymmetric::{ed25519, x25519},
     hkdf::{DerivationMaterial, InvalidLength},
 };
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
@@ -25,10 +25,10 @@ mod test;
 #[derive(Clone)]
 pub struct ClientKeys {
     /// identity key associated with the client instance.
-    identity_keypair: Arc<identity::KeyPair>,
+    identity_keypair: Arc<ed25519::KeyPair>,
 
     /// encryption key associated with the client instance.
-    encryption_keypair: Arc<encryption::KeyPair>,
+    encryption_keypair: Arc<x25519::KeyPair>,
 
     /// key used for producing and processing acknowledgement packets.
     ack_key: Arc<AckKey>,
@@ -41,8 +41,8 @@ impl ClientKeys {
         R: RngCore + CryptoRng,
     {
         ClientKeys {
-            identity_keypair: Arc::new(identity::KeyPair::new(rng)),
-            encryption_keypair: Arc::new(encryption::KeyPair::new(rng)),
+            identity_keypair: Arc::new(ed25519::KeyPair::new(rng)),
+            encryption_keypair: Arc::new(x25519::KeyPair::new(rng)),
             ack_key: Arc::new(AckKey::new(rng)),
         }
     }
@@ -56,18 +56,18 @@ impl ClientKeys {
     {
         let secret = derivation_material.derive_secret()?;
         Ok(ClientKeys {
-            identity_keypair: Arc::new(identity::KeyPair::from_secret(
+            identity_keypair: Arc::new(ed25519::KeyPair::from_secret(
                 secret,
                 derivation_material.index(),
             )),
-            encryption_keypair: Arc::new(encryption::KeyPair::new(rng)),
+            encryption_keypair: Arc::new(x25519::KeyPair::new(rng)),
             ack_key: Arc::new(AckKey::new(rng)),
         })
     }
 
     pub fn from_keys(
-        id_keypair: identity::KeyPair,
-        enc_keypair: encryption::KeyPair,
+        id_keypair: ed25519::KeyPair,
+        enc_keypair: x25519::KeyPair,
         ack_key: AckKey,
     ) -> Self {
         Self {
@@ -85,13 +85,13 @@ impl ClientKeys {
         store.store_keys(self).await
     }
 
-    /// Gets an atomically reference counted pointer to [`identity::KeyPair`].
-    pub fn identity_keypair(&self) -> Arc<identity::KeyPair> {
+    /// Gets an atomically reference counted pointer to [`ed25519::KeyPair`].
+    pub fn identity_keypair(&self) -> Arc<ed25519::KeyPair> {
         Arc::clone(&self.identity_keypair)
     }
 
-    /// Gets an atomically reference counted pointer to [`encryption::KeyPair`].
-    pub fn encryption_keypair(&self) -> Arc<encryption::KeyPair> {
+    /// Gets an atomically reference counted pointer to [`x25519::KeyPair`].
+    pub fn encryption_keypair(&self) -> Arc<x25519::KeyPair> {
         Arc::clone(&self.encryption_keypair)
     }
     /// Gets an atomically reference counted pointer to [`AckKey`].
@@ -103,8 +103,8 @@ impl ClientKeys {
 fn _assert_keys_zeroize_on_drop() {
     fn _assert_zeroize_on_drop<T: ZeroizeOnDrop>() {}
 
-    _assert_zeroize_on_drop::<identity::KeyPair>();
-    _assert_zeroize_on_drop::<encryption::KeyPair>();
+    _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>();

common/client-core/src/client/key_manager/persistence.rs

@@ -11,7 +11,7 @@ use tokio::sync::Mutex;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::config::disk_persistence::ClientKeysPaths;
 #[cfg(not(target_arch = "wasm32"))]
-use nym_crypto::asymmetric::{encryption, identity};
+use nym_crypto::asymmetric::{ed25519, x25519};
 #[cfg(not(target_arch = "wasm32"))]
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 #[cfg(not(target_arch = "wasm32"))]
@@ -86,13 +86,13 @@ impl OnDiskKeys {
     }
 
     #[doc(hidden)]
-    pub fn load_encryption_keypair(&self) -> Result<encryption::KeyPair, OnDiskKeysError> {
+    pub fn load_encryption_keypair(&self) -> Result<x25519::KeyPair, OnDiskKeysError> {
         let encryption_paths = self.paths.encryption_key_pair_path();
         self.load_keypair(encryption_paths, "encryption")
     }
 
     #[doc(hidden)]
-    pub fn load_identity_keypair(&self) -> Result<identity::KeyPair, OnDiskKeysError> {
+    pub fn load_identity_keypair(&self) -> Result<ed25519::KeyPair, OnDiskKeysError> {
         let identity_paths = self.paths.identity_key_pair_path();
         self.load_keypair(identity_paths, "identity")
     }

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

@@ -4,7 +4,7 @@
 use async_trait::async_trait;
 use log::{debug, error};
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_gateway_client::error::GatewayClientError;
 use nym_gateway_client::GatewayClient;
 pub use nym_gateway_client::{GatewayPacketRouter, PacketRouter};
@@ -30,7 +30,7 @@ fn erase_err<E: std::error::Error + Send + Sync + 'static>(err: E) -> ErasedGate
 /// This combines combines the functionalities of being able to send and receive mix packets.
 #[async_trait]
 pub trait GatewayTransceiver: GatewaySender + GatewayReceiver {
-    fn gateway_identity(&self) -> identity::PublicKey;
+    fn gateway_identity(&self) -> ed25519::PublicKey;
     fn ws_fd(&self) -> Option<RawFd>;
     async fn send_client_request(
         &mut self,
@@ -75,7 +75,7 @@ pub trait GatewayReceiver {
 #[async_trait]
 impl<G: GatewayTransceiver + ?Sized + Send> GatewayTransceiver for Box<G> {
     #[inline]
-    fn gateway_identity(&self) -> identity::PublicKey {
+    fn gateway_identity(&self) -> ed25519::PublicKey {
         (**self).gateway_identity()
     }
     fn ws_fd(&self) -> Option<RawFd> {
@@ -134,7 +134,7 @@ where
     St: CredentialStorage,
     <St as CredentialStorage>::StorageError: Send + Sync + 'static,
 {
-    fn gateway_identity(&self) -> identity::PublicKey {
+    fn gateway_identity(&self) -> ed25519::PublicKey {
         self.gateway_client.gateway_identity()
     }
     fn ws_fd(&self) -> Option<RawFd> {
@@ -190,7 +190,7 @@ pub enum LocalGatewayError {
 #[cfg(not(target_arch = "wasm32"))]
 pub struct LocalGateway {
     /// Identity of the locally managed gateway
-    local_identity: identity::PublicKey,
+    local_identity: ed25519::PublicKey,
 
     // 'sender' part
     /// Channel responsible for taking mix packets and forwarding them further into the further mixnet layers.
@@ -203,7 +203,7 @@ pub struct LocalGateway {
 #[cfg(not(target_arch = "wasm32"))]
 impl LocalGateway {
     pub fn new(
-        local_identity: identity::PublicKey,
+        local_identity: ed25519::PublicKey,
         packet_forwarder: nym_mixnet_client::forwarder::MixForwardingSender,
         packet_router_tx: oneshot::Sender<PacketRouter>,
     ) -> Self {
@@ -221,7 +221,7 @@ mod nonwasm_sealed {
 
     #[async_trait]
     impl GatewayTransceiver for LocalGateway {
-        fn gateway_identity(&self) -> identity::PublicKey {
+        fn gateway_identity(&self) -> ed25519::PublicKey {
             self.local_identity
         }
         fn ws_fd(&self) -> Option<RawFd> {
@@ -263,7 +263,7 @@ mod nonwasm_sealed {
 
 // if we ever decided to start writing unit tests... : )
 pub struct MockGateway {
-    dummy_identity: identity::PublicKey,
+    dummy_identity: ed25519::PublicKey,
     packet_router: Option<PacketRouter>,
     sent: Vec<MixPacket>,
 }
@@ -303,7 +303,7 @@ impl GatewaySender for MockGateway {
 
 #[async_trait]
 impl GatewayTransceiver for MockGateway {
-    fn gateway_identity(&self) -> identity::PublicKey {
+    fn gateway_identity(&self) -> ed25519::PublicKey {
         self.dummy_identity
     }
     fn ws_fd(&self) -> Option<RawFd> {

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

@@ -109,6 +109,10 @@ pub(crate) struct Config {
 
     /// Optional secondary predefined packet size used for the encapsulated messages.
     secondary_packet_size: Option<PacketSize>,
+
+    /// Specify whether any constructed reply surbs should use the legacy format,
+    /// where the payload keys are explicitly attached rather than using the seeds
+    use_legacy_sphinx_format: bool,
 }
 
 impl Config {
@@ -118,6 +122,7 @@ impl Config {
         average_packet_delay: Duration,
         average_ack_delay: Duration,
         deterministic_route_selection: bool,
+        use_legacy_reply_surb_format: bool,
     ) -> Self {
         Config {
             ack_key,
@@ -127,6 +132,7 @@ impl Config {
             average_ack_delay,
             primary_packet_size: PacketSize::default(),
             secondary_packet_size: None,
+            use_legacy_sphinx_format: use_legacy_reply_surb_format,
         }
     }
 
@@ -186,6 +192,7 @@ where
             config.sender_address,
             config.average_packet_delay,
             config.average_ack_delay,
+            config.use_legacy_sphinx_format,
         );
         MessageHandler {
             config,
@@ -254,9 +261,11 @@ where
         let topology_permit = self.topology_access.get_read_permit().await;
         let topology = self.get_topology(&topology_permit)?;
 
-        let reply_surbs = self
-            .message_preparer
-            .generate_reply_surbs(amount, topology)?;
+        let reply_surbs = self.message_preparer.generate_reply_surbs(
+            self.config.use_legacy_sphinx_format,
+            amount,
+            topology,
+        )?;
 
         let reply_keys = reply_surbs
             .iter()
@@ -522,6 +531,7 @@ where
             self.generate_reply_surbs_with_keys(amount as usize).await?;
 
         let message = NymMessage::new_repliable(RepliableMessage::new_additional_surbs(
+            self.config.use_legacy_sphinx_format,
             sender_tag,
             reply_surbs,
         ));
@@ -559,8 +569,12 @@ where
             .generate_reply_surbs_with_keys(num_reply_surbs as usize)
             .await?;
 
-        let message =
-            NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));
+        let message = NymMessage::new_repliable(RepliableMessage::new_data(
+            self.config.use_legacy_sphinx_format,
+            message,
+            sender_tag,
+            reply_surbs,
+        ));
 
         self.try_split_and_send_non_reply_message(
             message,

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

@@ -99,6 +99,7 @@ impl<'a> From<&'a Config> for message_handler::Config {
             cfg.traffic.average_packet_delay,
             cfg.acks.average_ack_delay,
             cfg.traffic.deterministic_route_selection,
+            cfg.traffic.use_legacy_sphinx_format,
         )
         .with_custom_primary_packet_size(cfg.traffic.primary_packet_size)
         .with_custom_secondary_packet_size(cfg.traffic.secondary_packet_size)

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

@@ -252,6 +252,7 @@ where
                 (
                     generate_loop_cover_packet(
                         &mut self.rng,
+                        self.config.traffic.use_legacy_sphinx_format,
                         topology_ref,
                         &self.config.ack_key,
                         &self.config.our_full_destination,

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

@@ -9,7 +9,7 @@ use futures::channel::mpsc;
 use futures::lock::Mutex;
 use futures::StreamExt;
 use log::*;
-use nym_crypto::asymmetric::encryption;
+use nym_crypto::asymmetric::x25519;
 use nym_crypto::Digest;
 use nym_gateway_client::MixnetMessageReceiver;
 use nym_sphinx::anonymous_replies::requests::{
@@ -39,7 +39,7 @@ pub type ReconstructedMessagesReceiver = mpsc::UnboundedReceiver<Vec<Reconstruct
 
 struct ReceivedMessagesBufferInner<R: MessageReceiver> {
     messages: Vec<ReconstructedMessage>,
-    local_encryption_keypair: Arc<encryption::KeyPair>,
+    local_encryption_keypair: Arc<x25519::KeyPair>,
 
     // TODO: looking how it 'looks' here, perhaps `MessageReceiver` should be renamed to something
     // else instead.
@@ -176,7 +176,7 @@ struct ReceivedMessagesBuffer<R: MessageReceiver> {
 
 impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
     fn new(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
+        local_encryption_keypair: Arc<x25519::KeyPair>,
         reply_key_storage: SentReplyKeys,
         reply_controller_sender: ReplyControllerSender,
         stats_tx: ClientStatsSender,
@@ -250,10 +250,10 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
         let mut reconstructed = Vec::new();
         for msg in msgs {
             let (reply_surbs, from_surb_request) = match msg.content {
-                RepliableMessageContent::Data {
-                    message,
-                    reply_surbs,
-                } => {
+                RepliableMessageContent::Data(content) => {
+                    let reply_surbs = content.reply_surbs;
+                    let message = content.message;
+
                     trace!(
                         "received message that also contained additional {} reply surbs from {:?}!",
                         reply_surbs.len(),
@@ -264,7 +264,9 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
 
                     (reply_surbs, false)
                 }
-                RepliableMessageContent::AdditionalSurbs { reply_surbs } => {
+                RepliableMessageContent::AdditionalSurbs(content) => {
+                    let reply_surbs = content.reply_surbs;
+
                     trace!(
                         "received additional {} reply surbs from {:?}!",
                         reply_surbs.len(),
@@ -272,9 +274,37 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                     );
                     (reply_surbs, true)
                 }
-                RepliableMessageContent::Heartbeat {
-                    additional_reply_surbs,
-                } => {
+                RepliableMessageContent::Heartbeat(content) => {
+                    let additional_reply_surbs = content.additional_reply_surbs;
+                    error!("received a repliable heartbeat message - we don't know how to handle it yet (and we won't know until future PRs)");
+                    (additional_reply_surbs, false)
+                }
+                RepliableMessageContent::DataV2(content) => {
+                    let reply_surbs = content.reply_surbs;
+                    let message = content.message;
+
+                    trace!(
+                        "received message that also contained additional {} reply surbs from {:?}!",
+                        reply_surbs.len(),
+                        msg.sender_tag
+                    );
+
+                    reconstructed.push(ReconstructedMessage::new(message, msg.sender_tag));
+
+                    (reply_surbs, false)
+                }
+                RepliableMessageContent::AdditionalSurbsV2(content) => {
+                    let reply_surbs = content.reply_surbs;
+
+                    trace!(
+                        "received additional {} reply surbs from {:?}!",
+                        reply_surbs.len(),
+                        msg.sender_tag
+                    );
+                    (reply_surbs, true)
+                }
+                RepliableMessageContent::HeartbeatV2(content) => {
+                    let additional_reply_surbs = content.additional_reply_surbs;
                     error!("received a repliable heartbeat message - we don't know how to handle it yet (and we won't know until future PRs)");
                     (additional_reply_surbs, false)
                 }
@@ -536,7 +566,7 @@ pub(crate) struct ReceivedMessagesBufferController<R: MessageReceiver> {
 
 impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferController<R> {
     pub(crate) fn new(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
+        local_encryption_keypair: Arc<x25519::KeyPair>,
         query_receiver: ReceivedBufferRequestReceiver,
         mixnet_packet_receiver: MixnetMessageReceiver,
         reply_key_storage: SentReplyKeys,

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

@@ -1,214 +0,0 @@
-use crate::config::GroupBy;
-use log::{debug, error};
-use nym_explorer_client::{ExplorerClient, PrettyDetailedMixNodeBond};
-use nym_network_defaults::var_names::EXPLORER_API;
-use nym_topology::{
-    provider_trait::{async_trait, TopologyProvider},
-    NymTopology,
-};
-use nym_validator_client::client::NodeId;
-use rand::{prelude::SliceRandom, thread_rng};
-use std::collections::HashMap;
-use tap::TapOptional;
-use url::Url;
-
-pub use nym_country_group::CountryGroup;
-
-fn create_explorer_client() -> Option<ExplorerClient> {
-    let Ok(explorer_api_url) = std::env::var(EXPLORER_API) else {
-        error!("Missing EXPLORER_API");
-        return None;
-    };
-
-    let Ok(explorer_api_url) = explorer_api_url.parse() else {
-        error!("Failed to parse EXPLORER_API");
-        return None;
-    };
-
-    log::debug!("Using explorer-api url: {}", explorer_api_url);
-    let Ok(client) = nym_explorer_client::ExplorerClient::new(explorer_api_url) else {
-        error!("Failed to create explorer-api client");
-        return None;
-    };
-
-    Some(client)
-}
-
-fn group_mixnodes_by_country_code(
-    mixnodes: Vec<PrettyDetailedMixNodeBond>,
-) -> HashMap<CountryGroup, Vec<NodeId>> {
-    mixnodes
-        .into_iter()
-        .fold(HashMap::<CountryGroup, Vec<NodeId>>::new(), |mut acc, m| {
-            if let Some(ref location) = m.location {
-                let country_code = location.two_letter_iso_country_code.clone();
-                let group_code = CountryGroup::new(country_code.as_str());
-                let mixnodes = acc.entry(group_code).or_default();
-                mixnodes.push(m.mix_id);
-            }
-            acc
-        })
-}
-
-fn log_mixnode_distribution(mixnodes: &HashMap<CountryGroup, Vec<NodeId>>) {
-    let mixnode_distribution = mixnodes
-        .iter()
-        .map(|(k, v)| format!("{}: {}", k, v.len()))
-        .collect::<Vec<_>>()
-        .join(", ");
-    debug!("Mixnode distribution - {}", mixnode_distribution);
-}
-
-fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {
-    if topology.ensure_minimally_routable().is_err() {
-        error!("Layer is missing in topology!");
-        return Err(());
-    }
-    Ok(())
-}
-
-#[deprecated(note = "use NymApiTopologyProvider instead as explorer API will soon be removed")]
-pub struct GeoAwareTopologyProvider {
-    validator_client: nym_validator_client::client::NymApiClient,
-    filter_on: GroupBy,
-}
-
-#[allow(deprecated)]
-impl GeoAwareTopologyProvider {
-    pub fn new(mut nym_api_urls: Vec<Url>, filter_on: GroupBy) -> GeoAwareTopologyProvider {
-        log::info!(
-            "Creating geo-aware topology provider with filter on {}",
-            filter_on
-        );
-        nym_api_urls.shuffle(&mut thread_rng());
-
-        GeoAwareTopologyProvider {
-            validator_client: nym_validator_client::client::NymApiClient::new(
-                nym_api_urls[0].clone(),
-            ),
-            filter_on,
-        }
-    }
-
-    async fn get_topology(&self) -> Option<NymTopology> {
-        let rewarded_set = self
-            .validator_client
-            .get_current_rewarded_set()
-            .await
-            .inspect_err(|err| error!("failed to get current rewarded set: {err}"))
-            .ok()?;
-
-        let mut topology = NymTopology::new_empty(rewarded_set);
-
-        let mixnodes = match self
-            .validator_client
-            .get_all_basic_active_mixing_assigned_nodes()
-            .await
-        {
-            Err(err) => {
-                error!("failed to get network mixnodes - {err}");
-                return None;
-            }
-            Ok(mixes) => mixes,
-        };
-
-        let gateways = match self
-            .validator_client
-            .get_all_basic_entry_assigned_nodes()
-            .await
-        {
-            Err(err) => {
-                error!("failed to get network gateways - {err}");
-                return None;
-            }
-            Ok(gateways) => gateways,
-        };
-
-        // Also fetch mixnodes cached by explorer-api, with the purpose of getting their
-        // geolocation.
-        debug!("Fetching mixnodes from explorer-api...");
-        let explorer_client = create_explorer_client()?;
-        let Ok(mixnodes_from_explorer_api) = explorer_client.get_mixnodes().await else {
-            error!("failed to get mixnodes from explorer-api");
-            return None;
-        };
-
-        debug!("Fetching gateways from explorer-api...");
-        let Ok(gateways_from_explorer_api) = explorer_client.get_gateways().await else {
-            error!("failed to get mixnodes from explorer-api");
-            return None;
-        };
-
-        // Determine what we should filter around
-        let filter_on = match self.filter_on {
-            GroupBy::CountryGroup(group) => group,
-            GroupBy::NymAddress(recipient) => {
-                // Convert recipient into a country group by extracting out the gateway part and
-                // using that as the country code.
-                let gateway = recipient.gateway().to_base58_string();
-
-                // Lookup the location of this gateway by using the location data from the
-                // explorer-api
-                let gateway_location = gateways_from_explorer_api
-                    .iter()
-                    .find(|g| g.gateway.identity_key == gateway)
-                    .and_then(|g| g.location.clone())
-                    .map(|location| location.two_letter_iso_country_code)
-                    .tap_none(|| error!("No location found for the gateway: {}", gateway))?;
-                debug!(
-                    "Filtering on nym-address: {}, with location: {}",
-                    recipient, gateway_location
-                );
-
-                CountryGroup::new(&gateway_location)
-            }
-        };
-        debug!("Filter group: {}", filter_on);
-
-        // Partition mixnodes_from_explorer_api according to the value of
-        // two_letter_iso_country_code.
-        // NOTE: we construct the full distribution here, but only use the one we're interested in.
-        // The reason we this instead of a straight filter is that this opens up the possibility to
-        // complement a small grouping with mixnodes from adjecent countries.
-        let mixnode_distribution = group_mixnodes_by_country_code(mixnodes_from_explorer_api);
-        log_mixnode_distribution(&mixnode_distribution);
-
-        let Some(filtered_mixnode_ids) = mixnode_distribution.get(&filter_on) else {
-            error!("no mixnodes found for: {}", filter_on);
-            return None;
-        };
-
-        let mixnodes = mixnodes
-            .into_iter()
-            .filter(|m| filtered_mixnode_ids.contains(&m.node_id))
-            .collect::<Vec<_>>();
-
-        topology.add_skimmed_nodes(&mixnodes);
-        topology.add_skimmed_nodes(&gateways);
-
-        // TODO: return real error type
-        check_layer_integrity(topology.clone()).ok()?;
-
-        Some(topology)
-    }
-}
-
-#[allow(deprecated)]
-#[cfg(not(target_arch = "wasm32"))]
-#[async_trait]
-impl TopologyProvider for GeoAwareTopologyProvider {
-    // this will be manually refreshed on a timer specified inside mixnet client config
-    async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        self.get_topology().await
-    }
-}
-
-#[allow(deprecated)]
-#[cfg(target_arch = "wasm32")]
-#[async_trait(?Send)]
-impl TopologyProvider for GeoAwareTopologyProvider {
-    // this will be manually refreshed on a timer specified inside mixnet client config
-    async fn get_new_topology(&mut self) -> Option<NymTopology> {
-        self.get_topology().await
-    }
-}

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

@@ -17,11 +17,8 @@ use tokio::time::sleep;
 use wasmtimer::tokio::sleep;
 
 mod accessor;
-pub mod geo_aware_provider;
 pub mod nym_api_provider;
 
-#[allow(deprecated)]
-pub use geo_aware_provider::GeoAwareTopologyProvider;
 pub use nym_api_provider::{Config as NymApiTopologyProviderConfig, NymApiTopologyProvider};
 pub use nym_topology::provider_trait::TopologyProvider;
 

common/client-core/src/error.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::mix_traffic::transceiver::ErasedGatewayError;
-use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
+use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
 use nym_gateway_client::error::GatewayClientError;
 use nym_topology::node::RoutingNodeError;
 use nym_topology::{NodeId, NymTopologyError};

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

@@ -5,7 +5,7 @@ use crate::error::ClientCoreError;
 use crate::init::types::RegistrationResult;
 use futures::{SinkExt, StreamExt};
 use log::{debug, info, trace, warn};
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_gateway_client::GatewayClient;
 use nym_topology::node::RoutingNode;
 use nym_validator_client::client::IdentityKeyRef;
@@ -52,7 +52,7 @@ const PING_TIMEOUT: Duration = Duration::from_millis(1000);
 // The abstraction that some of these helpers use
 pub trait ConnectableGateway {
     fn node_id(&self) -> NodeId;
-    fn identity(&self) -> identity::PublicKey;
+    fn identity(&self) -> ed25519::PublicKey;
     fn clients_address(&self, prefer_ipv6: bool) -> Option<String>;
     fn is_wss(&self) -> bool;
 }
@@ -62,7 +62,7 @@ impl ConnectableGateway for RoutingNode {
         self.node_id
     }
 
-    fn identity(&self) -> identity::PublicKey {
+    fn identity(&self) -> ed25519::PublicKey {
         self.identity_key
     }
 
@@ -287,7 +287,7 @@ pub(super) fn get_specified_gateway(
     must_use_tls: bool,
 ) -> Result<RoutingNode, ClientCoreError> {
     log::debug!("Requesting specified gateway: {}", gateway_identity);
-    let user_gateway = identity::PublicKey::from_base58_string(gateway_identity)
+    let user_gateway = ed25519::PublicKey::from_base58_string(gateway_identity)
         .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;
 
     let gateway = gateways
@@ -312,9 +312,9 @@ pub(super) fn get_specified_gateway(
 }
 
 pub(super) async fn register_with_gateway(
-    gateway_id: identity::PublicKey,
+    gateway_id: ed25519::PublicKey,
     gateway_listener: Url,
-    our_identity: Arc<identity::KeyPair>,
+    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(

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

@@ -9,7 +9,7 @@ use crate::init::{setup_gateway, use_loaded_gateway_details};
 use nym_client_core_gateways_storage::{
     GatewayRegistration, GatewaysDetailsStore, RemoteGatewayDetails,
 };
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_gateway_client::client::InitGatewayClient;
 use nym_gateway_requests::shared_key::SharedGatewayKey;
 use nym_sphinx::addressing::clients::Recipient;
@@ -26,14 +26,14 @@ use url::Url;
 
 pub enum SelectedGateway {
     Remote {
-        gateway_id: identity::PublicKey,
+        gateway_id: ed25519::PublicKey,
 
         gateway_owner_address: Option<AccountId>,
 
         gateway_listener: Url,
     },
     Custom {
-        gateway_id: identity::PublicKey,
+        gateway_id: ed25519::PublicKey,
         additional_data: Option<Vec<u8>>,
     },
 }
@@ -77,7 +77,7 @@ impl SelectedGateway {
         gateway_id: String,
         additional_data: Option<Vec<u8>>,
     ) -> Result<Self, ClientCoreError> {
-        let gateway_id = identity::PublicKey::from_base58_string(&gateway_id)
+        let gateway_id = ed25519::PublicKey::from_base58_string(&gateway_id)
             .map_err(|source| ClientCoreError::MalformedGatewayIdentity { gateway_id, source })?;
 
         Ok(SelectedGateway::Custom {
@@ -86,7 +86,7 @@ impl SelectedGateway {
         })
     }
 
-    pub fn gateway_id(&self) -> &identity::PublicKey {
+    pub fn gateway_id(&self) -> &ed25519::PublicKey {
         match self {
             SelectedGateway::Remote { gateway_id, .. } => gateway_id,
             SelectedGateway::Custom { gateway_id, .. } => gateway_id,
@@ -142,7 +142,7 @@ impl InitialisationResult {
         )
     }
 
-    pub fn gateway_id(&self) -> identity::PublicKey {
+    pub fn gateway_id(&self) -> ed25519::PublicKey {
         self.gateway_registration.details.gateway_id()
     }
 }
@@ -271,7 +271,7 @@ impl GatewaySetup {
     }
 
     /// new gateway setup performed by each client that's inbuilt in a gateway (like NR or IPR)
-    pub fn new_inbuilt(identity: identity::PublicKey) -> Self {
+    pub fn new_inbuilt(identity: ed25519::PublicKey) -> Self {
         GatewaySetup::New {
             specification: GatewaySelectionSpecification::Custom {
                 gateway_identity: identity.to_base58_string(),

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

@@ -17,7 +17,7 @@ use nym_credential_storage::ephemeral_storage::EphemeralStorage as EphemeralCred
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_credentials::CredentialSpendingData;
 use nym_credentials_interface::TicketType;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_gateway_requests::registration::handshake::client_handshake;
 use nym_gateway_requests::{
     BinaryRequest, ClientControlRequest, ClientRequest, GatewayProtocolVersionExt,
@@ -57,7 +57,7 @@ pub(crate) mod websockets;
 use websockets::connect_async;
 
 pub struct GatewayConfig {
-    pub gateway_identity: identity::PublicKey,
+    pub gateway_identity: ed25519::PublicKey,
 
     // currently a dead field
     pub gateway_owner: Option<String>,
@@ -67,7 +67,7 @@ pub struct GatewayConfig {
 
 impl GatewayConfig {
     pub fn new(
-        gateway_identity: identity::PublicKey,
+        gateway_identity: ed25519::PublicKey,
         gateway_owner: Option<String>,
         gateway_listener: String,
     ) -> Self {
@@ -93,8 +93,8 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
     authenticated: bool,
     bandwidth: ClientBandwidth,
     gateway_address: String,
-    gateway_identity: identity::PublicKey,
-    local_identity: Arc<identity::KeyPair>,
+    gateway_identity: ed25519::PublicKey,
+    local_identity: Arc<ed25519::KeyPair>,
     shared_key: Option<Arc<SharedGatewayKey>>,
     connection: SocketState,
     packet_router: PacketRouter,
@@ -117,7 +117,7 @@ impl<C, St> GatewayClient<C, St> {
     pub fn new(
         cfg: GatewayClientConfig,
         gateway_config: GatewayConfig,
-        local_identity: Arc<identity::KeyPair>,
+        local_identity: Arc<ed25519::KeyPair>,
         // TODO: make it mandatory. if you don't want to pass it, use `new_init`
         shared_key: Option<Arc<SharedGatewayKey>>,
         packet_router: PacketRouter,
@@ -145,7 +145,7 @@ impl<C, St> GatewayClient<C, St> {
         }
     }
 
-    pub fn gateway_identity(&self) -> identity::PublicKey {
+    pub fn gateway_identity(&self) -> ed25519::PublicKey {
         self.gateway_identity
     }
 
@@ -1063,8 +1063,8 @@ 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_listener: Url,
-        gateway_identity: identity::PublicKey,
-        local_identity: Arc<identity::KeyPair>,
+        gateway_identity: ed25519::PublicKey,
+        local_identity: Arc<ed25519::KeyPair>,
         #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
     ) -> Self {
         log::trace!("Initialising gateway client");

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

@@ -24,10 +24,10 @@ use tracing::*;
 
 #[derive(Clone, Copy)]
 pub struct Config {
-    initial_reconnection_backoff: Duration,
-    maximum_reconnection_backoff: Duration,
-    initial_connection_timeout: Duration,
-    maximum_connection_buffer_size: usize,
+    pub initial_reconnection_backoff: Duration,
+    pub maximum_reconnection_backoff: Duration,
+    pub initial_connection_timeout: Duration,
+    pub maximum_connection_buffer_size: usize,
 }
 
 impl Config {
@@ -50,7 +50,7 @@ pub trait SendWithoutResponse {
     // Without response in this context means we will not listen for anything we might get back (not
     // that we should get anything), including any possible io errors
     fn send_without_response(
-        &mut self,
+        &self,
         address: NymNodeRoutingAddress,
         packet: NymPacket,
         packet_type: PacketType,
@@ -196,7 +196,7 @@ impl Client {
         }
     }
 
-    fn make_connection(&mut self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
+    fn make_connection(&self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
         let (sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);
 
         // this CAN'T fail because we just created the channel which has a non-zero capacity
@@ -247,7 +247,7 @@ impl Client {
 
 impl SendWithoutResponse for Client {
     fn send_without_response(
-        &mut self,
+        &self,
         address: NymNodeRoutingAddress,
         packet: NymPacket,
         packet_type: PacketType,

common/commands/src/ecash/issue_ticket_book.rs

@@ -15,7 +15,7 @@ use nym_credentials::{
     AggregatedCoinIndicesSignatures, AggregatedExpirationDateSignatures, EpochVerificationKey,
 };
 use nym_credentials_interface::TicketType;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use std::fs;
 use std::path::PathBuf;
 use tempfile::NamedTempFile;
@@ -83,7 +83,7 @@ async fn issue_client_ticketbook(
     );
 
     let persistent_storage = initialise_persistent_storage(credentials_store).await;
-    let private_id_key: identity::PrivateKey = nym_pemstore::load_key(private_id_key)?;
+    let private_id_key: ed25519::PrivateKey = nym_pemstore::load_key(private_id_key)?;
     utils::issue_credential(
         &client,
         &persistent_storage,

common/commands/src/validator/mixnet/operators/identity_key/mod.rs

@@ -1,6 +1,6 @@
 use clap::{Args, Parser, Subcommand};
 use nym_bin_common::output_format::OutputFormat;
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_types::helpers::ConsoleSigningOutput;
 use nym_validator_client::nyxd::error::NyxdError;
 use std::path::PathBuf;
@@ -34,14 +34,14 @@ pub struct SignArgs {
 
 pub async fn sign(args: SignArgs) -> Result<(), NyxdError> {
     eprintln!(">>> loading: {}", args.private_key.display());
-    let private_identity_key: identity::PrivateKey =
+    let private_identity_key: ed25519::PrivateKey =
         nym_pemstore::load_key(args.private_key).expect("failed to load key");
 
     print_signed_msg(&private_identity_key, &args.base58_msg, args.output);
     Ok(())
 }
 
-fn print_signed_msg(private_key: &identity::PrivateKey, raw_msg: &str, output: OutputFormat) {
+fn print_signed_msg(private_key: &ed25519::PrivateKey, raw_msg: &str, output: OutputFormat) {
     let trimmed = raw_msg.trim();
     eprintln!(">>> attempting to sign: {trimmed}");
 

common/cosmwasm-smart-contracts/coconut-dkg/src/types.rs

@@ -219,7 +219,7 @@ impl Epoch {
                 EpochState::VerificationKeyFinalization { .. } => {
                     time_configuration.verification_key_finalization_time_secs
                 }
-                EpochState::InProgress { .. } => 0,
+                EpochState::InProgress => 0,
             };
             finish += adding;
         }

common/country-group/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "nym-country-group"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-serde = { workspace = true, features = ["derive"] }
-tracing.workspace = true

common/country-group/src/lib.rs

@@ -1,158 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use serde::{Deserialize, Serialize};
-use std::fmt;
-use tracing::info;
-
-#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub enum CountryGroup {
-    Europe,
-    NorthAmerica,
-    SouthAmerica,
-    Oceania,
-    Asia,
-    Africa,
-    Unknown,
-}
-
-impl CountryGroup {
-    // We map country codes into group, which initially are continent codes to a first approximation,
-    // but we do it manually to reserve the right to tweak this distribution for our purposes.
-    // NOTE: I did this quickly, and it's not a complete list of all countries, but only those that
-    // were present in the network at the time. Please add more as needed.
-    pub fn new(country_code: &str) -> Self {
-        let country_code = country_code.to_uppercase();
-        use CountryGroup::*;
-        match country_code.as_ref() {
-            // Europe
-            "AT" => Europe,
-            "BG" => Europe,
-            "CH" => Europe,
-            "CY" => Europe,
-            "CZ" => Europe,
-            "DE" => Europe,
-            "DK" => Europe,
-            "ES" => Europe,
-            "FI" => Europe,
-            "FR" => Europe,
-            "GB" => Europe,
-            "GR" => Europe,
-            "IE" => Europe,
-            "IT" => Europe,
-            "LT" => Europe,
-            "LU" => Europe,
-            "LV" => Europe,
-            "MD" => Europe,
-            "MT" => Europe,
-            "NL" => Europe,
-            "NO" => Europe,
-            "PL" => Europe,
-            "RO" => Europe,
-            "SE" => Europe,
-            "SK" => Europe,
-            "TR" => Europe,
-            "UA" => Europe,
-
-            // North America
-            "CA" => NorthAmerica,
-            "MX" => NorthAmerica,
-            "US" => NorthAmerica,
-
-            // South America
-            "AR" => SouthAmerica,
-            "BR" => SouthAmerica,
-            "CL" => SouthAmerica,
-            "CO" => SouthAmerica,
-            "CR" => SouthAmerica,
-            "GT" => SouthAmerica,
-
-            // Oceania
-            "AU" => Oceania,
-
-            // Asia
-            "AM" => Asia,
-            "BH" => Asia,
-            "CN" => Asia,
-            "GE" => Asia,
-            "HK" => Asia,
-            "ID" => Asia,
-            "IL" => Asia,
-            "IN" => Asia,
-            "JP" => Asia,
-            "KH" => Asia,
-            "KR" => Asia,
-            "KZ" => Asia,
-            "MY" => Asia,
-            "RU" => Asia,
-            "SG" => Asia,
-            "TH" => Asia,
-            "VN" => Asia,
-
-            // Africa
-            "SC" => Africa,
-            "UG" => Africa,
-            "ZA" => Africa,
-
-            // And group level codes work too
-            "EU" => Europe,
-            "NA" => NorthAmerica,
-            "SA" => SouthAmerica,
-            "OC" => Oceania,
-            "AS" => Asia,
-            "AF" => Africa,
-
-            // And some aliases
-            "EUROPE" => Europe,
-            "NORTHAMERICA" => NorthAmerica,
-            "SOUTHAMERICA" => SouthAmerica,
-            "OCEANIA" => Oceania,
-            "ASIA" => Asia,
-            "AFRICA" => Africa,
-
-            _ => {
-                info!("Unknown country code: {country_code}");
-                Unknown
-            }
-        }
-    }
-}
-
-impl fmt::Display for CountryGroup {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use CountryGroup::*;
-        match self {
-            Europe => write!(f, "EU"),
-            NorthAmerica => write!(f, "NA"),
-            SouthAmerica => write!(f, "SA"),
-            Oceania => write!(f, "OC"),
-            Asia => write!(f, "AS"),
-            Africa => write!(f, "AF"),
-            Unknown => write!(f, "Unknown"),
-        }
-    }
-}
-
-impl std::str::FromStr for CountryGroup {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let group = CountryGroup::new(s);
-        if group == CountryGroup::Unknown {
-            Err(())
-        } else {
-            Ok(group)
-        }
-    }
-}
-
-impl CountryGroup {
-    #[allow(unused)]
-    fn known(self) -> Option<CountryGroup> {
-        use CountryGroup::*;
-        match self {
-            Europe | NorthAmerica | SouthAmerica | Oceania | Asia | Africa => Some(self),
-            Unknown => None,
-        }
-    }
-}

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

@@ -172,6 +172,21 @@ impl MemoryEcachTicketbookManager {
         );
     }
 
+    pub(crate) async fn contains_ticketbook(&self, ticketbook: &IssuedTicketBook) -> bool {
+        let ser = ticketbook.pack();
+        let search_data = Zeroizing::new(ser.data);
+        self.inner
+            .read()
+            .await
+            .ticketbooks
+            .iter()
+            .any(|ticketbook| {
+                let ser = ticketbook.1.ticketbook.pack();
+                let data = Zeroizing::new(ser.data);
+                search_data.eq(&data)
+            })
+    }
+
     pub(crate) async fn get_ticketbooks_info(&self) -> Vec<BasicTicketbookInformation> {
         let guard = self.inner.read().await;
 

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

@@ -95,6 +95,24 @@ impl SqliteEcashTicketbookManager {
         Ok(())
     }
 
+    pub(crate) async fn contains_ticketbook_data(&self, data: &[u8]) -> Result<bool, sqlx::Error> {
+        let exists = sqlx::query(
+            r#"
+                SELECT EXISTS (
+                    SELECT 1
+                    FROM ecash_ticketbook
+                    WHERE ticketbook_data = ?
+                )
+            "#,
+        )
+        .bind(data)
+        .fetch_optional(&self.connection_pool)
+        .await?
+        .is_some();
+
+        Ok(exists)
+    }
+
     pub(crate) async fn get_ticketbooks_info(
         &self,
     ) -> Result<Vec<BasicTicketbookInformation>, sqlx::Error> {

common/credential-storage/src/ephemeral_storage.rs

@@ -70,6 +70,13 @@ impl Storage for EphemeralStorage {
         Ok(())
     }
 
+    async fn contains_issued_ticketbook(
+        &self,
+        ticketbook: &IssuedTicketBook,
+    ) -> Result<bool, StorageError> {
+        Ok(self.storage_manager.contains_ticketbook(ticketbook).await)
+    }
+
     async fn get_ticketbooks_info(
         &self,
     ) -> Result<Vec<BasicTicketbookInformation>, Self::StorageError> {

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

@@ -145,6 +145,16 @@ impl Storage for PersistentStorage {
         Ok(())
     }
 
+    async fn contains_issued_ticketbook(
+        &self,
+        ticketbook: &IssuedTicketBook,
+    ) -> Result<bool, Self::StorageError> {
+        let ser = ticketbook.pack();
+        let data = Zeroizing::new(ser.data);
+
+        Ok(self.storage_manager.contains_ticketbook_data(&data).await?)
+    }
+
     async fn get_ticketbooks_info(
         &self,
     ) -> Result<Vec<BasicTicketbookInformation>, Self::StorageError> {

common/credential-storage/src/storage.rs

@@ -37,6 +37,11 @@ pub trait Storage: Clone + Send + Sync {
         ticketbook: &IssuedTicketBook,
     ) -> Result<(), Self::StorageError>;
 
+    async fn contains_issued_ticketbook(
+        &self,
+        ticketbook: &IssuedTicketBook,
+    ) -> Result<bool, Self::StorageError>;
+
     async fn get_ticketbooks_info(
         &self,
     ) -> Result<Vec<BasicTicketbookInformation>, Self::StorageError>;

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

@@ -12,7 +12,7 @@ use nym_credentials_interface::{
     BlindedSignature, KeyPairUser, PartialWallet, TicketType, VerificationKeyAuth,
     WalletSignatures, WithdrawalRequest,
 };
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_ecash_contract_common::deposit::DepositId;
 use nym_ecash_time::{ecash_default_expiration_date, ecash_today, EcashTime};
 use nym_validator_client::nym_api::EpochId;
@@ -27,7 +27,7 @@ pub struct IssuanceTicketBook {
     deposit_id: DepositId,
 
     /// base58 encoded private key ensuring the depositer requested these attributes
-    signing_key: identity::PrivateKey,
+    signing_key: ed25519::PrivateKey,
 
     /// ecash keypair related to the credential
     ecash_keypair: KeyPairUser,
@@ -43,7 +43,7 @@ impl IssuanceTicketBook {
     pub fn new<M: AsRef<[u8]>>(
         deposit_id: DepositId,
         identifier: M,
-        signing_key: identity::PrivateKey,
+        signing_key: ed25519::PrivateKey,
         ticketbook_type: TicketType,
     ) -> Self {
         //this expiration date will get fed to the ecash library, force midnight to be set
@@ -59,7 +59,7 @@ impl IssuanceTicketBook {
     pub fn new_with_expiration<M: AsRef<[u8]>>(
         deposit_id: DepositId,
         identifier: M,
-        signing_key: identity::PrivateKey,
+        signing_key: ed25519::PrivateKey,
         ticketbook_type: TicketType,
         expiration_date: Date,
     ) -> Self {
@@ -93,7 +93,7 @@ impl IssuanceTicketBook {
         message
     }
 
-    fn request_signature(&self, signing_request: &CredentialSigningData) -> identity::Signature {
+    fn request_signature(&self, signing_request: &CredentialSigningData) -> ed25519::Signature {
         let message = Self::request_plaintext(&signing_request.withdrawal_request, self.deposit_id);
         self.signing_key.sign(message)
     }
@@ -127,7 +127,7 @@ impl IssuanceTicketBook {
         self.deposit_id
     }
 
-    pub fn identity_key(&self) -> &identity::PrivateKey {
+    pub fn identity_key(&self) -> &ed25519::PrivateKey {
         &self.signing_key
     }
 

common/credentials/src/error.rs

@@ -3,7 +3,7 @@
 
 use crate::ecash::bandwidth::issued::CURRENT_SERIALIZATION_REVISION;
 use nym_credentials_interface::CompactEcashError;
-use nym_crypto::asymmetric::encryption::KeyRecoveryError;
+use nym_crypto::asymmetric::x25519::KeyRecoveryError;
 use nym_validator_client::ValidatorClientError;
 use thiserror::Error;
 

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

@@ -6,7 +6,6 @@ use ed25519_dalek::{SecretKey, Signer, SigningKey};
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 use std::fmt::{self, Debug, Display, Formatter};
-use std::hash::{Hash, Hasher};
 use std::str::FromStr;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};
@@ -154,17 +153,9 @@ impl PemStorableKeyPair for KeyPair {
 }
 
 /// ed25519 EdDSA Public Key
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct PublicKey(ed25519_dalek::VerifyingKey);
 
-impl Hash for PublicKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        // each public key has unique bytes representation which can be used
-        // for the hash implementation
-        self.to_bytes().hash(state)
-    }
-}
-
 impl Display for PublicKey {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         Display::fmt(&self.to_base58_string(), f)

common/crypto/src/asymmetric/ed25519/serde_helpers.rs

@@ -18,7 +18,7 @@ pub mod bs58_ed25519_pubkey {
 }
 
 pub mod bs58_ed25519_signature {
-    use crate::asymmetric::identity::Signature;
+    use crate::asymmetric::ed25519::Signature;
     use serde::{Deserialize, Deserializer, Serializer};
 
     pub fn serialize<S: Serializer>(

common/crypto/src/asymmetric/mod.rs

@@ -1,8 +1,13 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-pub mod encryption;
-pub mod identity;
+pub mod ed25519;
+pub mod x25519;
 
-pub use encryption as x25519;
-pub use identity as ed25519;
+// don't break existing imports
+// but deprecate them
+#[deprecated(note = "use ed25519 instead")]
+pub use ed25519 as identity;
+
+#[deprecated(note = "use x25519 instead")]
+pub use x25519 as encryption;

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

@@ -132,6 +132,10 @@ impl PublicKey {
         *self.0.as_bytes()
     }
 
+    pub fn as_bytes(&self) -> &[u8; PUBLIC_KEY_SIZE] {
+        self.0.as_bytes()
+    }
+
     pub fn from_bytes(b: &[u8]) -> Result<Self, KeyRecoveryError> {
         if b.len() != PUBLIC_KEY_SIZE {
             return Err(KeyRecoveryError::InvalidSizePublicKey {
@@ -228,7 +232,6 @@ impl<'a> From<&'a PrivateKey> for PublicKey {
         PublicKey((&pk.0).into())
     }
 }
-
 impl FromStr for PrivateKey {
     type Err = KeyRecoveryError;
 

common/crypto/src/shared_key.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::asymmetric::encryption;
+use crate::asymmetric::x25519;
 use crate::hkdf;
 use cipher::{Key, KeyIvInit, StreamCipher};
 use digest::crypto_common::BlockSizeUser;
@@ -15,14 +15,14 @@ use rand::{CryptoRng, RngCore};
 #[cfg(feature = "rand")]
 pub fn new_ephemeral_shared_key<C, D, R>(
     rng: &mut R,
-    remote_key: &encryption::PublicKey,
-) -> (encryption::KeyPair, Key<C>)
+    remote_key: &x25519::PublicKey,
+) -> (x25519::KeyPair, Key<C>)
 where
     C: StreamCipher + KeyIvInit,
     D: Digest + BlockSizeUser + Clone,
     R: RngCore + CryptoRng,
 {
-    let ephemeral_keypair = encryption::KeyPair::new(rng);
+    let ephemeral_keypair = x25519::KeyPair::new(rng);
 
     // after performing diffie-hellman we don't care about the private component anymore
     let dh_result = ephemeral_keypair.private_key().diffie_hellman(remote_key);
@@ -43,8 +43,8 @@ where
 
 /// Recompute shared key using remote public key and local private key.
 pub fn recompute_shared_key<C, D>(
-    remote_key: &encryption::PublicKey,
-    local_key: &encryption::PrivateKey,
+    remote_key: &x25519::PublicKey,
+    local_key: &x25519::PrivateKey,
 ) -> Key<C>
 where
     C: StreamCipher + KeyIvInit,

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

@@ -6,7 +6,7 @@ use crate::registration::handshake::state::State;
 use crate::SharedGatewayKey;
 use futures::future::BoxFuture;
 use futures::{Sink, Stream};
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use rand::{CryptoRng, RngCore};
 use std::future::Future;
 use std::pin::Pin;
@@ -48,8 +48,8 @@ impl Future for GatewayHandshake<'_> {
 pub fn client_handshake<'a, S, R>(
     rng: &'a mut R,
     ws_stream: &'a mut S,
-    identity: &'a identity::KeyPair,
-    gateway_pubkey: identity::PublicKey,
+    identity: &'a ed25519::KeyPair,
+    gateway_pubkey: ed25519::PublicKey,
     expects_credential_usage: bool,
     derive_aes256_gcm_siv_key: bool,
     #[cfg(not(target_arch = "wasm32"))] shutdown: TaskClient,
@@ -78,7 +78,7 @@ where
 pub fn gateway_handshake<'a, S, R>(
     rng: &'a mut R,
     ws_stream: &'a mut S,
-    identity: &'a identity::KeyPair,
+    identity: &'a ed25519::KeyPair,
     received_init_payload: Vec<u8>,
     shutdown: TaskClient,
 ) -> GatewayHandshake<'a>

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

@@ -14,11 +14,7 @@ use crate::{
 use futures::{Sink, SinkExt, Stream, StreamExt};
 use nym_crypto::asymmetric::{ed25519, x25519};
 use nym_crypto::symmetric::aead::random_nonce;
-use nym_crypto::{
-    asymmetric::{encryption, identity},
-    generic_array::typenum::Unsigned,
-    hkdf,
-};
+use nym_crypto::{generic_array::typenum::Unsigned, hkdf};
 use nym_sphinx::params::{GatewayEncryptionAlgorithm, GatewaySharedKeyHkdfAlgorithm};
 use rand::{thread_rng, CryptoRng, RngCore};
 use std::any::{type_name, Any};
@@ -74,14 +70,14 @@ impl<'a, S, R> State<'a, S, R> {
     pub(crate) fn new(
         rng: &'a mut R,
         ws_stream: &'a mut S,
-        identity: &'a identity::KeyPair,
-        remote_pubkey: Option<identity::PublicKey>,
+        identity: &'a ed25519::KeyPair,
+        remote_pubkey: Option<ed25519::PublicKey>,
         #[cfg(not(target_arch = "wasm32"))] shutdown: TaskClient,
     ) -> Self
     where
         R: CryptoRng + RngCore,
     {
-        let ephemeral_keypair = encryption::KeyPair::new(rng);
+        let ephemeral_keypair = x25519::KeyPair::new(rng);
         State {
             ws_stream,
             rng,
@@ -113,7 +109,7 @@ impl<'a, S, R> State<'a, S, R> {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn local_ephemeral_key(&self) -> &encryption::PublicKey {
+    pub(crate) fn local_ephemeral_key(&self) -> &x25519::PublicKey {
         self.ephemeral_keypair.public_key()
     }
 
@@ -150,7 +146,7 @@ impl<'a, S, R> State<'a, S, R> {
 
     pub(crate) fn derive_shared_key(
         &mut self,
-        remote_ephemeral_key: &encryption::PublicKey,
+        remote_ephemeral_key: &x25519::PublicKey,
         initiator_salt: Option<&[u8]>,
     ) {
         let dh_result = self
@@ -189,7 +185,7 @@ impl<'a, S, R> State<'a, S, R> {
     // assuming x is local and y is remote
     pub(crate) fn prepare_key_material_sig(
         &self,
-        remote_ephemeral_key: &encryption::PublicKey,
+        remote_ephemeral_key: &x25519::PublicKey,
     ) -> Result<MaterialExchange, HandshakeError> {
         let plaintext: Vec<_> = self
             .ephemeral_keypair
@@ -243,7 +239,7 @@ impl<'a, S, R> State<'a, S, R> {
         )?;
 
         // now verify signature itself
-        let signature = identity::Signature::from_bytes(&decrypted_signature)
+        let signature = ed25519::Signature::from_bytes(&decrypted_signature)
             .map_err(|_| HandshakeError::InvalidSignature)?;
 
         // g^y || g^x, if y is remote and x is local
@@ -261,7 +257,7 @@ impl<'a, S, R> State<'a, S, R> {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    pub(crate) fn update_remote_identity(&mut self, remote_pubkey: identity::PublicKey) {
+    pub(crate) fn update_remote_identity(&mut self, remote_pubkey: ed25519::PublicKey) {
         self.remote_pubkey = Some(remote_pubkey)
     }
 

common/ip-packet-requests/src/v7/request.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use nym_crypto::asymmetric::identity;
+use nym_crypto::asymmetric::ed25519;
 use nym_sphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
@@ -200,7 +200,7 @@ impl fmt::Display for IpPacketRequestData {
 }
 
 impl IpPacketRequestData {
-    pub fn add_signature(&mut self, signature: identity::Signature) -> Option<identity::Signature> {
+    pub fn add_signature(&mut self, signature: ed25519::Signature) -> Option<ed25519::Signature> {
         match self {
             IpPacketRequestData::StaticConnect(request) => {
                 request.signature = Some(signature);
@@ -269,11 +269,11 @@ impl StaticConnectRequest {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct SignedStaticConnectRequest {
     pub request: StaticConnectRequest,
-    pub signature: Option<identity::Signature>,
+    pub signature: Option<ed25519::Signature>,
 }
 
 impl SignedRequest for SignedStaticConnectRequest {
-    fn identity(&self) -> Option<&identity::PublicKey> {
+    fn identity(&self) -> Option<&ed25519::PublicKey> {
         Some(self.request.reply_to.identity())
     }
 
@@ -286,7 +286,7 @@ impl SignedRequest for SignedStaticConnectRequest {
             })
     }
 
-    fn signature(&self) -> Option<&identity::Signature> {
+    fn signature(&self) -> Option<&ed25519::Signature> {
         self.signature.as_ref()
     }
 
@@ -333,11 +333,11 @@ impl DynamicConnectRequest {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct SignedDynamicConnectRequest {
     pub request: DynamicConnectRequest,
-    pub signature: Option<identity::Signature>,
+    pub signature: Option<ed25519::Signature>,
 }
 
 impl SignedRequest for SignedDynamicConnectRequest {
-    fn identity(&self) -> Option<&identity::PublicKey> {
+    fn identity(&self) -> Option<&ed25519::PublicKey> {
         Some(self.request.reply_to.identity())
     }
 
@@ -350,7 +350,7 @@ impl SignedRequest for SignedDynamicConnectRequest {
             })
     }
 
-    fn signature(&self) -> Option<&identity::Signature> {
+    fn signature(&self) -> Option<&ed25519::Signature> {
         self.signature.as_ref()
     }
 
@@ -382,11 +382,11 @@ impl DisconnectRequest {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct SignedDisconnectRequest {
     pub request: DisconnectRequest,
-    pub signature: Option<identity::Signature>,
+    pub signature: Option<ed25519::Signature>,
 }
 
 impl SignedRequest for SignedDisconnectRequest {
-    fn identity(&self) -> Option<&identity::PublicKey> {
+    fn identity(&self) -> Option<&ed25519::PublicKey> {
         Some(self.request.reply_to.identity())
     }
 
@@ -399,7 +399,7 @@ impl SignedRequest for SignedDisconnectRequest {
             })
     }
 
-    fn signature(&self) -> Option<&identity::Signature> {
+    fn signature(&self) -> Option<&ed25519::Signature> {
         self.signature.as_ref()
     }
 

common/mixnode-common/src/packet_processor/error.rs

@@ -10,9 +10,6 @@ pub enum MixProcessingError {
     #[error("failed to recover the expected SURB-Ack packet: {0}")]
     MalformedSurbAck(#[from] SurbAckRecoveryError),
 
-    #[error("the received packet was set to use the very old and very much deprecated 'VPN' mode")]
-    ReceivedOldTypeVpnPacket,
-
     #[error("failed to process received Nym packet: {0}")]
     NymPacketProcessingError(#[from] PacketProcessingError),
 }

common/network-defaults/src/ecash.rs

@@ -37,32 +37,3 @@ impl TicketTypeRepr {
         }
     }
 }
-
-// Constants for bloom filter for double spending detection
-//Chosen for FP of
-//Calculator at https://hur.st/bloomfilter/
-pub const ECASH_DS_BLOOMFILTER_PARAMS: BloomfilterParameters = BloomfilterParameters {
-    num_hashes: 10,
-    bitmap_size: 1_500_000_000,
-    sip_keys: [
-        (12345678910111213141, 1415926535897932384),
-        (7182818284590452353, 3571113171923293137),
-    ],
-};
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct BloomfilterParameters {
-    pub num_hashes: u32,
-    pub bitmap_size: u64,
-    pub sip_keys: [(u64, u64); 2],
-}
-
-impl BloomfilterParameters {
-    pub const fn byte_size(&self) -> u64 {
-        self.bitmap_size / 8
-    }
-
-    pub const fn default_ecash() -> Self {
-        ECASH_DS_BLOOMFILTER_PARAMS
-    }
-}

common/node-tester-utils/src/node.rs

@@ -64,7 +64,7 @@ pub enum NodeType {
 
 impl NodeType {
     pub fn is_mixnode(&self) -> bool {
-        matches!(self, NodeType::Mixnode { .. })
+        matches!(self, NodeType::Mixnode)
     }
 }
 

common/node-tester-utils/src/processor.rs

@@ -3,7 +3,7 @@
 
 use crate::error::NetworkTestingError;
 use crate::TestMessage;
-use nym_crypto::asymmetric::encryption;
+use nym_crypto::asymmetric::x25519;
 use nym_sphinx::acknowledgements::identifier::recover_identifier;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::chunking::fragment::FragmentIdentifier;
@@ -31,7 +31,7 @@ impl<T> From<FragmentIdentifier> for Received<T> {
 }
 
 pub struct TestPacketProcessor<T, R: MessageReceiver = SphinxMessageReceiver> {
-    local_encryption_keypair: Arc<encryption::KeyPair>,
+    local_encryption_keypair: Arc<x25519::KeyPair>,
     ack_key: Arc<AckKey>,
 
     /// Structure responsible for decrypting and recovering plaintext message from received ciphertexts.
@@ -42,7 +42,7 @@ pub struct TestPacketProcessor<T, R: MessageReceiver = SphinxMessageReceiver> {
 
 impl<T> TestPacketProcessor<T, SphinxMessageReceiver> {
     pub fn new_sphinx_processor(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
+        local_encryption_keypair: Arc<x25519::KeyPair>,
         ack_key: Arc<AckKey>,
     ) -> Self {
         Self::new(local_encryption_keypair, ack_key)
@@ -53,7 +53,7 @@ impl<T, R> TestPacketProcessor<T, R>
 where
     R: MessageReceiver,
 {
-    pub fn new(local_encryption_keypair: Arc<encryption::KeyPair>, ack_key: Arc<AckKey>) -> Self {
+    pub fn new(local_encryption_keypair: Arc<x25519::KeyPair>, ack_key: Arc<AckKey>) -> Self {
         TestPacketProcessor {
             local_encryption_keypair,
             ack_key,

common/node-tester-utils/src/receiver.rs

@@ -6,7 +6,7 @@ use crate::processor::{Received, TestPacketProcessor};
 use crate::{log_err, log_info, log_warn};
 use futures::channel::mpsc;
 use futures::StreamExt;
-use nym_crypto::asymmetric::encryption;
+use nym_crypto::asymmetric::x25519;
 use nym_sphinx::acknowledgements::AckKey;
 use nym_sphinx::receiver::{MessageReceiver, SphinxMessageReceiver};
 use nym_task::TaskClient;
@@ -29,7 +29,7 @@ pub struct SimpleMessageReceiver<T, R: MessageReceiver = SphinxMessageReceiver>
 
 impl<T> SimpleMessageReceiver<T, SphinxMessageReceiver> {
     pub fn new_sphinx_receiver(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
+        local_encryption_keypair: Arc<x25519::KeyPair>,
         ack_key: Arc<AckKey>,
         mixnet_message_receiver: mpsc::UnboundedReceiver<Vec<Vec<u8>>>,
         acks_receiver: mpsc::UnboundedReceiver<Vec<Vec<u8>>>,
@@ -49,7 +49,7 @@ impl<T> SimpleMessageReceiver<T, SphinxMessageReceiver> {
 
 impl<T, R: MessageReceiver> SimpleMessageReceiver<T, R> {
     pub fn new(
-        local_encryption_keypair: Arc<encryption::KeyPair>,
+        local_encryption_keypair: Arc<x25519::KeyPair>,
         ack_key: Arc<AckKey>,
         mixnet_message_receiver: mpsc::UnboundedReceiver<Vec<Vec<u8>>>,
         acks_receiver: mpsc::UnboundedReceiver<Vec<Vec<u8>>>,