More optimized parsing

try a different parse_dst_addr
Try with split state
2023-11-28 10:11:41 +01:00 · 2023-11-28 09:59:15 +01:00 · 2023-11-28 09:42:55 +01:00 · 2023-11-28 09:25:05 +01:00 · 2023-11-28 08:56:20 +01:00 · 2023-11-28 08:43:03 +01:00
378 changed files with 5216 additions and 2110 deletions
@@ -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,25 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

+## [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)

@@ -1554,8 +1554,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 +1572,7 @@ dependencies = [
 "futures",
 "hdrhistogram",
 "humantime 2.1.0",
- "prost-types",
+ "prost-types 0.11.9",
 "serde",
 "serde_json",
 "thread_local",
@@ -1661,30 +1661,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 +2009,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"
@@ -3696,30 +3687,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 +3925,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]]
@@ -4658,7 +4602,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 +4688,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 +4746,7 @@ dependencies = [
 "libp2p-swarm 0.42.0",
 "log",
 "lru 0.9.0",
- "prost",
+ "prost 0.11.9",
 "prost-build",
 "prost-codec",
 "smallvec",
@@ -4952,7 +4896,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 +5148,7 @@ dependencies = [
 "libp2p-noise 0.42.0",
 "log",
 "multihash",
- "prost",
+ "prost 0.11.9",
 "prost-build",
 "prost-codec",
 "rand 0.8.5",
@@ -5961,7 +5905,7 @@ dependencies = [

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

 [[package]]
 name = "nym-cli"
-version = "1.1.31"
+version = "1.1.32"
 dependencies = [
 "anyhow",
 "base64 0.13.1",
@@ -6657,10 +6601,25 @@ 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",
+ "dashmap",
 "etherparse",
 "futures",
 "log",
@@ -6668,13 +6627,16 @@ 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",
@@ -6920,6 +6882,7 @@ dependencies = [
 "nym-crypto",
 "nym-node-requests",
 "nym-task",
+ "nym-wireguard",
 "nym-wireguard-types",
 "rand 0.7.3",
 "serde",
@@ -7462,6 +7425,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 +7473,7 @@ version = "0.1.0"
 dependencies = [
 "async-trait",
 "base64 0.13.1",
+ "bip32",
 "bip39",
 "colored",
 "cosmrs",
@@ -7528,7 +7504,7 @@ dependencies = [
 "nym-service-provider-directory-common",
 "nym-vesting-contract-common",
 "openssl",
- "prost",
+ "prost 0.12.1",
 "reqwest",
 "serde",
 "serde_json",
@@ -7581,6 +7557,7 @@ version = "0.1.0"
 dependencies = [
 "async-recursion",
 "base64 0.21.4",
+ "bincode",
 "boringtun",
 "bytes",
 "dashmap",
@@ -7589,7 +7566,10 @@ dependencies = [
 "ip_network",
 "ip_network_table",
 "log",
+ "nym-network-defaults",
+ "nym-sphinx",
 "nym-task",
+ "nym-tun",
 "nym-wireguard-types",
 "rand 0.8.5",
 "serde",
@@ -7605,14 +7585,19 @@ version = "0.1.0"
 dependencies = [
 "base64 0.21.4",
 "boringtun",
+ "bytes",
 "dashmap",
 "hmac 0.12.1",
+ "ip_network",
+ "ip_network_table",
+ "log",
 "nym-crypto",
 "rand 0.7.3",
 "serde",
 "serde_json",
 "sha2 0.10.8",
 "thiserror",
+ "tokio",
 "utoipa",
 "x25519-dalek 2.0.0",
 ]
@@ -8396,7 +8381,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 +8408,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 +8423,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 +8441,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 +8981,7 @@ dependencies = [
 "http",
 "http-body",
 "hyper",
+ "hyper-rustls",
 "hyper-tls",
 "ipnet",
 "js-sys",
@@ -8973,12 +8991,16 @@ 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",
 "tower-service",
 "url",
@@ -9378,12 +9400,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",
 ]
@@ -10584,9 +10606,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 +10619,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 +10637,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 +10651,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 +10669,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 +10904,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"
@@ -11076,7 +11105,7 @@ dependencies = [
 "hyper-timeout",
 "percent-encoding",
 "pin-project",
- "prost",
+ "prost 0.11.9",
 "tokio",
 "tokio-stream",
 "tower",
@@ -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",
@@ -140,21 +142,6 @@ 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,7 +159,6 @@ 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
 thiserror = "1.0.48"
 tokio = "1.24.1"
 tokio-tungstenite = "0.20.1"
@@ -184,6 +170,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"
@@ -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.
@@ -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(())
 }
@@ -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(())
 }
@@ -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)]
@@ -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;
                }
            }
        }
@@ -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;
                }
            }
        }
@@ -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);
@@ -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 {
@@ -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 {
@@ -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;
@@ -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,
        }
@@ -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 {
@@ -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,373 @@
+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,
+    pub reply_to: Recipient,
+    pub reply_to_hops: Option<u8>,
+    pub reply_to_avg_mix_delays: Option<f64>,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct DynamicConnectRequest {
+    pub request_id: u64,
+    pub reply_to: Recipient,
+    pub reply_to_hops: Option<u8>,
+    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]),
+            })
+        );
+    }
+}
@@ -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";
@@ -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,96 @@ 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
+    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 +446,7 @@ pub fn sign(
 #[cfg(test)]
 mod tests {
    use super::*;
+    use crate::scheme::keygen::keygen;

    #[test]
    fn blind_sign_request_bytes_roundtrip() {
@@ -385,4 +478,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()
+        ),);
+    }
 }
