Add 1 Delay(0)

.github/workflows/cd-docs.yml

@@ -1,8 +1,9 @@
-name: cd-docs
+name: CD docs
 
 on:
   workflow_dispatch:
   push:
+    branches: master
     paths:
       - 'documentation/docs/**'
 
@@ -25,7 +26,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --workspace --release
+          args: --workspace --release --all
       - name: Install mdbook
         run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.33" mdbook)
       - name: Install mdbook plugins
@@ -38,6 +39,30 @@ jobs:
         run: cd documentation && ./build_all_to_dist.sh
         continue-on-error: false
 
+      - name: Deploy branch master to dev
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "dist/docs/"
+          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_DEV }}
+          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
+          EXCLUDE: "/node_modules/"
+
+      - name: Deploy branch master to prod
+        if: github.ref == 'refs/heads/master'
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "dist/docs/"
+          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_PROD }}
+          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
+          EXCLUDE: "/node_modules/"
+
       - name: Post process
         run: cd documentation && ./post_process.sh
         continue-on-error: false

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

@@ -1,4 +1,4 @@
-name: ci-binary-config-checker
+name: Run config checks on all binaries
 
 on:
   workflow_dispatch:

.github/workflows/ci-docs.yml

@@ -26,7 +26,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --workspace --release
+          args: --workspace --release --all
       - name: Install mdbook
         run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.35" mdbook)
       - name: Install mdbook plugins

.github/workflows/ci-nym-connect-desktop-rust.yml

@@ -33,12 +33,6 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --manifest-path nym-connect/desktop/Cargo.toml --all -- --check
-
       - name: Build all binaries
         uses: actions-rs/cargo@v1
         with:
@@ -51,6 +45,12 @@ jobs:
           command: test
           args: --manifest-path nym-connect/desktop/Cargo.toml --workspace
 
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path nym-connect/desktop/Cargo.toml --all -- --check
+
       - uses: actions-rs/clippy-check@v1
         name: Clippy checks
         continue-on-error: true

.github/workflows/ci-nym-vpn-ui-rust.yml

@@ -35,7 +35,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --manifest-path ${{ env.CARGOTOML_PATH }} --features custom-protocol
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --lib --features custom-protocol
 
 #      - name: Run all tests
 #        uses: actions-rs/cargo@v1

.github/workflows/deploy-github-pages.yml

@@ -1,43 +0,0 @@
-# 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

.github/workflows/nightly-build.yml

@@ -4,25 +4,25 @@ on:
   workflow_dispatch:
   schedule:
     - cron: '14 1 * * *'
-
 jobs:
   build:
     strategy:
       fail-fast: false
       matrix:
         rust: [stable, beta]
-        os: [ubuntu-20.04, windows-latest, macos-latest]
+        os: [custom-linux, windows10, custom-runner-mac-m1]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
     continue-on-error: true
     steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
-        if: matrix.os == 'ubuntu-20.04'
+        continue-on-error: true
+        if: matrix.os == 'custom-linux'
+
+      - name: Check out repository code
+        uses: actions/checkout@v3
 
       - name: Install Rust toolchain
         uses: actions-rs/toolchain@v1
@@ -32,12 +32,6 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      - name: Install Protoc
-        uses: arduino/setup-protoc@v2
-        if: matrix.os == 'macos-latest' || matrix.os == 'windows-latest'
-        with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
-
       - name: Check formatting
         uses: actions-rs/cargo@v1
         with:
@@ -48,27 +42,13 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --release --workspace
+          args: --workspace
 
       - name: Build examples
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: --release --workspace --examples
-
-      # To avoid running out of disk space, skip generating debug symbols
-      - name: Set debug to false (unix)
-        if: matrix.os == 'ubuntu-20.04' || matrix.os == 'macos-latest'
-        run: |
-          sed -i.bak 's/\[profile.dev\]/\[profile.dev\]\ndebug = false/' Cargo.toml
-          git diff
-
-      - name: Set debug to false (win)
-        if: matrix.os == 'windows-latest'
-        shell: pwsh
-        run: |
-          (Get-Content Cargo.toml) -replace '\[profile.dev\]', "`$&`ndebug = false" | Set-Content Cargo.toml
-          git diff
+          args: --workspace --examples
 
       - name: Run unit tests
         uses: actions-rs/cargo@v1
@@ -82,11 +62,6 @@ jobs:
           command: test
           args: --workspace -- --ignored
 
-      - name: Clean
-        uses: actions-rs/cargo@v1
-        with:
-          command: clean
-
       - name: Clippy
         uses: actions-rs/cargo@v1
         with:

.github/workflows/nightly-nym-connect-desktop-build.yml

@@ -1,92 +0,0 @@
-name: nightly-nym-connect-desktop-build
-
-on:
-  workflow_dispatch:
-  schedule:
-    - cron: '14 1 * * *'
-
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-20.04, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    env:
-      CARGO_TERM_COLOR: always
-      MANIFEST_PATH: --manifest-path nym-connect/desktop/Cargo.toml
-    continue-on-error: true
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v3
-
-      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
-
-      - name: Install rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          override: true
-          components: rustfmt, clippy
-
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: ${{ env.MANIFEST_PATH }} --all -- --check
-
-      - name: Build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: ${{ env.MANIFEST_PATH }} --release --workspace
-
-      - name: Unit tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: ${{ env.MANIFEST_PATH }} --workspace
-
-      - name: Clippy
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: ${{ env.MANIFEST_PATH }} --workspace --all-targets -- -D warnings
-
-  notification:
-    needs: build
-    runs-on: custom-linux
-    steps:
-      - name: Collect jobs status
-        uses: technote-space/workflow-conclusion-action@v2
-      - name: Check out repository code
-        uses: actions/checkout@v3
-      - name: install npm
-        uses: actions/setup-node@v3
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        with:
-          node-version: 18
-      - name: Matrix - Node Install
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        run: npm install
-        working-directory: .github/workflows/support-files
-      - name: Matrix - Send Notification
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        env:
-          NYM_NOTIFICATION_KIND: nightly
-          NYM_PROJECT_NAME: "nym-connect-desktop-nightly-build"
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          IS_SUCCESS: "${{ env.WORKFLOW_CONCLUSION == 'success' }}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_NIGHTLY }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh

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

@@ -5,24 +5,27 @@ on:
   schedule:
     - cron: '14 1 * * *'
 
+defaults:
+  run:
+    working-directory: nym-wallet
+
 jobs:
   build:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macos-latest, windows-latest]
+        os: [custom-ubuntu-20.04, macos-latest, windows10]
     runs-on: ${{ matrix.os }}
     env:
       CARGO_TERM_COLOR: always
-      MANIFEST_PATH: --manifest-path nym-wallet/Cargo.toml
     continue-on-error: true
     steps:
       - name: Check out repository code
         uses: actions/checkout@v3
 
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
-        if: matrix.os == 'ubuntu-20.04'
+        run: sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
+        if: matrix.os == 'custom-ubuntu-20.04'
 
       - name: Install rust toolchain
         uses: actions-rs/toolchain@v1
@@ -32,29 +35,40 @@ jobs:
           override: true
           components: rustfmt, clippy
 
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v2
+        if: matrix.os == 'macos-latest'
+
       - name: Check formatting
         uses: actions-rs/cargo@v1
         with:
           command: fmt
-          args: ${{ env.MANIFEST_PATH }} --all -- --check
+          args: --all -- --check
 
       - name: Build
         uses: actions-rs/cargo@v1
         with:
           command: build
-          args: ${{ env.MANIFEST_PATH }} --release --workspace
+          args: --workspace
 
       - name: Unit tests
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: ${{ env.MANIFEST_PATH }} --workspace
+          args: --workspace
+
+      - name: Annotate with clippy warnings
+        uses: actions-rs/clippy-check@v1
+        continue-on-error: true
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --workspace
 
       - name: Clippy
         uses: actions-rs/cargo@v1
         with:
           command: clippy
-          args: ${{ env.MANIFEST_PATH }} --workspace --all-targets -- -D warnings
+          args: --workspace --all-targets -- -D warnings
 
   notification:
     needs: build

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

@@ -39,7 +39,6 @@ jobs:
         env:
           APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
           APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
           KEYCHAIN_PASSWORD: ${{ secrets.KEYCHAIN_PASSWORD }}
         run: |
           # create variables
@@ -74,7 +73,6 @@ jobs:
           ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
           APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
           APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
           APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
           APPLE_ID: ${{ secrets.APPLE_ID }}
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}

.gitignore

@@ -9,7 +9,6 @@
 target
 .env
 .env.dev
-envs/devnet.env
 /.vscode/settings.json
 validator/.vscode
 sample-configs/validator-config.toml
@@ -46,6 +45,4 @@ envs/qwerty.env
 cpu-cycles/libcpucycles/build
 foxyfox.env
 
-.next
-ppa-private-key.b64
-ppa-private-key.asc
+.next

CHANGELOG.md

@@ -3,50 +3,9 @@
 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [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)
