changed filtering behaviour to always use ALL bonded mixnodes and gateways

post-rebase clippy
fixed gateway test
2023-12-07 08:55:43 +00:00 · 2023-12-07 08:54:38 +00:00 · 2023-12-07 08:54:38 +00:00 · 2023-12-07 08:54:38 +00:00 · 2023-12-07 08:54:37 +00:00 · 2023-12-07 08:54:37 +00:00
1007 changed files with 19868 additions and 47678 deletions
@@ -3,8 +3,27 @@ import fetch from "node-fetch";
 import { Octokit } from "@octokit/rest";
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
+
+function getBinInfo(path) {
+    // let's be super naive about it. add a+x bits on the file and try to run the command
+    try {
+        let mode = fs.statSync(path).mode
+        fs.chmodSync(path, mode | 0o111)
+
+        const raw = execSync(`${path} build-info --output=json`, { stdio: 'pipe', encoding: "utf8" });
+        const parsed = JSON.parse(raw)
+        return parsed
+    } catch (_) {
+        return undefined
+    }
+}

 async function run(assets, algorithm, filename, cache) {
+    if (!cache) {
+        console.warn("cache is set to 'false', but we we no longer support it")
+    }
+
    try {
        fs.mkdirSync('.tmp');
    } catch(e) {
@@ -19,26 +38,25 @@ async function run(assets, algorithm, filename, cache) {

            let buffer = null;
            let sig = null;
-            if(cache) {
-                // cache in `${WORKING_DIR}/.tmp/`
-                const cacheFilename = path.resolve(`.tmp/${asset.name}`);
-                if(!fs.existsSync(cacheFilename)) {
-                    console.log(`Downloading ${asset.browser_download_url}... to ${cacheFilename}`);
-                    buffer = Buffer.from(await fetch(asset.browser_download_url).then(res => res.arrayBuffer()));
-                    fs.writeFileSync(cacheFilename, buffer);
-                } else {
-                    console.log(`Loading from ${cacheFilename}`);
-                    buffer = Buffer.from(fs.readFileSync(cacheFilename));

-                    // console.log('Reading signature from content');
-                    // if(asset.name.endsWith('.sig')) {
-                    //     sig = fs.readFileSync(cacheFilename).toString();
-                    // }
-                }
-            } else {
-                // fetch always
+            // cache in `${WORKING_DIR}/.tmp/`
+            const cacheFilename = path.resolve(`.tmp/${asset.name}`);
+            if(!fs.existsSync(cacheFilename)) {
+                console.log(`Downloading ${asset.browser_download_url}... to ${cacheFilename}`);
                buffer = Buffer.from(await fetch(asset.browser_download_url).then(res => res.arrayBuffer()));
+                fs.writeFileSync(cacheFilename, buffer);
+            } else {
+                console.log(`Loading from ${cacheFilename}`);
+                buffer = Buffer.from(fs.readFileSync(cacheFilename));
+
+                // console.log('Reading signature from content');
+                // if(asset.name.endsWith('.sig')) {
+                //     sig = fs.readFileSync(cacheFilename).toString();
+                // }
            }
+
+            const binInfo = getBinInfo(cacheFilename)
+
            if(!hashes[asset.name]) {
                hashes[asset.name] = {};
            }
@@ -99,6 +117,9 @@ async function run(assets, algorithm, filename, cache) {
            if(kind) {
                hashes[asset.name].kind = kind;
            }
+            if(binInfo) {
+                hashes[asset.name].details = binInfo;
+            }

            // process Tauri signature files
            if(asset.name.endsWith('.sig')) {
@@ -225,6 +246,8 @@ export async function createHashesFromReleaseTagOrNameOrId({ releaseTagOrNameOrI
            assets: hashes,
        };

+        console.log(output)
+
        if(upload) {
            console.log(`🚚 Uploading ${filename} to release name="${release.name}" id=${release.id} (${release.upload_url})...`);

@@ -2,15 +2,14 @@ name: cd-docs

 on:
  workflow_dispatch:
-  push:
-    paths:
-      - 'documentation/docs/**'

 jobs:
  build:
-    runs-on: custom-linux
+    runs-on: ubuntu-20.04-16-core
    steps:
      - uses: actions/checkout@v3
+      - 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
      - name: Install rsync
        run: sudo apt-get install rsync
      - uses: rlespinasse/github-slug-action@v3.x
@@ -26,14 +25,11 @@ jobs:
        with:
          command: build
          args: --workspace --release
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.33" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "=0.2.2" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
-            && cargo install --vers "^0.7.7" mdbook-linkcheck
+      - name: Install mdbook and plugins
+        run: cd documentation && ./install_mdbook_deps.sh
+      - name: Remove existing Nym config directory (`~/.nym/`)
+        run: cd documentation && ./remove_existing_config.sh
+        continue-on-error: false
      - name: Build all projects in documentation/ & move to ~/dist/docs/
        run: cd documentation && ./build_all_to_dist.sh
        continue-on-error: false
@@ -52,6 +48,7 @@ jobs:

      - name: Install Vercel CLI
        run: npm install --global vercel@latest
+        continue-on-error: false

      - name: Pull Vercel Environment Information (preview)
        if: github.ref != 'refs/heads/master'
@@ -61,15 +58,18 @@ jobs:
        if: github.ref == 'refs/heads/master'
        run: vercel pull --yes --environment=production --token=${{ secrets.VERCEL_TOKEN }}
        working-directory: dist/docs
+        continue-on-error: false

      - name: Build Project Artifacts (preview)
        if: github.ref != 'refs/heads/master'
        run: vercel build --token=${{ secrets.VERCEL_TOKEN }}
        working-directory: dist/docs
+        continue-on-error: false
      - name: Build Project Artifacts (production)
        if: github.ref == 'refs/heads/master'
        run: vercel build --prod --token=${{ secrets.VERCEL_TOKEN }}
        working-directory: dist/docs
+        continue-on-error: false

      - name: Deploy Project Artifacts to Vercel (preview)
        if: github.ref != 'refs/heads/master'
@@ -79,6 +79,7 @@ jobs:
        if: github.ref == 'refs/heads/master'
        run: vercel deploy --prebuilt --prod --token=${{ secrets.VERCEL_TOKEN }}
        working-directory: dist/docs
+        continue-on-error: false

      - name: Matrix - Node Install
        run: npm install
@@ -9,9 +9,11 @@ on:

 jobs:
  build:
-    runs-on: custom-linux
+    runs-on: ubuntu-20.04-16-core
    steps:
      - uses: actions/checkout@v3
+      - 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
      - name: Install rsync
        run: sudo apt-get install rsync
      - uses: rlespinasse/github-slug-action@v3.x
@@ -27,22 +29,15 @@ jobs:
        with:
          command: build
          args: --workspace --release
-      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.35" mdbook)
-      - name: Install mdbook plugins
-        run: |
-          cargo install --vers "=0.2.2" mdbook-variables && cargo install \
-            --vers "^1.8.0" mdbook-admonish --force && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
-            && cargo install --vers "^0.7.7" mdbook-linkcheck \
-            # && cd documentation \
-            # && mdbook-admonish install dev-portal \
-            # && mdbook-admonish install docs \
-            # && mdbook-admonish install operators
-
-      - name: Build all projects in documentation/ & move to ~/dist/docs/
-        run: cd documentation && ./build_all_to_dist.sh 
+      - name: Install mdbook and plugins
+        run: cd documentation && ./install_mdbook_deps.sh
+      - name: Remove existing Nym config directory (`~/.nym/`)
+        run: cd documentation && ./remove_existing_config.sh
        continue-on-error: false
+      - name: Build all projects in documentation/ & move to ~/dist/docs/
+        run: cd documentation && ./build_all_to_dist.sh
+        continue-on-error: false
+
      - name: Deploy branch to CI www
        continue-on-error: true
        uses: easingthemes/ssh-deploy@main
@@ -54,6 +49,7 @@ jobs:
          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/docs-${{ env.GITHUB_REF_SLUG }}
          EXCLUDE: "/node_modules/"
+
      - name: Matrix - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
@@ -35,7 +35,7 @@ jobs:
        uses: actions-rs/cargo@v1
        with:
          command: build
-          args: --manifest-path ${{ env.CARGOTOML_PATH }} --lib --features custom-protocol
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --features custom-protocol

 #      - name: Run all tests
 #        uses: actions-rs/cargo@v1
@@ -0,0 +1,43 @@
+# Simple workflow for deploying static content to GitHub Pages
+name: Deploy static content to Pages
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["feature/ppa-repo"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  # Single deploy job since we're just deploying
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Setup Pages
+        uses: actions/configure-pages@v3
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v2
+        with:
+          # Upload entire repository
+          path: './ppa'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v2
@@ -45,4 +45,6 @@ envs/qwerty.env
 cpu-cycles/libcpucycles/build
 foxyfox.env

-.next
+.next
+ppa-private-key.b64
+ppa-private-key.asc
@@ -4,17 +4,41 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

+## [2023.5-rolo] (2023-11-28)
+
+- Gateway won't open websocket listener until embedded Network Requester becomes available ([#4166])
+- Feature/gateway described nr ([#4147])
+- Bugfix/prerelease versionbump ([#4145])
+- returning 'nil' for non-existing origin as opposed to an empty string ([#4135])
+- using performance^20 when calculating active set selection weight ([#4126])
+- Change default http API timeout from 3s to 10s ([#4117])
+
+[#4166]: https://github.com/nymtech/nym/issues/4166
+[#4147]: https://github.com/nymtech/nym/pull/4147
+[#4145]: https://github.com/nymtech/nym/pull/4145
+[#4135]: https://github.com/nymtech/nym/pull/4135
+[#4126]: https://github.com/nymtech/nym/pull/4126
+[#4117]: https://github.com/nymtech/nym/pull/4117
+
+## [2023.nyxd-upgrade] (2023-11-22)
+
+- Chore/nyxd 043 upgrade ([#3968])
+
+[#3968]: https://github.com/nymtech/nym/pull/3968
+
 ## [2023.4-galaxy] (2023-11-07)

 - DRY up client cli ([#4077])
 - [mixnode] replace rocket with axum ([#4071])
 - incorporate the nym node HTTP api into the mixnode ([#4070])
 - replaced '--disable-sign-ext' with '--signext-lowering' when running wasm-opt ([#3896])
+- Added PPA repo hosting support and nym-mixnode package with tooling for publishing ([#4165])

 [#4077]: https://github.com/nymtech/nym/pull/4077
 [#4071]: https://github.com/nymtech/nym/pull/4071
 [#4070]: https://github.com/nymtech/nym/issues/4070
 [#3896]: https://github.com/nymtech/nym/pull/3896
+[#4165]: https://github.com/nymtech/nym/pull/4165

 ## [2023.3-kinder] (2023-10-31)

@@ -628,17 +628,6 @@ dependencies = [
 "event-listener",
 ]

-[[package]]
-name = "async-recursion"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd55a5ba1179988837d24ab4c7cc8ed6efdeff578ede0416b4225a5fca35bd0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.38",
-]
-
 [[package]]
 name = "async-stream"
 version = "0.3.5"
@@ -1030,29 +1019,6 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "845141a4fade3f790628b7daaaa298a25b204fb28907eb54febe5142db6ce653"

-[[package]]
-name = "boringtun"
-version = "0.6.0"
-source = "git+https://github.com/cloudflare/boringtun?rev=e1d6360d6ab4529fc942a078e4c54df107abe2ba#e1d6360d6ab4529fc942a078e4c54df107abe2ba"
-dependencies = [
- "aead 0.5.2",
- "base64 0.13.1",
- "blake2 0.10.6",
- "chacha20poly1305 0.10.1",
- "hex",
- "hmac 0.12.1",
- "ip_network",
- "ip_network_table",
- "libc",
- "nix 0.25.1",
- "parking_lot 0.12.1",
- "rand_core 0.6.4",
- "ring 0.16.20",
- "tracing",
- "untrusted 0.9.0",
- "x25519-dalek 2.0.0",
-]
-
 [[package]]
 name = "brotli"
 version = "3.4.0"
@@ -1554,8 +1520,8 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2895653b4d9f1538a83970077cb01dfc77a4810524e51a110944688e916b18e"
 dependencies = [
- "prost",
- "prost-types",
+ "prost 0.11.9",
+ "prost-types 0.11.9",
 "tonic",
 "tracing-core",
 ]
@@ -1572,7 +1538,7 @@ dependencies = [
 "futures",
 "hdrhistogram",
 "humantime 2.1.0",
- "prost-types",
+ "prost-types 0.11.9",
 "serde",
 "serde_json",
 "thread_local",
@@ -1661,30 +1627,30 @@ dependencies = [

 [[package]]
 name = "cosmos-sdk-proto"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73c9d2043a9e617b0d602fbc0a0ecd621568edbf3a9774890a6d562389bd8e1c"
+checksum = "32560304ab4c365791fd307282f76637213d8083c1a98490c35159cd67852237"
 dependencies = [
- "prost",
- "prost-types",
+ "prost 0.12.1",
+ "prost-types 0.12.1",
 "tendermint-proto",
 ]

 [[package]]
 name = "cosmrs"
-version = "0.14.0"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af13955d6f356272e6def9ff5e2450a7650df536d8934f47052a20c76513d2f6"
+checksum = "47126f5364df9387b9d8559dcef62e99010e1d4098f39eb3f7ee4b5c254e40ea"
 dependencies = [
 "bip32",
 "cosmos-sdk-proto",
 "ecdsa 0.16.8",
 "eyre",
- "getrandom 0.2.10",
 "k256",
 "rand_core 0.6.4",
 "serde",
 "serde_json",
+ "signature 2.1.0",
 "subtle-encoding",
 "tendermint",
 "tendermint-rpc",
@@ -2009,15 +1975,6 @@ dependencies = [
 "subtle 2.4.1",
 ]

-[[package]]
-name = "ct-logs"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1a816186fa68d9e426e3cb4ae4dff1fcd8e4a2c34b781bf7a822574a0d0aac8"
-dependencies = [
- "sct 0.6.1",
-]
-
 [[package]]
 name = "ctor"
 version = "0.1.26"
@@ -2346,6 +2303,25 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "defguard_wireguard_rs"
+version = "0.3.0"
+source = "git+https://github.com/neacsu/wireguard-rs.git?rev=c2cd0c1119f699f4bc43f5e6ffd6fc242caa42ed#c2cd0c1119f699f4bc43f5e6ffd6fc242caa42ed"
+dependencies = [
+ "base64 0.21.4",
+ "libc",
+ "log",
+ "netlink-packet-core 0.7.0",
+ "netlink-packet-generic",
+ "netlink-packet-route 0.17.1",
+ "netlink-packet-utils",
+ "netlink-packet-wireguard",
+ "netlink-sys",
+ "nix 0.27.1",
+ "serde",
+ "thiserror",
+]
+
 [[package]]
 name = "der"
 version = "0.6.1"
@@ -2938,7 +2914,7 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"

 [[package]]
 name = "explorer-api"
-version = "1.1.31"
+version = "1.1.32"
 dependencies = [
 "chrono",
 "clap 4.4.7",
@@ -3696,30 +3672,6 @@ dependencies = [
 "num-traits",
 ]

-[[package]]
-name = "headers"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06683b93020a07e3dbcf5f8c0f6d40080d725bea7936fc01ad345c01b97dc270"
-dependencies = [
- "base64 0.21.4",
- "bytes",
- "headers-core",
- "http",
- "httpdate",
- "mime",
- "sha1",
-]
-
-[[package]]
-name = "headers-core"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429"
-dependencies = [
- "http",
-]
-
 [[package]]
 name = "heck"
 version = "0.3.3"
@@ -3958,40 +3910,17 @@ dependencies = [
 ]

 [[package]]
-name = "hyper-proxy"
-version = "0.9.1"
+name = "hyper-rustls"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca815a891b24fdfb243fa3239c86154392b0953ee584aa1a2a1f66d20cbe75cc"
+checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
 dependencies = [
- "bytes",
- "futures",
- "headers",
+ "futures-util",
 "http",
 "hyper",
- "hyper-rustls",
- "rustls-native-certs",
+ "rustls 0.21.7",
 "tokio",
- "tokio-rustls 0.22.0",
- "tower-service",
- "webpki 0.21.4",
-]
-
-[[package]]
-name = "hyper-rustls"
-version = "0.22.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f9f7a97316d44c0af9b0301e65010573a853a9fc97046d7331d7f6bc0fd5a64"
-dependencies = [
- "ct-logs",
- "futures-util",
- "hyper",
- "log",
- "rustls 0.19.1",
- "rustls-native-certs",
- "tokio",
- "tokio-rustls 0.22.0",
- "webpki 0.21.4",
- "webpki-roots 0.21.1",
+ "tokio-rustls 0.24.1",
 ]

 [[package]]
@@ -4248,22 +4177,6 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "aa2f047c0a98b2f299aa5d6d7088443570faae494e9ae1305e48be000c9e0eb1"

-[[package]]
-name = "ip_network_table"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4099b7cfc5c5e2fe8c5edf3f6f7adf7a714c9cc697534f63a5a5da30397cb2c0"
-dependencies = [
- "ip_network",
- "ip_network_table-deps-treebitmap",
-]
-
-[[package]]
-name = "ip_network_table-deps-treebitmap"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e537132deb99c0eb4b752f0346b6a836200eaaa3516dd7e5514b63930a09e5d"
-
 [[package]]
 name = "ipconfig"
 version = "0.3.2"
@@ -4658,7 +4571,7 @@ dependencies = [
 "once_cell",
 "parking_lot 0.12.1",
 "pin-project",
- "prost",
+ "prost 0.11.9",
 "prost-build",
 "rand 0.8.5",
 "rw-stream-sink 0.3.0 (git+https://github.com/ChainSafe/rust-libp2p.git?rev=e3440d25681df380c9f0f8cfdcfd5ecc0a4f2fb6)",
@@ -4744,7 +4657,7 @@ dependencies = [
 "libp2p-swarm 0.42.0",
 "log",
 "prometheus-client",
- "prost",
+ "prost 0.11.9",
 "prost-build",
 "prost-codec",
 "rand 0.8.5",
@@ -4802,7 +4715,7 @@ dependencies = [
 "libp2p-swarm 0.42.0",
 "log",
 "lru 0.9.0",
- "prost",
+ "prost 0.11.9",
 "prost-build",
 "prost-codec",
 "smallvec",
@@ -4952,7 +4865,7 @@ dependencies = [
 "libp2p-core 0.39.0",
 "log",
 "once_cell",
- "prost",
+ "prost 0.11.9",
 "prost-build",
 "rand 0.8.5",
 "sha2 0.10.8",
@@ -5204,7 +5117,7 @@ dependencies = [
 "libp2p-noise 0.42.0",
 "log",
 "multihash",
- "prost",
+ "prost 0.11.9",
 "prost-build",
 "prost-codec",
 "rand 0.8.5",
@@ -5750,6 +5663,29 @@ dependencies = [
 "netlink-packet-utils",
 ]

+[[package]]
+name = "netlink-packet-core"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72724faf704479d67b388da142b186f916188505e7e0b26719019c525882eda4"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "netlink-packet-utils",
+]
+
+[[package]]
+name = "netlink-packet-generic"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cd7eb8ad331c84c6b8cb7f685b448133e5ad82e1ffd5acafac374af4a5a308b"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "netlink-packet-core 0.7.0",
+ "netlink-packet-utils",
+]
+
 [[package]]
 name = "netlink-packet-route"
 version = "0.12.0"
@@ -5760,7 +5696,21 @@ dependencies = [
 "bitflags 1.3.2",
 "byteorder",
 "libc",
- "netlink-packet-core",
+ "netlink-packet-core 0.4.2",
+ "netlink-packet-utils",
+]
+
+[[package]]
+name = "netlink-packet-route"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053998cea5a306971f88580d0829e90f270f940befd7cf928da179d4187a5a66"
+dependencies = [
+ "anyhow",
+ "bitflags 1.3.2",
+ "byteorder",
+ "libc",
+ "netlink-packet-core 0.7.0",
 "netlink-packet-utils",
 ]

@@ -5776,6 +5726,20 @@ dependencies = [
 "thiserror",
 ]

+[[package]]
+name = "netlink-packet-wireguard"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b25b050ff1f6a1e23c6777b72db22790fe5b6b5ccfd3858672587a79876c8f"
+dependencies = [
+ "anyhow",
+ "byteorder",
+ "libc",
+ "log",
+ "netlink-packet-generic",
+ "netlink-packet-utils",
+]
+
 [[package]]
 name = "netlink-proto"
 version = "0.10.0"
@@ -5785,7 +5749,7 @@ dependencies = [
 "bytes",
 "futures",
 "log",
- "netlink-packet-core",
+ "netlink-packet-core 0.4.2",
 "netlink-sys",
 "thiserror",
 "tokio",
@@ -5816,18 +5780,6 @@ dependencies = [
 "memoffset 0.6.5",
 ]

-[[package]]
-name = "nix"
-version = "0.25.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
-dependencies = [
- "autocfg 1.1.0",
- "bitflags 1.3.2",
- "cfg-if",
- "libc",
-]
-
 [[package]]
 name = "nix"
 version = "0.27.1"
@@ -5837,6 +5789,7 @@ dependencies = [
 "bitflags 2.4.1",
 "cfg-if",
 "libc",
+ "memoffset 0.9.0",
 ]

 [[package]]
@@ -5961,7 +5914,7 @@ dependencies = [

 [[package]]
 name = "nym-api"
-version = "1.1.32"
+version = "1.1.34"
 dependencies = [
 "actix-web",
 "anyhow",
@@ -6111,7 +6064,7 @@ dependencies = [

 [[package]]
 name = "nym-cli"
-version = "1.1.31"
+version = "1.1.33"
 dependencies = [
 "anyhow",
 "base64 0.13.1",
@@ -6184,7 +6137,7 @@ dependencies = [

 [[package]]
 name = "nym-client"
-version = "1.1.31"
+version = "1.1.32"
 dependencies = [
 "clap 4.4.7",
 "dirs 4.0.0",
@@ -6528,7 +6481,7 @@ dependencies = [

 [[package]]
 name = "nym-gateway"
-version = "1.1.31"
+version = "1.1.32"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -6538,6 +6491,7 @@ dependencies = [
 "clap 4.4.7",
 "colored",
 "dashmap",
+ "defguard_wireguard_rs",
 "dirs 4.0.0",
 "dotenvy",
 "futures",
@@ -6567,7 +6521,6 @@ dependencies = [
 "nym-validator-client",
 "nym-wireguard",
 "once_cell",
- "pretty_env_logger",
 "rand 0.7.3",
 "rand 0.8.5",
 "serde",
@@ -6657,10 +6610,24 @@ dependencies = [
 "thiserror",
 ]

+[[package]]
+name = "nym-ip-packet-requests"
+version = "0.1.0"
+dependencies = [
+ "bincode",
+ "bytes",
+ "nym-sphinx",
+ "rand 0.8.5",
+ "serde",
+ "thiserror",
+]
+
 [[package]]
 name = "nym-ip-packet-router"
 version = "0.1.0"
 dependencies = [
+ "bincode",
+ "bytes",
 "etherparse",
 "futures",
 "log",
@@ -6668,19 +6635,23 @@ dependencies = [
 "nym-client-core",
 "nym-config",
 "nym-exit-policy",
+ "nym-ip-packet-requests",
 "nym-network-requester",
 "nym-sdk",
 "nym-service-providers-common",
 "nym-sphinx",
 "nym-task",
+ "nym-tun",
 "nym-wireguard",
 "nym-wireguard-types",
+ "rand 0.8.5",
 "reqwest",
 "serde",
 "serde_json",
 "tap",
 "thiserror",
 "tokio",
+ "tokio-tun",
 "url",
 ]

@@ -6719,7 +6690,7 @@ dependencies = [

 [[package]]
 name = "nym-mixnode"
-version = "1.1.33"
+version = "1.1.34"
 dependencies = [
 "anyhow",
 "axum",
@@ -6751,7 +6722,6 @@ dependencies = [
 "nym-types",
 "nym-validator-client",
 "opentelemetry",
- "pretty_env_logger",
 "rand 0.7.3",
 "serde",
 "serde_json",
@@ -6776,6 +6746,7 @@ dependencies = [
 "log",
 "nym-bin-common",
 "nym-crypto",
+ "nym-mixnet-contract-common",
 "nym-network-defaults",
 "nym-sphinx-acknowledgements",
 "nym-sphinx-addressing",
@@ -6785,6 +6756,7 @@ dependencies = [
 "nym-sphinx-types",
 "nym-task",
 "nym-validator-client",
+ "parking_lot 0.12.1",
 "rand 0.8.5",
 "serde",
 "thiserror",
@@ -6839,7 +6811,7 @@ dependencies = [

 [[package]]
 name = "nym-network-requester"
-version = "1.1.31"
+version = "1.1.32"
 dependencies = [
 "anyhow",
 "async-file-watcher",
@@ -6887,7 +6859,7 @@ dependencies = [

 [[package]]
 name = "nym-network-statistics"
-version = "1.1.31"
+version = "1.1.32"
 dependencies = [
 "dirs 4.0.0",
 "log",
@@ -6920,6 +6892,7 @@ dependencies = [
 "nym-crypto",
 "nym-node-requests",
 "nym-task",
+ "nym-wireguard",
 "nym-wireguard-types",
 "rand 0.7.3",
 "serde",
@@ -7131,7 +7104,7 @@ dependencies = [

 [[package]]
 name = "nym-socks5-client"
-version = "1.1.31"
+version = "1.1.32"
 dependencies = [
 "clap 4.4.7",
 "lazy_static",
@@ -7462,6 +7435,18 @@ dependencies = [
 "wasm-utils",
 ]

+[[package]]
+name = "nym-tun"
+version = "0.1.0"
+dependencies = [
+ "etherparse",
+ "log",
+ "nym-wireguard-types",
+ "thiserror",
+ "tokio",
+ "tokio-tun",
+]
+
 [[package]]
 name = "nym-types"
 version = "1.0.0"
@@ -7498,6 +7483,7 @@ version = "0.1.0"
 dependencies = [
 "async-trait",
 "base64 0.13.1",
+ "bip32",
 "bip39",
 "colored",
 "cosmrs",
@@ -7528,7 +7514,7 @@ dependencies = [
 "nym-service-provider-directory-common",
 "nym-vesting-contract-common",
 "openssl",
- "prost",
+ "prost 0.12.1",
 "reqwest",
 "serde",
 "serde_json",
@@ -7579,24 +7565,15 @@ dependencies = [
 name = "nym-wireguard"
 version = "0.1.0"
 dependencies = [
- "async-recursion",
 "base64 0.21.4",
- "boringtun",
- "bytes",
- "dashmap",
- "etherparse",
- "futures",
+ "defguard_wireguard_rs",
 "ip_network",
- "ip_network_table",
 "log",
+ "nym-network-defaults",
 "nym-task",
 "nym-wireguard-types",
- "rand 0.8.5",
- "serde",
- "tap",
- "thiserror",
 "tokio",
- "tokio-tun",
+ "x25519-dalek 2.0.0",
 ]

 [[package]]
@@ -7604,9 +7581,9 @@ name = "nym-wireguard-types"
 version = "0.1.0"
 dependencies = [
 "base64 0.21.4",
- "boringtun",
 "dashmap",
 "hmac 0.12.1",
+ "log",
 "nym-crypto",
 "rand 0.7.3",
 "serde",
@@ -7617,6 +7594,36 @@ dependencies = [
 "x25519-dalek 2.0.0",
 ]

+[[package]]
+name = "nymvisor"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-file-watcher",
+ "bytes",
+ "clap 4.4.7",
+ "dotenvy",
+ "flate2",
+ "futures",
+ "hex",
+ "humantime 2.1.0",
+ "humantime-serde",
+ "nix 0.27.1",
+ "nym-bin-common",
+ "nym-config",
+ "nym-task",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "sha2 0.10.8",
+ "tar",
+ "thiserror",
+ "time",
+ "tokio",
+ "tracing",
+ "url",
+]
+
 [[package]]
 name = "object"
 version = "0.32.1"
@@ -8396,7 +8403,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b82eaa1d779e9a4bc1c3217db8ffbeabaae1dca241bf70183242128d48681cd"
 dependencies = [
 "bytes",
- "prost-derive",
+ "prost-derive 0.11.9",
+]
+
+[[package]]
+name = "prost"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4fdd22f3b9c31b53c060df4a0613a1c7f062d4115a2b984dd15b1858f7e340d"
+dependencies = [
+ "bytes",
+ "prost-derive 0.12.1",
 ]

 [[package]]
@@ -8413,8 +8430,8 @@ dependencies = [
 "multimap",
 "petgraph",
 "prettyplease",
- "prost",
- "prost-types",
+ "prost 0.11.9",
+ "prost-types 0.11.9",
 "regex",
 "syn 1.0.109",
 "tempfile",
@@ -8428,7 +8445,7 @@ source = "git+https://github.com/ChainSafe/rust-libp2p.git?rev=e3440d25681df380c
 dependencies = [
 "asynchronous-codec",
 "bytes",
- "prost",
+ "prost 0.11.9",
 "thiserror",
 "unsigned-varint",
 ]
@@ -8446,13 +8463,35 @@ dependencies = [
 "syn 1.0.109",
 ]

+[[package]]
+name = "prost-derive"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "265baba7fabd416cf5078179f7d2cbeca4ce7a9041111900675ea7c4cb8a4c32"
+dependencies = [
+ "anyhow",
+ "itertools 0.11.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.38",
+]
+
 [[package]]
 name = "prost-types"
 version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "213622a1460818959ac1181aaeb2dc9c7f63df720db7d788b3e24eacd1983e13"
 dependencies = [
- "prost",
+ "prost 0.11.9",
+]
+
+[[package]]
+name = "prost-types"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e081b29f63d83a4bc75cfc9f3fe424f9156cf92d8a4f0c9407cce9a1b67327cf"
+dependencies = [
+ "prost 0.12.1",
 ]

 [[package]]
@@ -8964,6 +9003,7 @@ dependencies = [
 "http",
 "http-body",
 "hyper",
+ "hyper-rustls",
 "hyper-tls",
 "ipnet",
 "js-sys",
@@ -8973,17 +9013,23 @@ dependencies = [
 "once_cell",
 "percent-encoding",
 "pin-project-lite 0.2.13",
+ "rustls 0.21.7",
+ "rustls-native-certs",
+ "rustls-pemfile",
 "serde",
 "serde_json",
 "serde_urlencoded",
 "system-configuration",
 "tokio",
 "tokio-native-tls",
+ "tokio-rustls 0.24.1",
 "tokio-socks",
+ "tokio-util",
 "tower-service",
 "url",
 "wasm-bindgen",
 "wasm-bindgen-futures",
+ "wasm-streams",
 "web-sys",
 "winreg",
 ]
@@ -9202,7 +9248,7 @@ checksum = "322c53fd76a18698f1c27381d58091de3a043d356aa5bd0d510608b565f469a0"
 dependencies = [
 "futures",
 "log",
- "netlink-packet-route",
+ "netlink-packet-route 0.12.0",
 "netlink-proto",
 "nix 0.24.3",
 "thiserror",
@@ -9378,12 +9424,12 @@ dependencies = [

 [[package]]
 name = "rustls-native-certs"
-version = "0.5.0"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a07b7c1885bd8ed3831c289b7870b13ef46fe0e856d288c30d9cc17d75a2092"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
 dependencies = [
 "openssl-probe",
- "rustls 0.19.1",
+ "rustls-pemfile",
 "schannel",
 "security-framework",
 ]
@@ -9442,9 +9488,9 @@ checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"

 [[package]]
 name = "safer-ffi"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9c1d19b288ca9898cd421c7b105fb7269918a7f8e9253a991e228981ca421ad"
+checksum = "395ace5aff9629c7268ca8255aceb945525b2cb644015f3caec5131a6a537c11"
 dependencies = [
 "inventory",
 "libc",
@@ -9459,9 +9505,9 @@ dependencies = [

 [[package]]
 name = "safer_ffi-proc_macros"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2d7a04caa3ca2224f5ea4ddd850e2629c3b36b2b83621f87a8303bf41020110"
+checksum = "9255504d5467bae9e07d58b8de446ba6739b29bf72e1fa35b2387e30d29dcbfe"
 dependencies = [
 "macro_rules_attribute",
 "prettyplease",
@@ -10569,6 +10615,17 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"

+[[package]]
+name = "tar"
+version = "0.4.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
 [[package]]
 name = "tempfile"
 version = "3.8.0"
@@ -10584,9 +10641,9 @@ dependencies = [

 [[package]]
 name = "tendermint"
-version = "0.32.2"
+version = "0.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f0a7d05cf78524782337f8edd55cbc578d159a16ad4affe2135c92f7dbac7f0"
+checksum = "bc2294fa667c8b548ee27a9ba59115472d0a09c2ba255771092a7f1dcf03a789"
 dependencies = [
 "bytes",
 "digest 0.10.7",
@@ -10597,8 +10654,8 @@ dependencies = [
 "k256",
 "num-traits",
 "once_cell",
- "prost",
- "prost-types",
+ "prost 0.12.1",
+ "prost-types 0.12.1",
 "ripemd",
 "serde",
 "serde_bytes",
@@ -10615,9 +10672,9 @@ dependencies = [

 [[package]]
 name = "tendermint-config"
-version = "0.32.2"
+version = "0.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71a72dbbea6dde12045d261f2c70c0de039125675e8a026c8d5ad34522756372"
+checksum = "5a25dbe8b953e80f3d61789fbdb83bf9ad6c0ef16df5ca6546f49912542cc137"
 dependencies = [
 "flex-error",
 "serde",
@@ -10629,16 +10686,16 @@ dependencies = [

 [[package]]
 name = "tendermint-proto"
-version = "0.32.2"
+version = "0.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0cec054567d16d85e8c3f6a3139963d1a66d9d3051ed545d31562550e9bcc3d"
+checksum = "2cc728a4f9e891d71adf66af6ecaece146f9c7a11312288a3107b3e1d6979aaf"
 dependencies = [
 "bytes",
 "flex-error",
 "num-derive",
 "num-traits",
- "prost",
- "prost-types",
+ "prost 0.12.1",
+ "prost-types 0.12.1",
 "serde",
 "serde_bytes",
 "subtle-encoding",
@@ -10647,21 +10704,18 @@ dependencies = [

 [[package]]
 name = "tendermint-rpc"
-version = "0.32.2"
+version = "0.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d119d83a130537fc4a98c3c9eb6899ebe857fea4860400a61675bfb5f0b35129"
+checksum = "dfbf0a4753b46a190f367337e0163d0b552a2674a6bac54e74f9f2cdcde2969b"
 dependencies = [
 "async-trait",
 "bytes",
 "flex-error",
 "futures",
 "getrandom 0.2.10",
- "http",
- "hyper",
- "hyper-proxy",
- "hyper-rustls",
 "peg",
 "pin-project",
+ "reqwest",
 "semver 1.0.20",
 "serde",
 "serde_bytes",
@@ -10885,6 +10939,16 @@ dependencies = [
 "webpki 0.22.4",
 ]

+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.7",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-socks"
 version = "0.5.1"
@@ -10924,9 +10988,9 @@ dependencies = [

 [[package]]
 name = "tokio-tun"
-version = "0.9.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4a67d1405a577ba1f4cd61f46608f1db2cadbb6a9549c3fc2eed7f1195393c9"
+checksum = "bf2efaf33e86779a3a68b1f1d6e9e13a346c1c75ee3cab7a4293235c463b2668"
 dependencies = [
 "libc",
 "nix 0.27.1",
@@ -11076,7 +11140,7 @@ dependencies = [
 "hyper-timeout",
 "percent-encoding",
 "pin-project",
- "prost",
+ "prost 0.11.9",
 "tokio",
 "tokio-stream",
 "tower",
@@ -11926,6 +11990,19 @@ dependencies = [
 "wasm-utils",
 ]

+[[package]]
+name = "wasm-streams"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4609d447824375f43e1ffbc051b50ad8f4b3ae8219680c94452ea05eb240ac7"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
 [[package]]
 name = "wasm-timer"
 version = "0.2.5"
@@ -12550,6 +12627,15 @@ dependencies = [
 "time",
 ]

+[[package]]
+name = "xattr"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4686009f71ff3e5c4dbcf1a282d0a44db3f021ba69350cd42086b3e5f1c6985"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "yamux"
 version = "0.10.2"
@@ -49,6 +49,7 @@ members = [
    "common/exit-policy",
    "common/http-api-client",
    "common/inclusion-probability",
+    "common/ip-packet-requests",
    "common/ledger",
    "common/mixnode-common",
    "common/network-defaults",
@@ -74,6 +75,7 @@ members = [
    "common/store-cipher",
    "common/task",
    "common/topology",
+    "common/tun",
    "common/types",
    "common/wasm/client-core",
    "common/wasm/storage",
@@ -103,6 +105,7 @@ members = [
    "tools/internal/sdk-version-bump",
    "tools/nym-cli",
    "tools/nym-nr-query",
+    "tools/nymvisor",
    "tools/ts-rs-cli",
    "wasm/client",
 #    "wasm/full-nym-wasm",
@@ -118,6 +121,7 @@ default-members = [
    "service-providers/network-statistics",
    "mixnode",
    "nym-api",
+    "tools/nymvisor",
    "explorer-api",
 ]

@@ -137,24 +141,8 @@ async-trait = "0.1.68"
 axum = "0.6.20"
 base64 = "0.21.4"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
-boringtun = { git = "https://github.com/cloudflare/boringtun", rev = "e1d6360d6ab4529fc942a078e4c54df107abe2ba" }
 clap = "4.4.7"
 cfg-if = "1.0.0"
-cosmwasm-derive = "=1.3.0"
-cosmwasm-schema = "=1.3.0"
-cosmwasm-std = "=1.3.0"
-# use 0.5.0 as that's the version used by cosmwasm-std 1.3.0
-# (and ideally we don't want to pull the same dependency twice)
-serde-json-wasm = "=0.5.0"
-cosmwasm-storage = "=1.3.0"
-cosmrs = "=0.14.0"
-# same version as used by cosmrs
-cw-utils = "=1.0.1"
-cw-storage-plus = "=1.1.0"
-cw2 = { version = "=1.1.0" }
-cw3 = { version = "=1.1.0" }
-cw4 = { version = "=1.1.0" }
-cw-controllers = { version = "=1.1.0" }
 dashmap = "5.5.3"
 dotenvy = "0.15.6"
 futures = "0.3.28"
@@ -172,10 +160,12 @@ schemars = "0.8.1"
 serde = "1.0.152"
 serde_json = "1.0.91"
 tap = "1.0.1"
-tendermint-rpc = "0.32" # same version as used by cosmrs
+time = "0.3.30"
 thiserror = "1.0.48"
-tokio = "1.24.1"
+tokio = "1.33.0"
+tokio-stream = "0.1.14"
 tokio-tungstenite = "0.20.1"
+tokio-util = "0.7.9"
 tracing = "0.1.37"
 tungstenite = { version = "0.20.1", default-features = false }
 ts-rs = "7.0.0"
@@ -184,6 +174,28 @@ utoipa-swagger-ui = "3.1.5"
 url = "2.4"
 zeroize = "1.6.0"

+# cosmwasm-related
+cosmwasm-derive = "=1.3.0"
+cosmwasm-schema = "=1.3.0"
+cosmwasm-std = "=1.3.0"
+# use 0.5.0 as that's the version used by cosmwasm-std 1.3.0
+# (and ideally we don't want to pull the same dependency twice)
+serde-json-wasm = "=0.5.0"
+cosmwasm-storage = "=1.3.0"
+# same version as used by cosmwasm
+cw-utils = "=1.0.1"
+cw-storage-plus = "=1.1.0"
+cw2 = { version = "=1.1.0" }
+cw3 = { version = "=1.1.0" }
+cw4 = { version = "=1.1.0" }
+cw-controllers = { version = "=1.1.0" }
+
+# cosmrs-related
+bip32 = "0.5.1"
+cosmrs = "=0.15.0"
+tendermint-rpc = "0.34" # same version as used by cosmrs
+prost = "0.12"
+
 # wasm-related dependencies
 gloo-utils = "0.1.7"
 js-sys = "0.3.63"
@@ -0,0 +1,439 @@
+Attribution-NonCommercial-ShareAlike 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial-ShareAlike 4.0 International Public License
+("Public License"). To the extent this Public License may be
+interpreted as a contract, You are granted the Licensed Rights in
+consideration of Your acceptance of these terms and conditions, and the
+Licensor grants You such rights in consideration of benefits the
+Licensor receives from making the Licensed Material available under
+these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-NC-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution, NonCommercial, and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+
+  l. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  m. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  n. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-NC-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+     including for purposes of Section 3(b); and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the â€œLicensor.â€ The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+
+
@@ -81,7 +81,7 @@ works, such as semiconductor masks.
 License.  Each licensee is addressed as "you".  "Licensees" and
 "recipients" may be individuals or organizations.

-  To "modify" a work means to copy from or adapt all or part of the work
+  To "modify" a work means tocopy from or adapt all or part of the work
 in a fashion requiring copyright permission, other than the making of an
 exact copy.  The resulting work is called a "modified version" of the
 earlier work or a work "based on" the earlier work.
@@ -672,3 +672,4 @@ may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
 <https://www.gnu.org/licenses/why-not-lgpl.html>.
+ 
@@ -168,3 +168,7 @@ generate-typescript:
 run-api-tests:
 	cd nym-api/tests/functional_test && yarn test:qa

+# Build debian package, and update PPA
+# Requires base64 encode GPG key to be set up in environment PPA_SIGNING_KEY
+deb:
+	scripts/ppa.sh
@@ -15,7 +15,6 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-explorer - a (projected) block explorer and (existing) mixnet viewer.
 * nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework.

-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/nymtech/nym/build.yml?branch=develop&style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)


@@ -83,4 +82,11 @@ where `s'` is stake `s` scaled over total token circulating supply.

 ### Licensing and copyright information

-This program is available as open source under the terms of the Apache 2.0 license. However, some elements are being licensed under CC0-1.0 and MIT. For accurate information, please check individual files.
+This is a monorepo and components that make up Nym as a system are licensed individually, so for accurate information, please check individual files.
+
+As a general approach, licensing is as follows this pattern:
+- applications and binaries are GPLv3
+- libraries and components are Apache 2.0 or MIT
+- documentation is Apache 2.0 or CC0-1.0
+
+Again, for accurate information, please check individual files.
@@ -1,19 +0,0 @@
-#!/bin/sh
-#  ci_post_clone.sh
-cd /nym-vpn/desktop && \
-curl https://sh.rustup.rs -sSf | sh && \
-cargo install cargo-deb;
-cargo install --force cargo-make;
-cargo install sd;
-cargo install ripgrep;
-cargo install cargo-about;
-cargo install cargo-generate-rpm;
-brew install protobuf;
-APPLICATION_SIGNING_IDENTITY="Developer ID Application: Nym Technologies SA (VW5DZLFHM5)" \
-INSTALLER_SIGNING_IDENTITY="3rd Party Mac Developer Installer: Nym Technologies SA (VW5DZLFHM5)"  \
-APPLE_TEAM_ID=VW5DZLFHM5 \
-cargo make pkg;
-
-
-
-
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.31"
+version = "1.1.32"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -22,5 +22,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    }
    setup_logging();

-    commands::execute(args).await
+    if let Err(err) = commands::execute(args).await {
+        log::error!("{err}");
+        println!("An error occurred: {err}");
+        std::process::exit(1);
+    }
+    Ok(())
 }
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.31"
+version = "1.1.32"
 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"
@@ -21,5 +21,10 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    }
    setup_logging();

-    commands::execute(args).await
+    if let Err(err) = commands::execute(args).await {
+        log::error!("{err}");
+        println!("An error occurred: {err}");
+        std::process::exit(1);
+    }
+    Ok(())
 }
@@ -10,6 +10,8 @@ use std::path::{Path, PathBuf};
 use std::time::Duration;
 use tokio::time::Instant;

+pub use notify::{Error as NotifyError, Result as NotifyResult};
+
 pub type FileWatcherEventSender = mpsc::UnboundedSender<Event>;
 pub type FileWatcherEventReceiver = mpsc::UnboundedReceiver<Event>;

@@ -22,7 +24,7 @@ pub struct AsyncFileWatcher {
    last_received: HashMap<EventKind, Instant>,
    tick_duration: Duration,

-    inner_rx: mpsc::UnboundedReceiver<notify::Result<Event>>,
+    inner_rx: mpsc::UnboundedReceiver<NotifyResult<Event>>,
    event_sender: FileWatcherEventSender,
 }

@@ -30,7 +32,7 @@ impl AsyncFileWatcher {
    pub fn new_file_changes_watcher<P: AsRef<Path>>(
        path: P,
        event_sender: FileWatcherEventSender,
-    ) -> notify::Result<Self> {
+    ) -> NotifyResult<Self> {
        Self::new(
            path,
            event_sender,
@@ -48,7 +50,7 @@ impl AsyncFileWatcher {
        event_sender: FileWatcherEventSender,
        filters: Option<Vec<EventKind>>,
        tick_duration: Option<Duration>,
-    ) -> notify::Result<Self> {
+    ) -> NotifyResult<Self> {
        let watcher_config = Config::default();
        let (inner_tx, inner_rx) = mpsc::unbounded();
        let watcher = RecommendedWatcher::new(
@@ -112,17 +114,17 @@ impl AsyncFileWatcher {
        false
    }

-    fn start_watching(&mut self) -> notify::Result<()> {
+    fn start_watching(&mut self) -> NotifyResult<()> {
        self.is_watching = true;
        self.watcher.watch(&self.path, RecursiveMode::NonRecursive)
    }

-    fn stop_watching(&mut self) -> notify::Result<()> {
+    fn stop_watching(&mut self) -> NotifyResult<()> {
        self.is_watching = false;
        self.watcher.unwatch(&self.path)
    }

-    pub async fn watch(&mut self) -> notify::Result<()> {
+    pub async fn watch(&mut self) -> NotifyResult<()> {
        self.start_watching()?;

        while let Some(event) = self.inner_rx.next().await {
@@ -47,8 +47,9 @@ default = []
 openapi = ["utoipa"]
 output_format = ["serde_json"]
 bin_info_schema = ["schemars"]
+basic_tracing = ["tracing-subscriber"]
 tracing = [
-    "tracing-subscriber",
+    "basic_tracing",
    "tracing-tree",
    "opentelemetry-jaeger",
    "tracing-opentelemetry",
@@ -80,7 +80,7 @@ impl BinaryBuildInformation {
    }
 }

-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[cfg_attr(feature = "bin_info_schema", derive(schemars::JsonSchema))]
 pub struct BinaryBuildInformationOwned {
@@ -43,6 +43,30 @@ pub fn setup_logging() {
        .init();
 }

+#[cfg(feature = "basic_tracing")]
+pub fn setup_tracing_logger() {
+    let log_builder = tracing_subscriber::fmt()
+        // Use a more compact, abbreviated log format
+        .compact()
+        // Display source code file paths
+        .with_file(true)
+        // Display source code line numbers
+        .with_line_number(true)
+        // Don't display the event's target (module path)
+        .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()
+    }
+}
+
 // TODO: This has to be a macro, running it as a function does not work for the file_appender for some reason
 #[cfg(feature = "tracing")]
 #[macro_export]
@@ -47,7 +47,7 @@ nym-credential-storage = { path = "../credential-storage" }
 nym-network-defaults = { path = "../network-defaults" }

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
-version = "0.1.11"
+workspace = true
 features = ["time"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
@@ -55,7 +55,7 @@ workspace = true
 features = ["time"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
-version = "0.20.1"
+workspace = true

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 version = "0.6.2"
@@ -77,7 +77,7 @@ pub struct PersistedGatewayConfig {
    key_hash: Vec<u8>,

    /// Actual gateway details being persisted.
-    pub(crate) details: GatewayEndpointConfig,
+    pub details: GatewayEndpointConfig,
 }

 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -28,6 +28,7 @@ pub enum InputMessage {
        recipient: Recipient,
        data: Vec<u8>,
        lane: TransmissionLane,
+        mix_hops: Option<u8>,
    },

    /// Creates a message used for a duplex anonymous communication where the recipient
@@ -43,6 +44,7 @@ pub enum InputMessage {
        data: Vec<u8>,
        reply_surbs: u32,
        lane: TransmissionLane,
+        mix_hops: Option<u8>,
    },

    /// Attempt to use our internally received and stored `ReplySurb` to send the message back
@@ -92,6 +94,29 @@ impl InputMessage {
            recipient,
            data,
            lane,
+            mix_hops: None,
+        };
+        if let Some(packet_type) = packet_type {
+            InputMessage::new_wrapper(message, packet_type)
+        } else {
+            message
+        }
+    }
+
+    // IMHO `new_regular` should take `mix_hops: Option<u8>` as an argument instead of creating
+    // this function, but that would potentially break backwards compatibility with the current API
+    pub fn new_regular_with_custom_hops(
+        recipient: Recipient,
+        data: Vec<u8>,
+        lane: TransmissionLane,
+        packet_type: Option<PacketType>,
+        mix_hops: Option<u8>,
+    ) -> Self {
+        let message = InputMessage::Regular {
+            recipient,
+            data,
+            lane,
+            mix_hops,
        };
        if let Some(packet_type) = packet_type {
            InputMessage::new_wrapper(message, packet_type)
@@ -112,6 +137,31 @@ impl InputMessage {
            data,
            reply_surbs,
            lane,
+            mix_hops: None,
+        };
+        if let Some(packet_type) = packet_type {
+            InputMessage::new_wrapper(message, packet_type)
+        } else {
+            message
+        }
+    }
+
+    // IMHO `new_anonymous` should take `mix_hops: Option<u8>` as an argument instead of creating
+    // this function, but that would potentially break backwards compatibility with the current API
+    pub fn new_anonymous_with_custom_hops(
+        recipient: Recipient,
+        data: Vec<u8>,
+        reply_surbs: u32,
+        lane: TransmissionLane,
+        packet_type: Option<PacketType>,
+        mix_hops: Option<u8>,
+    ) -> Self {
+        let message = InputMessage::Anonymous {
+            recipient,
+            data,
+            reply_surbs,
+            lane,
+            mix_hops,
        };
        if let Some(packet_type) = packet_type {
            InputMessage::new_wrapper(message, packet_type)
@@ -263,7 +263,7 @@ impl ActionController {
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
        debug!("Started ActionController with graceful shutdown support");

-        while !shutdown.is_shutdown() {
+        loop {
            tokio::select! {
                action = self.incoming_actions.next() => match action {
                    Some(action) => self.process_action(action),
@@ -283,6 +283,7 @@ impl ActionController {
                },
                _ = shutdown.recv_with_delay() => {
                    log::trace!("ActionController: Received shutdown");
+                    break;
                }
            }
        }
@@ -73,10 +73,11 @@ where
        content: Vec<u8>,
        lane: TransmissionLane,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_plain_message(recipient, content, lane, packet_type)
+            .try_send_plain_message(recipient, content, lane, packet_type, mix_hops)
            .await
        {
            warn!("failed to send a plain message - {err}")
@@ -90,10 +91,18 @@ where
        reply_surbs: u32,
        lane: TransmissionLane,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type)
+            .try_send_message_with_reply_surbs(
+                recipient,
+                content,
+                reply_surbs,
+                lane,
+                packet_type,
+                mix_hops,
+            )
            .await
        {
            warn!("failed to send a repliable message - {err}")
@@ -106,8 +115,9 @@ where
                recipient,
                data,
                lane,
+                mix_hops,
            } => {
-                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
+                self.handle_plain_message(recipient, data, lane, PacketType::Mix, mix_hops)
                    .await
            }
            InputMessage::Anonymous {
@@ -115,9 +125,17 @@ where
                data,
                reply_surbs,
                lane,
+                mix_hops,
            } => {
-                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
-                    .await
+                self.handle_repliable_message(
+                    recipient,
+                    data,
+                    reply_surbs,
+                    lane,
+                    PacketType::Mix,
+                    mix_hops,
+                )
+                .await
            }
            InputMessage::Reply {
                recipient_tag,
@@ -135,8 +153,9 @@ where
                    recipient,
                    data,
                    lane,
+                    mix_hops,
                } => {
-                    self.handle_plain_message(recipient, data, lane, packet_type)
+                    self.handle_plain_message(recipient, data, lane, packet_type, mix_hops)
                        .await
                }
                InputMessage::Anonymous {
@@ -144,9 +163,17 @@ where
                    data,
                    reply_surbs,
                    lane,
+                    mix_hops,
                } => {
-                    self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type)
-                        .await
+                    self.handle_repliable_message(
+                        recipient,
+                        data,
+                        reply_surbs,
+                        lane,
+                        packet_type,
+                        mix_hops,
+                    )
+                    .await
                }
                InputMessage::Reply {
                    recipient_tag,
@@ -69,6 +69,7 @@ pub(crate) struct PendingAcknowledgement {
    message_chunk: Fragment,
    delay: SphinxDelay,
    destination: PacketDestination,
+    mix_hops: Option<u8>,
 }

 impl PendingAcknowledgement {
@@ -77,11 +78,13 @@ impl PendingAcknowledgement {
        message_chunk: Fragment,
        delay: SphinxDelay,
        recipient: Recipient,
+        mix_hops: Option<u8>,
    ) -> Self {
        PendingAcknowledgement {
            message_chunk,
            delay,
            destination: PacketDestination::KnownRecipient(recipient.into()),
+            mix_hops,
        }
    }

@@ -98,6 +101,9 @@ impl PendingAcknowledgement {
                recipient_tag,
                extra_surb_request,
            },
+            // Messages sent using SURBs are using the number of mix hops set by the recipient when
+            // they provided the SURBs, so it doesn't make sense to include it here.
+            mix_hops: None,
        }
    }

@@ -49,12 +49,18 @@ where
        packet_recipient: Recipient,
        chunk_data: Fragment,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<PreparedFragment, PreparationError> {
        debug!("retransmitting normal packet...");

        // TODO: Figure out retransmission packet type signaling
        self.message_handler
-            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, packet_type)
+            .try_prepare_single_chunk_for_sending(
+                packet_recipient,
+                chunk_data,
+                packet_type,
+                mix_hops,
+            )
            .await
    }

@@ -89,6 +95,7 @@ where
                    **recipient,
                    timed_out_ack.message_chunk.clone(),
                    packet_type,
+                    timed_out_ack.mix_hops,
                )
                .await
            }
@@ -40,7 +40,7 @@ impl SentNotificationListener {
    pub(super) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
        debug!("Started SentNotificationListener with graceful shutdown support");

-        while !shutdown.is_shutdown() {
+        loop {
            tokio::select! {
                frag_id = self.sent_notifier.next() => match frag_id {
                    Some(frag_id) => {
@@ -53,6 +53,7 @@ impl SentNotificationListener {
                },
                _ = shutdown.recv_with_delay() => {
                    log::trace!("SentNotificationListener: Received shutdown");
+                    break;
                }
            }
        }
@@ -418,9 +418,10 @@ where
        message: Vec<u8>,
        lane: TransmissionLane,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<(), PreparationError> {
        let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type, mix_hops)
            .await
    }

@@ -430,6 +431,7 @@ where
        recipient: Recipient,
        lane: TransmissionLane,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<(), PreparationError> {
        debug!("Sending non-reply message with packet type {packet_type}");
        // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
@@ -461,6 +463,7 @@ where
                &self.config.ack_key,
                &recipient,
                packet_type,
+                mix_hops,
            )?;

            let real_message = RealMessage::new(
@@ -468,7 +471,8 @@ where
                Some(fragment.fragment_identifier()),
            );
            let delay = prepared_fragment.total_delay;
-            let pending_ack = PendingAcknowledgement::new_known(fragment, delay, recipient);
+            let pending_ack =
+                PendingAcknowledgement::new_known(fragment, delay, recipient, mix_hops);

            real_messages.push(real_message);
            pending_acks.push(pending_ack);
@@ -485,6 +489,7 @@ where
        recipient: Recipient,
        amount: u32,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<(), PreparationError> {
        debug!("Sending additional reply SURBs with packet type {packet_type}");
        let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -501,6 +506,7 @@ where
            recipient,
            TransmissionLane::AdditionalReplySurbs,
            packet_type,
+            mix_hops,
        )
        .await?;

@@ -517,6 +523,7 @@ where
        num_reply_surbs: u32,
        lane: TransmissionLane,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<(), SurbWrappedPreparationError> {
        debug!("Sending message with reply SURBs with packet type {packet_type}");
        let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -527,7 +534,7 @@ where
        let message =
            NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));

-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type, mix_hops)
            .await?;

        log::trace!("storing {} reply keys", reply_keys.len());
@@ -541,6 +548,7 @@ where
        recipient: Recipient,
        chunk: Fragment,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<PreparedFragment, PreparationError> {
        debug!("Sending single chunk with packet type {packet_type}");
        let topology_permit = self.topology_access.get_read_permit().await;
@@ -554,6 +562,7 @@ where
                &self.config.ack_key,
                &recipient,
                packet_type,
+                mix_hops,
            )
            .unwrap();

@@ -500,11 +500,12 @@ where
        {
            let mut status_timer = tokio::time::interval(Duration::from_secs(5));

-            while !shutdown.is_shutdown() {
+            loop {
                tokio::select! {
                    biased;
                    _ = shutdown.recv_with_delay() => {
                        log::trace!("OutQueueControl: Received shutdown");
+                        break;
                    }
                    _ = status_timer.tick() => {
                        self.log_status(&mut shutdown);
@@ -516,6 +516,7 @@ where
                    recipient,
                    to_send,
                    nym_sphinx::params::PacketType::Mix,
+                    self.config.reply_surbs.surb_mix_hops,
                )
                .await
            {
@@ -39,7 +39,7 @@ where
        mem_state: CombinedReplyStorage,
        mut shutdown: nym_task::TaskClient,
    ) {
-        use log::{debug, error, info, warn};
+        use log::{debug, error, info};

        debug!("Started PersistentReplyStorage");
        if let Err(err) = self.backend.start_storage_session().await {
@@ -50,7 +50,7 @@ where
        shutdown.recv().await;

        info!("PersistentReplyStorage is flushing all reply-related data to underlying storage");
-        warn!("you MUST NOT forcefully shutdown now or you risk data corruption!");
+        info!("you MUST NOT forcefully shutdown now or you risk data corruption!");
        if let Err(err) = self.backend.flush_surb_storage(&mem_state).await {
            error!("failed to flush our reply-related data to the persistent storage: {err}")
        } else {
@@ -607,6 +607,10 @@ pub struct ReplySurbs {
    /// This is going to be superseded by key rotation once implemented.
    #[serde(with = "humantime_serde")]
    pub maximum_reply_key_age: Duration,
+
+    /// Specifies the number of mixnet hops the packet should go through. If not specified, then
+    /// the default value is used.
+    pub surb_mix_hops: Option<u8>,
 }

 impl Default for ReplySurbs {
@@ -622,6 +626,7 @@ impl Default for ReplySurbs {
            maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
            maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
            maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
+            surb_mix_hops: None,
        }
    }
 }
@@ -155,6 +155,7 @@ impl From<ConfigV1_1_30> for Config {
                        .maximum_reply_surb_drop_waiting_period,
                    maximum_reply_surb_age: value.debug.reply_surbs.maximum_reply_surb_age,
                    maximum_reply_key_age: value.debug.reply_surbs.maximum_reply_key_age,
+                    surb_mix_hops: None,
                },
            },
        }
@@ -15,34 +15,34 @@ pub enum ClientCoreError {
    #[error("I/O error: {0}")]
    IoError(#[from] std::io::Error),

-    #[error("Gateway client error ({gateway_id}): {source}")]
+    #[error("gateway client error ({gateway_id}): {source}")]
    GatewayClientError {
        gateway_id: String,
        source: GatewayClientError,
    },

-    #[error("Custom gateway client error: {source}")]
+    #[error("custom gateway client error: {source}")]
    ErasedGatewayClientError {
        #[from]
        source: ErasedGatewayError,
    },

-    #[error("Ed25519 error: {0}")]
+    #[error("ed25519 error: {0}")]
    Ed25519RecoveryError(#[from] Ed25519RecoveryError),

-    #[error("Validator client error: {0}")]
+    #[error("validator client error: {0}")]
    ValidatorClientError(#[from] ValidatorClientError),

-    #[error("No gateway with id: {0}")]
+    #[error("no gateway with id: {0}")]
    NoGatewayWithId(String),

-    #[error("No gateways on network")]
+    #[error("no gateways on network")]
    NoGatewaysOnNetwork,

-    #[error("List of nym apis is empty")]
+    #[error("list of nym apis is empty")]
    ListOfNymApisIsEmpty,

-    #[error("The current network topology seem to be insufficient to route any packets through")]
+    #[error("the current network topology seem to be insufficient to route any packets through")]
    InsufficientNetworkTopology(#[from] NymTopologyError),

    #[error("experienced a failure with our reply surb persistent storage: {source}")]
@@ -60,7 +60,7 @@ pub enum ClientCoreError {
        source: Box<dyn Error + Send + Sync>,
    },

-    #[error("The gateway id is invalid - {0}")]
+    #[error("the gateway id is invalid - {0}")]
    UnableToCreatePublicKeyFromGatewayId(Ed25519RecoveryError),

    #[error("The gateway is malformed: {source}")]
@@ -79,23 +79,23 @@ pub enum ClientCoreError {
    #[error("failed to establish gateway connection (wasm)")]
    GatewayJsConnectionFailure,

-    #[error("Gateway connection was abruptly closed")]
+    #[error("gateway connection was abruptly closed")]
    GatewayConnectionAbruptlyClosed,

-    #[error("Timed out while trying to establish gateway connection")]
+    #[error("timed out while trying to establish gateway connection")]
    GatewayConnectionTimeout,

-    #[error("No ping measurements for the gateway ({identity}) performed")]
+    #[error("no ping measurements for the gateway ({identity}) performed")]
    NoGatewayMeasurements { identity: String },

    #[error("failed to register receiver for reconstructed mixnet messages")]
    FailedToRegisterReceiver,

-    #[error("Unexpected exit")]
+    #[error("unexpected exit")]
    UnexpectedExit,

    #[error(
-        "This operation would have resulted in clients keys being overwritten without permission"
+        "this operation would have resulted in clients keys being overwritten without permission"
    )]
    ForbiddenKeyOverwrite,

@@ -68,13 +68,23 @@ pub async fn current_gateways<R: Rng>(
    log::trace!("Fetching list of gateways from: {nym_api}");

    let gateways = client.get_cached_described_gateways().await?;
+    log::debug!("Found {} gateways", gateways.len());
+    log::trace!("Gateways: {:#?}", gateways);
+
    let valid_gateways = gateways
        .into_iter()
        .filter_map(|gateway| gateway.try_into().ok())
        .collect::<Vec<gateway::Node>>();
+    log::debug!("Ater checking validity: {}", valid_gateways.len());
+    log::trace!("Valid gateways: {:#?}", valid_gateways);

    // we were always filtering by version so I'm not removing that 'feature'
    let filtered_gateways = valid_gateways.filter_by_version(env!("CARGO_PKG_VERSION"));
+    log::debug!("After filtering for version: {}", filtered_gateways.len());
+    log::trace!("Filtered gateways: {:#?}", filtered_gateways);
+
+    log::info!("nym-api reports {} valid gateways", filtered_gateways.len());
+
    Ok(filtered_gateways)
 }

@@ -94,6 +94,8 @@ where
    D::StorageError: Send + Sync + 'static,
    T: DeserializeOwned + Serialize + Send + Sync,
 {
+    log::trace!("Setting up new gateway");
+
    // if we're setting up new gateway, failing to load existing information is fine.
    // as a matter of fact, it's only potentially a problem if we DO succeed
    if _load_gateway_details(details_store).await.is_ok() && !overwrite_data {
@@ -210,6 +212,7 @@ where
    D::StorageError: Send + Sync + 'static,
    T: DeserializeOwned + Serialize + Send + Sync,
 {
+    log::trace!("Setting up gateway");
    match setup {
        GatewaySetup::MustLoad => use_loaded_gateway_details(key_store, details_store).await,
        GatewaySetup::New {
@@ -40,7 +40,7 @@ workspace = true
 features = ["macros", "rt", "net", "sync", "time"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
-version = "0.1.11"
+workspace = true
 features = ["net", "sync", "time"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
@@ -10,7 +10,7 @@ edition = "2021"
 futures = { workspace = true }
 log = { workspace = true }
 tokio = { version = "1.24.1", features = ["time", "net", "rt"] }
-tokio-util = { version = "0.7.4", features = ["codec"] }
+tokio-util = { workspace = true, features = ["codec"] }

 # internal
 nym-sphinx = { path = "../../nymsphinx" }
@@ -123,13 +123,10 @@ impl Client {
        // We could have as well used conn.send_all(receiver.map(Ok)), but considering we don't care
        // about neither receiver nor the connection, it doesn't matter which one gets consumed
        if let Err(err) = receiver.map(Ok).forward(conn).await {
-            warn!("Failed to forward packets to {} - {err}", address);
+            warn!("Failed to forward packets to {address} - {err}");
        }

-        debug!(
-            "connection manager to {} is finished. Either the connection failed or mixnet client got dropped",
-            address
-        );
+        debug!("connection manager to {address} is finished. Either the connection failed or mixnet client got dropped");
    }

    /// If we're trying to reconnect, determine how long we should wait.
@@ -207,7 +204,7 @@ impl SendWithoutResponse for Client {
        if let Some(sender) = self.conn_new.get_mut(&address) {
            if let Err(err) = sender.channel.try_send(framed_packet) {
                if err.is_full() {
-                    debug!("Connection to {} seems to not be able to handle all the traffic - dropping the current packet", address);
+                    debug!("Connection to {address} seems to not be able to handle all the traffic - dropping the current packet");
                    // it's not a 'big' error, but we did not manage to send the packet
                    // if the queue is full, we can't really do anything but to drop the packet
                    Err(io::Error::new(
@@ -215,10 +212,8 @@ impl SendWithoutResponse for Client {
                        "connection queue is full",
                    ))
                } else if err.is_disconnected() {
-                    debug!(
-                        "Connection to {} seems to be dead. attempting to re-establish it...",
-                        address
-                    );
+                    debug!("Connection to {address} seems to be dead. attempting to re-establish it...");
+
                    // it's not a 'big' error, but we did not manage to send the packet, but queue
                    // it up to send it as soon as the connection is re-established
                    self.make_connection(address, err.into_inner());
@@ -238,7 +233,7 @@ impl SendWithoutResponse for Client {
            }
        } else {
            // there was never a connection to begin with
-            debug!("establishing initial connection to {}", address);
+            debug!("establishing initial connection to {address}");
            // it's not a 'big' error, but we did not manage to send the packet, but queue the packet
            // for sending for as soon as the connection is created
            self.make_connection(address, framed_packet);
@@ -45,13 +45,17 @@ cosmrs = { workspace = true, features = ["bip32", "cosmwasm"] }
 # import it just for the `Client` trait
 tendermint-rpc = { workspace = true }

+# this is an extremely nasty import. we're explicitly bringing in bip32 so that via the magic (or curse, pick your poison)
+# of cargo's feature unification we'd get `bip32/std` meaning we'd get `std::error::Error` for the re-exported (via cosmrs) bip32::Error type
+bip32 = { workspace = true, default-features = false, features = ["std"] }
+
 eyre = { version = "0.6" }
 cw-utils = { workspace = true }
 cw2 = { workspace = true }
 cw3 = { workspace = true }
 cw4 = { workspace = true }
 cw-controllers = { workspace = true }
-prost = { version = "0.11", default-features = false }
+prost = { workspace = true, default-features = false }
 flate2 = { version = "1.0.20" }
 sha2 = { version = "0.9.5" }
 itertools = { version = "0.10" }
@@ -20,12 +20,12 @@ impl CheckResponse for broadcast::tx_commit::Response {
            });
        }

-        if self.deliver_tx.code.is_err() {
+        if self.tx_result.code.is_err() {
            return Err(NyxdError::BroadcastTxErrorDeliverTx {
                hash: self.hash,
                height: Some(self.height),
-                code: self.deliver_tx.code.value(),
-                raw_log: self.deliver_tx.log,
+                code: self.tx_result.code.value(),
+                raw_log: self.tx_result.log,
            });
        }

@@ -11,7 +11,7 @@ pub mod gas_price;

 pub type GasAdjustment = f32;

-pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: GasAdjustment = 1.3;
+pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: GasAdjustment = 1.5;

 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AutoFeeGrant {
@@ -34,7 +34,9 @@ pub use crate::nyxd::fee::Fee;
 pub use crate::rpc::TendermintRpcClient;
 pub use coin::Coin;
 pub use cosmrs::bank::MsgSend;
-pub use cosmrs::tendermint::abci::{response::DeliverTx, Event, EventAttribute};
+pub use cosmrs::tendermint::abci::{
+    response::DeliverTx, types::ExecTxResult, Event, EventAttribute,
+};
 pub use cosmrs::tendermint::block::Height;
 pub use cosmrs::tendermint::hash::{self, Algorithm, Hash};
 pub use cosmrs::tendermint::validator::Info as TendermintValidatorInfo;
@@ -53,6 +55,9 @@ pub use tendermint_rpc::{
 };
 pub use tendermint_rpc::{Request, Response, SimpleRequest};

+#[cfg(feature = "http-client")]
+pub use tendermint_rpc::Url as RpcUrl;
+
 #[cfg(feature = "http-client")]
 use crate::http_client;
 #[cfg(feature = "http-client")]
@@ -28,7 +28,7 @@ where
    U: TryInto<HttpClientUrl, Error = Error>,
 {
    HttpRpcClient::builder(url.try_into()?)
-        .compat_mode(CompatMode::V0_34)
+        .compat_mode(CompatMode::V0_37)
        .build()
 }

@@ -36,7 +36,8 @@ pub struct ReqwestRpcClient {
 impl ReqwestRpcClient {
    pub fn new(url: Url) -> Self {
        ReqwestRpcClient {
-            compat: CompatMode::V0_34,
+            // after updating to nyxd 0.42 and thus updating to cometbft, the compat mode changed
+            compat: CompatMode::V0_37,
            inner: reqwest::Client::new(),
            url,
        }
@@ -21,7 +21,7 @@ rand = {version = "0.6", features = ["std"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
-time = { version = "0.3.6", features = ["parsing", "formatting"] }
+time = { workspace = true, features = ["parsing", "formatting"] }
 toml = "0.5.6"
 url = { workspace = true }
 tap = "1"
@@ -4,7 +4,7 @@
 use handlebars::{Handlebars, TemplateRenderError};
 use serde::de::DeserializeOwned;
 use serde::Serialize;
-use std::fs::File;
+use std::fs::{create_dir_all, File};
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::{fs, io};
@@ -72,16 +72,22 @@ where
    C: NymConfigTemplate,
    P: AsRef<Path>,
 {
-    log::debug!("trying to save config file to {}", path.as_ref().display());
-    let file = File::create(path.as_ref())?;
+    let path = path.as_ref();
+    log::debug!("trying to save config file to {}", path.display());

-    // TODO: check for whether any of our configs stores anything sensitive
+    if let Some(parent) = path.parent() {
+        create_dir_all(parent)?;
+    }
+
+    let file = File::create(path)?;
+
+    // TODO: check for whether any of our configs store anything sensitive
    // and change that to 0o644 instead
    #[cfg(target_family = "unix")]
    {
        use std::os::unix::fs::PermissionsExt;

-        let mut perms = fs::metadata(path.as_ref())?.permissions();
+        let mut perms = fs::metadata(path)?.permissions();
        perms.set_mode(0o600);
        fs::set_permissions(path, perms)?;
    }
@@ -142,7 +142,7 @@ pub fn funds_from_cosmos_msgs(msgs: Vec<CosmosMsg>) -> Option<Coin> {
        contract_addr: _,
        msg,
        funds: _,
-    })) = msgs.get(0)
+    })) = msgs.first()
    {
        if let Ok(ExecuteMsg::ReleaseFunds { funds }) = from_binary::<ExecuteMsg>(msg) {
            return Some(funds);
@@ -62,7 +62,7 @@ pub fn owner_from_cosmos_msgs(msgs: &[CosmosMsg]) -> Option<Addr> {
        contract_addr: _,
        msg,
        funds: _,
-    })) = msgs.get(0)
+    })) = msgs.first()
    {
        if let Ok(ExecuteMsg::VerifyVerificationKeyShare { owner, .. }) =
            from_binary::<ExecuteMsg>(msg)
@@ -3,6 +3,7 @@

 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::Decimal;
+use cosmwasm_std::OverflowError;
 use cosmwasm_std::Uint128;
 use serde::de::Error;
 use serde::{Deserialize, Deserializer};
@@ -71,6 +72,10 @@ impl Percent {
        // we know the cast from u128 to u8 is a safe one since the internal value must be within 0 - 1 range
        truncate_decimal(hundred * self.0).u128() as u8
    }
+
+    pub fn checked_pow(&self, exp: u32) -> Result<Self, OverflowError> {
+        self.0.checked_pow(exp).map(Percent)
+    }
 }

 impl Display for Percent {
@@ -25,12 +25,12 @@ humantime-serde = "1.1.1"

 # TO CHECK WHETHER STILL NEEDED:
 log = { workspace = true }
-time = { version = "0.3.6", features = ["parsing", "formatting"] }
+time = { workspace = true, features = ["parsing", "formatting"] }
 ts-rs = { workspace = true, optional = true }

 [dev-dependencies]
 rand_chacha = "0.3"
-time = { version = "0.3.5", features = ["serde", "macros"] }
+time = { workspace = true, features = ["serde", "macros"] }

 [features]
 default = []
@@ -623,6 +623,24 @@ pub enum Layer {
    Three = 3,
 }

+impl Layer {
+    pub fn try_next(&self) -> Option<Self> {
+        match self {
+            Layer::One => Some(Layer::Two),
+            Layer::Two => Some(Layer::Three),
+            Layer::Three => None,
+        }
+    }
+
+    pub fn try_previous(&self) -> Option<Self> {
+        match self {
+            Layer::One => None,
+            Layer::Two => Some(Layer::One),
+            Layer::Three => Some(Layer::Two),
+        }
+    }
+}
+
 impl From<Layer> for String {
    fn from(layer: Layer) -> Self {
        (layer as u8).to_string()
@@ -49,7 +49,7 @@ impl Account {

    pub fn period_duration(&self) -> Result<u64, VestingContractError> {
        self.periods
-            .get(0)
+            .first()
            .ok_or(VestingContractError::UnpopulatedVestingPeriods {
                owner: self.owner_address.clone(),
            })
@@ -366,11 +366,7 @@ pub fn creating_proof_of_chunking_for_100_parties(c: &mut Criterion) {
        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
        .collect::<Vec<_>>();

-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
+    let remote_share_key_pairs = shares.iter().zip(receivers.values()).collect::<Vec<_>>();
    let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();

    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);
@@ -400,11 +396,7 @@ pub fn verifying_proof_of_chunking_for_100_parties(c: &mut Criterion) {
        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
        .collect::<Vec<_>>();

-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
+    let remote_share_key_pairs = shares.iter().zip(receivers.values()).collect::<Vec<_>>();
    let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();

    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);
@@ -436,11 +428,7 @@ pub fn creating_proof_of_secret_sharing_for_100_parties(c: &mut Criterion) {
        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
        .collect::<Vec<_>>();

-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
+    let remote_share_key_pairs = shares.iter().zip(receivers.values()).collect::<Vec<_>>();

    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);

@@ -478,11 +466,7 @@ pub fn verifying_proof_of_secret_sharing_for_100_parties(c: &mut Criterion) {
        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
        .collect::<Vec<_>>();

-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
+    let remote_share_key_pairs = shares.iter().zip(receivers.values()).collect::<Vec<_>>();

    let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);

@@ -545,11 +529,7 @@ pub fn share_encryption_100(c: &mut Criterion) {
        .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
        .collect::<Vec<_>>();

-    let remote_share_key_pairs = shares
-        .iter()
-        .zip(receivers.values())
-        .map(|(share, key)| (share, key))
-        .collect::<Vec<_>>();
+    let remote_share_key_pairs = shares.iter().zip(receivers.values()).collect::<Vec<_>>();

    c.bench_function("100 shares encryption", |b| {
        b.iter(|| black_box(encrypt_shares(&remote_share_key_pairs, &params, &mut rng)))
@@ -115,11 +115,7 @@ impl Dealing {
            .map(|&node_index| polynomial.evaluate_at(&Scalar::from(node_index)).into())
            .collect::<Vec<_>>();

-        let remote_share_key_pairs = shares
-            .iter()
-            .zip(receivers.values())
-            .map(|(share, key)| (share, key))
-            .collect::<Vec<_>>();
+        let remote_share_key_pairs = shares.iter().zip(receivers.values()).collect::<Vec<_>>();
        let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();

        let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, params, &mut rng);
@@ -0,0 +1,19 @@
+[package]
+name = "nym-ip-packet-requests"
+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]
+bincode = "1.3.3"
+bytes = "1.5.0"
+nym-sphinx = { path = "../nymsphinx" }
+rand = "0.8.5"
+serde = { workspace = true, features = ["derive"] }
+thiserror = { workspace = true }
@@ -0,0 +1,383 @@
+use std::net::IpAddr;
+
+use nym_sphinx::addressing::clients::Recipient;
+use serde::{Deserialize, Serialize};
+
+pub const CURRENT_VERSION: u8 = 1;
+
+fn generate_random() -> u64 {
+    use rand::RngCore;
+    let mut rng = rand::rngs::OsRng;
+    rng.next_u64()
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct IpPacketRequest {
+    pub version: u8,
+    pub data: IpPacketRequestData,
+}
+
+impl IpPacketRequest {
+    pub fn new_static_connect_request(
+        ip: IpAddr,
+        reply_to: Recipient,
+        reply_to_hops: Option<u8>,
+        reply_to_avg_mix_delays: Option<f64>,
+    ) -> (Self, u64) {
+        let request_id = generate_random();
+        (
+            Self {
+                version: CURRENT_VERSION,
+                data: IpPacketRequestData::StaticConnect(StaticConnectRequest {
+                    request_id,
+                    ip,
+                    reply_to,
+                    reply_to_hops,
+                    reply_to_avg_mix_delays,
+                }),
+            },
+            request_id,
+        )
+    }
+
+    pub fn new_dynamic_connect_request(
+        reply_to: Recipient,
+        reply_to_hops: Option<u8>,
+        reply_to_avg_mix_delays: Option<f64>,
+    ) -> (Self, u64) {
+        let request_id = generate_random();
+        (
+            Self {
+                version: CURRENT_VERSION,
+                data: IpPacketRequestData::DynamicConnect(DynamicConnectRequest {
+                    request_id,
+                    reply_to,
+                    reply_to_hops,
+                    reply_to_avg_mix_delays,
+                }),
+            },
+            request_id,
+        )
+    }
+
+    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketRequestData::Data(DataRequest { ip_packet }),
+        }
+    }
+
+    pub fn id(&self) -> Option<u64> {
+        match &self.data {
+            IpPacketRequestData::StaticConnect(request) => Some(request.request_id),
+            IpPacketRequestData::DynamicConnect(request) => Some(request.request_id),
+            IpPacketRequestData::Data(_) => None,
+        }
+    }
+
+    pub fn recipient(&self) -> Option<&Recipient> {
+        match &self.data {
+            IpPacketRequestData::StaticConnect(request) => Some(&request.reply_to),
+            IpPacketRequestData::DynamicConnect(request) => Some(&request.reply_to),
+            IpPacketRequestData::Data(_) => None,
+        }
+    }
+
+    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().serialize(self)
+    }
+
+    pub fn from_reconstructed_message(
+        message: &nym_sphinx::receiver::ReconstructedMessage,
+    ) -> Result<Self, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().deserialize(&message.message)
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub enum IpPacketRequestData {
+    StaticConnect(StaticConnectRequest),
+    DynamicConnect(DynamicConnectRequest),
+    Data(DataRequest),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct StaticConnectRequest {
+    pub request_id: u64,
+    pub ip: IpAddr,
+    // The nym-address the response should be sent back to
+    pub reply_to: Recipient,
+    // The number of mix node hops that responses should take, in addition to the entry and exit
+    // node. Zero means only client -> entry -> exit -> client.
+    pub reply_to_hops: Option<u8>,
+    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
+    // ip packet router.
+    pub reply_to_avg_mix_delays: Option<f64>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct DynamicConnectRequest {
+    pub request_id: u64,
+    // The nym-address the response should be sent back to
+    pub reply_to: Recipient,
+    // The number of mix node hops that responses should take, in addition to the entry and exit
+    // node. Zero means only client -> entry -> exit -> client.
+    pub reply_to_hops: Option<u8>,
+    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
+    // ip packet router.
+    pub reply_to_avg_mix_delays: Option<f64>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct DataRequest {
+    pub ip_packet: bytes::Bytes,
+}
+
+// ---
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct IpPacketResponse {
+    pub version: u8,
+    pub data: IpPacketResponseData,
+}
+
+impl IpPacketResponse {
+    pub fn new_static_connect_success(request_id: u64, reply_to: Recipient) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
+                request_id,
+                reply_to,
+                reply: StaticConnectResponseReply::Success,
+            }),
+        }
+    }
+
+    pub fn new_static_connect_failure(
+        request_id: u64,
+        reply_to: Recipient,
+        reason: StaticConnectFailureReason,
+    ) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
+                request_id,
+                reply_to,
+                reply: StaticConnectResponseReply::Failure(reason),
+            }),
+        }
+    }
+
+    pub fn new_dynamic_connect_success(request_id: u64, reply_to: Recipient, ip: IpAddr) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
+                request_id,
+                reply_to,
+                reply: DynamicConnectResponseReply::Success(DynamicConnectSuccess { ip }),
+            }),
+        }
+    }
+
+    pub fn new_dynamic_connect_failure(
+        request_id: u64,
+        reply_to: Recipient,
+        reason: DynamicConnectFailureReason,
+    ) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
+                request_id,
+                reply_to,
+                reply: DynamicConnectResponseReply::Failure(reason),
+            }),
+        }
+    }
+
+    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
+        Self {
+            version: CURRENT_VERSION,
+            data: IpPacketResponseData::Data(DataResponse { ip_packet }),
+        }
+    }
+
+    pub fn id(&self) -> Option<u64> {
+        match &self.data {
+            IpPacketResponseData::StaticConnect(response) => Some(response.request_id),
+            IpPacketResponseData::DynamicConnect(response) => Some(response.request_id),
+            IpPacketResponseData::Data(_) => None,
+        }
+    }
+
+    pub fn recipient(&self) -> Option<&Recipient> {
+        match &self.data {
+            IpPacketResponseData::StaticConnect(response) => Some(&response.reply_to),
+            IpPacketResponseData::DynamicConnect(response) => Some(&response.reply_to),
+            IpPacketResponseData::Data(_) => None,
+        }
+    }
+
+    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().serialize(self)
+    }
+
+    pub fn from_reconstructed_message(
+        message: &nym_sphinx::receiver::ReconstructedMessage,
+    ) -> Result<Self, bincode::Error> {
+        use bincode::Options;
+        make_bincode_serializer().deserialize(&message.message)
+    }
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum IpPacketResponseData {
+    StaticConnect(StaticConnectResponse),
+    DynamicConnect(DynamicConnectResponse),
+    Data(DataResponse),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct StaticConnectResponse {
+    pub request_id: u64,
+    pub reply_to: Recipient,
+    pub reply: StaticConnectResponseReply,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum StaticConnectResponseReply {
+    Success,
+    Failure(StaticConnectFailureReason),
+}
+
+impl StaticConnectResponseReply {
+    pub fn is_success(&self) -> bool {
+        match self {
+            StaticConnectResponseReply::Success => true,
+            StaticConnectResponseReply::Failure(_) => false,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
+pub enum StaticConnectFailureReason {
+    #[error("requested ip address is already in use")]
+    RequestedIpAlreadyInUse,
+    #[error("requested nym-address is already in use")]
+    RequestedNymAddressAlreadyInUse,
+    #[error("{0}")]
+    Other(String),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct DynamicConnectResponse {
+    pub request_id: u64,
+    pub reply_to: Recipient,
+    pub reply: DynamicConnectResponseReply,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum DynamicConnectResponseReply {
+    Success(DynamicConnectSuccess),
+    Failure(DynamicConnectFailureReason),
+}
+
+impl DynamicConnectResponseReply {
+    pub fn is_success(&self) -> bool {
+        match self {
+            DynamicConnectResponseReply::Success(_) => true,
+            DynamicConnectResponseReply::Failure(_) => false,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct DynamicConnectSuccess {
+    pub ip: IpAddr,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
+pub enum DynamicConnectFailureReason {
+    #[error("requested nym-address is already in use")]
+    RequestedNymAddressAlreadyInUse,
+    #[error("no available ip address")]
+    NoAvailableIp,
+    #[error("{0}")]
+    Other(String),
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct DataResponse {
+    pub ip_packet: bytes::Bytes,
+}
+
+fn make_bincode_serializer() -> impl bincode::Options {
+    use bincode::Options;
+    bincode::DefaultOptions::new()
+        .with_big_endian()
+        .with_varint_encoding()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn check_size_of_request() {
+        let connect = IpPacketRequest {
+            version: 4,
+            data: IpPacketRequestData::StaticConnect(
+                StaticConnectRequest {
+                    request_id: 123,
+                    ip: IpAddr::from([10, 0, 0, 1]),
+                    reply_to: Recipient::try_from_base58_string("D1rrpsysCGCYXy9saP8y3kmNpGtJZUXN9SvFoUcqAsM9.9Ssso1ea5NfkbMASdiseDSjTN1fSWda5SgEVjdSN4CvV@GJqd3ZxpXWSNxTfx7B1pPtswpetH4LnJdFeLeuY5KUuN").unwrap(),
+                    reply_to_hops: None,
+                    reply_to_avg_mix_delays: None,
+                },
+            )
+        };
+        assert_eq!(connect.to_bytes().unwrap().len(), 107);
+    }
+
+    #[test]
+    fn check_size_of_data() {
+        let data = IpPacketRequest {
+            version: 4,
+            data: IpPacketRequestData::Data(DataRequest {
+                ip_packet: bytes::Bytes::from(vec![1u8; 32]),
+            }),
+        };
+        assert_eq!(data.to_bytes().unwrap().len(), 35);
+    }
+
+    #[test]
+    fn serialize_and_deserialize_data_request() {
+        let data = IpPacketRequest {
+            version: 4,
+            data: IpPacketRequestData::Data(DataRequest {
+                ip_packet: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
+            }),
+        };
+
+        let serialized = data.to_bytes().unwrap();
+        let deserialized = IpPacketRequest::from_reconstructed_message(
+            &nym_sphinx::receiver::ReconstructedMessage {
+                message: serialized,
+                sender_tag: None,
+            },
+        )
+        .unwrap();
+
+        assert_eq!(deserialized.version, 4);
+        assert_eq!(
+            deserialized.data,
+            IpPacketRequestData::Data(DataRequest {
+                ip_packet: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
+            })
+        );
+    }
+}
@@ -12,20 +12,21 @@ futures = { workspace = true }
 humantime-serde = "1.0"
 log = { workspace = true }
 rand = "0.8"
-serde = { version = "1.0", features = ["derive"] }
-tokio = { version = "1.24.1", features = [
+serde = { workspace = true, features = ["derive"] }
+tokio = { workspace = true, features = [
    "time",
    "macros",
    "rt",
    "net",
    "io-util",
 ] }
-tokio-util = { version = "0.7.4", features = ["codec"] }
+tokio-util = { workspace = true, features = ["codec"] }
 url = { workspace = true }
 thiserror = { workspace = true }
+parking_lot = { workspace = true }

 ## tracing
-tracing = { version = "0.1.37", optional = true }
+tracing = { workspace = true, optional = true }

 nym-crypto = { path = "../crypto" }
 nym-network-defaults = { path = "../network-defaults" }
@@ -37,6 +38,7 @@ nym-sphinx-params = { path = "../nymsphinx/params" }
 nym-sphinx-types = { path = "../nymsphinx/types" }
 nym-task = { path = "../task" }
 nym-validator-client = { path = "../client-libs/validator-client" }
+nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-bin-common = { path = "../bin-common" }

 cfg-if = "1.0.0"
@@ -0,0 +1,27 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_validator_client::nyxd::error::NyxdError;
+use std::net::IpAddr;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum ForwardTravelError {
+    #[error("received a connection request from a forbidden address: '{address}'")]
+    DisallowedIngressAddress { address: IpAddr },
+
+    #[error("received a request to open connection to a forbidden address: '{address}'")]
+    DisallowedEgressAddress { address: IpAddr },
+
+    #[error("no valid nyxd urls are available for topology queries")]
+    NoNyxdUrlsAvailable,
+
+    #[error("nyxd interaction failure: {source}")]
+    NyxdFailure {
+        #[from]
+        source: NyxdError,
+    },
+
+    #[error("the current epoch appears to be stuck")]
+    StuckEpoch,
+}
@@ -0,0 +1,356 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::forward_travel::error::ForwardTravelError;
+use log::{debug, error, info, trace, warn};
+use nym_mixnet_contract_common::{EpochId, GatewayBond, Layer, MixNodeBond};
+use nym_network_defaults::NymNetworkDetails;
+use nym_task::TaskClient;
+use nym_validator_client::client::IdentityKey;
+use nym_validator_client::nyxd::contract_traits::{MixnetQueryClient, PagedMixnetQueryClient};
+use nym_validator_client::{nyxd, QueryHttpRpcNyxdClient};
+use parking_lot::RwLock;
+use rand::seq::SliceRandom;
+use rand::{thread_rng, Rng};
+use std::collections::HashSet;
+use std::mem;
+use std::net::{IpAddr, ToSocketAddrs};
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::time::sleep;
+use url::Url;
+
+pub mod error;
+
+// TODO: to allow for separate ingress/egress we have to change our layer selection algorithm, i.e. it has to be announced before epoch change
+pub type AllowedIngress = AllowedPaths;
+pub type AllowedEgress = AllowedPaths;
+
+pub struct AllowedAddressesProvider {
+    current_epoch: EpochId,
+
+    identity: IdentityKey,
+
+    client_config: nyxd::Config,
+
+    /// URLs to the nyxd validators for obtaining unfiltered network topology.
+    nyxd_endpoints: Vec<Url>,
+
+    // to allow for separate ingress/egress we have to change our layer selection algorithm, i.e. it has to be announced before epoch change
+    // ingress: AllowedIngress,
+    // egress: AllowedEgress,
+    allowed: AllowedPaths,
+}
+
+#[allow(dead_code)]
+impl AllowedAddressesProvider {
+    pub async fn new(
+        identity: IdentityKey,
+        nyxd_endpoints: Vec<Url>,
+        allow_all: bool,
+        network_details: Option<NymNetworkDetails>,
+    ) -> Result<Self, ForwardTravelError> {
+        let network = network_details.unwrap_or(NymNetworkDetails::new_mainnet());
+        let mut provider = AllowedAddressesProvider {
+            current_epoch: 0,
+            identity,
+            client_config: nyxd::Config::try_from_nym_network_details(&network)?,
+            nyxd_endpoints,
+            allowed: AllowedPaths::new(allow_all),
+        };
+
+        if !allow_all {
+            // set initial values for ingress/egress
+            let client = provider.ephemeral_nyxd_client()?;
+            provider.update_state(client).await?;
+        }
+
+        Ok(provider)
+    }
+
+    fn ephemeral_nyxd_client(&self) -> Result<QueryHttpRpcNyxdClient, ForwardTravelError> {
+        let mut possible_nyxd_endpoints = self.nyxd_endpoints.clone();
+        possible_nyxd_endpoints.shuffle(&mut thread_rng());
+
+        let mut last_error = match QueryHttpRpcNyxdClient::connect(
+            self.client_config.clone(),
+            possible_nyxd_endpoints
+                .pop()
+                .ok_or(ForwardTravelError::NoNyxdUrlsAvailable)?
+                .as_str(),
+        ) {
+            Ok(client) => return Ok(client),
+            Err(err) => err,
+        };
+
+        for url in possible_nyxd_endpoints {
+            match QueryHttpRpcNyxdClient::connect(self.client_config.clone(), url.as_str()) {
+                Ok(client) => return Ok(client),
+                Err(err) => last_error = err,
+            };
+        }
+
+        Err(last_error.into())
+    }
+
+    pub fn ingress(&self) -> AllowedIngress {
+        self.allowed.clone()
+    }
+
+    pub fn egress(&self) -> AllowedEgress {
+        self.allowed.clone()
+    }
+
+    fn add_node_ips(raw_host: &str, identity: &str, set: &mut HashSet<IpAddr>) {
+        if let Ok(ip) = IpAddr::from_str(raw_host) {
+            set.insert(ip);
+        } else {
+            // this might still be a valid hostname
+            //
+            // annoyingly there exists a method of looking up a socket address but not an ip address,
+            // so append any port and perform the lookup
+            let Ok(sockets) = format!("{raw_host}:1789").to_socket_addrs() else {
+                warn!("failed to resolve ip address of node '{identity}' (hostname: '{raw_host}')");
+                return;
+            };
+
+            for socket in sockets {
+                set.insert(socket.ip());
+            }
+        }
+    }
+
+    fn get_all_addresses(nodes: &[MixNodeBond], gateways: &[GatewayBond]) -> HashSet<IpAddr> {
+        let mut allowed = HashSet::new();
+
+        for node in nodes.iter() {
+            Self::add_node_ips(&node.mix_node.host, node.identity(), &mut allowed);
+        }
+
+        for gateway in gateways.iter() {
+            Self::add_node_ips(&gateway.gateway.host, gateway.identity(), &mut allowed);
+        }
+
+        allowed
+    }
+
+    /// Gets ip addresses of all mixnodes on given layer
+    fn get_addresses_on_layer(layer: Layer, nodes: &[MixNodeBond]) -> HashSet<IpAddr> {
+        let mut allowed = HashSet::new();
+
+        for node in nodes.iter().filter(|m| m.layer == layer) {
+            Self::add_node_ips(&node.mix_node.host, node.identity(), &mut allowed);
+        }
+
+        allowed
+    }
+
+    fn gateway_addresses(gateways: &[GatewayBond]) -> HashSet<IpAddr> {
+        let mut allowed = HashSet::new();
+
+        for gateway in gateways.iter() {
+            Self::add_node_ips(&gateway.gateway.host, gateway.identity(), &mut allowed);
+        }
+
+        allowed
+    }
+
+    fn locate_layer(&self, nodes: &[MixNodeBond]) -> Option<Layer> {
+        nodes
+            .iter()
+            .find(|m| m.identity() == self.identity)
+            .map(|m| m.layer)
+    }
+
+    fn is_gateway(&self, gateways: &[GatewayBond]) -> bool {
+        gateways
+            .iter()
+            .any(|g| g.gateway.identity_key == self.identity)
+    }
+
+    async fn update_state(
+        &mut self,
+        client: QueryHttpRpcNyxdClient,
+    ) -> Result<(), ForwardTravelError> {
+        let current_interval = client.get_current_interval_details().await?;
+        let current_epoch = current_interval.interval.current_epoch_absolute_id();
+
+        if current_epoch == self.current_epoch {
+            error!("can't update the allowed ips list as the epoch appears to be stuck");
+            return Err(ForwardTravelError::StuckEpoch);
+        }
+
+        let has_epoch_deviated = current_epoch > self.current_epoch + 1;
+
+        let mixnodes = client.get_all_mixnode_bonds().await?;
+        let gateways = client.get_all_gateways().await?;
+
+        let new_allowed = Self::get_all_addresses(&mixnodes, &gateways);
+
+        // I'm leaving this code commented out to preserve this logic for when we need it
+        // to update to proper ingress/egress filtering
+
+        // let our_mix_layer = self.locate_layer(&mixnodes);
+        //
+        // let previous_mix_layer = our_mix_layer.and_then(|l| l.try_previous());
+        // let next_mix_layer = our_mix_layer.and_then(|l| l.try_next());
+        //
+        // let (allowed_ingress, allowed_egress) = match (previous_mix_layer, next_mix_layer) {
+        //     // layer 1
+        //     (None, Some(next)) => {
+        //         let gateways = client.get_all_gateways().await?;
+        //
+        //         (
+        //             Self::gateway_addresses(&gateways),
+        //             Self::get_addresses_on_layer(next, &mixnodes),
+        //         )
+        //     }
+        //     // layer 2
+        //     (Some(previous), Some(next)) => (
+        //         Self::get_addresses_on_layer(previous, &mixnodes),
+        //         Self::get_addresses_on_layer(next, &mixnodes),
+        //     ),
+        //     // layer 3
+        //     (Some(previous), None) => {
+        //         let gateways = client.get_all_gateways().await?;
+        //         (
+        //             Self::get_addresses_on_layer(previous, &mixnodes),
+        //             Self::gateway_addresses(&gateways),
+        //         )
+        //     }
+        //     // gateway (or not bonded)
+        //     (None, None) => {
+        //         let gateways = client.get_all_gateways().await?;
+        //
+        //         if self.is_gateway(&gateways) {
+        //             let mut base_ingress = Self::get_addresses_on_layer(Layer::Three, &mixnodes);
+        //             let mut base_egress = Self::get_addresses_on_layer(Layer::One, &mixnodes);
+        //
+        //             // TODO: this extension should be conditional on whether the node is running the vpn module
+        //             let gw_extension = Self::gateway_addresses(&gateways);
+        //
+        //             base_ingress.extend(gw_extension.clone());
+        //             base_egress.extend(gw_extension.clone());
+        //
+        //             (base_ingress, base_egress)
+        //         } else {
+        //             warn!("our node doesn't appear to be bonded - going to permit traffic from ALL mixnodes and gateways");
+        //             let all = Self::get_all_addresses(&mixnodes, &gateways);
+        //             (all.clone(), all)
+        //         }
+        //     }
+        // };
+
+        self.current_epoch = current_epoch;
+        self.allowed.advance_epoch(new_allowed, has_epoch_deviated);
+
+        Ok(())
+    }
+
+    async fn update_allowed_addresses(&mut self) -> Result<(), ForwardTravelError> {
+        // create new client every epoch because it results in different nyxd endpoint being used
+        // what may help in distributing the load
+        let client = self.ephemeral_nyxd_client()?;
+        self.wait_for_epoch_rollover(&client).await?;
+        self.update_state(client).await
+    }
+
+    async fn wait_for_epoch_rollover(
+        &self,
+        client: &QueryHttpRpcNyxdClient,
+    ) -> Result<(), ForwardTravelError> {
+        let current_interval = client.get_current_interval_details().await?;
+        let current_epoch = current_interval.interval.current_epoch_absolute_id();
+
+        if current_epoch <= self.current_epoch {
+            let remaining = current_interval.time_until_current_epoch_end();
+            // add few more seconds to account for block time drift and to spread queries of all
+            // other nodes
+            let adjustment_secs = rand::thread_rng().gen_range(5..90);
+            sleep(remaining + Duration::from_secs(adjustment_secs)).await;
+        }
+
+        Ok(())
+    }
+
+    pub async fn run(&mut self, mut task_client: TaskClient) {
+        if self.allowed.allow_all {
+            // debug_assert!(self.egress.allow_all);
+
+            info!("the forward travel is currently disabled - there's no point in starting the route refresher");
+            task_client.mark_as_success();
+            return;
+        }
+
+        debug!("Started ValidAddressesProvider with graceful shutdown support");
+        while !task_client.is_shutdown() {
+            tokio::select! {
+                biased;
+                _ = task_client.recv() => {
+                    trace!("ValidAddressesProvider: Received shutdown");
+                }
+                res = self.update_allowed_addresses() => {
+                    if let Err(err) = res {
+                        warn!("failed to update the allowed addresses: {err}");
+
+                        // don't retry immediately in case it was a network failure, wait a bit instead.
+                        task_client.wait(Duration::from_secs(5 * 60)).await
+                    }
+                }
+            }
+        }
+        task_client.recv_timeout().await;
+        log::debug!("ValidAddressesProvider: Exiting");
+    }
+}
+
+#[derive(Clone)]
+pub struct AllowedPaths {
+    // this is fine that this value is not wrapped in an Arc and is not atomic given
+    // it's not expected to be modified at runtime
+    allow_all: bool,
+    inner: Arc<RwLock<AllowedPathsInner>>,
+}
+
+impl AllowedPaths {
+    fn new(allow_all: bool) -> Self {
+        AllowedPaths {
+            allow_all,
+            inner: Arc::new(RwLock::new(AllowedPathsInner {
+                previous_epoch: HashSet::new(),
+                current_epoch: HashSet::new(),
+            })),
+        }
+    }
+
+    pub fn is_allowed(&self, address: IpAddr) -> bool {
+        if self.allow_all {
+            return true;
+        }
+
+        let guard = self.inner.read();
+        guard.current_epoch.contains(&address) || guard.previous_epoch.contains(&address)
+    }
+
+    fn advance_epoch(&self, current_epoch: HashSet<IpAddr>, reset_previous: bool) {
+        // if this is triggered, it's an implementation bug;
+        // we shouldn't be updating data if we're allowing everything regardless
+        debug_assert!(!self.allow_all);
+
+        let mut guard = self.inner.write();
+
+        let old_current = mem::replace(&mut guard.current_epoch, current_epoch);
+
+        if reset_previous {
+            guard.previous_epoch = HashSet::new()
+        } else {
+            guard.previous_epoch = old_current;
+        }
+    }
+}
+
+struct AllowedPathsInner {
+    previous_epoch: HashSet<IpAddr>,
+    current_epoch: HashSet<IpAddr>,
+}
@@ -1,5 +1,7 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
+
+pub mod forward_travel;
 pub mod packet_processor;
 pub mod verloc;

@@ -1,81 +1,50 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::fmt::{self, Display, Formatter};
 use std::io;
+use thiserror::Error;

-#[derive(Debug)]
+#[derive(Debug, Error)]
 pub enum RttError {
+    #[error("the received echo packet had unexpected size")]
    UnexpectedEchoPacketSize,
+
+    #[error("the received reply packet had unexpected size")]
    UnexpectedReplyPacketSize,

+    #[error("the received echo packet had malformed sender")]
    MalformedSenderIdentity,

+    #[error("the received echo packet had malformed signature")]
    MalformedEchoSignature,
+
+    #[error("the received reply packet had malformed signature")]
    MalformedReplySignature,

+    #[error("the received echo packet had invalid signature")]
    InvalidEchoSignature,
+
+    #[error("the received reply packet had invalid signature")]
    InvalidReplySignature,

-    UnreachableNode(String, io::Error),
-    UnexpectedConnectionFailureWrite(String, io::Error),
-    UnexpectedConnectionFailureRead(String, io::Error),
+    #[error("could not establish connection to {0}: {1}")]
+    UnreachableNode(String, #[source] io::Error),
+
+    #[error("failed to write echo packet to {0}: {1}")]
+    UnexpectedConnectionFailureWrite(String, #[source] io::Error),
+
+    #[error("failed to read reply packet from {0}: {1}")]
+    UnexpectedConnectionFailureRead(String, #[source] io::Error),
+
+    #[error("timed out while trying to read reply packet from {0}")]
    ConnectionReadTimeout(String),
+
+    #[error("timed out while trying to write echo packet to {0}")]
    ConnectionWriteTimeout(String),

+    #[error("the received reply packet had an unexpected sequence number")]
    UnexpectedReplySequence,

+    #[error("shutdown signal received")]
    ShutdownReceived,
 }
-
-impl Display for RttError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            RttError::UnexpectedEchoPacketSize => {
-                write!(f, "The received echo packet had unexpected size")
-            }
-            RttError::UnexpectedReplyPacketSize => {
-                write!(f, "The received reply packet had unexpected size")
-            }
-            RttError::MalformedSenderIdentity => {
-                write!(f, "The received echo packet had malformed sender")
-            }
-            RttError::MalformedEchoSignature => {
-                write!(f, "The received echo packet had malformed signature")
-            }
-            RttError::MalformedReplySignature => {
-                write!(f, "The received reply packet had malformed signature")
-            }
-            RttError::InvalidEchoSignature => {
-                write!(f, "The received echo packet had invalid signature")
-            }
-            RttError::InvalidReplySignature => {
-                write!(f, "The received reply packet had invalid signature")
-            }
-            RttError::UnreachableNode(id, err) => {
-                write!(f, "Could not establish connection to {id} - {err}")
-            }
-            RttError::UnexpectedConnectionFailureWrite(id, err) => {
-                write!(f, "Failed to write echo packet to {id} - {err}")
-            }
-            RttError::UnexpectedConnectionFailureRead(id, err) => {
-                write!(f, "Failed to read reply packet from {id} - {err}")
-            }
-            RttError::ConnectionReadTimeout(id) => {
-                write!(f, "Timed out while trying to read reply packet from {id}")
-            }
-            RttError::ConnectionWriteTimeout(id) => {
-                write!(f, "Timed out while trying to write echo packet to {id}")
-            }
-            RttError::UnexpectedReplySequence => write!(
-                f,
-                "The received reply packet had an unexpected sequence number"
-            ),
-            RttError::ShutdownReceived => {
-                write!(f, "Shutdown signal received")
-            }
-        }
-    }
-}
-
-impl std::error::Error for RttError {}
@@ -476,3 +476,11 @@ pub const DEFAULT_NYM_NODE_HTTP_PORT: u16 = 8080;
 pub const TOTAL_SUPPLY: u128 = 1_000_000_000_000_000;

 pub const DEFAULT_PROFIT_MARGIN: u8 = 10;
+
+// WIREGUARD
+pub const WG_PORT: u16 = 51822;
+
+// The interface used to route traffic
+pub const WG_TUN_BASE_NAME: &str = "nymwg";
+pub const WG_TUN_DEVICE_ADDRESS: &str = "10.1.0.1";
+pub const WG_TUN_DEVICE_NETMASK: &str = "255.255.255.0";
@@ -258,6 +258,7 @@ where
            &address,
            &address,
            PacketType::Mix,
+            None,
        )?)
    }

@@ -7,13 +7,13 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-tokio-stream = "0.1.11" # this one seems to be a thing until `Stream` trait is stabilised in stdlib
+tokio-stream = { workspace = true } # this one seems to be a thing until `Stream` trait is stabilised in stdlib

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
 workspace = true

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-util]
-version = "0.7.4"
+workspace = true
 features = ["time"]

 [target."cfg(target_arch = \"wasm32\")".dependencies.wasmtimer]
@@ -6,9 +6,10 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use ff::Field;
 use group::{Curve, Group};
 use nym_coconut::{
-    aggregate_signature_shares, aggregate_verification_keys, blind_sign, elgamal_keygen,
-    prepare_blind_sign, prove_bandwidth_credential, setup, ttp_keygen, verify_credential,
-    Attribute, BlindedSignature, Parameters, Signature, SignatureShare, VerificationKey,
+    aggregate_signature_shares, aggregate_verification_keys, blind_sign, prepare_blind_sign,
+    prove_bandwidth_credential, setup, ttp_keygen, verify_credential,
+    verify_partial_blind_signature, Attribute, BlindedSignature, Parameters, Signature,
+    SignatureShare, VerificationKey,
 };
 use rand::seq::SliceRandom;
 use std::ops::Neg;
@@ -175,8 +176,6 @@ fn bench_coconut(c: &mut Criterion) {
    let binding_number = params.random_scalar();
    let private_attributes = vec![serial_number, binding_number];

-    let _elgamal_keypair = elgamal_keygen(&params);
-
    // The prepare blind sign is performed by the user
    let (pedersen_commitments_openings, blind_sign_request) =
        prepare_blind_sign(&params, &private_attributes, &public_attributes).unwrap();
@@ -242,6 +241,29 @@ fn bench_coconut(c: &mut Criterion) {
        .map(|keypair| keypair.verification_key())
        .collect();

+    // verify a random partial blind signature
+    let rand_idx = 1;
+    let random_blind_signature = blinded_signatures.get(rand_idx).unwrap();
+    let partial_verification_key = verification_keys.get(rand_idx).unwrap();
+
+    group.bench_function(
+        &format!(
+            "verify_partial_blind_signature_{}_private_attributes_{}_public_attributes",
+            case.num_private_attrs, case.num_public_attrs
+        ),
+        |b| {
+            b.iter(|| {
+                verify_partial_blind_signature(
+                    &params,
+                    &blind_sign_request,
+                    &public_attributes,
+                    random_blind_signature,
+                    partial_verification_key,
+                )
+            })
+        },
+    );
+
    // Lets bench worse case, ie aggregating all
    let indices: Vec<u64> = (1..=case.num_authorities).collect();
    // aggregate verification keys
@@ -14,6 +14,7 @@ pub use scheme::aggregation::aggregate_signature_shares;
 pub use scheme::aggregation::aggregate_verification_keys;
 pub use scheme::issuance::blind_sign;
 pub use scheme::issuance::prepare_blind_sign;
+pub use scheme::issuance::verify_partial_blind_signature;
 pub use scheme::issuance::BlindSignRequest;
 pub use scheme::keygen::ttp_keygen;
 pub use scheme::keygen::KeyPair;
@@ -50,7 +50,7 @@ where
 impl Aggregatable for PartialSignature {
    fn aggregate(sigs: &[PartialSignature], indices: Option<&[u64]>) -> Result<Signature> {
        let h = sigs
-            .get(0)
+            .first()
            .ok_or_else(|| CoconutError::Aggregation("Empty set of signatures".to_string()))?
            .sig1();

@@ -3,12 +3,14 @@

 use std::convert::TryFrom;
 use std::convert::TryInto;
+use std::ops::Neg;

-use bls12_381::{G1Affine, G1Projective, Scalar};
-use group::{Curve, GroupEncoding};
+use bls12_381::{multi_miller_loop, G1Affine, G1Projective, G2Prepared, Scalar};
+use group::{Curve, Group, GroupEncoding};

 use crate::error::{CoconutError, Result};
 use crate::proofs::ProofCmCs;
+use crate::scheme::keygen::VerificationKey;
 use crate::scheme::setup::Parameters;
 use crate::scheme::BlindedSignature;
 use crate::scheme::SecretKey;
@@ -318,6 +320,97 @@ pub fn blind_sign(
    Ok(BlindedSignature(h, sig))
 }

+/// Verifies a partial blind signature using the provided parameters and validator's verification key.
+///
+/// # Arguments
+///
+/// * `params` - A reference to the cryptographic parameters.
+/// * `blind_sign_request` - A reference to the blind signature request signed by the client.
+/// * `public_attributes` - A reference to the public attributes included in the client's request.
+/// * `blind_sig` - A reference to the issued partial blinded signature to be verified.
+/// * `partial_verification_key` - A reference to the validator's partial verification key.
+///
+/// # Returns
+///
+/// A boolean indicating whether the partial blind signature is valid (`true`) or not (`false`).
+///
+/// # Remarks
+///
+/// This function verifies the correctness and validity of a partial blind signature using
+/// the provided cryptographic parameters, blind signature request, blinded signature,
+/// and partial verification key.
+/// It calculates pairings based on the provided values and checks whether the partial blind signature
+/// is consistent with the verification key and commitments in the blind signature request.
+/// The function returns `true` if the partial blind signature is valid, and `false` otherwise.
+pub fn verify_partial_blind_signature(
+    params: &Parameters,
+    blind_sign_request: &BlindSignRequest,
+    public_attributes: &[Attribute],
+    blind_sig: &BlindedSignature,
+    partial_verification_key: &VerificationKey,
+) -> bool {
+    let num_private_attributes = blind_sign_request.private_attributes_commitments.len();
+    if num_private_attributes + public_attributes.len() > partial_verification_key.beta_g2.len() {
+        return false;
+    }
+
+    // TODO: we're losing some memory here due to extra allocation,
+    // but worst-case scenario (given SANE amount of attributes), it's just few kb at most
+    let c_neg = blind_sig.1.to_affine().neg();
+    let g2_prep = params.prepared_miller_g2();
+
+    let mut terms = vec![
+        // (c^{-1}, g2)
+        (c_neg, g2_prep.clone()),
+        // (s, alpha)
+        (
+            blind_sig.0.to_affine(),
+            G2Prepared::from(partial_verification_key.alpha.to_affine()),
+        ),
+    ];
+
+    // for each private attribute, add (cm_i, beta_i) to the miller terms
+    for (private_attr_commit, beta_g2) in blind_sign_request
+        .private_attributes_commitments
+        .iter()
+        .zip(&partial_verification_key.beta_g2)
+    {
+        // (cm_i, beta_i)
+        terms.push((
+            private_attr_commit.to_affine(),
+            G2Prepared::from(beta_g2.to_affine()),
+        ))
+    }
+
+    // for each public attribute, add (s^pub_j, beta_{priv + j}) to the miller terms
+    for (pub_attr, beta_g2) in public_attributes.iter().zip(
+        partial_verification_key
+            .beta_g2
+            .iter()
+            .skip(num_private_attributes),
+    ) {
+        // (s^pub_j, beta_j)
+        terms.push((
+            (blind_sig.0 * pub_attr).to_affine(),
+            G2Prepared::from(beta_g2.to_affine()),
+        ))
+    }
+
+    // get the references to all the terms to get the arguments the miller loop expects
+    #[allow(clippy::map_identity)]
+    let terms_refs = terms.iter().map(|(g1, g2)| (g1, g2)).collect::<Vec<_>>();
+
+    // since checking whether e(a, b) == e(c, d)
+    // is equivalent to checking e(a, b) • e(c, d)^{-1} == id
+    // and thus to e(a, b) • e(c^{-1}, d) == id
+    //
+    // compute e(c^1, g2) • e(s, alpha) • e(cm_0, beta_0) • e(cm_i, beta_i) • (s^pub_0, beta_{i+1}) (s^pub_j, beta_{i + j})
+    multi_miller_loop(&terms_refs)
+        .final_exponentiation()
+        .is_identity()
+        .into()
+}
+
 #[cfg(test)]
 pub fn sign(
    params: &mut Parameters,
@@ -354,6 +447,7 @@ pub fn sign(
 #[cfg(test)]
 mod tests {
    use super::*;
+    use crate::scheme::keygen::keygen;

    #[test]
    fn blind_sign_request_bytes_roundtrip() {
@@ -385,4 +479,81 @@ mod tests {
            lambda
        );
    }
+
+    #[test]
+    fn successful_verify_partial_blind_signature() {
+        let params = Parameters::new(4).unwrap();
+        let private_attributes = params.n_random_scalars(2);
+        let public_attributes = params.n_random_scalars(2);
+
+        let (_commitments_openings, request) =
+            prepare_blind_sign(&params, &private_attributes, &public_attributes).unwrap();
+
+        let validator_keypair = keygen(&params);
+        let blind_sig = blind_sign(
+            &params,
+            &validator_keypair.secret_key(),
+            &request,
+            &public_attributes,
+        )
+        .unwrap();
+
+        assert!(verify_partial_blind_signature(
+            &params,
+            &request,
+            &public_attributes,
+            &blind_sig,
+            &validator_keypair.verification_key()
+        ));
+    }
+
+    #[test]
+    fn successful_verify_partial_blind_signature_no_public_attributes() {
+        let params = Parameters::new(4).unwrap();
+        let private_attributes = params.n_random_scalars(2);
+
+        let (_commitments_openings, request) =
+            prepare_blind_sign(&params, &private_attributes, &[]).unwrap();
+
+        let validator_keypair = keygen(&params);
+        let blind_sig =
+            blind_sign(&params, &validator_keypair.secret_key(), &request, &[]).unwrap();
+
+        assert!(verify_partial_blind_signature(
+            &params,
+            &request,
+            &[],
+            &blind_sig,
+            &validator_keypair.verification_key()
+        ));
+    }
+
+    #[test]
+    fn fail_verify_partial_blind_signature_with_wrong_key() {
+        let params = Parameters::new(4).unwrap();
+        let private_attributes = params.n_random_scalars(2);
+        let public_attributes = params.n_random_scalars(2);
+
+        let (_commitments_openings, request) =
+            prepare_blind_sign(&params, &private_attributes, &public_attributes).unwrap();
+
+        let validator_keypair = keygen(&params);
+        let validator2_keypair = keygen(&params);
+        let blind_sig = blind_sign(
+            &params,
+            &validator_keypair.secret_key(),
+            &request,
+            &public_attributes,
+        )
+        .unwrap();
+
+        // this assertion should fail, as we try to verify with a wrong validator key
+        assert!(!verify_partial_blind_signature(
+            &params,
+            &request,
+            &public_attributes,
+            &blind_sig,
+            &validator2_keypair.verification_key()
+        ),);
+    }
 }
@@ -9,7 +9,7 @@ repository = { workspace = true }

 [dependencies]
 bytes = "1.0"
-tokio-util = { version = "0.7.4", features = ["codec"] }
+tokio-util = { workspace = true, features = ["codec"] }
 thiserror = { workspace = true }

 nym-sphinx-types = { path = "../types", features = ["sphinx", "outfox"] }
@@ -181,6 +181,7 @@ pub trait FragmentPreparer {
    /// - compute vk_b = g^x || v_b
    /// - compute sphinx_plaintext = SURB_ACK || g^x || v_b
    /// - compute sphinx_packet = Sphinx(recipient, sphinx_plaintext)
+    #[allow(clippy::too_many_arguments)]
    fn prepare_chunk_for_sending(
        &mut self,
        fragment: Fragment,
@@ -189,6 +190,7 @@ pub trait FragmentPreparer {
        packet_sender: &Recipient,
        packet_recipient: &Recipient,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<PreparedFragment, NymTopologyError> {
        // each plain or repliable packet (i.e. not a reply) attaches an ephemeral public key so that the recipient
        // could perform diffie-hellman with its own keys followed by a kdf to re-derive
@@ -226,7 +228,8 @@ pub trait FragmentPreparer {
        };

        // generate pseudorandom route for the packet
-        let hops = self.num_mix_hops();
+        let hops = mix_hops.unwrap_or(self.num_mix_hops());
+        log::trace!("Preparing chunk for sending with {} mix hops", hops);
        let route =
            topology.random_route_to_gateway(self.rng(), hops, packet_recipient.gateway())?;
        let destination = packet_recipient.as_sphinx_destination();
@@ -389,6 +392,7 @@ where
        ack_key: &AckKey,
        packet_recipient: &Recipient,
        packet_type: PacketType,
+        mix_hops: Option<u8>,
    ) -> Result<PreparedFragment, NymTopologyError> {
        let sender = self.sender_address;

@@ -400,6 +404,7 @@ where
            &sender,
            packet_recipient,
            packet_type,
+            mix_hops,
        )
    }

@@ -169,6 +169,10 @@ pub struct SphinxMessageReceiver {

 impl SphinxMessageReceiver {
    /// Allows setting non-default number of expected mix hops in the network.
+    // IMPORTANT NOTE: this is among others used to deserialize SURBs. Meaning that this is a
+    // global setting and currently always set to the default value. The implication is that it is
+    // not currently possible to have different number of hops for different SURB messages. So,
+    // don't try to use <3 mix hops for SURBs until this is refactored.
    #[must_use]
    pub fn with_mix_hops(mut self, hops: u8) -> Self {
        self.num_mix_hops = hops;
@@ -9,7 +9,7 @@ edition = "2021"
 [dependencies]
 bytes = "1.0"
 tokio = { version = "1.24.1", features = [ "net", "io-util", "sync", "macros", "time", "rt-multi-thread" ] }
-tokio-util = { version = "0.7.4", features = [ "io" ] } # reason for getting this guy is to to able to port to tokio 1.X more quickly by being able to use
+tokio-util = { workspace = true, features = [ "io" ] } # reason for getting this guy is to to able to port to tokio 1.X more quickly by being able to use
 # their `read_buf` [from the util crate] replacement rather than having to rethink/reimplement `AvailableReader` with the new AsyncRead trait definition.
 # In the long run, the dependency should probably get removed in favour of pure-tokio implementation, but for time being it's fine.
 futures = { workspace = true }
@@ -373,6 +373,14 @@ impl TaskClient {
        }
    }

+    pub async fn wait(&mut self, duration: Duration) {
+        tokio::select! {
+            biased;
+            _ = self.recv() => (),
+            _ = sleep(duration) => (),
+        }
+    }
+
    // Create a dummy that will never report that we should shutdown.
    pub fn dummy() -> TaskClient {
        let (_notify_tx, notify_rx) = watch::channel(());
@@ -493,10 +501,16 @@ impl TaskClient {
 impl Drop for TaskClient {
    fn drop(&mut self) {
        if !self.mode.should_signal_on_drop() {
-            self.log(Level::Debug, "the task client is getting dropped");
+            self.log(
+                Level::Debug,
+                "the task client is getting dropped: this is expected during client shutdown",
+            );
            return;
        } else {
-            self.log(Level::Info, "the task client is getting dropped");
+            self.log(
+                Level::Info,
+                "the task client is getting dropped: this is expected during client shutdown",
+            );
        }

        if !self.is_shutdown_poll() {
@@ -1,7 +1,6 @@
 use crate::{manager::SentError, TaskManager};

 #[cfg(unix)]
-#[deprecated]
 pub async fn wait_for_signal() {
    use tokio::signal::unix::{signal, SignalKind};
    let mut sigterm = signal(SignalKind::terminate()).expect("Failed to setup SIGTERM channel");
@@ -0,0 +1,21 @@
+[package]
+name = "nym-tun"
+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]
+thiserror.workspace = true
+tokio = { workspace = true, features = ["rt-multi-thread", "net", "io-util", "time", "sync", "macros"] }
+etherparse = "0.13.0"
+log.workspace = true
+nym-wireguard-types = { path = "../wireguard-types", optional = true }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+tokio-tun = "0.11.2"
@@ -0,0 +1,7 @@
+#[cfg(target_os = "linux")]
+mod linux;
+
+pub mod tun_task_channel;
+
+#[cfg(target_os = "linux")]
+pub use linux::tun_device;
@@ -0,0 +1,255 @@
+use std::{
+    collections::HashMap,
+    net::{IpAddr, Ipv4Addr},
+    time::Duration,
+};
+
+use etherparse::{InternetSlice, SlicedPacket};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    time::timeout,
+};
+
+use crate::tun_task_channel::{
+    tun_task_channel, tun_task_response_channel, TunTaskPayload, TunTaskResponseRx,
+    TunTaskResponseSendError, TunTaskResponseTx, TunTaskRx, TunTaskTx,
+};
+
+const TUN_WRITE_TIMEOUT_MS: u64 = 1000;
+
+#[derive(thiserror::Error, Debug)]
+pub enum TunDeviceError {
+    #[error("timeout writing to tun device, dropping packet")]
+    TunWriteTimeout,
+
+    #[error("error writing to tun device: {source}")]
+    TunWriteError { source: std::io::Error },
+
+    #[error("failed to forward responding packet with tag: {source}")]
+    ForwardNatResponseFailed {
+        #[from]
+        source: TunTaskResponseSendError,
+    },
+
+    #[error("unable to parse headers in packet")]
+    UnableToParseHeaders {
+        #[from]
+        source: etherparse::ReadError,
+    },
+
+    #[error("unable to parse src and dst address from packet: ip header missing")]
+    UnableToParseAddressIpHeaderMissing,
+
+    #[error("unable to lock peer mutex")]
+    FailedToLockPeer,
+}
+
+fn setup_tokio_tun_device(name: &str, address: Ipv4Addr, netmask: Ipv4Addr) -> tokio_tun::Tun {
+    log::info!("Creating TUN device with: address={address}, netmask={netmask}");
+    // Read MTU size from env variable NYM_MTU_SIZE, else default to 1420.
+    let mtu = std::env::var("NYM_MTU_SIZE")
+        .map(|mtu| mtu.parse().expect("NYM_MTU_SIZE must be a valid integer"))
+        .unwrap_or(1420);
+    log::info!("Using MTU size: {mtu}");
+    tokio_tun::Tun::builder()
+        .name(name)
+        .tap(false)
+        .packet_info(false)
+        .mtu(mtu)
+        .up()
+        .address(address)
+        .netmask(netmask)
+        .try_build()
+        .expect("Failed to setup tun device, do you have permission?")
+}
+
+pub struct TunDevice {
+    // The TUN device that we read/write to, to send/receive packets
+    tun: tokio_tun::Tun,
+
+    // Incoming data that we should send
+    tun_task_rx: TunTaskRx,
+
+    // And when we get replies, this is where we should send it
+    tun_task_response_tx: TunTaskResponseTx,
+
+    routing_mode: RoutingMode,
+}
+
+pub enum RoutingMode {
+    // This is an alternative to the routing table, where we just match outgoing source IP with
+    // incoming destination IP.
+    Nat(NatInner),
+
+    // Just forward without checking anything
+    Passthrough,
+}
+
+impl RoutingMode {
+    pub fn new_nat() -> Self {
+        RoutingMode::Nat(NatInner {
+            nat_table: HashMap::new(),
+        })
+    }
+
+    pub fn new_passthrough() -> Self {
+        RoutingMode::Passthrough
+    }
+}
+
+pub struct NatInner {
+    nat_table: HashMap<IpAddr, u64>,
+}
+
+pub struct TunDeviceConfig {
+    pub base_name: String,
+    pub ip: Ipv4Addr,
+    pub netmask: Ipv4Addr,
+}
+
+impl TunDevice {
+    pub fn new(
+        routing_mode: RoutingMode,
+        config: TunDeviceConfig,
+    ) -> (Self, TunTaskTx, TunTaskResponseRx) {
+        let tun = Self::new_device_only(config);
+
+        // Channels to communicate with the other tasks
+        let (tun_task_tx, tun_task_rx) = tun_task_channel();
+        let (tun_task_response_tx, tun_task_response_rx) = tun_task_response_channel();
+
+        let tun_device = TunDevice {
+            tun_task_rx,
+            tun_task_response_tx,
+            tun,
+            routing_mode,
+        };
+
+        (tun_device, tun_task_tx, tun_task_response_rx)
+    }
+
+    pub fn new_device_only(config: TunDeviceConfig) -> tokio_tun::Tun {
+        let TunDeviceConfig {
+            base_name,
+            ip,
+            netmask,
+        } = config;
+        let name = format!("{base_name}%d");
+
+        let tun = setup_tokio_tun_device(&name, ip, netmask);
+        log::info!("Created TUN device: {}", tun.name());
+        tun
+    }
+
+    // Send outbound packets out on the wild internet
+    async fn handle_tun_write(&mut self, data: TunTaskPayload) -> Result<(), TunDeviceError> {
+        let (tag, packet) = data;
+        let ParsedAddresses { src_addr, dst_addr } = parse_src_dst_address(&packet)?;
+        log::debug!(
+            "iface: write Packet({src_addr} -> {dst_addr}, {} bytes)",
+            packet.len()
+        );
+
+        // TODO: expire old entries
+        if let RoutingMode::Nat(nat_table) = &mut self.routing_mode {
+            nat_table.nat_table.insert(src_addr, tag);
+        }
+
+        timeout(
+            Duration::from_millis(TUN_WRITE_TIMEOUT_MS),
+            self.tun.write_all(&packet),
+        )
+        .await
+        .map_err(|_| TunDeviceError::TunWriteTimeout)?
+        .map_err(|err| TunDeviceError::TunWriteError { source: err })
+    }
+
+    // Receive reponse packets from the wild internet
+    async fn handle_tun_read(&self, packet: &[u8]) -> Result<(), TunDeviceError> {
+        let ParsedAddresses { src_addr, dst_addr } = parse_src_dst_address(packet)?;
+        log::debug!(
+            "iface: read Packet({dst_addr} <- {src_addr}, {} bytes)",
+            packet.len(),
+        );
+
+        // Route packet to the correct peer.
+
+        match self.routing_mode {
+            // But we can also do it by consulting the NAT table.
+            RoutingMode::Nat(ref nat_table) => {
+                if let Some(tag) = nat_table.nat_table.get(&dst_addr) {
+                    log::debug!("Forward packet with NAT tag: {tag}");
+                    return self
+                        .tun_task_response_tx
+                        .try_send((*tag, packet.to_vec()))
+                        .map_err(|err| err.into());
+                }
+            }
+
+            RoutingMode::Passthrough => {
+                // TODO: skip the parsing at the top of the function
+                log::debug!("Forward packet without checking anything");
+                return self
+                    .tun_task_response_tx
+                    .try_send((0, packet.to_vec()))
+                    .map_err(|err| err.into());
+            }
+        }
+
+        log::info!("No peer found, packet dropped");
+        Ok(())
+    }
+
+    pub async fn run(mut self) {
+        let mut buf = [0u8; 65535];
+
+        loop {
+            tokio::select! {
+                // Reading from the TUN device
+                len = self.tun.read(&mut buf) => match len {
+                    Ok(len) => {
+                        let packet = &buf[..len];
+                        if let Err(err) = self.handle_tun_read(packet).await {
+                            log::error!("iface: handle_tun_read failed: {err}")
+                        }
+                    },
+                    Err(err) => {
+                        log::info!("iface: read error: {err}");
+                        // break;
+                    }
+                },
+                // Writing to the TUN device
+                Some(data) = self.tun_task_rx.recv() => {
+                    if let Err(err) = self.handle_tun_write(data).await {
+                        log::error!("iface: handle_tun_write failed: {err}");
+                    }
+                }
+            }
+        }
+        // log::info!("TUN device shutting down");
+    }
+
+    pub fn start(self) {
+        tokio::spawn(async move { self.run().await });
+    }
+}
+
+struct ParsedAddresses {
+    src_addr: IpAddr,
+    dst_addr: IpAddr,
+}
+
+fn parse_src_dst_address(packet: &[u8]) -> Result<ParsedAddresses, TunDeviceError> {
+    let headers = SlicedPacket::from_ip(packet)?;
+    match headers.ip {
+        Some(InternetSlice::Ipv4(ip, _)) => Ok(ParsedAddresses {
+            src_addr: ip.source_addr().into(),
+            dst_addr: ip.destination_addr().into(),
+        }),
+        Some(InternetSlice::Ipv6(ip, _)) => Ok(ParsedAddresses {
+            src_addr: ip.source_addr().into(),
+            dst_addr: ip.destination_addr().into(),
+        }),
+        None => Err(TunDeviceError::UnableToParseAddressIpHeaderMissing),
+    }
+}
@@ -0,0 +1,84 @@
+#![cfg_attr(not(target_os = "linux"), allow(dead_code))]
+
+use std::time::Duration;
+
+use tokio::sync::mpsc::{
+    self,
+    error::{SendError, SendTimeoutError, TrySendError},
+};
+
+pub(crate) type TunTaskPayload = (u64, Vec<u8>);
+
+#[derive(Clone)]
+pub struct TunTaskTx(mpsc::Sender<TunTaskPayload>);
+pub(crate) struct TunTaskRx(mpsc::Receiver<TunTaskPayload>);
+
+impl TunTaskTx {
+    pub async fn send(&self, data: TunTaskPayload) -> Result<(), SendError<TunTaskPayload>> {
+        self.0.send(data).await
+    }
+
+    pub fn try_send(&self, data: TunTaskPayload) -> Result<(), TrySendError<TunTaskPayload>> {
+        self.0.try_send(data)
+    }
+}
+
+impl TunTaskRx {
+    pub(crate) async fn recv(&mut self) -> Option<TunTaskPayload> {
+        self.0.recv().await
+    }
+}
+
+pub(crate) fn tun_task_channel() -> (TunTaskTx, TunTaskRx) {
+    let (tun_task_tx, tun_task_rx) = tokio::sync::mpsc::channel(128);
+    (TunTaskTx(tun_task_tx), TunTaskRx(tun_task_rx))
+}
+
+const TUN_TASK_RESPONSE_SEND_TIMEOUT_MS: u64 = 1_000;
+
+// Send responses back from the tun device back to the PacketRelayer
+pub(crate) struct TunTaskResponseTx(mpsc::Sender<TunTaskPayload>);
+pub struct TunTaskResponseRx(mpsc::Receiver<TunTaskPayload>);
+
+#[derive(thiserror::Error, Debug)]
+pub enum TunTaskResponseSendError {
+    #[error("failed to send tun response: {0}")]
+    SendTimeoutError(#[from] SendTimeoutError<TunTaskPayload>),
+
+    #[error("failed to send tun response: {0}")]
+    SendError(#[from] SendError<TunTaskPayload>),
+
+    #[error("failed to send tun response: {0}")]
+    TrySendError(#[from] TrySendError<TunTaskPayload>),
+}
+
+impl TunTaskResponseTx {
+    #[allow(unused)]
+    pub(crate) async fn send(&self, data: TunTaskPayload) -> Result<(), TunTaskResponseSendError> {
+        Ok(self
+            .0
+            .send_timeout(
+                data,
+                Duration::from_millis(TUN_TASK_RESPONSE_SEND_TIMEOUT_MS),
+            )
+            .await?)
+    }
+
+    pub(crate) fn try_send(&self, data: TunTaskPayload) -> Result<(), TunTaskResponseSendError> {
+        Ok(self.0.try_send(data)?)
+    }
+}
+
+impl TunTaskResponseRx {
+    pub async fn recv(&mut self) -> Option<TunTaskPayload> {
+        self.0.recv().await
+    }
+}
+
+pub(crate) fn tun_task_response_channel() -> (TunTaskResponseTx, TunTaskResponseRx) {
+    let (tun_task_tx, tun_task_rx) = tokio::sync::mpsc::channel(128);
+    (
+        TunTaskResponseTx(tun_task_tx),
+        TunTaskResponseRx(tun_task_rx),
+    )
+}
@@ -434,6 +434,10 @@ pub struct ReplySurbsWasm {
    /// Defines maximum amount of time given reply key is going to be valid for.
    /// This is going to be superseded by key rotation once implemented.
    pub maximum_reply_key_age_ms: u32,
+
+    /// Defines how many mix nodes the reply surb should go through.
+    /// If not set, the default value is going to be used.
+    pub surb_mix_hops: Option<u8>,
 }

 impl Default for ReplySurbsWasm {
@@ -463,6 +467,7 @@ impl From<ReplySurbsWasm> for ConfigReplySurbs {
            maximum_reply_key_age: Duration::from_millis(
                reply_surbs.maximum_reply_key_age_ms as u64,
            ),
+            surb_mix_hops: reply_surbs.surb_mix_hops,
        }
    }
 }
@@ -484,6 +489,7 @@ impl From<ConfigReplySurbs> for ReplySurbsWasm {
                .as_millis() as u32,
            maximum_reply_surb_age_ms: reply_surbs.maximum_reply_surb_age.as_millis() as u32,
            maximum_reply_key_age_ms: reply_surbs.maximum_reply_key_age.as_millis() as u32,
+            surb_mix_hops: reply_surbs.surb_mix_hops,
        }
    }
 }
@@ -303,6 +303,9 @@ pub struct ReplySurbsWasmOverride {
    /// This is going to be superseded by key rotation once implemented.
    #[tsify(optional)]
    pub maximum_reply_key_age_ms: Option<u32>,
+
+    #[tsify(optional)]
+    pub surb_mix_hops: Option<u8>,
 }

 impl From<ReplySurbsWasmOverride> for ReplySurbsWasm {
@@ -337,6 +340,7 @@ impl From<ReplySurbsWasmOverride> for ReplySurbsWasm {
            maximum_reply_key_age_ms: value
                .maximum_reply_key_age_ms
                .unwrap_or(def.maximum_reply_key_age_ms),
+            surb_mix_hops: value.surb_mix_hops,
        }
    }
 }
@@ -13,6 +13,7 @@ license.workspace = true
 [dependencies]
 base64 = { workspace = true }
 dashmap = { workspace = true }
+log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }

@@ -28,13 +29,7 @@ sha2 = { version = "0.10.8", optional = true }
 utoipa = { workspace = true, optional = true }
 serde_json = { workspace = true, optional = true }

-# target-specific dependencies
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.boringtun]
-workspace = true
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.x25519-dalek]
-version = "2.0.0"
-
+x25519-dalek = { version = "2.0.0", features = ["static_secrets"] }

 [dev-dependencies]
 rand = "0.7.3"
@@ -45,4 +40,4 @@ nym-crypto = { path = "../crypto", features = ["rand"]}
 default = ["verify"]
 openapi = ["utoipa", "serde_json"]
 # this is moved to a separate feature as we really need clients to import it (especially, *cough*, wasm)
-verify = ["hmac", "sha2"]
+verify = ["hmac", "sha2"]
@@ -13,5 +13,3 @@ pub use registration::{

 #[cfg(feature = "verify")]
 pub use registration::HmacSha256;
-
-pub const WG_PORT: u16 = 51822;
@@ -10,20 +10,14 @@ use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 use std::str::FromStr;

-// underneath the same library is being used, i.e. x25519-dalek 2.0,
-// which is being reexported by boringtun but wasm hates internals of boringtun
-#[cfg(target_arch = "wasm32")]
-use x25519_dalek::PublicKey as BoringtunPublicKey;
-
-#[cfg(not(target_arch = "wasm32"))]
-use boringtun::x25519::PublicKey as BoringtunPublicKey;
+use x25519_dalek::PublicKey;

 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub struct PeerPublicKey(BoringtunPublicKey);
+pub struct PeerPublicKey(PublicKey);

 impl PeerPublicKey {
    #[allow(dead_code)]
-    pub fn new(key: BoringtunPublicKey) -> Self {
+    pub fn new(key: PublicKey) -> Self {
        PeerPublicKey(key)
    }

@@ -45,7 +39,7 @@ impl Hash for PeerPublicKey {
 }

 impl Deref for PeerPublicKey {
-    type Target = BoringtunPublicKey;
+    type Target = PublicKey;

    fn deref(&self) -> &Self::Target {
        &self.0
@@ -71,7 +65,7 @@ impl FromStr for PeerPublicKey {
            })?;
        };

-        Ok(PeerPublicKey(BoringtunPublicKey::from(key_arr)))
+        Ok(PeerPublicKey(PublicKey::from(key_arr)))
    }
 }

@@ -93,11 +93,10 @@ impl GatewayClient {
    ) -> Self {
        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
        #[allow(clippy::expect_used)]
-        let static_secret = boringtun::x25519::StaticSecret::try_from(local_secret.to_bytes())
-            .expect("conversion between x25519 private keys is infallible");
-        let local_public: boringtun::x25519::PublicKey = (&static_secret).into();
+        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
+        let local_public: x25519_dalek::PublicKey = (&static_secret).into();

-        let remote_public = boringtun::x25519::PublicKey::from(remote_public.to_bytes());
+        let remote_public = x25519_dalek::PublicKey::from(remote_public.to_bytes());

        let dh = static_secret.diffie_hellman(&remote_public);

@@ -123,8 +122,7 @@ impl GatewayClient {
    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 = boringtun::x25519::StaticSecret::try_from(gateway_key.to_bytes())
-            .expect("conversion between x25519 private keys is infallible");
+        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());

        let dh = static_secret.diffie_hellman(&self.pub_key);

@@ -11,27 +11,15 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-async-recursion = "1.0.4"
 base64 = "0.21.3"
 # The latest version on crates.io at the time of writing this (6.0.0) has a
 # version mismatch with x25519-dalek/curve25519-dalek that is resolved in the
 # latest commit. So pick that for now.
-#boringtun = "0.6.0"
-boringtun = { workspace = true }
-bytes = "1.5.0"
-dashmap = "5.5.3"
-etherparse = "0.13.0"
-futures = "0.3.28"
+x25519-dalek = "2.0.0"
+defguard_wireguard_rs = { git = "https://github.com/neacsu/wireguard-rs.git", rev = "c2cd0c1119f699f4bc43f5e6ffd6fc242caa42ed" }
 ip_network = "0.4.1"
-ip_network_table = "0.2.0"
 log.workspace = true
+nym-network-defaults = { path = "../network-defaults" }
 nym-task = { path = "../task" }
 nym-wireguard-types = { path = "../wireguard-types" }
-rand.workspace = true
-serde = { workspace = true, features = ["derive"] }
-tap.workspace = true
-thiserror.workspace = true
 tokio = { workspace = true, features = ["rt-multi-thread", "net", "io-util"] }
-
-[target.'cfg(target_os = "linux")'.dependencies]
-tokio-tun = "0.9.0"
@@ -1,74 +0,0 @@
-use std::net::SocketAddr;
-
-use boringtun::x25519;
-use dashmap::{
-    mapref::one::{Ref, RefMut},
-    DashMap,
-};
-use tokio::sync::mpsc::{self};
-
-use crate::event::Event;
-
-// Channels that are used to communicate with the various tunnels
-#[derive(Clone)]
-pub struct PeerEventSender(mpsc::Sender<Event>);
-pub(crate) struct PeerEventReceiver(mpsc::Receiver<Event>);
-
-impl PeerEventSender {
-    pub(crate) async fn send(&self, event: Event) -> Result<(), mpsc::error::SendError<Event>> {
-        self.0.send(event).await
-    }
-}
-
-impl PeerEventReceiver {
-    pub(crate) async fn recv(&mut self) -> Option<Event> {
-        self.0.recv().await
-    }
-}
-
-pub(crate) fn peer_event_channel() -> (PeerEventSender, PeerEventReceiver) {
-    let (tx, rx) = mpsc::channel(16);
-    (PeerEventSender(tx), PeerEventReceiver(rx))
-}
-
-pub(crate) type PeersByKey = DashMap<x25519::PublicKey, PeerEventSender>;
-pub(crate) type PeersByAddr = DashMap<SocketAddr, PeerEventSender>;
-
-#[derive(Default)]
-pub(crate) struct ActivePeers {
-    active_peers: PeersByKey,
-    active_peers_by_addr: PeersByAddr,
-}
-
-impl ActivePeers {
-    pub(crate) fn remove(&self, public_key: &x25519::PublicKey) {
-        log::info!("Removing peer: {public_key:?}");
-        self.active_peers.remove(public_key);
-        log::warn!("TODO: remove from peers_by_ip?");
-        log::warn!("TODO: remove from peers_by_addr");
-    }
-
-    pub(crate) fn insert(
-        &self,
-        public_key: x25519::PublicKey,
-        addr: SocketAddr,
-        peer_tx: PeerEventSender,
-    ) {
-        self.active_peers.insert(public_key, peer_tx.clone());
-        self.active_peers_by_addr.insert(addr, peer_tx);
-    }
-
-    pub(crate) fn get_by_key_mut(
-        &self,
-        public_key: &x25519::PublicKey,
-    ) -> Option<RefMut<'_, x25519::PublicKey, PeerEventSender>> {
-        self.active_peers.get_mut(public_key)
-    }
-
-    pub(crate) fn get_by_addr(
-        &self,
-        addr: &SocketAddr,
-    ) -> Option<Ref<'_, SocketAddr, PeerEventSender>> {
-        self.active_peers_by_addr.get(addr)
-    }
-}
@@ -1,9 +0,0 @@
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum WgError {
-    #[error("unable to get tunnel")]
-    UnableToGetTunnel,
-    #[error("handshake failed")]
-    HandshakeFailed,
-}
@@ -1,34 +0,0 @@
-use std::fmt::{Display, Formatter};
-
-use bytes::Bytes;
-
-#[allow(unused)]
-#[derive(Debug)]
-pub enum Event {
-    /// IP packet received from the WireGuard tunnel that should be passed through to the
-    /// corresponding virtual device/internet.
-    Wg(Bytes),
-    /// IP packet received from the WireGuard tunnel that was verified as part of the handshake.
-    WgVerified(Bytes),
-    /// IP packet to be sent through the WireGuard tunnel as crafted by the virtual device.
-    Ip(Bytes),
-}
-
-impl Display for Event {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Event::Wg(data) => {
-                let size = data.len();
-                write!(f, "Wg{{ size={size} }}")
-            }
-            Event::WgVerified(data) => {
-                let size = data.len();
-                write!(f, "WgVerified{{ size={size} }}")
-            }
-            Event::Ip(data) => {
-                let size = data.len();
-                write!(f, "Ip{{ size={size} }}")
-            }
-        }
-    }
-}
@@ -3,89 +3,55 @@
 // #![warn(clippy::expect_used)]
 // #![warn(clippy::unwrap_used)]

-mod active_peers;
-mod error;
-mod event;
-mod network_table;
-mod packet_relayer;
-mod platform;
-mod registered_peers;
-mod setup;
-pub mod tun_task_channel;
-mod udp_listener;
-mod wg_tunnel;
+pub mod setup;

 use nym_wireguard_types::registration::GatewayClientRegistry;
 use std::sync::Arc;

 // Currently the module related to setting up the virtual network device is platform specific.
 #[cfg(target_os = "linux")]
-pub use platform::linux::tun_device;
+use crate::setup::{peer_allowed_ips, peer_static_public_key, PRIVATE_KEY};
+use defguard_wireguard_rs::WGApi;
+#[cfg(target_os = "linux")]
+use defguard_wireguard_rs::{
+    host::Peer, key::Key, net::IpAddrMask, InterfaceConfiguration, WireguardInterfaceApi,
+};
+#[cfg(target_os = "linux")]
+use nym_network_defaults::{WG_PORT, WG_TUN_DEVICE_ADDRESS};

-/// Start wireguard UDP listener and TUN device
-///
-/// # Errors
-///
-/// This function will return an error if either the UDP listener of the TUN device fails to start.
+/// Start wireguard device
 #[cfg(target_os = "linux")]
 pub async fn start_wireguard(
-    task_client: nym_task::TaskClient,
-    gateway_client_registry: Arc<GatewayClientRegistry>,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    // TODO: make this configurable
-
-    // We can optionally index peers by their IP like standard wireguard. If we don't then we do
-    // plain NAT where we match incoming destination IP with outgoing source IP.
-    let peers_by_ip = Arc::new(tokio::sync::Mutex::new(network_table::NetworkTable::new()));
-
-    // Alternative 1:
-    let routing_mode = tun_device::RoutingMode::new_allowed_ips(peers_by_ip.clone());
-    // Alternative 2:
-    //let routing_mode = tun_device::RoutingMode::new_nat();
-
-    // Start the tun device that is used to relay traffic outbound
-    let config = tun_device::TunDeviceConfig {
-        base_name: setup::TUN_BASE_NAME.to_string(),
-        ip: setup::TUN_DEVICE_ADDRESS.parse().unwrap(),
-        netmask: setup::TUN_DEVICE_NETMASK.parse().unwrap(),
+    mut task_client: nym_task::TaskClient,
+    _gateway_client_registry: Arc<GatewayClientRegistry>,
+) -> Result<WGApi, Box<dyn std::error::Error + Send + Sync + 'static>> {
+    let ifname = String::from("wg0");
+    let wgapi = WGApi::new(ifname.clone(), false)?;
+    wgapi.create_interface()?;
+    let interface_config = InterfaceConfiguration {
+        name: ifname.clone(),
+        prvkey: PRIVATE_KEY.to_string(),
+        address: WG_TUN_DEVICE_ADDRESS.to_string(),
+        port: WG_PORT as u32,
+        peers: vec![],
    };
-    let (tun, tun_task_tx, tun_task_response_rx) = tun_device::TunDevice::new(routing_mode, config);
-    tun.start();
+    wgapi.configure_interface(&interface_config)?;
+    let peer = peer_static_public_key();
+    let mut peer = Peer::new(Key::new(peer.to_bytes()));
+    let peer_ip = peer_allowed_ips();
+    let peer_ip_mask = IpAddrMask::new(peer_ip.network_address(), peer_ip.netmask());
+    peer.set_allowed_ips(vec![peer_ip_mask]);
+    wgapi.configure_peer(&peer)?;
+    wgapi.configure_peer_routing(&[peer.clone()])?;

-    // We also index peers by a tag
-    let peers_by_tag = Arc::new(tokio::sync::Mutex::new(wg_tunnel::PeersByTag::new()));
+    tokio::spawn(async move { task_client.recv().await });

-    // If we want to have the tun device on a separate host, it's the tun_task and
-    // tun_task_response channels that needs to be sent over the network to the host where the tun
-    // device is running.
-
-    // The packet relayer's responsibility is to route packets between the correct tunnel and the
-    // tun device. The tun device may or may not be on a separate host, which is why we can't do
-    // this routing in the tun device itself.
-    let (packet_relayer, packet_tx) = packet_relayer::PacketRelayer::new(
-        tun_task_tx.clone(),
-        tun_task_response_rx,
-        peers_by_tag.clone(),
-    );
-    packet_relayer.start();
-
-    // Start the UDP listener that clients connect to
-    let udp_listener = udp_listener::WgUdpListener::new(
-        packet_tx,
-        peers_by_ip,
-        peers_by_tag,
-        Arc::clone(&gateway_client_registry),
-    )
-    .await?;
-    udp_listener.start(task_client);
-
-    Ok(())
+    Ok(wgapi)
 }
-
 #[cfg(not(target_os = "linux"))]
 pub async fn start_wireguard(
    _task_client: nym_task::TaskClient,
    _gateway_client_registry: Arc<GatewayClientRegistry>,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+) -> Result<WGApi, Box<dyn std::error::Error + Send + Sync + 'static>> {
    todo!("WireGuard is currently only supported on Linux")
 }
@@ -1,25 +0,0 @@
-use std::net::IpAddr;
-
-use ip_network::IpNetwork;
-use ip_network_table::IpNetworkTable;
-
-#[derive(Default)]
-pub struct NetworkTable<T> {
-    ips: IpNetworkTable<T>,
-}
-
-impl<T> NetworkTable<T> {
-    pub(crate) fn new() -> Self {
-        Self {
-            ips: IpNetworkTable::new(),
-        }
-    }
-
-    pub fn insert<N: Into<IpNetwork>>(&mut self, network: N, data: T) -> Option<T> {
-        self.ips.insert(network, data)
-    }
-
-    pub fn longest_match<I: Into<IpAddr>>(&self, ip: I) -> Option<(IpNetwork, &T)> {
-        self.ips.longest_match(ip)
-    }
-}
@@ -1,76 +0,0 @@
-use std::{collections::HashMap, sync::Arc};
-
-use tap::TapFallible;
-use tokio::sync::mpsc::{self};
-
-use crate::{
-    active_peers::PeerEventSender,
-    event::Event,
-    tun_task_channel::{TunTaskResponseRx, TunTaskTx},
-};
-
-#[derive(Clone)]
-pub struct PacketRelaySender(pub(crate) mpsc::Sender<(u64, Vec<u8>)>);
-pub(crate) struct PacketRelayReceiver(pub(crate) mpsc::Receiver<(u64, Vec<u8>)>);
-
-pub(crate) fn packet_relay_channel() -> (PacketRelaySender, PacketRelayReceiver) {
-    let (tx, rx) = mpsc::channel(16);
-    (PacketRelaySender(tx), PacketRelayReceiver(rx))
-}
-
-// The tunnels send packets to the packet relayer, which then relays it to the tun device. And
-// conversely, it's where the tun device send responses to, which are relayed back to the correct
-// tunnel.
-pub(crate) struct PacketRelayer {
-    // Receive packets from the various tunnels
-    packet_rx: PacketRelayReceiver,
-
-    // After receive from tunnels, send to the tun device
-    tun_task_tx: TunTaskTx,
-
-    // Receive responses from the tun device
-    tun_task_response_rx: TunTaskResponseRx,
-
-    // After receiving from the tun device, relay back to the correct tunnel
-    peers_by_tag: Arc<tokio::sync::Mutex<HashMap<u64, PeerEventSender>>>,
-}
-
-impl PacketRelayer {
-    pub(crate) fn new(
-        tun_task_tx: TunTaskTx,
-        tun_task_response_rx: TunTaskResponseRx,
-        peers_by_tag: Arc<tokio::sync::Mutex<HashMap<u64, PeerEventSender>>>,
-    ) -> (Self, PacketRelaySender) {
-        let (packet_tx, packet_rx) = packet_relay_channel();
-        (
-            Self {
-                packet_rx,
-                tun_task_tx,
-                tun_task_response_rx,
-                peers_by_tag,
-            },
-            packet_tx,
-        )
-    }
-
-    pub(crate) async fn run(mut self) {
-        loop {
-            tokio::select! {
-                Some((tag, packet)) = self.packet_rx.0.recv() => {
-                    log::info!("Sent packet to tun device with tag: {tag}");
-                    self.tun_task_tx.send((tag, packet)).await.tap_err(|e| log::error!("{e}")).ok();
-                },
-                Some((tag, packet)) = self.tun_task_response_rx.recv() => {
-                    log::info!("Received response from tun device with tag: {tag}");
-                    if let Some(tx) = self.peers_by_tag.lock().await.get(&tag) {
-                        tx.send(Event::Ip(packet.into())).await.tap_err(|e| log::error!("{e}")).ok();
-                    }
-                }
-            }
-        }
-    }
-
-    pub(crate) fn start(self) {
-        tokio::spawn(async move { self.run().await });
-    }
-}
@@ -1,260 +0,0 @@
-use std::{
-    collections::HashMap,
-    net::{IpAddr, Ipv4Addr},
-    sync::Arc,
-};
-
-use etherparse::{InternetSlice, SlicedPacket};
-use tap::TapFallible;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
-
-use crate::{
-    event::Event,
-    tun_task_channel::{
-        tun_task_channel, tun_task_response_channel, TunTaskPayload, TunTaskResponseRx,
-        TunTaskResponseTx, TunTaskRx, TunTaskTx,
-    },
-    udp_listener::PeersByIp,
-};
-
-fn setup_tokio_tun_device(name: &str, address: Ipv4Addr, netmask: Ipv4Addr) -> tokio_tun::Tun {
-    log::info!("Creating TUN device with: address={address}, netmask={netmask}");
-    // Read MTU size from env variable NYM_MTU_SIZE, else default to 1420.
-    let mtu = std::env::var("NYM_MTU_SIZE")
-        .map(|mtu| mtu.parse().expect("NYM_MTU_SIZE must be a valid integer"))
-        .unwrap_or(1420);
-    log::info!("Using MTU size: {mtu}");
-    tokio_tun::Tun::builder()
-        .name(name)
-        .tap(false)
-        .packet_info(false)
-        .mtu(mtu)
-        .up()
-        .address(address)
-        .netmask(netmask)
-        .try_build()
-        .expect("Failed to setup tun device, do you have permission?")
-}
-
-pub struct TunDevice {
-    // The TUN device that we read/write to, to send/receive packets
-    tun: tokio_tun::Tun,
-
-    // Incoming data that we should send
-    tun_task_rx: TunTaskRx,
-
-    // And when we get replies, this is where we should send it
-    tun_task_response_tx: TunTaskResponseTx,
-
-    routing_mode: RoutingMode,
-}
-
-pub enum RoutingMode {
-    // The routing table, as how wireguard does it
-    AllowedIps(AllowedIpsInner),
-
-    // This is an alternative to the routing table, where we just match outgoing source IP with
-    // incoming destination IP.
-    Nat(NatInner),
-}
-
-impl RoutingMode {
-    pub fn new_nat() -> Self {
-        RoutingMode::Nat(NatInner {
-            nat_table: HashMap::new(),
-        })
-    }
-
-    pub fn new_allowed_ips(peers_by_ip: Arc<tokio::sync::Mutex<PeersByIp>>) -> Self {
-        RoutingMode::AllowedIps(AllowedIpsInner { peers_by_ip })
-    }
-}
-
-pub struct AllowedIpsInner {
-    peers_by_ip: Arc<tokio::sync::Mutex<PeersByIp>>,
-}
-
-pub struct NatInner {
-    nat_table: HashMap<IpAddr, u64>,
-}
-
-pub struct TunDeviceConfig {
-    pub base_name: String,
-    pub ip: Ipv4Addr,
-    pub netmask: Ipv4Addr,
-}
-
-impl TunDevice {
-    pub fn new(
-        routing_mode: RoutingMode,
-        config: TunDeviceConfig,
-    ) -> (Self, TunTaskTx, TunTaskResponseRx) {
-        let TunDeviceConfig {
-            base_name,
-            ip,
-            netmask,
-        } = config;
-        let name = format!("{base_name}%d");
-
-        let tun = setup_tokio_tun_device(&name, ip, netmask);
-        log::info!("Created TUN device: {}", tun.name());
-
-        // Channels to communicate with the other tasks
-        let (tun_task_tx, tun_task_rx) = tun_task_channel();
-        let (tun_task_response_tx, tun_task_response_rx) = tun_task_response_channel();
-
-        let tun_device = TunDevice {
-            tun_task_rx,
-            tun_task_response_tx,
-            tun,
-            routing_mode,
-        };
-
-        (tun_device, tun_task_tx, tun_task_response_rx)
-    }
-
-    // Send outbound packets out on the wild internet
-    async fn handle_tun_write(&mut self, data: TunTaskPayload) {
-        let (tag, packet) = data;
-        let Some(dst_addr) = boringtun::noise::Tunn::dst_address(&packet) else {
-            log::error!("Unable to parse dst_address in packet that was supposed to be written to tun device");
-            return;
-        };
-        let Some(src_addr) = parse_src_address(&packet) else {
-            log::error!("Unable to parse src_address in packet that was supposed to be written to tun device");
-            return;
-        };
-        log::info!(
-            "iface: write Packet({src_addr} -> {dst_addr}, {} bytes)",
-            packet.len()
-        );
-
-        // TODO: expire old entries
-        if let RoutingMode::Nat(nat_table) = &mut self.routing_mode {
-            nat_table.nat_table.insert(src_addr, tag);
-        }
-
-        tokio::time::timeout(
-            std::time::Duration::from_millis(1000),
-            self.tun.write_all(&packet),
-        )
-        .await
-        .tap_err(|err| {
-            log::error!("iface: write error: {err}");
-        })
-        .ok();
-    }
-
-    // Receive reponse packets from the wild internet
-    async fn handle_tun_read(&self, packet: &[u8]) {
-        let Some(dst_addr) = boringtun::noise::Tunn::dst_address(packet) else {
-            log::error!("Unable to parse dst_address in packet that was read from tun device");
-            return;
-        };
-        let Some(src_addr) = parse_src_address(packet) else {
-            log::error!("Unable to parse src_address in packet that was read from tun device");
-            return;
-        };
-        log::info!(
-            "iface: read Packet({src_addr} -> {dst_addr}, {} bytes)",
-            packet.len(),
-        );
-
-        // Route packet to the correct peer.
-
-        match self.routing_mode {
-            // This is how wireguard does it, by consulting the AllowedIPs table.
-            RoutingMode::AllowedIps(ref peers_by_ip) => {
-                let Ok(peers) = tokio::time::timeout(
-                    std::time::Duration::from_millis(1000),
-                    peers_by_ip.peers_by_ip.as_ref().lock(),
-                )
-                .await
-                else {
-                    log::error!("Failed to lock peer");
-                    return;
-                };
-
-                if let Some(peer_tx) = peers.longest_match(dst_addr).map(|(_, tx)| tx) {
-                    log::info!("Forward packet to wg tunnel");
-                    tokio::time::timeout(
-                        std::time::Duration::from_millis(1000),
-                        peer_tx.send(Event::Ip(packet.to_vec().into())),
-                    )
-                    .await
-                    .tap_err(|err| log::error!("Failed to forward packet to wg tunnel: {err}"))
-                    .ok();
-                    return;
-                }
-            }
-
-            // But we can also do it by consulting the NAT table.
-            RoutingMode::Nat(ref nat_table) => {
-                if let Some(tag) = nat_table.nat_table.get(&dst_addr) {
-                    log::info!("Forward packet with tag: {tag}");
-                    tokio::time::timeout(
-                        std::time::Duration::from_millis(1000),
-                        self.tun_task_response_tx.send((*tag, packet.to_vec())),
-                    )
-                    .await
-                    .tap_err(|err| log::error!("Failed to foward packet with tag: {err}"))
-                    .ok();
-                    return;
-                }
-            }
-        }
-
-        log::info!("No peer found, packet dropped");
-    }
-
-    pub async fn run(mut self) {
-        let mut buf = [0u8; 65535];
-
-        loop {
-            tokio::select! {
-                // Reading from the TUN device
-                len = self.tun.read(&mut buf) => match len {
-                    Ok(len) => {
-                        let packet = &buf[..len];
-                        tokio::time::timeout(
-                            std::time::Duration::from_millis(1000),
-                            self.handle_tun_read(packet)
-                        )
-                        .await
-                        .tap_err(|_err| log::error!("Failed: handle_tun_read timeout"))
-                        .ok();
-                    },
-                    Err(err) => {
-                        log::info!("iface: read error: {err}");
-                        // break;
-                    }
-                },
-                // Writing to the TUN device
-                Some(data) = self.tun_task_rx.recv() => {
-                    tokio::time::timeout(
-                        std::time::Duration::from_millis(1000),
-                        self.handle_tun_write(data)
-                    )
-                    .await
-                    .tap_err(|_err| log::error!("Failed: handle_tun_write timeout"))
-                    .ok();
-                }
-            }
-        }
-        // log::info!("TUN device shutting down");
-    }
-
-    pub fn start(self) {
-        tokio::spawn(async move { self.run().await });
-    }
-}
-
-fn parse_src_address(packet: &[u8]) -> Option<IpAddr> {
-    let headers = SlicedPacket::from_ip(packet)
-        .tap_err(|err| log::error!("Unable to parse IP packet: {err:?}"))
-        .ok()?;
-    Some(match headers.ip? {
-        InternetSlice::Ipv4(ip, _) => ip.source_addr().into(),
-        InternetSlice::Ipv6(ip, _) => ip.source_addr().into(),
-    })
-}
@@ -1,2 +0,0 @@
-#[cfg(target_os = "linux")]
-pub(crate) mod linux;
@@ -1,61 +0,0 @@
-use std::{collections::HashMap, sync::Arc};
-
-use ip_network::IpNetwork;
-use nym_wireguard_types::PeerPublicKey;
-
-pub(crate) type PeerIdx = u32;
-
-#[derive(Debug)]
-pub(crate) struct RegisteredPeer {
-    pub(crate) public_key: PeerPublicKey,
-    pub(crate) index: PeerIdx,
-    pub(crate) allowed_ips: IpNetwork,
-    // endpoint: SocketAddr,
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct RegisteredPeers {
-    peers: HashMap<PeerPublicKey, Arc<tokio::sync::Mutex<RegisteredPeer>>>,
-    peers_by_idx: HashMap<PeerIdx, Arc<tokio::sync::Mutex<RegisteredPeer>>>,
-}
-
-impl RegisteredPeers {
-    pub(crate) fn contains_key(&self, public_key: &PeerPublicKey) -> bool {
-        self.peers.contains_key(public_key)
-    }
-
-    pub(crate) fn next_idx(&self) -> PeerIdx {
-        self.peers_by_idx.keys().max().unwrap_or(&0) + 1
-    }
-
-    pub(crate) async fn insert(&mut self, peer: Arc<tokio::sync::Mutex<RegisteredPeer>>) {
-        let peer_idx = { peer.lock().await.index };
-        let public_key = { peer.lock().await.public_key };
-        self.peers.insert(public_key, Arc::clone(&peer));
-        self.peers_by_idx.insert(peer_idx, peer);
-    }
-
-    #[allow(unused)]
-    pub(crate) async fn remove(&mut self, public_key: &PeerPublicKey) {
-        if let Some(peer) = self.peers.remove(public_key) {
-            let peer_idx = peer.lock().await.index;
-            if self.peers_by_idx.remove(&peer_idx).is_none() {
-                log::error!("Removed registered peer but no registered index was found");
-            }
-        }
-    }
-
-    pub(crate) fn get_by_key(
-        &self,
-        public_key: &PeerPublicKey,
-    ) -> Option<&Arc<tokio::sync::Mutex<RegisteredPeer>>> {
-        self.peers.get(public_key)
-    }
-
-    pub(crate) fn get_by_idx(
-        &self,
-        peer_idx: PeerIdx,
-    ) -> Option<&Arc<tokio::sync::Mutex<RegisteredPeer>>> {
-        self.peers_by_idx.get(&peer_idx)
-    }
-}
@@ -1,20 +1,14 @@
 use std::net::IpAddr;

 use base64::{engine::general_purpose, Engine as _};
-use boringtun::x25519;
 use log::info;

 // The wireguard UDP listener
 pub const WG_ADDRESS: &str = "0.0.0.0";

-// The interface used to route traffic
-pub const TUN_BASE_NAME: &str = "nymwg";
-pub const TUN_DEVICE_ADDRESS: &str = "10.1.0.1";
-pub const TUN_DEVICE_NETMASK: &str = "255.255.255.0";
-
 // The private key of the listener
 // Corresponding public key: "WM8s8bYegwMa0TJ+xIwhk+dImk2IpDUKslDBCZPizlE="
-const PRIVATE_KEY: &str = "AEqXrLFT4qjYq3wmX0456iv94uM6nDj5ugp6Jedcflg=";
+pub(crate) const PRIVATE_KEY: &str = "AEqXrLFT4qjYq3wmX0456iv94uM6nDj5ugp6Jedcflg=";

 // The AllowedIPs for the connected peer, which is one a single IP and the same as the IP that the
 // peer has configured on their side.
@@ -28,11 +22,11 @@ fn decode_base64_key(base64_key: &str) -> [u8; 32] {
        .unwrap()
 }

-pub fn server_static_private_key() -> x25519::StaticSecret {
+pub fn server_static_private_key() -> x25519_dalek::StaticSecret {
    // TODO: this is a temporary solution for development
    let static_private_bytes: [u8; 32] = decode_base64_key(PRIVATE_KEY);
-    let static_private = x25519::StaticSecret::try_from(static_private_bytes).unwrap();
-    let static_public = x25519::PublicKey::from(&static_private);
+    let static_private = x25519_dalek::StaticSecret::from(static_private_bytes);
+    let static_public = x25519_dalek::PublicKey::from(&static_private);
    info!(
        "wg public key: {}",
        general_purpose::STANDARD.encode(static_public)
@@ -40,14 +34,14 @@ pub fn server_static_private_key() -> x25519::StaticSecret {
    static_private
 }

-pub fn peer_static_public_key() -> x25519::PublicKey {
+pub fn peer_static_public_key() -> x25519_dalek::PublicKey {
    // A single static public key is used during development

    // Read from NYM_PEER_PUBLIC_KEY env variable
    let peer = std::env::var("NYM_PEER_PUBLIC_KEY").expect("NYM_PEER_PUBLIC_KEY must be set");

    let peer_static_public_bytes: [u8; 32] = decode_base64_key(&peer);
-    let peer_static_public = x25519::PublicKey::try_from(peer_static_public_bytes).unwrap();
+    let peer_static_public = x25519_dalek::PublicKey::from(peer_static_public_bytes);
    info!(
        "Adding wg peer public key: {}",
        general_purpose::STANDARD.encode(peer_static_public)
@@ -57,6 +51,6 @@ pub fn peer_static_public_key() -> x25519::PublicKey {

 pub fn peer_allowed_ips() -> ip_network::IpNetwork {
    let key: IpAddr = ALLOWED_IPS.parse().unwrap();
-    let cidr = 0u8;
+    let cidr = 32u8;
    ip_network::IpNetwork::new_truncate(key, cidr).unwrap()
 }
--- a/Show More
+++ b/Show More