@@ -493,10 +493,13 @@ 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::Trace,
+                "the task client is getting dropped (but instructed to not signal)",
+            );
            return;
        } else {
-            self.log(Level::Info, "the task client is getting dropped");
+            self.log(Level::Debug, "the task client is getting dropped");
        }

        if !self.is_shutdown_poll() {
@@ -0,0 +1,24 @@
+[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.9.0"
+
+[features]
+wireguard = ["nym-wireguard-types"]
@@ -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,326 @@
+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,
+};
+
+#[cfg(feature = "wireguard")]
+use nym_wireguard_types::tun_common::{
+    active_peers::{PeerEventSenderError, PeersByIp},
+    event::Event,
+};
+
+#[cfg(feature = "wireguard")]
+const MUTEX_LOCK_TIMEOUT_MS: u64 = 200;
+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 },
+
+    #[cfg(feature = "wireguard")]
+    #[error("failed forwarding packet to peer: {source}")]
+    ForwardToPeerFailed {
+        #[from]
+        source: PeerEventSenderError,
+    },
+
+    #[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 {
+    // The routing table, as how wireguard does it
+    #[cfg(feature = "wireguard")]
+    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(),
+        })
+    }
+
+    #[cfg(feature = "wireguard")]
+    pub fn new_allowed_ips(peers_by_ip: std::sync::Arc<tokio::sync::Mutex<PeersByIp>>) -> Self {
+        RoutingMode::AllowedIps(AllowedIpsInner { peers_by_ip })
+    }
+}
+
+#[cfg(feature = "wireguard")]
+pub struct AllowedIpsInner {
+    peers_by_ip: std::sync::Arc<tokio::sync::Mutex<PeersByIp>>,
+}
+
+#[cfg(feature = "wireguard")]
+impl AllowedIpsInner {
+    async fn lock(&self) -> Result<tokio::sync::MutexGuard<PeersByIp>, TunDeviceError> {
+        timeout(
+            Duration::from_millis(MUTEX_LOCK_TIMEOUT_MS),
+            self.peers_by_ip.as_ref().lock(),
+        )
+        .await
+        .map_err(|_| TunDeviceError::FailedToLockPeer)
+    }
+}
+
+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) -> 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
+        // #[allow(irrefutable_let_patterns)]
+        // 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(),
+        // );
+        let dst_addr =
+            parse_dst_addr(packet).ok_or(TunDeviceError::UnableToParseAddressIpHeaderMissing)?;
+
+        // Route packet to the correct peer.
+
+        match self.routing_mode {
+            // This is how wireguard does it, by consulting the AllowedIPs table.
+            #[cfg(feature = "wireguard")]
+            RoutingMode::AllowedIps(ref peers_by_ip) => {
+                let peers = peers_by_ip.lock().await?;
+                if let Some(peer_tx) = peers.longest_match(dst_addr).map(|(_, tx)| tx) {
+                    log::debug!("Forward packet to wg tunnel");
+                    return peer_tx
+                        .send(Event::Ip(packet.to_vec().into()))
+                        .await
+                        .map_err(|err| err.into());
+                }
+            }
+
+            // 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()))
+                    .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!("ifcae: 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),
+    }
+}
+
+// Copyright (c) 2019 Cloudflare, Inc. All rights reserved.
+// SPDX-License-Identifier: BSD-3-Clause
+const IPV4_MIN_HEADER_SIZE: usize = 20;
+const IPV4_DST_IP_OFF: usize = 16;
+const IPV4_IP_SZ: usize = 4;
+
+const IPV6_MIN_HEADER_SIZE: usize = 40;
+const IPV6_DST_IP_OFF: usize = 24;
+const IPV6_IP_SZ: usize = 16;
+
+pub fn parse_dst_addr(packet: &[u8]) -> Option<IpAddr> {
+    if packet.is_empty() {
+        return None;
+    }
+
+    match packet[0] >> 4 {
+        4 if packet.len() >= IPV4_MIN_HEADER_SIZE => {
+            let addr_bytes: [u8; IPV4_IP_SZ] = packet
+                [IPV4_DST_IP_OFF..IPV4_DST_IP_OFF + IPV4_IP_SZ]
+                .try_into()
+                .unwrap();
+            Some(IpAddr::from(addr_bytes))
+        }
+        6 if packet.len() >= IPV6_MIN_HEADER_SIZE => {
+            let addr_bytes: [u8; IPV6_IP_SZ] = packet
+                [IPV6_DST_IP_OFF..IPV6_DST_IP_OFF + IPV6_IP_SZ]
+                .try_into()
+                .unwrap();
+            Some(IpAddr::from(addr_bytes))
+        }
+        _ => None,
+    }
+}
@@ -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),
+    )
+}
@@ -12,9 +12,14 @@ license.workspace = true

 [dependencies]
 base64 = { workspace = true }
+bytes = "1.5.0"
 dashmap = { workspace = true }
+ip_network = "0.4.1"
+ip_network_table = "0.2.0"
+log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
+tokio = { workspace = true, features = ["sync", "time"] }

 nym-crypto = { path = "../crypto", features = ["asymmetric"] }