-
-- suppress error output ([#4056])
-- Update frontend type for current vesting period ([#4042])
-- re-exported additional types for tx queries ([#4036])
-- fixed fmt::Display impl for GatewayNetworkRequesterDetails ([#4033])
-- Add exit node policy from TorNull and Tor Exit Node Policy ([#4024])
-- basic self-described api for gateways to dynamically announce its details + nym-api aggregation ([#4017])
-- use saturating sub in case outfox is not enabled ([#3986])
-- Fix sorting for mixnodes and gateways ([#3985])
-- Gateway client registry and api routes ([#3955])
-- Feature/configurable socks5 bind address ([#3992])
-
-[#4056]: https://github.com/nymtech/nym/pull/4056
-[#4042]: https://github.com/nymtech/nym/pull/4042
-[#4036]: https://github.com/nymtech/nym/pull/4036
-[#4033]: https://github.com/nymtech/nym/pull/4033
-[#4024]: https://github.com/nymtech/nym/issues/4024
-[#4017]: https://github.com/nymtech/nym/issues/4017
-[#3986]: https://github.com/nymtech/nym/pull/3986
-[#3985]: https://github.com/nymtech/nym/pull/3985
-[#3955]: https://github.com/nymtech/nym/pull/3955
-[#3992]: https://github.com/nymtech/nym/pull/3992
+- add client registry to Gateway ([#3955])
+- add HTTP API to Gateway ([#3955])
+- add `/client/<pub-key>`, `clients` and `register` routes to the gateway ([#3955])
 
 ## [2023.1-milka] (2023-09-24)
 

Cargo.toml

@@ -49,7 +49,6 @@ members = [
     "common/exit-policy",
     "common/http-api-client",
     "common/inclusion-probability",
-    "common/ip-packet-requests",
     "common/ledger",
     "common/mixnode-common",
     "common/network-defaults",
@@ -75,7 +74,6 @@ members = [
     "common/store-cipher",
     "common/task",
     "common/topology",
-    "common/tun",
     "common/types",
     "common/wasm/client-core",
     "common/wasm/storage",
@@ -103,12 +101,11 @@ members = [
     "nym-outfox",
     "tools/internal/ssl-inject",
     "tools/internal/sdk-version-bump",
-    "tools/internal/dkg-manager",
     "tools/nym-cli",
     "tools/nym-nr-query",
     "tools/ts-rs-cli",
     "wasm/client",
-#    "wasm/full-nym-wasm",
+    "wasm/full-nym-wasm",
     "wasm/mix-fetch",
     "wasm/node-tester",
 ]
@@ -143,6 +140,21 @@ 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"
@@ -160,9 +172,9 @@ 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.33.0"
-tokio-util = "0.7.10"
+tokio = "1.24.1"
 tokio-tungstenite = "0.20.1"
 tracing = "0.1.37"
 tungstenite = { version = "0.20.1", default-features = false }
@@ -172,28 +184,6 @@ 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"

Makefile

@@ -104,7 +104,7 @@ sdk-wasm-build:
 	$(MAKE) -C wasm/client
 	$(MAKE) -C wasm/node-tester
 	$(MAKE) -C wasm/mix-fetch
-	#$(MAKE) -C wasm/full-nym-wasm
+	$(MAKE) -C wasm/full-nym-wasm
 
 # run this from npm/yarn to ensure tools are in the path, e.g. yarn build:sdk from root of repo
 sdk-typescript-build:
@@ -114,7 +114,7 @@ sdk-typescript-build:
 	yarn --cwd sdk/typescript/codegen/contract-clients build
 
 # NOTE: These targets are part of the main workspace (but not as wasm32-unknown-unknown)
-WASM_CRATES = extension-storage nym-client-wasm nym-node-tester-wasm
+WASM_CRATES = extension-storage nym-client-wasm nym-node-tester-wasm nym-wasm-sdk
 
 sdk-wasm-test:
 	#cargo test $(addprefix -p , $(WASM_CRATES)) --target wasm32-unknown-unknown -- -Dwarnings
@@ -168,7 +168,3 @@ 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

README.md

@@ -15,6 +15,7 @@ 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)
 
 
@@ -82,11 +83,4 @@ where `s'` is stake `s` scaled over total token circulating supply.
 
 ### 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
-
-Again, for accurate information, please check individual files.
+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.

clients/native/Cargo.toml

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

clients/native/src/main.rs

@@ -22,10 +22,5 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     }
     setup_logging();
 
-    if let Err(err) = commands::execute(args).await {
-        log::error!("{err}");
-        println!("An error occurred: {err}");
-        std::process::exit(1);
-    }
-    Ok(())
+    commands::execute(args).await
 }

clients/socks5/Cargo.toml

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

clients/socks5/src/main.rs

@@ -21,10 +21,5 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     }
     setup_logging();
 
-    if let Err(err) = commands::execute(args).await {
-        log::error!("{err}");
-        println!("An error occurred: {err}");
-        std::process::exit(1);
-    }
-    Ok(())
+    commands::execute(args).await
 }

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

@@ -77,7 +77,7 @@ pub struct PersistedGatewayConfig {
     key_hash: Vec<u8>,
 
     /// Actual gateway details being persisted.
-    pub details: GatewayEndpointConfig,
+    pub(crate) details: GatewayEndpointConfig,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

common/client-core/src/client/real_messages_control/acknowledgement_control/action_controller.rs

@@ -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");
 
-        loop {
+        while !shutdown.is_shutdown() {
             tokio::select! {
                 action = self.incoming_actions.next() => match action {
                     Some(action) => self.process_action(action),
@@ -283,7 +283,6 @@ impl ActionController {
                 },
                 _ = shutdown.recv_with_delay() => {
                     log::trace!("ActionController: Received shutdown");
-                    break;
                 }
             }
         }

common/client-core/src/client/real_messages_control/acknowledgement_control/sent_notification_listener.rs

@@ -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");
 
-        loop {
+        while !shutdown.is_shutdown() {
             tokio::select! {
                 frag_id = self.sent_notifier.next() => match frag_id {
                     Some(frag_id) => {
@@ -53,7 +53,6 @@ impl SentNotificationListener {
                 },
                 _ = shutdown.recv_with_delay() => {
                     log::trace!("SentNotificationListener: Received shutdown");
-                    break;
                 }
             }
         }

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

@@ -500,12 +500,11 @@ where
         {
             let mut status_timer = tokio::time::interval(Duration::from_secs(5));
 
-            loop {
+            while !shutdown.is_shutdown() {
                 tokio::select! {
                     biased;
                     _ = shutdown.recv_with_delay() => {
                         log::trace!("OutQueueControl: Received shutdown");
-                        break;
                     }
                     _ = status_timer.tick() => {
                         self.log_status(&mut shutdown);

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

@@ -39,7 +39,7 @@ where
         mem_state: CombinedReplyStorage,
         mut shutdown: nym_task::TaskClient,
     ) {
-        use log::{debug, error, info};
+        use log::{debug, error, info, warn};
 
         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");
-        info!("you MUST NOT forcefully shutdown now or you risk data corruption!");
+        warn!("you MUST NOT forcefully shutdown now or you risk data corruption!");
         if let Err(err) = self.backend.flush_surb_storage(&mem_state).await {
             error!("failed to flush our reply-related data to the persistent storage: {err}")
         } else {

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

@@ -69,7 +69,7 @@ impl NymApiTopologyProvider {
             Ok(mixes) => mixes,
         };
 
-        let gateways = match self.validator_client.get_cached_described_gateways().await {
+        let gateways = match self.validator_client.get_cached_gateways().await {
             Err(err) => {
                 error!("failed to get network gateways - {err}");
                 return None;

common/client-core/src/error.rs

@@ -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,
 

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

@@ -67,24 +67,14 @@ 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 gateways = client.get_cached_gateways().await?;
     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)
 }
 

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

@@ -94,8 +94,6 @@ 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 {
@@ -212,7 +210,6 @@ 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 {

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

@@ -9,8 +9,8 @@ edition = "2021"
 [dependencies]
 futures = { workspace = true }
 log = { workspace = true }
-tokio = { workspace = true, features = ["time", "net", "rt"] }
-tokio-util = { workspace = true, features = ["codec"] }
+tokio = { version = "1.24.1", features = ["time", "net", "rt"] }
+tokio-util = { version = "0.7.4", features = ["codec"] }
 
 # internal
 nym-sphinx = { path = "../../nymsphinx" }

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

@@ -45,17 +45,13 @@ 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 = { workspace = true, default-features = false }
+prost = { version = "0.11", default-features = false }
 flate2 = { version = "1.0.20" }
 sha2 = { version = "0.9.5" }
 itertools = { version = "0.10" }

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

@@ -32,7 +32,7 @@ pub trait CoconutBandwidthSigningClient {
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NyxdError> {
         let req = CoconutBandwidthExecuteMsg::DepositFunds {
-            data: DepositData::new(info, verification_key, encryption_key),
+            data: DepositData::new(info.to_string(), verification_key, encryption_key),
         };
         self.execute_coconut_bandwidth_contract(
             fee,

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

@@ -6,8 +6,8 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cw3::{
-    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterDetail,
-    VoterListResponse, VoterResponse,
+    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterListResponse,
+    VoterResponse,
 };
 use cw_utils::ThresholdResponse;
 use nym_multisig_contract_common::msg::QueryMsg as MultisigQueryMsg;
@@ -114,26 +114,6 @@ pub trait PagedMultisigQueryClient: MultisigQueryClient {
 
         Ok(proposals)
     }
-
-    async fn get_all_voters(&self) -> Result<Vec<VoterDetail>, NyxdError> {
-        let mut voters = Vec::new();
-        let mut start_after = None;
-
-        loop {
-            let mut paged_response = self.list_voters(start_after.take(), None).await?;
-
-            let last_voter = paged_response.voters.last().map(|prop| prop.addr.clone());
-            voters.append(&mut paged_response.voters);
-
-            if let Some(start_after_res) = last_voter {
-                start_after = Some(start_after_res)
-            } else {
-                break;
-            }
-        }
-
-        Ok(voters)
-    }
 }
 
 #[async_trait]

common/client-libs/validator-client/src/nyxd/cosmwasm_client/helpers.rs

@@ -20,12 +20,12 @@ impl CheckResponse for broadcast::tx_commit::Response {
             });
         }
 
-        if self.tx_result.code.is_err() {
+        if self.deliver_tx.code.is_err() {
             return Err(NyxdError::BroadcastTxErrorDeliverTx {
                 hash: self.hash,
                 height: Some(self.height),
-                code: self.tx_result.code.value(),
-                raw_log: self.tx_result.log,
+                code: self.deliver_tx.code.value(),
+                raw_log: self.deliver_tx.log,
             });
         }
 

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

@@ -11,7 +11,7 @@ pub mod gas_price;
 
 pub type GasAdjustment = f32;
 
-pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: GasAdjustment = 1.5;
+pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: GasAdjustment = 1.3;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AutoFeeGrant {

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

@@ -34,9 +34,7 @@ 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, types::ExecTxResult, Event, EventAttribute,
-};
+pub use cosmrs::tendermint::abci::{response::DeliverTx, Event, EventAttribute};
 pub use cosmrs::tendermint::block::Height;
 pub use cosmrs::tendermint::hash::{self, Algorithm, Hash};
 pub use cosmrs::tendermint::validator::Info as TendermintValidatorInfo;
@@ -47,10 +45,6 @@ pub use cosmrs::Coin as CosmosCoin;
 pub use cosmrs::Gas;
 pub use cosmrs::{bip32, AccountId, Denom};
 pub use cosmwasm_std::Coin as CosmWasmCoin;
-pub use cw2;
-pub use cw3;
-pub use cw4;
-pub use cw_controllers;
 pub use fee::{gas_price::GasPrice, GasAdjustable, GasAdjustment};
 pub use tendermint_rpc::{
     endpoint::{tx::Response as TxResponse, validators::Response as ValidatorResponse},

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

@@ -28,7 +28,7 @@ where
     U: TryInto<HttpClientUrl, Error = Error>,
 {
     HttpRpcClient::builder(url.try_into()?)
-        .compat_mode(CompatMode::V0_37)
+        .compat_mode(CompatMode::V0_34)
         .build()
 }
 

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

@@ -36,8 +36,7 @@ pub struct ReqwestRpcClient {
 impl ReqwestRpcClient {
     pub fn new(url: Url) -> Self {
         ReqwestRpcClient {
-            // after updating to nyxd 0.42 and thus updating to cometbft, the compat mode changed
-            compat: CompatMode::V0_37,
+            compat: CompatMode::V0_34,
             inner: reqwest::Client::new(),
             url,
         }

common/commands/src/validator/mixnet/operators/mixnode/settings/mod.rs

@@ -4,7 +4,6 @@
 use clap::{Args, Subcommand};
 
 pub mod update_config;
-pub mod update_cost_params;
 pub mod vesting_update_config;
 
 #[derive(Debug, Args)]
@@ -21,5 +20,7 @@ pub enum MixnetOperatorsMixnodeSettingsCommands {
     /// Update mixnode configuration for a mixnode bonded with locked tokens
     VestingUpdateConfig(vesting_update_config::Args),
     /// Update mixnode cost parameters
-    UpdateCostParameters(update_cost_params::Args),
+    UpdateCostParameters,
+    /// Update mixnode cost parameters for a mixnode bonded with locked tokens
+    VestingUpdateCostParameters,
 }

common/commands/src/validator/mixnet/operators/mixnode/settings/update_cost_params.rs

@@ -1,48 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::SigningClient;
-use clap::Parser;
-use cosmwasm_std::Uint128;
-use log::info;
-use nym_mixnet_contract_common::{MixNodeCostParams, Percent};
-use nym_validator_client::nyxd::contract_traits::MixnetSigningClient;
-use nym_validator_client::nyxd::CosmWasmCoin;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(
-        long,
-        help = "input your profit margin as follows; (so it would be 10, rather than 0.1)"
-    )]
-    pub profit_margin_percent: Option<u8>,
-
-    #[clap(
-        long,
-        help = "operating cost in current DENOMINATION (so it would be 'unym', rather than 'nym')"
-    )]
-    pub interval_operating_cost: Option<u128>,
-}
-
-pub async fn update_cost_params(args: Args, client: SigningClient) {
-    let denom = client.current_chain_details().mix_denom.base.as_str();
-
-    let cost_params = MixNodeCostParams {
-        profit_margin_percent: Percent::from_percentage_value(
-            args.profit_margin_percent.unwrap_or(10) as u64,
-        )
-        .unwrap(),
-        interval_operating_cost: CosmWasmCoin {
-            denom: denom.into(),
-            amount: Uint128::new(args.interval_operating_cost.unwrap_or(40_000_000)),
-        },
-    };
-
-    info!("Starting mixnode params updating!");
-    let res = client
-        .update_mixnode_cost_params(cost_params, None)
-        .await
-        .expect("failed to update cost params");
-
-    info!("Cost params result: {:?}", res)
-}

common/config/src/lib.rs

@@ -25,20 +25,12 @@ pub const DEFAULT_CONFIG_FILENAME: &str = "config.toml";
 
 #[cfg(feature = "dirs")]
 pub fn must_get_home() -> PathBuf {
-    if let Some(home_dir) = std::env::var_os("NYM_HOME_DIR") {
-        home_dir.into()
-    } else {
-        dirs::home_dir().expect("Failed to evaluate $HOME value")
-    }
+    dirs::home_dir().expect("Failed to evaluate $HOME value")
 }
 
 #[cfg(feature = "dirs")]
 pub fn may_get_home() -> Option<PathBuf> {
-    if let Some(home_dir) = std::env::var_os("NYM_HOME_DIR") {
-        Some(home_dir.into())
-    } else {
-        dirs::home_dir()
-    }
+    dirs::home_dir()
 }
 
 pub trait NymConfigTemplate: Serialize {

common/cosmwasm-smart-contracts/coconut-bandwidth-contract/src/spend_credential.rs

@@ -142,7 +142,7 @@ pub fn funds_from_cosmos_msgs(msgs: Vec<CosmosMsg>) -> Option<Coin> {
         contract_addr: _,
         msg,
         funds: _,
-    })) = msgs.first()
+    })) = msgs.get(0)
     {
         if let Ok(ExecuteMsg::ReleaseFunds { funds }) = from_binary::<ExecuteMsg>(msg) {
             return Some(funds);

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

@@ -174,19 +174,17 @@ impl Display for EpochState {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             EpochState::PublicKeySubmission { resharing } => {
-                write!(f, "PublicKeySubmission (resharing: {resharing})")
-            }
-            EpochState::DealingExchange { resharing } => {
-                write!(f, "DealingExchange (resharing: {resharing})")
+                write!(f, "PublicKeySubmission with resharing {resharing}")
             }
+            EpochState::DealingExchange { resharing } => write!(f, "DealingExchange {resharing}"),
             EpochState::VerificationKeySubmission { resharing } => {
-                write!(f, "VerificationKeySubmission (resharing: {resharing})")
+                write!(f, "VerificationKeySubmission with resharing {resharing}")
             }
             EpochState::VerificationKeyValidation { resharing } => {
-                write!(f, "VerificationKeyValidation (resharing: {resharing})")
+                write!(f, "VerificationKeyValidation with resharing {resharing}")
             }
             EpochState::VerificationKeyFinalization { resharing } => {
-                write!(f, "VerificationKeyFinalization (resharing: {resharing})")
+                write!(f, "VerificationKeyFinalization with resharing {resharing}")
             }
             EpochState::InProgress => write!(f, "InProgress"),
         }

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

@@ -62,7 +62,7 @@ pub fn owner_from_cosmos_msgs(msgs: &[CosmosMsg]) -> Option<Addr> {
         contract_addr: _,
         msg,
         funds: _,
-    })) = msgs.first()
+    })) = msgs.get(0)
     {
         if let Ok(ExecuteMsg::VerifyVerificationKeyShare { owner, .. }) =
             from_binary::<ExecuteMsg>(msg)

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

@@ -3,7 +3,6 @@
 
 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};
@@ -72,10 +71,6 @@ 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 {

common/cosmwasm-smart-contracts/vesting-contract/src/account.rs

@@ -49,7 +49,7 @@ impl Account {
 
     pub fn period_duration(&self) -> Result<u64, VestingContractError> {
         self.periods
-            .first()
+            .get(0)
             .ok_or(VestingContractError::UnpopulatedVestingPeriods {
                 owner: self.owner_address.clone(),
             })

common/dkg/benches/benchmarks.rs

@@ -366,7 +366,11 @@ 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()).collect::<Vec<_>>();
+    let remote_share_key_pairs = shares
+        .iter()
+        .zip(receivers.values())
+        .map(|(share, key)| (share, key))
+        .collect::<Vec<_>>();
     let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();
 
     let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);
@@ -396,7 +400,11 @@ 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()).collect::<Vec<_>>();
+    let remote_share_key_pairs = shares
+        .iter()
+        .zip(receivers.values())
+        .map(|(share, key)| (share, key))
+        .collect::<Vec<_>>();
     let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();
 
     let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);
@@ -428,7 +436,11 @@ 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()).collect::<Vec<_>>();
+    let remote_share_key_pairs = shares
+        .iter()
+        .zip(receivers.values())
+        .map(|(share, key)| (share, key))
+        .collect::<Vec<_>>();
 
     let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);
 
@@ -466,7 +478,11 @@ 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()).collect::<Vec<_>>();
+    let remote_share_key_pairs = shares
+        .iter()
+        .zip(receivers.values())
+        .map(|(share, key)| (share, key))
+        .collect::<Vec<_>>();
 
     let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, &params, &mut rng);
 
@@ -529,7 +545,11 @@ 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()).collect::<Vec<_>>();
+    let remote_share_key_pairs = shares
+        .iter()
+        .zip(receivers.values())
+        .map(|(share, key)| (share, key))
+        .collect::<Vec<_>>();
 
     c.bench_function("100 shares encryption", |b| {
         b.iter(|| black_box(encrypt_shares(&remote_share_key_pairs, &params, &mut rng)))

common/dkg/src/dealing.rs

@@ -115,7 +115,11 @@ 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()).collect::<Vec<_>>();
+        let remote_share_key_pairs = shares
+            .iter()
+            .zip(receivers.values())
+            .map(|(share, key)| (share, key))
+            .collect::<Vec<_>>();
         let ordered_public_keys = receivers.values().copied().collect::<Vec<_>>();
 
         let (ciphertexts, hazmat) = encrypt_shares(&remote_share_key_pairs, params, &mut rng);

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

@@ -11,7 +11,7 @@ use thiserror::Error;
 use tracing::warn;
 use url::Url;
 
-pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
+pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(3);
 
 pub type PathSegments<'a> = &'a [&'a str];
 pub type Params<'a, K, V> = &'a [(K, V)];

common/ip-packet-requests/Cargo.toml

@@ -1,19 +0,0 @@
-[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 }

common/ip-packet-requests/src/lib.rs

@@ -1,373 +0,0 @@
-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]),
-            })
-        );
-    }
-}

common/mixnode-common/Cargo.toml

@@ -20,7 +20,7 @@ tokio = { version = "1.24.1", features = [
     "net",
     "io-util",
 ] }
-tokio-util = { workspace = true, features = ["codec"] }
+tokio-util = { version = "0.7.4", features = ["codec"] }
 url = { workspace = true }
 thiserror = { workspace = true }
 

common/network-defaults/src/lib.rs

@@ -476,11 +476,3 @@ 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";

common/nymcoconut/benches/benchmarks.rs

@@ -6,10 +6,9 @@ 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, prepare_blind_sign,
-    prove_bandwidth_credential, setup, ttp_keygen, verify_credential,
-    verify_partial_blind_signature, Attribute, BlindedSignature, Parameters, Signature,
-    SignatureShare, VerificationKey,
+    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,
 };
 use rand::seq::SliceRandom;
 use std::ops::Neg;
@@ -176,6 +175,8 @@ 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();
@@ -241,29 +242,6 @@ 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

common/nymcoconut/src/lib.rs

@@ -14,7 +14,6 @@ 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;

common/nymcoconut/src/scheme/aggregation.rs

@@ -50,7 +50,7 @@ where
 impl Aggregatable for PartialSignature {
     fn aggregate(sigs: &[PartialSignature], indices: Option<&[u64]>) -> Result<Signature> {
         let h = sigs
-            .first()
+            .get(0)
             .ok_or_else(|| CoconutError::Aggregation("Empty set of signatures".to_string()))?
             .sig1();
 

common/nymcoconut/src/scheme/issuance.rs

@@ -3,14 +3,12 @@
 
 use std::convert::TryFrom;
 use std::convert::TryInto;
-use std::ops::Neg;
 
-use bls12_381::{multi_miller_loop, G1Affine, G1Projective, G2Prepared, Scalar};
-use group::{Curve, Group, GroupEncoding};
+use bls12_381::{G1Affine, G1Projective, Scalar};
+use group::{Curve, 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;
@@ -320,96 +318,6 @@ 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,
@@ -446,7 +354,6 @@ pub fn sign(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::scheme::keygen::keygen;
 
     #[test]
     fn blind_sign_request_bytes_roundtrip() {
@@ -478,81 +385,4 @@ 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()
-        ),);
-    }
 }

common/nymsphinx/Cargo.toml

@@ -30,7 +30,9 @@ nym-topology = { path = "../topology" }
 
 [dev-dependencies]
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
-nym-crypto = { path = "../crypto", version = "0.4.0", features = ["asymmetric"] }
+nym-crypto = { path = "../crypto", version = "0.4.0", features = [
+    "asymmetric",
+] }
 
 # do not include this when compiling into wasm as it somehow when combined together with reqwest, it will require
 # net2 via tokio-util -> tokio -> mio -> net2
@@ -43,5 +45,13 @@ features = ["sync"]
 
 [features]
 default = ["sphinx"]
-sphinx = ["nym-crypto/sphinx", "nym-sphinx-params/sphinx", "nym-sphinx-types/sphinx"]
-outfox = ["nym-crypto/outfox", "nym-sphinx-params/outfox", "nym-sphinx-types/outfox"]
+sphinx = [
+    "nym-crypto/sphinx",
+    "nym-sphinx-params/sphinx",
+    "nym-sphinx-types/sphinx",
+]
+outfox = [
+    "nym-crypto/outfox",
+    "nym-sphinx-params/outfox",
+    "nym-sphinx-types/outfox",
+]

common/nymsphinx/framing/Cargo.toml

@@ -9,7 +9,7 @@ repository = { workspace = true }
 
 [dependencies]
 bytes = "1.0"
-tokio-util = { workspace = true, features = ["codec"] }
+tokio-util = { version = "0.7.4", features = ["codec"] }
 thiserror = { workspace = true }
 
 nym-sphinx-types = { path = "../types", features = ["sphinx", "outfox"] }

common/nymsphinx/params/src/lib.rs

@@ -17,7 +17,7 @@ pub mod packet_version;
 
 // If somebody can provide an argument why it might be reasonable to have more than 255 mix hops,
 // I will change this to [`usize`]
-pub const DEFAULT_NUM_MIX_HOPS: u8 = 3;
+pub const DEFAULT_NUM_MIX_HOPS: u8 = 0;
 
 // TODO: not entirely sure how to feel about those being defined here, ideally it'd be where [`Fragment`]
 // is defined, but that'd introduce circular dependencies as the acknowledgements crate also needs

common/nymsphinx/types/Cargo.toml

@@ -8,9 +8,11 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-sphinx-packet = { version = "0.1.0", optional = true }
+# sphinx-packet = { version = "0.1.0", optional = true }
+sphinx-packet = { git = "https://github.com/nymtech/sphinx.git", branch="feature/clone-surb", optional = true }
 nym-outfox = { path = "../../../nym-outfox", optional = true }
 thiserror = { workspace = true }
+once_cell = "1.18"
 
 [features]
 default = ["sphinx"]

common/nymsphinx/types/src/lib.rs

@@ -9,6 +9,8 @@ pub use nym_outfox::{
 // re-exporting types and constants available in sphinx
 #[cfg(feature = "outfox")]
 use nym_outfox::packet::{OutfoxPacket, OutfoxProcessedPacket};
+
+use once_cell::sync::OnceCell;
 #[cfg(feature = "sphinx")]
 pub use sphinx_packet::{
     constants::{
@@ -28,6 +30,9 @@ use sphinx_packet::{SphinxPacket, SphinxPacketBuilder};
 use std::{array::TryFromSliceError, fmt};
 use thiserror::Error;
 
+static REUSABLE_SURB: OnceCell<SURB> = OnceCell::new();
+static REUSABLE_HEADER: OnceCell<ProcessedHeader> = OnceCell::new();
+
 #[derive(Error, Debug)]
 pub enum NymPacketError {
     #[error("Sphinx error: {0}")]
@@ -77,6 +82,30 @@ impl fmt::Debug for NymPacket {
 }
 
 impl NymPacket {
+    #[cfg(feature = "sphinx")]
+    pub fn from_surb<M: AsRef<[u8]>>(
+        size: usize,
+        message: M,
+        route: &[Node],
+        destination: &Destination,
+        delays: &[Delay],
+    ) -> Result<NymPacket, NymPacketError> {
+        let (packet, _address) = if let Some(surb) = REUSABLE_SURB.get() {
+            let new_surb = surb.clone();
+            new_surb.use_surb(message.as_ref(), size)?
+        } else {
+            let surb_material =
+                SURBMaterial::new(route.to_vec(), vec![Delay::new_from_millis(0)], destination.to_owned());
+            let surb = SURB::new(EphemeralSecret::new(), surb_material)?;
+            REUSABLE_SURB
+                .set(surb.clone())
+                .expect("ReusableSURB was already set!");
+            surb.use_surb(message.as_ref(), size)?
+        };
+
+        Ok(NymPacket::Sphinx(packet))
+    }
+
     #[cfg(feature = "sphinx")]
     pub fn sphinx_build<M: AsRef<[u8]>>(
         size: usize,
@@ -85,11 +114,12 @@ impl NymPacket {
         destination: &Destination,
         delays: &[Delay],
     ) -> Result<NymPacket, NymPacketError> {
-        Ok(NymPacket::Sphinx(
-            SphinxPacketBuilder::new()
-                .with_payload_size(size)
-                .build_packet(message, route, destination, delays)?,
-        ))
+        NymPacket::from_surb(size, message, route, destination, delays)
+        // Ok(NymPacket::Sphinx(
+        //     SphinxPacketBuilder::new()
+        //         .with_payload_size(size)
+        //         .build_packet(message, route, destination, delays)?,
+        // ))
     }
     #[cfg(feature = "sphinx")]
     pub fn sphinx_from_bytes(bytes: &[u8]) -> Result<NymPacket, NymPacketError> {
@@ -149,7 +179,43 @@ impl NymPacket {
     ) -> Result<NymProcessedPacket, NymPacketError> {
         match self {
             NymPacket::Sphinx(packet) => {
-                Ok(NymProcessedPacket::Sphinx(packet.process(node_secret_key)?))
+                let unwrapped_header: ProcessedHeader = if let Some(header) = REUSABLE_HEADER.get() {
+                    header.clone()
+                } else {
+                    let header = packet.header.process(node_secret_key)?;
+                    let _ = REUSABLE_HEADER.set(header.clone());
+                    header
+                };
+
+                let processed_packet = match unwrapped_header {
+                    ProcessedHeader::ForwardHop(
+                        new_header,
+                        next_hop_address,
+                        delay,
+                        payload_key,
+                    ) => {
+                        let new_payload = packet.payload.unwrap(&payload_key)?;
+                        let new_packet = SphinxPacket {
+                            header: *new_header,
+                            payload: new_payload,
+                        };
+                        ProcessedPacket::ForwardHop(
+                            Box::new(new_packet),
+                            next_hop_address,
+                            delay,
+                        )
+                    }
+                    ProcessedHeader::FinalHop(destination, identifier, payload_key) => {
+                        let new_payload = packet.payload.unwrap(&payload_key)?;
+                        ProcessedPacket::FinalHop(
+                            destination,
+                            identifier,
+                            new_payload,
+                        )
+                    }
+                };
+
+                Ok(NymProcessedPacket::Sphinx(processed_packet))
             }
             #[cfg(feature = "outfox")]
             NymPacket::Outfox(mut packet) => {

common/socks5/proxy-helpers/Cargo.toml

@@ -8,8 +8,8 @@ edition = "2021"
 
 [dependencies]
 bytes = "1.0"
-tokio = { workspace = true, features = [ "net", "io-util", "sync", "macros", "time", "rt-multi-thread" ] }
-tokio-util = { workspace = true, features = [ "io" ] } # reason for getting this guy is to to able to port to tokio 1.X more quickly by being able to use
+tokio = { version = "1.24.1", features = [ "net", "io-util", "sync", "macros", "time", "rt-multi-thread" ] }
+tokio-util = { version = "0.7.4", features = [ "io" ] } # reason for getting this guy is to to able to port to tokio 1.X more quickly by being able to use
 # their `read_buf` [from the util crate] replacement rather than having to rethink/reimplement `AvailableReader` with the new AsyncRead trait definition.
 # In the long run, the dependency should probably get removed in favour of pure-tokio implementation, but for time being it's fine.
 futures = { workspace = true }

common/task/src/manager.rs

@@ -493,13 +493,10 @@ impl TaskClient {
 impl Drop for TaskClient {
     fn drop(&mut self) {
         if !self.mode.should_signal_on_drop() {
-            self.log(
-                Level::Trace,
-                "the task client is getting dropped (but instructed to not signal)",
-            );
+            self.log(Level::Debug, "the task client is getting dropped");
             return;
         } else {
-            self.log(Level::Debug, "the task client is getting dropped");
+            self.log(Level::Info, "the task client is getting dropped");
         }
 
         if !self.is_shutdown_poll() {

common/tun/Cargo.toml

@@ -1,24 +0,0 @@
-[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"]

common/tun/src/lib.rs

@@ -1,7 +0,0 @@
-#[cfg(target_os = "linux")]
-mod linux;
-
-pub mod tun_task_channel;
-
-#[cfg(target_os = "linux")]
-pub use linux::tun_device;

common/tun/src/linux/mod.rs

@@ -1 +0,0 @@
-pub mod tun_device;

common/tun/src/linux/tun_device.rs

@@ -1,289 +0,0 @@
-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(),
-        );
-
-        // 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()))
-                        .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),
-    }
-}

common/tun/src/tun_task_channel.rs

@@ -1,84 +0,0 @@
-#![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),
-    )
-}

common/types/src/gateway.rs

@@ -119,7 +119,6 @@ pub struct GatewayNetworkRequesterDetails {
     pub encryption_key: String,
 
     pub open_proxy: bool,
-    pub exit_policy: bool,
     pub enabled_statistics: bool,
 
     // just a convenience wrapper around all the keys
@@ -141,7 +140,6 @@ impl fmt::Display for GatewayNetworkRequesterDetails {
         writeln!(f, "\taddress: {}", self.address)?;
 
         writeln!(f, "\tuses open proxy: {}", self.open_proxy)?;
-        writeln!(f, "\tuses exit policy: {}", self.exit_policy)?;
         writeln!(f, "\tsends statistics: {}", self.enabled_statistics)?;
 
         writeln!(f, "\tallow list path: {}", self.allow_list_path)?;

common/wireguard-types/Cargo.toml

@@ -12,14 +12,9 @@ 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"] }
 
@@ -50,4 +45,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"]

common/wireguard-types/src/lib.rs

@@ -4,8 +4,6 @@
 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;
@@ -15,3 +13,5 @@ pub use registration::{
 
 #[cfg(feature = "verify")]
 pub use registration::HmacSha256;
+
+pub const WG_PORT: u16 = 51822;

common/wireguard-types/src/registration.rs

@@ -6,7 +6,6 @@ use crate::PeerPublicKey;
 use base64::{engine::general_purpose, Engine};
 use dashmap::DashMap;
 use serde::{Deserialize, Serialize};
-use std::net::IpAddr;
 use std::{fmt, ops::Deref, str::FromStr};
 
 #[cfg(feature = "verify")]
@@ -18,13 +17,11 @@ use sha2::Sha256;
 
 pub type GatewayClientRegistry = DashMap<PeerPublicKey, GatewayClient>;
 pub type PendingRegistrations = DashMap<PeerPublicKey, Nonce>;
-pub type PrivateIPs = DashMap<IpAddr, Free>;
 
 #[cfg(feature = "verify")]
 pub type HmacSha256 = Hmac<Sha256>;
 
 pub type Nonce = u64;
-pub type Free = bool;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(tag = "type", rename_all = "camelCase")]
@@ -75,9 +72,6 @@ pub struct GatewayClient {
     #[cfg_attr(feature = "openapi", schema(value_type = String, format = Byte))]
     pub pub_key: PeerPublicKey,
 
-    /// Assigned private IP
-    pub private_ip: IpAddr,
-
     /// Sha256 hmac on the data (alongside the prior nonce)
     #[cfg_attr(feature = "openapi", schema(value_type = String, format = Byte))]
     pub mac: ClientMac,
@@ -85,15 +79,11 @@ pub struct GatewayClient {
 
 impl GatewayClient {
     #[cfg(feature = "verify")]
-    pub fn new(
-        local_secret: &PrivateKey,
-        remote_public: PublicKey,
-        private_ip: IpAddr,
-        nonce: u64,
-    ) -> Self {
+    pub fn new(local_secret: &PrivateKey, remote_public: PublicKey, nonce: u64) -> Self {
         // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
         #[allow(clippy::expect_used)]
-        let static_secret = boringtun::x25519::StaticSecret::from(local_secret.to_bytes());
+        let static_secret = boringtun::x25519::StaticSecret::try_from(local_secret.to_bytes())
+            .expect("conversion between x25519 private keys is infallible");
         let local_public: boringtun::x25519::PublicKey = (&static_secret).into();
 
         let remote_public = boringtun::x25519::PublicKey::from(remote_public.to_bytes());
@@ -106,12 +96,10 @@ impl GatewayClient {
             .expect("x25519 shared secret is always 32 bytes long");
 
         mac.update(local_public.as_bytes());
-        mac.update(private_ip.to_string().as_bytes());
         mac.update(&nonce.to_le_bytes());
 
         GatewayClient {
             pub_key: PeerPublicKey::new(local_public),
-            private_ip,
             mac: ClientMac(mac.finalize().into_bytes().to_vec()),
         }
     }
@@ -122,7 +110,8 @@ 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::from(gateway_key.to_bytes());
+        let static_secret = boringtun::x25519::StaticSecret::try_from(gateway_key.to_bytes())
+            .expect("conversion between x25519 private keys is infallible");
 
         let dh = static_secret.diffie_hellman(&self.pub_key);
 
@@ -132,7 +121,6 @@ impl GatewayClient {
             .expect("x25519 shared secret is always 32 bytes long");
 
         mac.update(self.pub_key.as_bytes());
-        mac.update(self.private_ip.to_string().as_bytes());
         mac.update(&nonce.to_le_bytes());
 
         mac.verify_slice(&self.mac)
@@ -221,7 +209,6 @@ mod tests {
         let client = GatewayClient::new(
             client_key_pair.private_key(),
             *gateway_key_pair.public_key(),
-            "10.0.0.42".parse().unwrap(),
             nonce,
         );
         assert!(client.verify(gateway_key_pair.private_key(), nonce).is_ok())

common/wireguard-types/src/tun_common/mod.rs

@@ -1,3 +0,0 @@
-pub mod active_peers;
-pub mod event;
-pub mod network_table;

common/wireguard/Cargo.toml

@@ -13,7 +13,6 @@ 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.
@@ -26,11 +25,8 @@ 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

common/wireguard/src/active_peers.rs

@@ -1,4 +1,4 @@
-use std::{net::SocketAddr, time::Duration};
+use std::net::SocketAddr;
 
 use boringtun::x25519;
 use dashmap::{
@@ -7,47 +7,26 @@ use dashmap::{
 };
 use tokio::sync::mpsc::{self};
 
-use crate::tun_common::{event::Event, network_table::NetworkTable};
-
-// Registered peers
-pub type PeersByIp = NetworkTable<PeerEventSender>;
+use crate::event::Event;
 
 // Channels that are used to communicate with the various tunnels
 #[derive(Clone)]
 pub struct PeerEventSender(mpsc::Sender<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>,
-    },
-}
+pub(crate) struct PeerEventReceiver(mpsc::Receiver<Event>);
 
 impl PeerEventSender {
-    pub async fn send(&self, event: Event) -> Result<(), PeerEventSenderError> {
-        Ok(self
-            .0
-            .send_timeout(event, Duration::from_millis(1000))
-            .await?)
+    pub(crate) async fn send(&self, event: Event) -> Result<(), mpsc::error::SendError<Event>> {
+        self.0.send(event).await
     }
 }
 
 impl PeerEventReceiver {
-    pub async fn recv(&mut self) -> Option<Event> {
+    pub(crate) async fn recv(&mut self) -> Option<Event> {
         self.0.recv().await
     }
 }
 
-pub fn peer_event_channel() -> (PeerEventSender, PeerEventReceiver) {
+pub(crate) fn peer_event_channel() -> (PeerEventSender, PeerEventReceiver) {
     let (tx, rx) = mpsc::channel(16);
     (PeerEventSender(tx), PeerEventReceiver(rx))
 }
@@ -56,20 +35,20 @@ pub(crate) type PeersByKey = DashMap<x25519::PublicKey, PeerEventSender>;
 pub(crate) type PeersByAddr = DashMap<SocketAddr, PeerEventSender>;
 
 #[derive(Default)]
-pub struct ActivePeers {
+pub(crate) struct ActivePeers {
     active_peers: PeersByKey,
     active_peers_by_addr: PeersByAddr,
 }
 
 impl ActivePeers {
-    pub fn remove(&self, public_key: &x25519::PublicKey) {
+    pub(crate) fn remove(&self, public_key: &x25519::PublicKey) {
         log::info!("Removing peer: {public_key:?}");
         self.active_peers.remove(public_key);
         log::warn!("TODO: remove from peers_by_ip?");
         log::warn!("TODO: remove from peers_by_addr");
     }
 
-    pub fn insert(
+    pub(crate) fn insert(
         &self,
         public_key: x25519::PublicKey,
         addr: SocketAddr,
@@ -79,14 +58,17 @@ impl ActivePeers {
         self.active_peers_by_addr.insert(addr, peer_tx);
     }
 
-    pub fn get_by_key_mut(
+    pub(crate) fn get_by_key_mut(
         &self,
         public_key: &x25519::PublicKey,
     ) -> Option<RefMut<'_, x25519::PublicKey, PeerEventSender>> {
         self.active_peers.get_mut(public_key)
     }
 
-    pub fn get_by_addr(&self, addr: &SocketAddr) -> Option<Ref<'_, SocketAddr, PeerEventSender>> {
+    pub(crate) fn get_by_addr(
+        &self,
+        addr: &SocketAddr,
+    ) -> Option<Ref<'_, SocketAddr, PeerEventSender>> {
         self.active_peers_by_addr.get(addr)
     }
 }

common/wireguard/src/lib.rs

@@ -3,10 +3,15 @@
 // #![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;
-pub mod setup;
+mod setup;
+mod tun_task_channel;
 mod udp_listener;
 mod wg_tunnel;
 
@@ -15,9 +20,7 @@ use std::sync::Arc;
 
 // Currently the module related to setting up the virtual network device is platform specific.
 #[cfg(target_os = "linux")]
-use nym_tun::tun_device;
-
-use nym_tun::tun_task_channel;
+use platform::linux::tun_device;
 
 /// Start wireguard UDP listener and TUN device
 ///
@@ -29,31 +32,16 @@ pub async fn start_wireguard(
     task_client: nym_task::TaskClient,
     gateway_client_registry: Arc<GatewayClientRegistry>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
-    // TODO: make this configurable
+    // We can either index peers by their IP like standard wireguard
+    let peers_by_ip = Arc::new(tokio::sync::Mutex::new(network_table::NetworkTable::new()));
 
-    // 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.
-
-    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());
-    // Alternative 2:
-    //let routing_mode = tun_device::RoutingMode::new_nat();
+    // ... or by their tunnel tag, which is a random number assigned to them
+    let peers_by_tag = Arc::new(tokio::sync::Mutex::new(wg_tunnel::PeersByTag::new()));
 
     // Start the tun device that is used to relay traffic outbound
-    let config = tun_device::TunDeviceConfig {
-        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);
+    let (tun, tun_task_tx, tun_task_response_rx) = tun_device::TunDevice::new(peers_by_ip.clone());
     tun.start();
 
-    // We also index peers by a tag
-    let peers_by_tag = Arc::new(tokio::sync::Mutex::new(wg_tunnel::PeersByTag::new()));
-
     // If we want to have the tun device on a separate host, it's the tun_task and
     // tun_task_response channels that needs to be sent over the network to the host where the tun
     // device is running.

common/wireguard/src/network_table.rs

@@ -9,7 +9,7 @@ pub struct NetworkTable<T> {
 }
 
 impl<T> NetworkTable<T> {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self {
             ips: IpNetworkTable::new(),
         }

common/wireguard/src/packet_relayer.rs

@@ -3,9 +3,11 @@ use std::{collections::HashMap, sync::Arc};
 use tap::TapFallible;
 use tokio::sync::mpsc::{self};
 
-use crate::tun_task_channel::{TunTaskResponseRx, TunTaskTx};
-
-use nym_wireguard_types::tun_common::{active_peers::PeerEventSender, event::Event};
+use crate::{
+    active_peers::PeerEventSender,
+    event::Event,
+    tun_task_channel::{TunTaskResponseRx, TunTaskTx},
+};
 
 #[derive(Clone)]
 pub struct PacketRelaySender(pub(crate) mpsc::Sender<(u64, Vec<u8>)>);

common/wireguard/src/platform/linux/mod.rs

@@ -0,0 +1 @@
+pub(crate) mod tun_device;

common/wireguard/src/platform/linux/tun_device.rs

@@ -0,0 +1,192 @@
+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,
+    setup::{TUN_BASE_NAME, TUN_DEVICE_ADDRESS, TUN_DEVICE_NETMASK},
+    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}");
+    tokio_tun::Tun::builder()
+        .name(name)
+        .tap(false)
+        .packet_info(false)
+        .mtu(1350)
+        .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,
+
+    // The routing table, as how wireguard does it
+    peers_by_ip: Arc<tokio::sync::Mutex<PeersByIp>>,
+
+    // This is an alternative to the routing table, where we just match outgoing source IP with
+    // incoming destination IP.
+    nat_table: HashMap<IpAddr, u64>,
+}
+
+impl TunDevice {
+    pub fn new(
+        peers_by_ip: Arc<tokio::sync::Mutex<PeersByIp>>,
+    ) -> (Self, TunTaskTx, TunTaskResponseRx) {
+        let tun = setup_tokio_tun_device(
+            format!("{TUN_BASE_NAME}%d").as_str(),
+            TUN_DEVICE_ADDRESS.parse().unwrap(),
+            TUN_DEVICE_NETMASK.parse().unwrap(),
+        );
+        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,
+            peers_by_ip,
+            nat_table: HashMap::new(),
+        };
+
+        (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
+        self.nat_table.insert(src_addr, tag);
+
+        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.
+
+        // This is how wireguard does it, by consulting the AllowedIPs table.
+        if false {
+            let peers = self.peers_by_ip.lock().await;
+            if let Some(peer_tx) = peers.longest_match(dst_addr).map(|(_, tx)| tx) {
+                log::info!("Forward packet to wg tunnel");
+                peer_tx
+                    .send(Event::Ip(packet.to_vec().into()))
+                    .await
+                    .tap_err(|err| log::error!("{err}"))
+                    .ok();
+                return;
+            }
+        }
+
+        // But we do it by consulting the NAT table.
+        {
+            if let Some(tag) = self.nat_table.get(&dst_addr) {
+                log::info!("Forward packet to wg tunnel with tag: {tag}");
+                self.tun_task_response_tx
+                    .send((*tag, packet.to_vec()))
+                    .await
+                    .tap_err(|err| log::error!("{err}"))
+                    .ok();
+                return;
+            }
+        }
+
+        log::info!("No peer found, packet dropped");
+    }
+
+    pub async fn run(mut self) {
+        let mut buf = [0u8; 1024];
+
+        loop {
+            tokio::select! {
+                // Reading from the TUN device
+                len = self.tun.read(&mut buf) => match len {
+                    Ok(len) => {
+                        let packet = &buf[..len];
+                        self.handle_tun_read(packet).await;
+                    },
+                    Err(err) => {
+                        log::info!("iface: read error: {err}");
+                        break;
+                    }
+                },
+                // Writing to the TUN device
+                Some(data) = self.tun_task_rx.recv() => {
+                    self.handle_tun_write(data).await;
+                }
+            }
+        }
+        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(),
+    })
+}

common/wireguard/src/platform/mod.rs

@@ -0,0 +1,2 @@
+#[cfg(target_os = "linux")]
+pub(crate) mod linux;

common/wireguard/src/setup.rs

@@ -7,13 +7,22 @@ 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 = "nymtun";
+pub const TUN_DEVICE_ADDRESS: &str = "10.0.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=";
 
+// The public keys of the registered peer (clients)
+// Corresponding private key: "ILeN6gEh6vJ3Ju8RJ3HVswz+sPgkcKtAYTqzQRhTtlo="
+const PEER: &str = "NCIhkgiqxFx1ckKl3Zuh595DzIFl8mxju1Vg995EZhI=";
+
 // The AllowedIPs for the connected peer, which is one a single IP and the same as the IP that the
 // peer has configured on their side.
-const ALLOWED_IPS: &str = "10.1.0.2";
+const ALLOWED_IPS: &str = "10.0.0.2";
 
 fn decode_base64_key(base64_key: &str) -> [u8; 32] {
     general_purpose::STANDARD
@@ -26,7 +35,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::from(static_private_bytes);
+    let static_private = x25519::StaticSecret::try_from(static_private_bytes).unwrap();
     let static_public = x25519::PublicKey::from(&static_private);
     info!(
         "wg public key: {}",
@@ -37,12 +46,8 @@ pub fn server_static_private_key() -> x25519::StaticSecret {
 
 pub fn peer_static_public_key() -> x25519::PublicKey {
     // A single static public key is used during development
-
-    // Read from NYM_PEER_PUBLIC_KEY env variable
-    let peer = std::env::var("NYM_PEER_PUBLIC_KEY").expect("NYM_PEER_PUBLIC_KEY must be set");
-
-    let peer_static_public_bytes: [u8; 32] = decode_base64_key(&peer);
-    let peer_static_public = x25519::PublicKey::from(peer_static_public_bytes);
+    let peer_static_public_bytes: [u8; 32] = decode_base64_key(PEER);
+    let peer_static_public = x25519::PublicKey::try_from(peer_static_public_bytes).unwrap();
     info!(
         "Adding wg peer public key: {}",
         general_purpose::STANDARD.encode(peer_static_public)

common/wireguard/src/tun_task_channel.rs

@@ -0,0 +1,54 @@
+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(crate) 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(crate) 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),
+    )
+}

common/wireguard/src/udp_listener.rs

@@ -6,21 +6,16 @@ use boringtun::{
 };
 use futures::StreamExt;
 use log::error;
-use nym_network_defaults::WG_PORT;
 use nym_task::TaskClient;
-use nym_wireguard_types::{
-    registration::GatewayClientRegistry,
-    tun_common::{
-        active_peers::{ActivePeers, PeersByIp},
-        event::Event,
-    },
-    PeerPublicKey,
-};
+use nym_wireguard_types::{registration::GatewayClientRegistry, PeerPublicKey, WG_PORT};
 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},
@@ -29,6 +24,9 @@ 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;

common/wireguard/src/wg_tunnel.rs

@@ -7,16 +7,18 @@ 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::{error::WgError, packet_relayer::PacketRelaySender, registered_peers::PeerIdx};
+use crate::{
+    active_peers::{peer_event_channel, PeerEventReceiver, PeerEventSender},
+    error::WgError,
+    event::Event,
+    network_table::NetworkTable,
+    packet_relayer::PacketRelaySender,
+    registered_peers::PeerIdx,
+};
 
 const HANDSHAKE_MAX_RATE: u64 = 10;
 

documentation/README.md

@@ -9,15 +9,5 @@ Each directory contains a readme with more information about running and contrib
 ## Scripts 
 * `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.

documentation/dev-portal/.gitignore

@@ -19,6 +19,4 @@ theme/
 theme
 theme/*
 
-.idea
-
-notes
+.idea

documentation/dev-portal/src/SUMMARY.md

@@ -18,23 +18,14 @@
 
 # User Manuals
 
-- [NymConnect X Monero](tutorials/monero.md)
-- [NymConnect X Matrix](tutorials/matrix.md)
-- [NymConnect X Telegram](tutorials/telegram.md)
-- [NymConnect X Electrum](tutorials/electrum.md)
-- [NymConnect X Firo wallet](tutorials/firo.md)
-
-# Code Examples 
-
-- [Custom Service Providers](examples/custom-services.md)
-- [Apps Using Network Requesters](examples/using-nrs.md)
-- [Browser only](examples/browser-only.md)
-- [Monorepo examples](examples/monorepo-examples.md)
+- [NymConnect Monero](tutorials/monero.md)
+- [NymConnect Matrix](tutorials/matrix.md)
+- [NymConnect Telegram](tutorials/telegram.md)
 
 # Integrations
 
 - [Integration Options](integrations/integration-options.md)
-[//]: # (- [Mixnet Integration](integrations/mixnet-integration.md))
+- [Mixnet Integration](integrations/mixnet-integration.md)
 - [Payment Integration](integrations/payment-integration.md)
 
 # Tutorials
@@ -49,21 +40,15 @@
 		- [Preparing Your Service](tutorials/cosmos-service/service.md)
 		- [Preparing Your Service pt2](tutorials/cosmos-service/service-src.md)
 		- [Querying the Chain](tutorials/cosmos-service/querying.md)
-   
 - [Typescript](tutorials/typescript.md)
-    - [[DEPRECATED] Simple Service Provider](tutorials/simple-service-provider/simple-service-provider.md) 
-      	- [Tutorial Overview](tutorials/simple-service-provider/overview.md)
-      	- [Preparing Your User Client Environment](tutorials/simple-service-provider/preparating-env.md)
-      	- [Building Your User Client](tutorials/simple-service-provider/user-client.md)
-      	- [Preparing Your Service Provider Environment](tutorials/simple-service-provider/preparating-env2.md)
-      	- [Building Your Service Provider](tutorials/simple-service-provider/service-provider.md)
-      	- [Sending a Message Through the Mixnet](tutorials/simple-service-provider/sending-message.md)
+	- [Simple Service Provider](tutorials/simple-service-provider/simple-service-provider.md)
+		- [Tutorial Overview](tutorials/simple-service-provider/overview.md)
+		- [Preparing Your User Client Environment](tutorials/simple-service-provider/preparating-env.md)
+		- [Building Your User Client](tutorials/simple-service-provider/user-client.md)
+		- [Preparing Your Service Provider Environment](tutorials/simple-service-provider/preparating-env2.md)
+		- [Building Your Service Provider](tutorials/simple-service-provider/service-provider.md)
+		- [Sending a Message Through the Mixnet](tutorials/simple-service-provider/sending-message.md)
 
-# Shipyard Builders Hackathon 2023 
-- [General Info & Resources](shipyard/general.md)
-- [Hackathon Challenges](shipyard/challenges-overview.md)
-- [A Note on Infrastructure](shipyard/infra.md)
-- [Submission Guidelines](shipyard/guidelines.md)
 
 # Events
 

documentation/dev-portal/src/community-resources/community-applications-and-guides.md

@@ -1,6 +1,8 @@
 # Community Applications
 
-If you would like to share your application here, please submit a pull request to the `main` branch of the `nymtech/dev-portal` [repository](https://github.com/nymtech/dev-portal).
+We love seeing our developer community create applications using Nym. If you would like to share your application with the community, please submit a pull request to the `main` branch of the `nymtech/dev-portal` [repository](https://github.com/nymtech/dev-portal).
+
+
 
 ## <img src='../images/profile_picture/pastenym_ntv_pp.png' style="float: right; width: 75px; height: 75px;">Pastenym
 

documentation/dev-portal/src/examples/browser-only.md

@@ -1,10 +0,0 @@
-# Browser only
-With the Typescript SDK you can run a Nym client in a webworker - meaning you can connect to the mixnet through the browser without having to worry about any other code than your web framework. 
-
-- [NoTrustVerify](https://notrustverify.ch/) have set up an example application using [`mixFetch`](https://sdk.nymtech.net/examples/mix-fetch) to fetch crypto prices from CoinGecko over the mixnet. 
-  - [Website](https://notrustverify.github.io/mixfetch-examples/) 
-  - [Codebase](https://github.com/notrustverify/mixfetch-examples)  
-
-- There is a coconut-scheme based Credential Library playground [here](https://coco-demo.nymtech.net/). This is a WASM implementation of our Coconut libraries which generate raw Coconut credentials. Test it to create and re-randomize your own credentials. For more information on what is happening here check out the [Coconut docs](https://nymtech.net/docs/coconut.html).
-
-- You can find a browser-based 'hello world' chat app [here](https://chat-demo.nymtech.net). Either open in two browser windows and send messages to yourself, or share with a friend and send messages to each other through the mixnet.

documentation/dev-portal/src/examples/custom-services.md

@@ -1,16 +0,0 @@
-# Custom Services 
-Custom services involve two pieces of code that communicate via the mixnet: a client, and a custom server/service. This custom service will most likely interact with the wider internet / a clearnet service on your behalf, with the mixnet between you and the service, acting as a privacy shield. 
-
-- PasteNym is a private pastebin alternative. It involves a browser-based frontend utilising the Typescript SDK and a Python-based backend service communicating with a standalone Nym Websocket Client. **If you're a Python developer, start here!**.
-  - [Frontend codebase](https://github.com/notrustverify/pastenym)
-  - [Backend codebase](https://github.com/notrustverify/pastenym-frontend) 
-  
-- Nostr-Nym is another application written by [NoTrustVerify](https://notrustverify.ch/), standing between mixnet users and a Nostr server in order to protect their metadata from being revealed when gossiping. **Useful for Go and Python developers**.  
-  - [Codebase](https://github.com/notrustverify/nostr-nym)
-  
-- Spook and Nym-Ethtx are both examples of Ethereum transaction broadcasters utilising the mixnet, written in Rust. Since they were written before the release of the Rust SDK, they utilise standalone clients to communicate with the mixnet. 
-  - [Spook](https://github.com/EdenBlockVC/spook) (**Typescript**)
-  - [Nym-Ethtx](https://github.com/noot/nym-ethtx) (**Rust**)
-  
-- NymDrive is an early proof of concept application for privacy-enhanced file storage on IPFS. **JS and CSS**, and a good example of packaging as an Electrum app.  
-  - [Codebase](https://github.com/saleel/nymdrive)

documentation/dev-portal/src/examples/monorepo-examples.md

@@ -1,5 +0,0 @@
-# Monorepo examples
-As well as these examples, there are a bunch of examples for each SDK in the Nym monorepo. 
-
-- [Rust SDK examples](https://github.com/nymtech/nym/tree/develop/sdk/rust/nym-sdk/examples)
-- [Typescript SDK examples](https://github.com/nymtech/nym/tree/develop/sdk/typescript/examples)

documentation/dev-portal/src/examples/using-nrs.md

@@ -1,17 +0,0 @@
-# Apps Using Network Requesters
-These applications utilise custom app logic in the user-facing apps in order to communicate using the mixnet as a transport layer, without having to rely on custom server-side logic. Instead, they utilise existing Nym infrastructure - [Network Requesters](https://nymtech.net/operators/nodes/network-requester-setup.html) - with a custom whitelist addition. 
-
-If you are sending 'normal' application traffic, and/or don't require and custom logic to be happening on the 'other side' of the mixnet, this is most likely the best option to take as a developer who wishes to privacy-enhance their application. 
-
-> Nym will soon be switching from a whitelist-based approach to a blocklist-based approach to filtering traffic. As such, it will soon be even easier for developers to utilise the mixnet, as they will not have to run their own NRs or have to add their domains to the whitelist 
- 
-- DarkFi over Nym leverages Nym’s mixnet as a pluggable transport for DarkIRC, their p2p IRC variant. Users can anonymously connect to peers over the network, ensuring secure and private communication within the DarkFi ecosystem. Written in **Rust**.
-  - [Docs](https://darkrenaissance.github.io/darkfi/clients/nym_outbound.html?highlight=nym#3--run)
-  - [Github](https://github.com/darkrenaissance/darkfi/tree/master/doc) 
-
-- MiniBolt is a complete guide to building a Bitcoin & Lightning full node on a personal computer. It has the capacity to run network traffic (transactions and syncing) over the mixnet, so you can privately sync your node and not expose your home IP to the wider world when interacting with the rest of the network! 
-  - [Docs](https://v2.minibolt.info/bonus-guides/system/nym-mixnet#proxying-bitcoin-core)
-  - [Codebase](https://github.com/minibolt-guide/minibolt)
-
-- Email over Nym is a set of configuration options to set up a Network Requester to send and recieve emails over Nym, using something like Thunderbird. 
-  - [Codebase](https://github.com/dial0ut/nymstr-email)

documentation/dev-portal/src/infrastructure/node-types.md

@@ -4,11 +4,43 @@ Discover the workings of Nym's privacy-enhancing mixnet infrastructure through t
 
 <iframe width="700" height="400" src="https://www.youtube.com/embed/rnPpEsJS4FM" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
 
+### Mixnet Infrastructure
+
+There are few types of Nym infrastructure nodes:
+
+#### Mix Nodes
+Mix nodes play a critical role in the Nym network by providing enhanced security and privacy to network content and metadata. They are part of the three-layer mixnet that ensures that communication remains anonymous and untraceable. Mix nodes receive `NYM` tokens as compensation for their quality of service, which is measured by the network validators.
+
+Mix nodes anonymously relay encrypted Sphinx packets between each other, adding an extra layer of protection by reordering and delaying the packets before forwarding them to the intended recipient. Additionally, cover traffic is maintained through mix nodes sending Sphinx packets to other mix nodes, making it appear as if there is a constant flow of user messages and further protecting the privacy of legitimate data packets.
+
+With the ability to hide, reorder and add a delay to network traffic, mix nodes make it difficult for attackers to perform time-based correlation attacks and deanonymize users. By consistently delivering high-quality service, mix nodes are rewarded with NYM tokens, reinforcing the integrity of the Nym network.
+
+#### Gateways
+Gateways serve as the point of entry for user data into the mixnet, verifying that users have acquired sufficient NYM-based bandwidth credentials before allowing encrypted packets to be forwarded to mixnodes. They are also responsible for safeguarding against denial of service attacks and act as a message storage for users who may go offline.
+
+Gateways receive bandwidth credentials from users, which are periodically redeemed for `NYM` tokens as payment for their services. Users have the flexibility to choose a single gateway, split traffic across multiple gateways, run their own gateways, or a combination of these options.
+
+In addition, gateways also cache messages, functioning as an inbox for users who are offline. By providing secure, reliable access to the mixnet and ensuring that data remains protected, gateways play a crucial role in maintaining the integrity of the Nym network.
+
+#### Validators
+Validators are essential to the security and integrity of the Nym network, tasked with several key responsibilities. They utilize proof-of-stake Sybil defense measures to secure the network and determine which nodes are included within it. Through their collaborative efforts, validators create Coconut threshold credentials which provide anonymous access to network data and resources.
+
+Validators also play a critical role in maintaining the Nym Cosmos blockchain, a secure, public ledger that records network-wide information such as node public information and keys, network configuration parameters, CosmWasm smart contracts, and `NYM` and credential transactions.
+
+#### Service Providers
+Service Providers are a crucial aspect of the Nym infrastructure that support the application layer of the Nym network. Any application built with Nym will require a Service Provider, which can be created by anyone. Service Providers run a piece of binary code that enables them to handle requests from Nym users or other services, and then make requests to external servers on behalf of the users.
+
+For example, a Service Provider could receive a request to check a mail server and then forward the response to the user. The presence of Service Providers in the Nym network enhances its security and privacy, making it a reliable and robust platform for anonymous communication and data exchange.
+
 ### Where do I go from here? 💭
 
-For more in-depth information on the network architecture, head to the [Network Overview page](https://nymtech.net/docs/architecture/network-overview.html), and check out the [Operators book](https://nymtech.net/operators) if you want to run a node yourself. 
+Maybe you would like to concentrate on building a application that uses the mixnet:
 
-If you would like to concentrate on building an application that uses the mixnet:
-* Explore the [Quickstart](../quickstart/overview.md) options.
-* Check out examples of [Community Apps](../community-resources/community-applications-and-guides.md). 
-* Run through the [Rust SDK](../tutorials/rust-sdk.md) or [Typescript](../tutorials/typescript.md) tutorials. 
+* Explore the Tutorials section of the Developer Portal. Our in-depth tutorial on [Building a Simple Service Provider](../tutorials/simple-service-provider/simple-service-provider.md) give a good understanding of building User Clients and Service Providers in TypeScript, and how to configure Nym Websocket Clients for seamless communication with the mixnet.
+
+* Get started with using the Nym Mixnet quickly and easily by exploring the [Quickstart](../quickstart/overview.md) options, such a NymConnect, proxying traffic through the Nym Socks5 client, or dive into integrating Nym into your existing application with the [Integrations](../integrations/integration-options.md) section.
+
+Or perhaps you a developer that would like to run a infrastructure node such as a Gateway, Mix node or Network Requestor:
+* Check out the [Network Overview](https://nymtech.net/docs/architecture/network-overview.html) docs page.
+
+* Take a look at our [Node Setup Guide](https://nymtech.net/operators/nodes/setup-guides.html) with our Nym Docs, containing setup guides for setting up you own infrastructure node.

documentation/dev-portal/src/integrations/integration-options.md

@@ -1,14 +1,10 @@
 # Integration Options
-If you've already gone through the different [Quick Start](../quickstart/overview.md) options and had a look at the tutorials, you have seen the possibilities available to you for quickly connecting existing application code to another Nym process. 
+If you've already gone through the different [Quick Start](../quickstart/overview.md) options, you have seen the possibilities avaliable to you for quickly connecting existing application code to another Nym process. 
 
-Below are a resources that will be useful for either beginning to integrate mixnet functionality into existing application code or build a new app using Nym.  
+This section assumes you wish to integrate with Nym into your application code. 
 
-- **We suggest you begin with this [integration decision tree](https://sdk.nymtech.net/integrations)**. This will give you a better idea of what pieces of software (SDKs, standalone clients, service providers) your integration might involve, and what is currently possible to do with as little custom code as possible. 
-
-- The [integrations FAQ](../faq/integrations-faq.md) has a list of common questions regarding integrating with Nym and Nyx, as well as commonly required links. 
-
-- To get an idea of what is possible / has already been built, check the [community applications and resources](../community-resources/community-applications-and-guides.md) page, as well as the [developer tutorials codebase](https://github.com/nymtech/developer-tutorials). 
-
-> If you wish to integrate with the Nyx blockchain to use `NYM` for payments, start with the [payment integration](./payment-integration.md) page.
+The [integrations FAQ](../faq/integrations-faq.md) has a list of common questions regarding integrating with Nym and Nyx, as well as commonly required links. _This is a good place to start to get an overall idea of the tools and software avaliable to you_. 
 
+If you wish to integrate with Nym to use the mixnet for application traffic, start with the [mixnet integration](./mixnet-integration.md) page. 
 
+If you wish to integrate with the Nyx blockchain to use `NYM` for payments, start with the [payment integration](./payment-integration.md) page. 

documentation/dev-portal/src/integrations/mixnet-integration.md

@@ -13,7 +13,7 @@ As outlined in the [clients overview documentation](https://nymtech.net/docs/cli
 #### Websocket client
 Your first option is the native websocket client. This is a compiled program that can run on Linux, Mac OS X, and Windows machines. It runs as a persistent process on a desktop or server machine. You can connect to it with any language that supports websockets.
 
-[//]: # (You can see an example of how to connect to and manage interactions with this client in the [Simple Service Provider tutorial](../tutorials/simple-service-provider/simple-service-provider.md).)
+You can see an example of how to connect to and manage interactions with this client in the [Simple Service Provider tutorial](../tutorials/simple-service-provider/simple-service-provider.md).
 
 #### Webassembly client
 If you’re working in JavaScript or Typescript in the browser, or building an edge computing app, you’ll likely want to choose the webassembly client.

documentation/dev-portal/src/licensing.md

@@ -1,10 +1,5 @@
 # Licensing
 
-Components that make up Nym as a system are licensed individually, so for accurate information, please check individual files.
+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
-
-Again, 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.