@@ -45,4 +50,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"]
@@ -4,6 +4,8 @@
 pub mod error;
 pub mod public_key;
 pub mod registration;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod tun_common;

 pub use error::Error;
 pub use public_key::PeerPublicKey;
@@ -13,5 +15,3 @@ pub use registration::{

 #[cfg(feature = "verify")]
 pub use registration::HmacSha256;
-
-pub const WG_PORT: u16 = 51822;
@@ -93,8 +93,7 @@ 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 static_secret = boringtun::x25519::StaticSecret::from(local_secret.to_bytes());
        let local_public: boringtun::x25519::PublicKey = (&static_secret).into();

        let remote_public = boringtun::x25519::PublicKey::from(remote_public.to_bytes());
@@ -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 = boringtun::x25519::StaticSecret::from(gateway_key.to_bytes());

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

@@ -1,4 +1,4 @@
-use std::net::SocketAddr;
+use std::{net::SocketAddr, time::Duration};

 use boringtun::x25519;
 use dashmap::{
@@ -7,26 +7,47 @@ use dashmap::{
 };
 use tokio::sync::mpsc::{self};

-use crate::event::Event;
+use crate::tun_common::{event::Event, network_table::NetworkTable};
+
+// Registered peers
+pub type PeersByIp = NetworkTable<PeerEventSender>;

 // 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>);
+pub struct PeerEventReceiver(mpsc::Receiver<Event>);
+
+#[derive(thiserror::Error, Debug)]
+pub enum PeerEventSenderError {
+    #[error("send failed: timeout: {source}")]
+    SendTimeoutError {
+        #[from]
+        source: mpsc::error::SendTimeoutError<Event>,
+    },
+
+    #[error("send failed: {source}")]
+    SendError {
+        #[from]
+        source: mpsc::error::SendError<Event>,
+    },
+}

 impl PeerEventSender {
-    pub(crate) async fn send(&self, event: Event) -> Result<(), mpsc::error::SendError<Event>> {
-        self.0.send(event).await
+    pub async fn send(&self, event: Event) -> Result<(), PeerEventSenderError> {
+        Ok(self
+            .0
+            .send_timeout(event, Duration::from_millis(1000))
+            .await?)
    }
 }

 impl PeerEventReceiver {
-    pub(crate) async fn recv(&mut self) -> Option<Event> {
+    pub async fn recv(&mut self) -> Option<Event> {
        self.0.recv().await
    }
 }

-pub(crate) fn peer_event_channel() -> (PeerEventSender, PeerEventReceiver) {
+pub fn peer_event_channel() -> (PeerEventSender, PeerEventReceiver) {
    let (tx, rx) = mpsc::channel(16);
    (PeerEventSender(tx), PeerEventReceiver(rx))
 }
@@ -35,20 +56,20 @@ pub(crate) type PeersByKey = DashMap<x25519::PublicKey, PeerEventSender>;
 pub(crate) type PeersByAddr = DashMap<SocketAddr, PeerEventSender>;

 #[derive(Default)]
-pub(crate) struct ActivePeers {
+pub struct ActivePeers {
    active_peers: PeersByKey,
    active_peers_by_addr: PeersByAddr,
 }

 impl ActivePeers {
-    pub(crate) fn remove(&self, public_key: &x25519::PublicKey) {
+    pub 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(
+    pub fn insert(
        &self,
        public_key: x25519::PublicKey,
        addr: SocketAddr,
@@ -58,17 +79,14 @@ impl ActivePeers {
        self.active_peers_by_addr.insert(addr, peer_tx);
    }

-    pub(crate) fn get_by_key_mut(
+    pub 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>> {
+    pub fn get_by_addr(&self, addr: &SocketAddr) -> Option<Ref<'_, SocketAddr, PeerEventSender>> {
        self.active_peers_by_addr.get(addr)
    }
 }
@@ -0,0 +1,3 @@
+pub mod active_peers;
+pub mod event;
+pub mod network_table;
@@ -9,7 +9,7 @@ pub struct NetworkTable<T> {
 }

 impl<T> NetworkTable<T> {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
        Self {
            ips: IpNetworkTable::new(),
        }
@@ -13,6 +13,7 @@ license.workspace = true
 [dependencies]
 async-recursion = "1.0.4"
 base64 = "0.21.3"
+bincode = "1.3.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.
@@ -25,8 +26,11 @@ futures = "0.3.28"
 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" }
+nym-sphinx = { path = "../nymsphinx" }
+nym-tun = { path = "../tun" , features = ["wireguard"] }
 rand.workspace = true
 serde = { workspace = true, features = ["derive"] }
 tap.workspace = true
@@ -3,15 +3,10 @@
 // #![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;
+pub mod setup;
 mod udp_listener;
 mod wg_tunnel;

@@ -20,7 +15,9 @@ 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 nym_tun::tun_device;
+
+use nym_tun::tun_task_channel;

 /// Start wireguard UDP listener and TUN device
 ///
@@ -36,7 +33,9 @@ pub async fn start_wireguard(

    // 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()));
+
+    use nym_wireguard_types::tun_common::network_table::NetworkTable;
+    let peers_by_ip = Arc::new(tokio::sync::Mutex::new(NetworkTable::new()));

    // Alternative 1:
    let routing_mode = tun_device::RoutingMode::new_allowed_ips(peers_by_ip.clone());
@@ -45,9 +44,9 @@ pub async fn start_wireguard(

    // 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(),
+        base_name: nym_network_defaults::WG_TUN_BASE_NAME.to_string(),
+        ip: nym_network_defaults::WG_TUN_DEVICE_ADDRESS.parse().unwrap(),
+        netmask: nym_network_defaults::WG_TUN_DEVICE_NETMASK.parse().unwrap(),
    };
    let (tun, tun_task_tx, tun_task_response_rx) = tun_device::TunDevice::new(routing_mode, config);
    tun.start();
@@ -3,11 +3,9 @@ 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},
-};
+use crate::tun_task_channel::{TunTaskResponseRx, TunTaskTx};
+
+use nym_wireguard_types::tun_common::{active_peers::PeerEventSender, event::Event};

 #[derive(Clone)]
 pub struct PacketRelaySender(pub(crate) mpsc::Sender<(u64, Vec<u8>)>);
@@ -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;
@@ -7,11 +7,6 @@ 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=";
@@ -31,7 +26,7 @@ fn decode_base64_key(base64_key: &str) -> [u8; 32] {
 pub fn server_static_private_key() -> x25519::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_private = x25519::StaticSecret::from(static_private_bytes);
    let static_public = x25519::PublicKey::from(&static_private);
    info!(
        "wg public key: {}",
@@ -47,7 +42,7 @@ pub fn peer_static_public_key() -> x25519::PublicKey {
    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::PublicKey::from(peer_static_public_bytes);
    info!(
        "Adding wg peer public key: {}",
        general_purpose::STANDARD.encode(peer_static_public)
@@ -1,54 +0,0 @@
-use tokio::sync::mpsc;
-
-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<(), tokio::sync::mpsc::error::SendError<TunTaskPayload>> {
-        self.0.send(data).await
-    }
-}
-
-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(16);
-    (TunTaskTx(tun_task_tx), TunTaskRx(tun_task_rx))
-}
-
-// Send responses back from the tun device back to the PacketRelayer
-pub(crate) struct TunTaskResponseTx(mpsc::Sender<TunTaskPayload>);
-pub struct TunTaskResponseRx(mpsc::Receiver<TunTaskPayload>);
-
-impl TunTaskResponseTx {
-    pub(crate) async fn send(
-        &self,
-        data: TunTaskPayload,
-    ) -> Result<(), tokio::sync::mpsc::error::SendError<TunTaskPayload>> {
-        self.0.send(data).await
-    }
-}
-
-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(16);
-    (
-        TunTaskResponseTx(tun_task_tx),
-        TunTaskResponseRx(tun_task_rx),
-    )
-}
@@ -6,16 +6,21 @@ use boringtun::{
 };
 use futures::StreamExt;
 use log::error;
+use nym_network_defaults::WG_PORT;
 use nym_task::TaskClient;
-use nym_wireguard_types::{registration::GatewayClientRegistry, PeerPublicKey, WG_PORT};
+use nym_wireguard_types::{
+    registration::GatewayClientRegistry,
+    tun_common::{
+        active_peers::{ActivePeers, PeersByIp},
+        event::Event,
+    },
+    PeerPublicKey,
+};
 use tap::TapFallible;
 use tokio::{net::UdpSocket, sync::Mutex};

 use crate::{
-    active_peers::{ActivePeers, PeerEventSender},
    error::WgError,
-    event::Event,
-    network_table::NetworkTable,
    packet_relayer::PacketRelaySender,
    registered_peers::{RegisteredPeer, RegisteredPeers},
    setup::{self, WG_ADDRESS},
@@ -24,9 +29,6 @@ use crate::{

 const MAX_PACKET: usize = 65535;

-// Registered peers
-pub(crate) type PeersByIp = NetworkTable<PeerEventSender>;
-
 async fn add_test_peer(registered_peers: &mut RegisteredPeers) {
    let peer_static_public = PeerPublicKey::new(setup::peer_static_public_key());
    let peer_index = 0;
@@ -7,18 +7,16 @@ use boringtun::{
 };
 use bytes::Bytes;
 use log::{debug, error, info, warn};
+use nym_wireguard_types::tun_common::{
+    active_peers::{peer_event_channel, PeerEventReceiver, PeerEventSender},
+    event::Event,
+    network_table::NetworkTable,
+};
 use rand::RngCore;
 use tap::TapFallible;
 use tokio::{net::UdpSocket, sync::broadcast, time::timeout};

-use crate::{
-    active_peers::{peer_event_channel, PeerEventReceiver, PeerEventSender},
-    error::WgError,
-    event::Event,
-    network_table::NetworkTable,
-    packet_relayer::PacketRelaySender,
-    registered_peers::PeerIdx,
-};
+use crate::{error::WgError, packet_relayer::PacketRelaySender, registered_peers::PeerIdx};

 const HANDSHAKE_MAX_RATE: u64 = 10;

@@ -10,3 +10,14 @@ Each directory contains a readme with more information about running and contrib
 * `bump_versions.sh` allows you to update the ~~`platform_release_version` and~~ `wallet_release_version` variable~~s~~ in the `book.toml` of each mdbook project at once. You can also optionally update the `minimum_rust_version` as well. Helpful for lazy-updating when cutting a new version of the docs. 
 * `build_all_to_dist.sh` is used by the `ci-dev.yml` and `cd-dev.yml` scripts for building all mdbook projects and moving the rendered html to `../dist/` to be rsynced with various servers. 
 * `post_process.sh` is a script called by the github CI and CD workflows to post process CSS/image/href links for serving several mdbooks from a subdirectory. 
+
+
+### Licensing and copyright information
+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
+
+For accurate information, please check individual files.
@@ -1,5 +1,10 @@
 # Licensing

-Nym is Free Software released under the Apache License V2.
+Components that make up Nym as a system are licensed individually, so for accurate information, please check individual files.

-All of the contributions of the Nym core developers are © Nym Technologies SA. If you are interested in talking to us about other licenses, please get in touch.
+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.
@@ -29,7 +29,7 @@ cargo new nym-cosmos-service
 ```
 [dependencies]
 clap = { version = "4.0", features = ["derive"] }
-cosmrs = "=0.14.0"
+cosmrs = "=0.15.0"
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }
 serde = "1.0.152"
 serde_json = "1.0.91"
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -89,7 +89,7 @@ You can check the necessary parameters for the available commands by running:
 Before you can use the client, you need to initalise a new instance of it, which can be done with the following command:

 ```
-./nym-socks5-client init --id docs-example --provider Entztfv6Uaz2hpYHQJ6JKoaCTpDL5dja18SuQWVJAmmx.Cvhn9rBJw5Ay9wgHcbgCnVg89MPSV5s2muPV2YF1BXYu@Fo4f4SQLdoyoGkFae5TpVhRVoXCF8UiypLVGtGjujVPf
+./nym-socks5-client init --id docs-example --use-reply-surbs true --provider Entztfv6Uaz2hpYHQJ6JKoaCTpDL5dja18SuQWVJAmmx.Cvhn9rBJw5Ay9wgHcbgCnVg89MPSV5s2muPV2YF1BXYu@Fo4f4SQLdoyoGkFae5TpVhRVoXCF8UiypLVGtGjujVPf
 ```

 ~~~admonish example collapsible=true title="Console output"
@@ -100,6 +100,8 @@ Before you can use the client, you need to initalise a new instance of it, which

 The `--id` in the example above is a local identifier so that you can name your clients and keep track of them on your local system; it is **never** transmitted over the network.

+The `--use-reply-surbs` field denotes whether you wish to send [SURBs](../architecture/traffic-flow.md#private-replies-using-surbs) along with your request. It defaults to `false`, we are explicitly setting it as `true`. It defaults to `false` for compatibility with older versions of the [Network Requester](../nodes/network-requester.md).
+
 The `--provider` field needs to be filled with the Nym address of a Network Requester that can make network requests on your behalf. If you don't want to [run your own](../nodes/network-requester.md) you can select one from the [mixnet explorer](https://explorer.nymtech.net/network-components/service-providers) by copying its `Client ID` and using this as the value of the `--provider` flag. Alternatively, you could use [this list](https://harbourmaster.nymtech.net/).

 Since the nodes on this list are the infrastructure for [Nymconnect](https://nymtech.net/developers/quickstart/nymconnect-gui.html) they will support all apps on the [default whitelist](../nodes/network-requester.md#network-requester-whitelist): Keybase, Telegram, Electrum, Blockstream Green, and Helios.
@@ -148,7 +150,7 @@ Alternatively, a custom host can be set in the `config.toml` file under the `soc

 ### Running the socks5 client

-You can run the initalised client by doing this:
+You can run the initialised client by doing this:

 ```
 ./nym-socks5-client run --id docs-example
@@ -1,5 +1,8 @@
 # Licensing

-Nym is Free Software released under the Apache License V2.
+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

-All of the contributions of the Nym core developers are © Nym Technologies SA. If you are interested in talking to us about other licenses, please get in touch.
+Again, for accurate information, please check individual files.
@@ -12,5 +12,5 @@ You can read more about how SURBs function under the hood [here](../../../archit
 In order to reply to an incoming message using SURBs, you can construct a `recipient` from the `sender_tag` sent along with the message you wish to reply to:

 ```rust,noplayground
-{{#include ../../../../../../sdk/rust/nym-sdk/examples/surb-reply.rs}}
+{{#include ../../../../../../sdk/rust/nym-sdk/examples/surb_reply.rs}}
 ```
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
@@ -1,5 +1,8 @@
 # Licensing

-Nym is Free Software released under the Apache License V2.
+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

-All of the contributions of the Nym core developers are © Nym Technologies SA. If you are interested in talking to us about other licenses, please get in touch.
+Again, for accurate information, please check individual files.
@@ -136,7 +136,7 @@ pub enum Error {
    NotFound(String),
    #[error("Configuration file does not exist")]
    /// This is returned if IoError happens during configuration file read/write.
-    IoError(#[from] std::io::Error),
+    Io(#[from] std::io::Error),
    /// This is returned if configuration file is invalid.
    #[error("Configuration file is invalid: '{0}'")]
    InvalidFormat(String),
@@ -1,8 +1,9 @@
 # Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
-# SPDX-License-Identifier: Apache-2.0
+# SPDX-License-Identifier: GPL-3.0-only

 [package]
 name = "nym-gateway"
+license = "GPL-3"
 version = "1.1.31"
 authors = [
    "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
@@ -0,0 +1,25 @@
+<!--
+Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+SPDX-License-Identifier: GPL-3.0-only
+-->
+
+# Nym Gateway
+
+A Rust gateway implementation.
+
+## License
+
+Copyright (C) 2023 Nym Technologies SA <contact@nymtech.net>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
@@ -1,3 +1,6 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: GPL-3.0-only
+
 use sqlx::{Connection, SqliteConnection};
 use std::env;

@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use clap::Args;
 use nym_bin_common::bin_info_owned;
@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::commands::upgrade_helpers;
 use crate::config::default_config_filepath;
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::commands::helpers::{
    initialise_local_ip_packet_router, initialise_local_network_requester,
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::Cli;
 use clap::CommandFactory;
@@ -1,5 +1,5 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::commands::helpers::try_load_current_config;
 use crate::node::helpers::node_details;
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::commands::helpers::{
    ensure_config_version_compatibility, OverrideConfig, OverrideNetworkRequesterConfig,
@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::commands::helpers::{
    initialise_local_ip_packet_router, try_load_current_config, OverrideIpPacketRouterConfig,
@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::commands::helpers::{
    initialise_local_network_requester, try_load_current_config, OverrideNetworkRequesterConfig,
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::commands::helpers::{
    ensure_config_version_compatibility, ensure_correct_bech32_prefix, OverrideConfig,
@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::config::old_config_v1_1_20::ConfigV1_1_20;
 use crate::config::old_config_v1_1_28::ConfigV1_1_28;
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::config::persistence::paths::GatewayPaths;
 use crate::config::template::CONFIG_TEMPLATE;
@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::config::old_config_v1_1_28::{
    ConfigV1_1_28, DebugV1_1_28, GatewayPathsV1_1_28, GatewayV1_1_28, KeysPathsV1_1_28,
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::config::old_config_v1_1_29::{
    ConfigV1_1_29, DebugV1_1_29, GatewayPathsV1_1_29, GatewayV1_1_29, KeysPathsV1_1_29,
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use nym_config::{
    must_get_home, read_config_from_toml_file, DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_FILENAME, NYM_DIR,
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::config::persistence::paths::GatewayPaths;
 use nym_bin_common::logging::LoggingSettings;
@@ -1,4 +1,4 @@
 // Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 pub mod paths;
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::config::{default_config_directory, default_data_directory};
 use serde::{Deserialize, Deserializer, Serialize};
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 // While using normal toml marshalling would have been way simpler with less overhead,
 // I think it's useful to have comments attached to the saved config file to explain behaviour of
@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::node::storage::error::StorageError;
 use nym_ip_packet_router::error::IpPacketRouterError;
@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::config::Config;
 use crate::error::GatewayError;
@@ -229,14 +229,14 @@ impl<'a> HttpApiBuilder<'a> {
            IpAddr::from(Ipv4Addr::new(10, 1, 0, 0)),
            self.gateway_config.wireguard.private_network_prefix,
        )?;
-        let wg_state = self.client_registry.map(|client_registry| {
+        let wg_state = self.client_registry.and_then(|client_registry| {
            WireguardAppState::new(
-                self.sphinx_keypair,
                client_registry,
                Default::default(),
                self.gateway_config.wireguard.bind_address.port(),
                wireguard_private_network,
            )
+            .ok()
        });

        let router = nym_node::http::NymNodeRouter::new(config, wg_state);
@@ -1,5 +1,5 @@
 // Copyright 2020-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 #![warn(clippy::expect_used)]
 #![warn(clippy::unwrap_used)]
@@ -1,5 +1,5 @@
 // Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use super::websocket::message_receiver::{IsActiveRequestSender, MixMessageSender};
 use crate::node::client_handling::embedded_network_requester::LocalNetworkRequesterHandle;
@@ -1,5 +1,5 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use nym_coconut_interface::Credential;

@@ -1,5 +1,5 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::node::client_handling::websocket::message_receiver::{
    MixMessageReceiver, MixMessageSender,
@@ -1,5 +1,5 @@
 // Copyright 2020 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 pub(crate) mod active_clients;
 mod bandwidth;
@@ -1,5 +1,5 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use futures::{
    future::{FusedFuture, OptionFuture},
@@ -1,5 +1,5 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use super::authenticated::RequestHandlingError;
 use log::*;
@@ -1,5 +1,5 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: GPL-3.0-only

 use crate::node::client_handling::websocket::connection_handler::authenticated::RequestHandlingError;
 use nym_bandwidth_claim_contract::msg::ExecuteMsg;
@@ -7,9 +7,9 @@ use nym_bandwidth_claim_contract::payment::LinkPaymentData;
 use nym_credentials::token::bandwidth::TokenCredential;
 use nym_crypto::asymmetric::identity::{PublicKey, Signature, SIGNATURE_LENGTH};
 use nym_network_defaults::{ETH_EVENT_NAME, ETH_MIN_BLOCK_DEPTH};
-use std::str::FromStr;
 use nym_validator_client::nxmd::traits::MixnetQueryClient;
 use nym_validator_client::nyxd::{AccountId, NyxdClient, SigningNyxdClient};
+use std::str::FromStr;
 use web3::contract::tokens::Detokenize;
 use web3::contract::{Contract, Error};
 use web3::transports::Http;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jon Häggblad	a4b880ba4a	More optimized parsing	2023-11-28 10:11:41 +01:00
Jon Häggblad	76d6c51f91	try a different parse_dst_addr	2023-11-28 09:59:15 +01:00
Jon Häggblad	3a3d854eb7	Try with split state	2023-11-28 09:42:55 +01:00
Jon Häggblad	748dd1faf3	Fix typo in log	2023-11-28 09:25:05 +01:00
Jon Häggblad	c2cb343135	Fix connected clients	2023-11-28 08:56:20 +01:00
Jon Häggblad	0581d40bbf	Initial split out tun listener:	2023-11-28 08:43:03 +01:00
Jon Häggblad	4a8c09f476	Handle dynamic ip allocation in ip packet router (#4186 ) * Add dynamic connect support to ip packet router * Disconnect inactive clients * Don't generate ip same as tun device * clippy * Extract a few functions to separate mod * clippy	2023-11-27 15:31:35 +01:00
Jon Häggblad	ca2ad13579	Handle connect request in IPR (#4183 ) * wip: first attempt at connected clients * redo connected clients * fix bug in if statement	2023-11-27 13:18:31 +01:00
Jon Häggblad	44395f8466	Implement ip-packet-router connect request response outline (#4177 ) * Try revised request response connect types * wip: try to get data requests work * Also serialize response * tweak log * Add code path for connect response fail * Convenience functions on ip packet request * Remove commented out code * Restore log to debug	2023-11-27 12:17:58 +01:00
Jędrzej Stuczyński	39d714f2c0	Merge pull request #4171 from nymtech/research/partial_blind_signature_verification Research/partial blind signature verification	2023-11-27 09:57:44 +00:00
Jon Häggblad	336f220c83	Fix some clippy for beta toolchain (#4182 )	2023-11-27 10:52:18 +01:00
Tommy Verrall	6b2c13b3fd	Merge pull request #4126 from nymtech/chore/adjust-selection-weights using performance^20 when calculating active set selection weight	2023-11-27 07:46:57 +00:00
Tommy Verrall	17357da97e	Merge pull request #4167 from nymtech/bugfix/gateway-ws-listener-before-NR start gateway websocket listener before embedded NR	2023-11-24 17:59:06 +00:00
Bogdan-Ștefan Neacşu	bd830780e1	Add wireguard_mode flag to SDK (#4168 ) * Add wireguard_mode flag to SDK * Add to builder in sdk too * Move hardcoded IP in a lighter crate * Put in network defaults * Fix linux * Move wireguard mode swap before init * Use the updated gateway hosts * Set wireguard IP even for pre-inited mix client * Fix typo	2023-11-24 16:20:22 +01:00
Jon Häggblad	c79d864c3d	Merge remote-tracking branch 'origin/master' into develop	2023-11-24 14:23:49 +01:00
benedetta davico	25df954112	Merge pull request #4175 from nymtech/release/nyxd43 Merging release/nyxd43 into master	2023-11-24 12:32:52 +01:00
Jędrzej Stuczyński	d92c8c4149	deal with the pow error during stake adjustment	2023-11-24 09:40:17 +00:00
Jędrzej Stuczyński	4c8fa74dfe	remove the panic	2023-11-24 09:31:46 +00:00
mx	a8de6b75d9	Merge pull request #4174 from nymtech/feature/docs-license updated licensing information to be in line with monorepo	2023-11-23 16:02:21 +00:00
Mark Sinclair	3096a2307f	Change mixnode, gateway, network and nym-api binary licenses to GPLv3 (#4173 ) * Change mixnode, gateway, network and nym-api binary licenses to GPLv3 * Add license to cargo files * Revert model license to match crate * Add license to nym-node * Revert model license to match crate * Fix formatting --------- Co-authored-by: Mark Sinclair <mmsinclair@users.noreply.github.com>	2023-11-23 15:43:26 +00:00
mfahampshire	4b882d84ea	updated licensing information to be in line with monorepo	2023-11-23 16:37:29 +01:00
Drazen Urch	3b8cff8b32	Feature/ppa repo (#4165 ) * Test GH pages * Add workflow * Maybe fix path * Restructure * Rename list file * Naming * Restructure again * Add readme, final touches * Add script to update PPA * Update change log * Update Makefile * Avoid commiting keys by accident * Documnet PPA_SIGNING_KEY in script	2023-11-23 13:51:58 +01:00
Jon Häggblad	177cb22a3f	Fix action controller stopping too early (#4170 ) * Stop ActionController only after both incoming channels closed * Downgrade task getting dropped message to debug level * The warning to the user is not a warning that things didn't work * rustfmt * fix channel close logic * Don't close real traffic stream and sent notification listener too aggressively	2023-11-23 12:44:25 +01:00
Jędrzej Stuczyński	b1ac5b4e86	using multimiller loop for partial blinded signature verification	2023-11-23 11:21:47 +00:00
aniampio	ae22a132a3	Update benchmarks	2023-11-23 11:21:47 +00:00
aniampio	d0b9583b79	Add benchmark for verification of a single partial blind signature	2023-11-23 11:21:46 +00:00
aniampio	1f5568b4a7	Extend the function to support also public attributes	2023-11-23 11:21:46 +00:00
aniampio	16f51a0014	Add documentation to the verification function	2023-11-23 11:21:46 +00:00
aniampio	5e8767c5d6	Update tests	2023-11-23 11:21:46 +00:00
aniampio	15abfb390f	Make the function more generic	2023-11-23 11:21:46 +00:00
aniampio	45e5f12198	Add function to verify partial blind signature	2023-11-23 11:21:46 +00:00
Pierre Dommerc	809fabfc2b	feat(vpn-ui): init frontend NC-134 (#4160 )	2023-11-22 15:04:02 +01:00
Jędrzej Stuczyński	05ff6f0f62	fixed node-tester wallet dependency by applying package.json changes from #4103 more details at https://github.com/nymtech/nym/commit/268588daac9fb80b19cb7fa32f963e68e2a26828	2023-11-22 11:08:18 +00:00
Jędrzej Stuczyński	d475b7b2ae	updated wallet's lock file	2023-11-22 11:06:37 +00:00
Tommy Verrall	adea6966ea	Merge pull request #4169 from nymtech/benedettadavico-patch-1 Update CHANGELOG.md and Bump versions	2023-11-22 10:38:02 +00:00
Tommy Verrall	ab1c7206a3	Merge branch 'benedettadavico-patch-1' of https://github.com/nymtech/nym into benedettadavico-patch-1	2023-11-22 10:33:51 +00:00
Tommy Verrall	4c355848c6	upgrade wallet version	2023-11-22 10:33:42 +00:00
benedettadavico	7a6ddc67ed	Bump versions	2023-11-22 11:32:46 +01:00
benedetta davico	8e6596db48	Update CHANGELOG.md	2023-11-22 11:30:14 +01:00
Jędrzej Stuczyński	acf149e131	Merge pull request #3968 from nymtech/chore/nyxd-042-upgrade Chore/nyxd 043 upgrade	2023-11-22 10:13:23 +00:00
Jon Häggblad	acc62252be	Fix clippy in ephemera	2023-11-22 09:49:44 +00:00
Jon Häggblad	d682bc4573	Upgrade to safer-ffi 0.1.4 for clippy	2023-11-22 09:43:30 +00:00
Tommy Verrall	5eda5cc35d	amending gas adjustment to prevent tx broadcast errors	2023-11-22 09:37:54 +00:00
Jędrzej Stuczyński	3f243f111a	fixed cosmrs version used in the wallet	2023-11-22 09:37:54 +00:00
Jędrzej Stuczyński	6ac38f80c7	fixed coconut test fixture	2023-11-22 09:37:54 +00:00
Tommy Verrall	a4cf3b9166	amend gas adjustment otherwise we have no gas :(	2023-11-22 09:37:53 +00:00
Jędrzej Stuczyński	002c04051a	Changing from 034 compat mode to 037	2023-11-22 09:37:53 +00:00
Jędrzej Stuczyński	1aa12886db	'deliver_tx' => 'tx_result'	2023-11-22 09:37:53 +00:00
Jędrzej Stuczyński	6552cbaeda	Updated cosmrs-related dependencies	2023-11-22 09:37:52 +00:00
Jędrzej Stuczyński	24746dc47b	start gateway websocket listener before embedded NR	2023-11-21 14:32:23 +00:00
mx	8ee31d94ea	Merge pull request #4115 from nymtech/feature/increase-default-sdk-surbs Feature/increase default sdk surbs	2023-11-21 14:30:21 +00:00
Jon Häggblad	818d7ee13e	Add logging for client fetching gateways and pretty print error (#4164 ) * Add logging for client fetching gateways * Pretty print error in client * update	2023-11-21 11:41:03 +01:00
Jon Häggblad	81c692d305	Extract out tun crate (#4159 ) * wip * Use common interface request response * wip: extract crates * wip * new structure compiles * Create tun_common subdir * Comment out return_mix_delays for now * Remove unused boringtun dependency * Revert to previous packet encoding * Allow dead code on non-linux * Add new function	2023-11-21 09:55:35 +01:00
Jon Häggblad	1728de57b9	Fix bunch of warnings on latest rustc beta (#4161 )	2023-11-21 09:02:48 +01:00
Jędrzej Stuczyński	53fcebfd86	added 'build-info' command to nym-api (#4162 ) * added 'build-info' command to nym-api * moved run logic to cli::run * clippy	2023-11-20 17:10:03 +00:00
Jędrzej Stuczyński	4a5ceddeac	Feature/gateway described nr (#4147 ) * adding embedded NR information to gateways/described endpoint * using default for NR if not available	2023-11-20 16:18:32 +01:00
Bogdan-Ștefan Neacşu	a5c1e4abf0	Expose the same pub key that's used for wg (#4157 )	2023-11-17 13:04:22 +00:00
Jon Häggblad	3a1003c564	Create TaggedPacket (#4156 ) * Create TaggedPacket * Fix bug passing the correct data	2023-11-17 12:30:15 +01:00
Jon Häggblad	1cdd8f6c08	Rework error handling in tun device (#4146 ) * Rework error handling in tun device * Extract out timeout constants * Experiment with timeouts * Update error msg * try_send in one direction as hotfix for deadlock * Downgrade some log from info to debug * Update comment * rustfmt	2023-11-17 09:52:05 +01:00
mfahampshire	f47e1793a2	typo fix	2023-11-13 10:45:52 +01:00
Jędrzej Stuczyński	ef8e452f30	using performance^20 when calculating active set selection weight	2023-11-10 09:54:03 +00:00
mfahampshire	8e3f4ce08d	format change	2023-11-09 17:45:19 +01:00
mfahampshire	9b4262bb36	added flag to socks5 info	2023-11-09 17:44:05 +01:00
mfahampshire	6d37d7df8e	dropped default surbs to 10 for uniformity across sdks	2023-11-09 16:38:07 +01:00
mfahampshire	427f205a58	upped default attached number of surbs from 0 -> 10	2023-11-09 16:26:58 +01:00
mfahampshire	9549d3b681	revert change of file name	2023-11-07 15:12:33 +01:00
mfahampshire	1be81b96b3	upped default sdk surbs from 5 -> 20	2023-11-07 14:56:14 +01:00