Dummy WG implementation - cleaned up

Each packet to its own thread
Tun arc and mutex
2023-08-30 12:47:48 +02:00 · 2023-07-25 17:18:06 +02:00 · 2023-07-25 16:46:24 +02:00 · 2023-06-27 11:45:25 +02:00 · 2023-06-26 12:08:41 +02:00 · 2023-06-26 11:59:59 +02:00
65 changed files with 2048 additions and 403 deletions
@@ -68,8 +68,10 @@ jobs:
        working-directory: nym-connect/native/android
        env:
          ANDROID_SDK_ROOT: ${{ env.ANDROID_HOME }}
+          SENTRY_AUTH_TOKEN: ${{ secrets.NYMS5_ANDROID_SENTRY_AUTH_TOKEN }}
        # build for arm64 and x86_64
        run: |
+          echo "auth.token=$SENTRY_AUTH_TOKEN" | tee -a sentry.properties
          ./gradlew :app:assembleArch64Debug
          ./gradlew :app:assembleArch64Release

@@ -107,4 +109,3 @@ jobs:
          files: |
            apk/nyms5-arch64-debug.apk
            apk/nyms5-arch64-release.apk
-
@@ -43,4 +43,5 @@ envs/qwerty.env
 .parcel-cache
 **/.DS_Store
 cpu-cycles/libcpucycles/build
-foxyfox.env
+foxyfox.env
+gateway/deploy.sh
@@ -4,9 +4,24 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

+## [v1.1.22] (2023-06-20)
+
+- CLI tool for querying network-requesters ([#3539])
+- Statically link OpenSSL ([#3510])
+- NymConnect - add sentry.io reporting ([#3421])
+- init command does not change version number in config.toml ([#3336])
+- [Bug] Config version does not correspond to binary version ([#3434])
+
+[#3539]: https://github.com/nymtech/nym/issues/3539
+[#3510]: https://github.com/nymtech/nym/issues/3510
+[#3421]: https://github.com/nymtech/nym/issues/3421
+[#3336]: https://github.com/nymtech/nym/issues/3336
+[#3434]: https://github.com/nymtech/nym/issues/3434
+
 ## [v1.1.21] (2023-06-13)

- mixFetch: Change socks5 `SendRequest` to include OrderedMessage index as a field rather than making it serialized inside the `data` field
+- mixFetch: Change socks5 `SendRequest` to include OrderedMessage index as a field rather than making it serialized inside the `data` field
+ ([#3534])
 - Explorer - add more data columns to the Service Provider section: ([#3474])
 - network-requester: support report if they run an open proxy using `ControlRequest` API ([#3461])
 - Refactor client configs (London discussion) ([#3444])
@@ -113,8 +113,8 @@ edition = "2021"
 license = "Apache-2.0"

 [workspace.dependencies]
-async-trait = "0.1.64"
 anyhow = "1.0.71"
+async-trait = "0.1.64"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
 cfg-if = "1.0.0"
 cosmwasm-derive = "=1.0.0"
@@ -130,6 +130,7 @@ cw3-fixed-multisig = { version = "=0.13.4" }
 cw4 = { version = "=0.13.4" }
 dotenvy = "0.15.6"
 generic-array = "0.14.7"
+getrandom = "0.2.10"
 lazy_static = "1.4.0"
 log = "0.4"
 once_cell = "1.7.2"
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.21"
+version = "1.1.22"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -75,7 +75,7 @@ impl NymConfigTemplate for Config {
 impl Config {
    pub fn new<S: AsRef<str>>(id: S) -> Self {
        Config {
-            base: BaseClientConfig::new(id.as_ref()),
+            base: BaseClientConfig::new(id.as_ref(), env!("CARGO_PKG_VERSION")),
            storage_paths: ClientPaths::new_default(default_data_directory(id.as_ref())),
            logging: Default::default(),
            socket: Default::default(),
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.21"
+version = "1.1.22"
 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"
@@ -70,7 +70,11 @@ impl NymConfigTemplate for Config {
 impl Config {
    pub fn new<S: AsRef<str>>(id: S, provider_mix_address: S) -> Self {
        Config {
-            core: CoreConfig::new(id.as_ref(), provider_mix_address.as_ref()),
+            core: CoreConfig::new(
+                id.as_ref(),
+                env!("CARGO_PKG_VERSION"),
+                provider_mix_address.as_ref(),
+            ),
            storage_paths: SocksClientPaths::new_default(default_data_directory(id.as_ref())),
            logging: Default::default(),
        }
@@ -62,7 +62,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
 dependencies = [
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "once_cell",
 "version_check",
 ]
@@ -622,7 +622,7 @@ dependencies = [
 "cosmos-sdk-proto",
 "ecdsa",
 "eyre",
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "k256",
 "prost",
 "prost-types",
@@ -1442,9 +1442,9 @@ dependencies = [

 [[package]]
 name = "getrandom"
-version = "0.2.9"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85e1d9ab2eadba7e5040d4e09cbd6d072b76a557ad64e797c2cb9d4da21d7e4"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
 "cfg-if 1.0.0",
 "js-sys",
@@ -2240,7 +2240,7 @@ dependencies = [

 [[package]]
 name = "nym-bin-common"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
 "atty",
 "clap",
@@ -2255,7 +2255,7 @@ dependencies = [

 [[package]]
 name = "nym-client-core"
-version = "1.1.14"
+version = "1.1.15"
 dependencies = [
 "async-trait",
 "base64 0.21.2",
@@ -2300,7 +2300,7 @@ dependencies = [

 [[package]]
 name = "nym-client-wasm"
-version = "1.1.0"
+version = "1.1.1"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -2345,7 +2345,7 @@ dependencies = [
 "bs58",
 "digest 0.9.0",
 "ff 0.11.1",
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "group 0.11.0",
 "itertools",
 "nym-dkg",
@@ -2489,7 +2489,7 @@ name = "nym-gateway-client"
 version = "0.1.0"
 dependencies = [
 "futures",
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "log",
 "nym-bandwidth-controller",
 "nym-coconut-interface",
@@ -2636,7 +2636,7 @@ dependencies = [
 "chacha20",
 "chacha20poly1305",
 "curve25519-dalek",
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "log",
 "rand 0.7.3",
 "rayon",
@@ -2697,6 +2697,7 @@ dependencies = [
 "nym-pemstore",
 "nym-sphinx-addressing",
 "nym-sphinx-params",
+ "nym-sphinx-routing",
 "nym-sphinx-types",
 "nym-topology",
 "rand 0.7.3",
@@ -2723,6 +2724,7 @@ dependencies = [
 "nym-crypto",
 "nym-sphinx-addressing",
 "nym-sphinx-params",
+ "nym-sphinx-routing",
 "nym-sphinx-types",
 "nym-topology",
 "rand 0.7.3",
@@ -2753,6 +2755,7 @@ dependencies = [
 "nym-sphinx-chunking",
 "nym-sphinx-forwarding",
 "nym-sphinx-params",
+ "nym-sphinx-routing",
 "nym-sphinx-types",
 "nym-topology",
 "rand 0.7.3",
@@ -2816,7 +2819,7 @@ dependencies = [
 "aes-gcm",
 "argon2",
 "generic-array 0.14.7",
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "rand 0.8.5",
 "serde",
 "serde_json",
@@ -2884,6 +2887,7 @@ dependencies = [
 "nym-service-provider-directory-common",
 "nym-vesting-contract",
 "nym-vesting-contract-common",
+ "openssl",
 "prost",
 "reqwest",
 "serde",
@@ -2974,6 +2978,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"

+[[package]]
+name = "openssl-src"
+version = "111.26.0+1.1.1u"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efc62c9f12b22b8f5208c23a7200a442b2e5999f8bdf80233852122b5a4f6f37"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "openssl-sys"
 version = "0.9.87"
@@ -2982,6 +2995,7 @@ checksum = "8e17f59264b2809d77ae94f0e1ebabc434773f370d6ca667bd223ea10e06cc7e"
 dependencies = [
 "cc",
 "libc",
+ "openssl-src",
 "pkg-config",
 "vcpkg",
 ]
@@ -3402,7 +3416,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 ]

 [[package]]
@@ -3470,7 +3484,7 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "redox_syscall 0.2.16",
 "thiserror",
 ]
@@ -4388,7 +4402,7 @@ dependencies = [
 "bytes",
 "flex-error",
 "futures",
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "http",
 "hyper",
 "hyper-proxy",
@@ -4788,7 +4802,7 @@ version = "1.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "345444e32442451b267fc254ae85a209c64be56d2890e601a0c37ff0c3c5ecd2"
 dependencies = [
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "wasm-bindgen",
 ]

@@ -4964,7 +4978,7 @@ name = "wasm-utils"
 version = "0.1.0"
 dependencies = [
 "futures",
- "getrandom 0.2.9",
+ "getrandom 0.2.10",
 "indexed_db_futures",
 "js-sys",
 "nym-store-cipher",
@@ -1,7 +1,7 @@
 [package]
 name = "nym-client-wasm"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
-version = "1.1.0"
+version = "1.1.1"
 edition = "2021"
 keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy", "client"]
 license = "Apache-2.0"
@@ -116,11 +116,11 @@ async function testWithTester() {
    // B) first get topology directly from nym-api
    // const validator = 'https://qwerty-validator-api.qa.nymte.ch/api';
    // const topology = await current_network_topology(validator)
-    // const nodeTester = await new NymNodeTester(topology, preferredGateway);
+    // const nodeTester = await new NymNodeTester(topology, undefined, preferredGateway);
    //
    // C) use nym-api in the constructor (note: it does no filtering for 'good' nodes on other layers)
    // const validator = 'https://qwerty-validator-api.qa.nymte.ch/api';
-    // const nodeTester = await NymNodeTester.new_with_api(validator, preferredGateway)
+    // const nodeTester = await NymNodeTester.new_with_api(validator, undefined, preferredGateway)

    // D, E, F) you also don't have to specify the gateway. if you don't, a random one (from your topology) will be used
    // const topology = dummyTopology()
@@ -365,16 +365,16 @@ async function main() {
    set_panic_hook();

    // show reconnection capabilities
-    await testerReconnection()
+    // await testerReconnection()

    // run test on simplified and dedicated tester:
-    // await testWithTester()
+    await testWithTester()

    // hook-up the whole client for testing
    // await testWithNymClient()

    // 'Normal' client setup (to send 'normal' messages)
-    await normalNymClientUsage()
+    // await normalNymClientUsage()
 }

 // Let's get started!
@@ -29,7 +29,7 @@ impl Config {
    #[wasm_bindgen(constructor)]
    pub fn new(id: String, validator_server: String, debug: Option<DebugWasm>) -> Self {
        Config {
-            base: BaseClientConfig::new(id)
+            base: BaseClientConfig::new(id, env!("CARGO_PKG_VERSION").to_string())
                .with_custom_nyxd(vec![validator_server
                    .parse()
                    .expect("provided url was malformed")])
@@ -39,7 +39,7 @@ impl Config {

    pub(crate) fn new_tester_config<S: Into<String>>(id: S) -> Self {
        Config {
-            base: BaseClientConfig::new(id)
+            base: BaseClientConfig::new(id.into(), env!("CARGO_PKG_VERSION").to_string())
                .with_disabled_credentials(true)
                .with_disabled_cover_traffic(true)
                .with_disabled_topology_refresh(true),
@@ -73,6 +73,7 @@ pub struct NymNodeTester {
 #[wasm_bindgen]
 pub struct NymNodeTesterBuilder {
    gateway: Option<IdentityKey>,
+    id: Option<String>,

    base_topology: NymTopology,

@@ -94,9 +95,11 @@ impl NymNodeTesterBuilder {
    #[wasm_bindgen(constructor)]
    pub fn new(
        base_topology: WasmNymTopology,
+        id: Option<String>,
        gateway: Option<IdentityKey>,
    ) -> NymNodeTesterBuilder {
        NymNodeTesterBuilder {
+            id,
            gateway,
            base_topology: base_topology.into(),
            bandwidth_controller: None,
@@ -105,15 +108,20 @@ impl NymNodeTesterBuilder {

    async fn _new_with_api(
        api_url: String,
+        id: Option<String>,
        gateway: Option<IdentityKey>,
    ) -> Result<Self, WasmClientError> {
        let topology = current_network_topology_async(api_url).await?;
-        Ok(NymNodeTesterBuilder::new(topology, gateway))
+        Ok(NymNodeTesterBuilder::new(topology, id, gateway))
    }

-    pub fn new_with_api(gateway: Option<IdentityKey>, api_url: String) -> Promise {
+    pub fn new_with_api(
+        api_url: String,
+        id: Option<String>,
+        gateway: Option<IdentityKey>,
+    ) -> Promise {
        future_to_promise(async move {
-            Self::_new_with_api(api_url, gateway)
+            Self::_new_with_api(api_url, id, gateway)
                .await
                .into_promise_result()
        })
@@ -133,7 +141,13 @@ impl NymNodeTesterBuilder {
    async fn _setup_client(mut self) -> Result<NymNodeTester, WasmClientError> {
        let task_manager = TaskManager::default();

-        let client_store = ClientStorage::new_async(NODE_TESTER_ID, None).await?;
+        let storage_id = if let Some(client_id) = &self.id {
+            format!("{NODE_TESTER_ID}-{client_id}")
+        } else {
+            NODE_TESTER_ID.to_owned()
+        };
+
+        let client_store = ClientStorage::new_async(&storage_id, None).await?;

        let init_details = self.gateway_info(&client_store).await?;
        let gateway_endpoint = init_details.gateway_details;
@@ -234,24 +248,33 @@ async fn test_mixnode(
 impl NymNodeTester {
    #[wasm_bindgen(constructor)]
    #[allow(clippy::new_ret_no_self)]
-    pub fn new(topology: WasmNymTopology, gateway: Option<IdentityKey>) -> Promise {
+    pub fn new(
+        topology: WasmNymTopology,
+        id: Option<String>,
+        gateway: Option<IdentityKey>,
+    ) -> Promise {
        console_log!("constructing node tester!");
-        NymNodeTesterBuilder::new(topology, gateway).setup_client()
+        NymNodeTesterBuilder::new(topology, id, gateway).setup_client()
    }

    async fn _new_with_api(
        api_url: String,
+        id: Option<String>,
        gateway: Option<IdentityKey>,
    ) -> Result<Self, WasmClientError> {
-        NymNodeTesterBuilder::_new_with_api(api_url, gateway)
+        NymNodeTesterBuilder::_new_with_api(api_url, id, gateway)
            .await?
            ._setup_client()
            .await
    }

-    pub fn new_with_api(api_url: String, gateway: Option<IdentityKey>) -> Promise {
+    pub fn new_with_api(
+        api_url: String,
+        id: Option<String>,
+        gateway: Option<IdentityKey>,
+    ) -> Promise {
        future_to_promise(async move {
-            Self::_new_with_api(api_url, gateway)
+            Self::_new_with_api(api_url, id, gateway)
                .await
                .into_promise_result()
        })
@@ -1,6 +1,6 @@
 [package]
 name = "nym-bin-common"
-version = "0.5.0"
+version = "0.6.0"
 description = "Common code for nym binaries"
 edition = { workspace = true }
 authors = { workspace = true }
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client-core"
-version = "1.1.14"
+version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -66,9 +66,9 @@ pub struct Config {
 }

 impl Config {
-    pub fn new<S: Into<String>>(id: S) -> Self {
+    pub fn new<S: Into<String>>(id: S, version: S) -> Self {
        Config {
-            client: Client::new_default(id),
+            client: Client::new_default(id, version),
            debug: Default::default(),
        }
    }
@@ -243,7 +243,7 @@ pub struct Client {
 }

 impl Client {
-    pub fn new_default<S: Into<String>>(id: S) -> Self {
+    pub fn new_default<S: Into<String>>(id: S, version: S) -> Self {
        let network = NymNetworkDetails::new_mainnet();
        let nyxd_urls = network
            .endpoints
@@ -257,7 +257,7 @@ impl Client {
            .collect::<Vec<_>>();

        Client {
-            version: env!("CARGO_PKG_VERSION").to_string(),
+            version: version.into(),
            id: id.into(),
            disabled_credentials_mode: true,
            nyxd_urls,
@@ -29,6 +29,7 @@ log = { workspace = true }
 url = { version = "2.2", features = ["serde"] }
 tokio = { version = "1.24.1", features = ["sync", "time"] }
 futures = "0.3"
+openssl = { version = "0.10", features = ["vendored"], optional = true }

 nym-coconut-interface = { path = "../../coconut-interface" }
 nym-network-defaults = { path = "../../network-defaults" }
@@ -77,13 +78,14 @@ required-features = ["nyxd-client"]
 nyxd-client = [
    "async-trait",
    "cosmrs",
+    "cosmwasm-std",
    "cw3",
    "cw4",
-    "prost",
    "flate2",
-    "sha2",
    "itertools",
-    "cosmwasm-std",
+    "openssl",
+    "prost",
+    "sha2",
    "signing"
 ]
 signing = [
@@ -41,3 +41,6 @@ nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-co
 nym-service-provider-directory-common = { path = "../cosmwasm-smart-contracts/service-provider-directory" }
 nym-name-service-common = { path = "../cosmwasm-smart-contracts/name-service" }
 nym-sphinx = { path = "../../common/nymsphinx" }
+
+nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
+nym-types = { path = "../../common/types" }
@@ -0,0 +1,68 @@
+use clap::{Args, Parser, Subcommand};
+use nym_bin_common::output_format::OutputFormat;
+use nym_crypto::asymmetric::identity;
+use nym_types::helpers::ConsoleSigningOutput;
+use nym_validator_client::nyxd::error::NyxdError;
+use std::path::PathBuf;
+
+#[derive(Debug, Args)]
+#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
+pub struct MixnetOperatorsIdentityKey {
+    #[clap(subcommand)]
+    pub command: MixnetOperatorsIdentityKeyCommands,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum MixnetOperatorsIdentityKeyCommands {
+    /// Register a name alias for a nym address
+    Sign(SignArgs),
+}
+
+#[derive(Debug, Parser)]
+pub struct SignArgs {
+    /// Path to private identity key (example: private_identity_key.pem)
+    #[clap(long)]
+    private_key: PathBuf,
+
+    /// Base58 encoded message to sign
+    #[clap(long)]
+    base58_msg: String,
+
+    #[clap(short, long, default_value_t = OutputFormat::default())]
+    output: OutputFormat,
+}
+
+pub async fn sign(args: SignArgs) -> Result<(), NyxdError> {
+    eprintln!(">>> loading: {}", args.private_key.display());
+    let private_identity_key: identity::PrivateKey =
+        nym_pemstore::load_key(args.private_key).expect("failed to load key");
+
+    print_signed_msg(&private_identity_key, &args.base58_msg, args.output);
+    Ok(())
+}
+
+fn print_signed_msg(private_key: &identity::PrivateKey, raw_msg: &str, output: OutputFormat) {
+    let trimmed = raw_msg.trim();
+    eprintln!(">>> attempting to sign: {trimmed}");
+
+    let Ok(decoded) = bs58::decode(trimmed).into_vec() else {
+        println!("failed to base58 decode the message, did you copy it correctly?");
+        return;
+    };
+
+    eprintln!(">>> decoding the message...");
+
+    // we don't really care about what particular information is embedded inside of it,
+    // we just want to know if user correctly copied the string, i.e. whether it's a valid bs58 encoded json
+    if serde_json::from_slice::<serde_json::Value>(&decoded).is_err() {
+        println!("failed to parse the message after decoding, did you copy it correctly?");
+        return;
+    };
+
+    // if this is a valid json, it MUST be a valid string
+    let decoded_string = String::from_utf8(decoded.clone()).unwrap();
+    let signature = private_key.sign(&decoded).to_base58_string();
+
+    let sign_output = ConsoleSigningOutput::new(decoded_string, signature);
+    println!("{}", output.format(&sign_output));
+}
@@ -4,6 +4,7 @@
 use clap::{Args, Subcommand};

 pub mod gateway;
+pub mod identity_key;
 pub mod mixnode;
 pub mod name;
 pub mod service;
@@ -26,4 +27,6 @@ pub enum MixnetOperatorsCommands {
    ServiceProvider(service::MixnetOperatorsService),
    /// Manage your registered name
    Name(name::MixnetOperatorsName),
+    /// Sign messages using your private identity key
+    IdentityKey(identity_key::MixnetOperatorsIdentityKey),
 }
@@ -15,11 +15,12 @@ thiserror = { workspace = true }
 zeroize = { workspace = true }

 nym-crypto = { path = "../../crypto", features = ["symmetric", "rand"] }
+nym-pemstore = { path = "../../pemstore" }
 nym-sphinx-addressing = { path = "../addressing" }
 nym-sphinx-params = { path = "../params" }
+nym-sphinx-routing = { path = "../routing" }
 nym-sphinx-types = { path = "../types" }
-nym-pemstore = { path = "../../pemstore" }
 nym-topology = { path = "../../topology" }

 [features]
-serde = ["serde_crate", "generic-array"]
+serde = ["serde_crate", "generic-array"]
@@ -9,7 +9,7 @@ use nym_sphinx_addressing::nodes::{
 };
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::{PacketType, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::delays::{self, Delay};
+use nym_sphinx_types::delays::Delay;
 use nym_sphinx_types::{NymPacket, NymPacketError, MIN_PACKET_SIZE};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
@@ -51,7 +51,7 @@ impl SurbAck {
    {
        let route =
            topology.random_route_to_gateway(rng, DEFAULT_NUM_MIX_HOPS, recipient.gateway())?;
-        let delays = delays::generate_from_average_duration(route.len(), average_delay);
+        let delays = nym_sphinx_routing::generate_hop_delays(average_delay, route.len());
        let destination = recipient.as_sphinx_destination();

        let surb_ack_payload = prepare_identifier(rng, ack_key, marshaled_fragment_id);
@@ -16,6 +16,7 @@ thiserror = "1"
 nym-crypto = { path = "../../crypto", features = ["symmetric", "rand"] }
 nym-sphinx-addressing = { path = "../addressing" }
 nym-sphinx-params = { path = "../params" }
+nym-sphinx-routing = { path = "../routing" }
 nym-sphinx-types = { path = "../types" }
 nym-topology = { path = "../../topology" }

@@ -7,7 +7,7 @@ use nym_sphinx_addressing::clients::Recipient;
 use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, MAX_NODE_ADDRESS_UNPADDED_LEN};
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::{delays, NymPacket, SURBMaterial, SphinxError, SURB};
+use nym_sphinx_types::{NymPacket, SURBMaterial, SphinxError, SURB};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use serde::de::{Error as SerdeError, Visitor};
@@ -96,7 +96,7 @@ impl ReplySurb {
    {
        let route =
            topology.random_route_to_gateway(rng, DEFAULT_NUM_MIX_HOPS, recipient.gateway())?;
-        let delays = delays::generate_from_average_duration(route.len(), average_delay);
+        let delays = nym_sphinx_routing::generate_hop_delays(average_delay, route.len());
        let destination = recipient.as_sphinx_destination();

        let surb_material = SURBMaterial::new(route, delays, destination);
@@ -15,7 +15,8 @@ nym-crypto = { path = "../../crypto" }
 nym-sphinx-acknowledgements = { path = "../acknowledgements" }
 nym-sphinx-addressing = { path = "../addressing" }
 nym-sphinx-chunking = { path = "../chunking" }
-nym-sphinx-params = { path = "../params" }
 nym-sphinx-forwarding = { path = "../forwarding" }
+nym-sphinx-params = { path = "../params" }
+nym-sphinx-routing = { path = "../routing" }
 nym-sphinx-types = { path = "../types" }
 nym-topology = { path = "../../topology" }
@@ -13,7 +13,7 @@ use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::{
    PacketEncryptionAlgorithm, PacketHkdfAlgorithm, PacketType, DEFAULT_NUM_MIX_HOPS,
 };
-use nym_sphinx_types::{delays, NymPacket};
+use nym_sphinx_types::NymPacket;
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, RngCore};
 use std::convert::TryFrom;
@@ -120,7 +120,7 @@ where

    let route =
        topology.random_route_to_gateway(rng, DEFAULT_NUM_MIX_HOPS, full_address.gateway())?;
-    let delays = delays::generate_from_average_duration(route.len(), average_packet_delay);
+    let delays = nym_sphinx_routing::generate_hop_delays(average_packet_delay, route.len());
    let destination = full_address.as_sphinx_destination();

    let first_hop_address =
@@ -1,8 +1,10 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use std::time::Duration;
+
 use nym_sphinx_addressing::clients::Recipient;
-use nym_sphinx_types::Node;
+use nym_sphinx_types::{delays, Delay, Node};
 use thiserror::Error;

 pub trait SphinxRouteMaker {
@@ -41,3 +43,11 @@ impl SphinxRouteMaker for Vec<Node> {
        }
    }
 }
+
+pub fn generate_hop_delays(average_packet_delay: Duration, num_hops: usize) -> Vec<Delay> {
+    if average_packet_delay.is_zero() {
+        vec![nym_sphinx_types::Delay::new_from_millis(0); num_hops]
+    } else {
+        delays::generate_from_average_duration(num_hops, average_packet_delay)
+    }
+}
@@ -14,7 +14,7 @@ use nym_sphinx_chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_sphinx_forwarding::packet::MixPacket;
 use nym_sphinx_params::packet_sizes::PacketSize;
 use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
-use nym_sphinx_types::{delays, Delay, NymPacket};
+use nym_sphinx_types::{Delay, NymPacket};
 use nym_topology::{NymTopology, NymTopologyError};
 use rand::{CryptoRng, Rng};
 use std::convert::TryFrom;
@@ -233,7 +233,7 @@ pub trait FragmentPreparer {

        // including set of delays
        let delays =
-            delays::generate_from_average_duration(route.len(), self.average_packet_delay());
+            nym_sphinx_routing::generate_hop_delays(self.average_packet_delay(), route.len());

        // create the actual sphinx packet here. With valid route and correct payload size,
        // there's absolutely no reason for this call to fail.
@@ -27,9 +27,9 @@ pub struct Config {
 }

 impl Config {
-    pub fn new<S: Into<String>>(id: S, provider_mix_address: S) -> Self {
+    pub fn new<S: Into<String>>(id: S, version: S, provider_mix_address: S) -> Self {
        Config {
-            base: BaseClientConfig::new(id),
+            base: BaseClientConfig::new(id, version),
            socks5: Socks5::new(provider_mix_address),
        }
    }
@@ -31,7 +31,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "once_cell",
 "version_check",
 ]
@@ -936,9 +936,9 @@ dependencies = [

 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
 "cfg-if",
 "js-sys",
@@ -1148,9 +1148,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.142"
+version = "0.2.146"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a987beff54b60ffa6d51982e1aa1146bc42f19bd26be28b0586f252fccf5317"
+checksum = "f92be4933c13fd498862a9e02a3055f8a8d9c039ce33db97306fd5a6caa7f29b"

 [[package]]
 name = "libgit2-sys"
@@ -1444,7 +1444,7 @@ dependencies = [
 "chacha20",
 "chacha20poly1305",
 "curve25519-dalek",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "log",
 "rand 0.7.3",
 "rayon",
@@ -1750,7 +1750,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 ]

 [[package]]
@@ -1,6 +1,6 @@
 [package]
 name = "explorer-api"
-version = "1.1.21"
+version = "1.1.22"
 edition = "2021"

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

 [package]
 name = "nym-gateway"
-version = "1.1.21"
+version = "1.1.22"
 authors = [
    "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
    "Jędrzej Stuczyński <andrew@nymtech.net>",
@@ -34,16 +34,41 @@ pretty_env_logger = "0.4"
 rand = "0.7"
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-sqlx = { version = "0.5", features = [ "runtime-tokio-rustls", "sqlite", "macros", "migrate", ] }
+sqlx = { version = "0.5", features = [
+    "runtime-tokio-rustls",
+    "sqlite",
+    "macros",
+    "migrate",
+] }
 subtle-encoding = { version = "0.5", features = ["bech32-preview"] }
 thiserror = "1"
-tokio = { version = "1.24.1", features = [ "rt-multi-thread", "net", "signal", "fs", ] }
+tokio = { version = "1.24.1", features = [
+    "rt-multi-thread",
+    "net",
+    "signal",
+    "fs",
+] }
 tokio-stream = { version = "0.1.11", features = ["fs"] }
 tokio-tungstenite = "0.14"
 tokio-util = { version = "0.7.4", features = ["codec"] }
 url = { version = "2.2", features = ["serde"] }
 zeroize = { workspace = true }

+# wireguard
+# Forked it to be able to bump x25519-dalek to rc.3
+boringtun = { git = "https://github.com/durch/boringtun.git" }
+base64 = "0.21"
+x25519-dalek = { version = "=2.0.0-rc.3", features = [
+    "reusable_secrets",
+    "static_secrets",
+] }
+etherparse = "0.13.0"
+pnet = "0.34.0"
+bytes = "1.4.0"
+async-recursion = "1.0.4"
+smoltcp = "0.10.0"
+tun-tap = "0.1.3"
+
 # internal
 nym-api-requests = { path = "../nym-api/nym-api-requests" }
 nym-bin-common = { path = "../common/bin-common", features = ["output_format"] }
@@ -60,7 +85,9 @@ nym-sphinx = { path = "../common/nymsphinx" }
 nym-statistics-common = { path = "../common/statistics" }
 nym-task = { path = "../common/task" }
 nym-types = { path = "../common/types" }
-nym-validator-client = { path = "../common/client-libs/validator-client", features = [ "nyxd-client" ] }
+nym-validator-client = { path = "../common/client-libs/validator-client", features = [
+    "nyxd-client",
+] }

 [build-dependencies]
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }
@@ -0,0 +1 @@
+gA3NCDl+xOorR3heFVB47FlGunsZgS4RDX2M0IY73lc=
@@ -0,0 +1 @@
+mxV/mw7WZTe+0Msa0kvJHMHERDA/cSskiZWQce+TdEs=
@@ -0,0 +1 @@
+AEqXrLFT4qjYq3wmX0456iv94uM6nDj5ugp6Jedcflg=
@@ -0,0 +1 @@
+WM8s8bYegwMa0TJ+xIwhk+dImk2IpDUKslDBCZPizlE=
@@ -10,6 +10,7 @@ use crate::node::client_handling::websocket::connection_handler::coconut::Coconu
 use crate::node::mixnet_handling::receiver::connection_handler::ConnectionHandler;
 use crate::node::statistics::collector::GatewayStatisticsCollector;
 use crate::node::storage::Storage;
+use crate::node::wireguard::wireguard;
 use log::*;
 use nym_bin_common::output_format::OutputFormat;
 use nym_crypto::asymmetric::{encryption, identity};
@@ -28,6 +29,8 @@ pub(crate) mod client_handling;
 pub(crate) mod mixnet_handling;
 pub(crate) mod statistics;
 pub(crate) mod storage;
+mod wg;
+pub(crate) mod wireguard;

 /// Wire up and create Gateway instance
 pub(crate) async fn create_gateway(config: Config) -> Gateway<PersistentStorage> {
@@ -297,6 +300,8 @@ impl<St> Gateway<St> {
            Arc::new(coconut_verifier),
        );

+        tokio::spawn(wireguard());
+
        info!("Finished nym gateway startup procedure - it should now be able to receive mix and client traffic!");

        self.wait_for_interrupt(shutdown).await
@@ -0,0 +1,31 @@
+use bytes::Bytes;
+use std::fmt::{Display, Formatter};
+
+#[derive(Debug, Clone)]
+pub enum Event {
+    /// Dumb event with no data.
+    Dumb,
+    /// IP packet received from the WireGuard tunnel that should be passed through to the corresponding virtual device/internet.
+    /// Original implementation also has protocol here since it understands it, but we'll have to infer it downstream
+    WgPacket(Bytes),
+    /// IP packet to be sent through the WireGuard tunnel as crafted by the virtual device.
+    IpPacket(Bytes),
+}
+
+impl Display for Event {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Event::Dumb => {
+                write!(f, "Dumb{{}}")
+            }
+            Event::WgPacket(data) => {
+                let size = data.len();
+                write!(f, "WgPacket{{ size={} }}", size)
+            }
+            Event::IpPacket(data) => {
+                let size = data.len();
+                write!(f, "IpPacket{{ size={} }}", size)
+            }
+        }
+    }
+}
@@ -0,0 +1,437 @@
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::sync::Arc;
+use std::time::Duration;
+
+use async_recursion::async_recursion;
+use base64::engine::general_purpose;
+use base64::Engine as _;
+use boringtun::noise::errors::WireGuardError;
+use boringtun::noise::{Tunn, TunnResult};
+use etherparse::{InternetSlice, PacketBuilder, SlicedPacket, TransportSlice};
+use log::{debug, info, warn};
+use pnet::packet::ip::IpNextHeaderProtocols;
+use pnet::packet::ipv4::{Ipv4Packet, MutableIpv4Packet};
+use pnet::packet::{MutablePacket, Packet, PacketSize};
+use pnet::transport::{ipv4_packet_iter, transport_channel};
+use tokio::net::UdpSocket;
+use tokio::sync::{Mutex, RwLock};
+use tokio::time::{sleep, timeout};
+use x25519_dalek::StaticSecret;
+
+use crate::error;
+
+use self::events::Event;
+
+pub mod events;
+
+const MAX_PACKET: usize = 65536;
+
+/// A WireGuard tunnel. Encapsulates and decapsulates IP packets,
+/// recieves packets from the client on the udp_rx channel,
+/// and events from the internet on the eth_rx channel,
+/// sends data through udp socket or datalink sender directly.
+/// For now all tunnels recieve all events and filter on the source_peer_addr
+pub struct WireGuardTunnel {
+    source_peer_addr: Arc<RwLock<Option<(Ipv4Addr, u16)>>>,
+    /// `boringtun` peer/tunnel implementation, used for crypto & WG protocol.
+    peer: Arc<Mutex<Tunn>>,
+    udp: Arc<UdpSocket>,
+    peer_endpoint: SocketAddr,
+    bus_rx: tokio::sync::broadcast::Receiver<Event>,
+    bus_tx: tokio::sync::broadcast::Sender<Event>,
+}
+
+pub fn handle_l3_packet(data: &[u8], destination_addr: Ipv4Addr) -> Vec<u8> {
+    let (mut tx, mut rx) = transport_channel(
+        65535,
+        pnet::transport::TransportChannelType::Layer3(IpNextHeaderProtocols::Tcp),
+    )
+    .unwrap();
+
+    let mut rx_iterator = ipv4_packet_iter(&mut rx);
+
+    let mut must_send = true;
+    let mut cnt = 0;
+    while let Ok((packet, addr)) = rx_iterator.next() {
+        if must_send {
+            let data = data.to_vec();
+            let incoming_packet = Ipv4Packet::new(&data).unwrap();
+            let mut new_packet = vec![0; incoming_packet.packet_size()];
+            let mut outgoing_packet = MutableIpv4Packet::new(&mut new_packet).unwrap();
+            outgoing_packet.clone_from(&incoming_packet);
+            info!(
+                "Sending (ttl={}, proto={} from {} to {}({})",
+                outgoing_packet.get_ttl(),
+                outgoing_packet.get_next_level_protocol(),
+                outgoing_packet.get_source(),
+                outgoing_packet.get_destination(),
+                destination_addr
+            );
+            outgoing_packet.set_source("95.217.227.118".parse().unwrap());
+            let sent = tx
+                .send_to(outgoing_packet, IpAddr::V4(destination_addr))
+                .unwrap();
+            info!("Sent L3 packet ({sent})");
+            must_send = false;
+            continue;
+        }
+        cnt += 1;
+        let source = packet.get_source();
+        let destination = packet.get_destination();
+        info!("Ignoring packet from {source}");
+
+        if source == destination_addr {
+            info!("({addr}){source} -> {destination}");
+            return packet.payload().to_vec();
+        }
+        if cnt >= 10 {
+            break;
+        }
+    }
+    vec![]
+}
+
+impl WireGuardTunnel {
+    async fn set_source_peer_addr(&self, source_addr: Ipv4Addr, source_port: Option<u16>) {
+        {
+            if self.source_peer_addr.read().await.is_some() {
+                return;
+            }
+        }
+        let mut source_peer_addr = self.source_peer_addr.write().await;
+        *source_peer_addr = Some((source_addr, source_port.unwrap_or(0)))
+    }
+
+    pub async fn spin_off(mut self) {
+        info!("Spun off WG tunnel");
+        // We'll receive both inbound and outbound packages on the same channel, and filter on packet type
+        loop {
+            tokio::select! {
+                    packet = self.bus_rx.recv() => {
+                        match packet {
+                            Ok(p) => {
+                                info!("{p}");
+                                match p {
+                                    Event::IpPacket(data) => self.consume_eth(&data).await,
+                                    Event::WgPacket(data) => self.consume_wg(&data).await,
+                                    _ => {}
+                                }
+                            },
+                            Err(e) => error!("{e}")
+                        }
+                    },
+                    _ = sleep(Duration::from_millis(5))=> {
+                        let mut send_buf = [0u8; MAX_PACKET];
+                        let tun_result = {
+                            let mut tun = timeout(Duration::from_millis(100), self.peer()).await.unwrap();
+                            tun.update_timers(&mut send_buf)
+                        };
+                        self.handle_routine_tun_result(tun_result).await;
+                    }
+            }
+        }
+    }
+
+    pub async fn consume_eth(&self, data: &[u8]) {
+        let parsed_packet = SlicedPacket::from_ethernet(data).unwrap();
+        debug!("{parsed_packet:?}");
+        let (source_addr, destination_addr) = match parsed_packet.ip.unwrap() {
+            InternetSlice::Ipv4(ip, _) => (ip.source_addr(), ip.destination_addr()),
+            _ => unimplemented!(),
+        };
+        let (source_port, destination_port, icmp_type) = match parsed_packet.transport.as_ref() {
+            Some(TransportSlice::Tcp(tcp)) => {
+                (Some(tcp.source_port()), Some(tcp.destination_port()), None)
+            }
+            Some(TransportSlice::Udp(udp)) => {
+                (Some(udp.source_port()), Some(udp.destination_port()), None)
+            }
+            Some(TransportSlice::Icmpv4(icmp)) => (None, None, Some(icmp.icmp_type())),
+            Some(TransportSlice::Icmpv6(_)) => panic!("ICMPv6"),
+            Some(TransportSlice::Unknown(_)) => panic!("Unknown"),
+            None => panic!("No transport layer"),
+        };
+        debug!(
+            "{:?}:{:?} -> {:?}:{:?} - ({:?})",
+            source_addr, source_port, destination_addr, destination_port, icmp_type
+        );
+
+        if destination_addr == self.source_peer_addr.read().await.unwrap().0 {
+            info!("Sending {} to {}", data.len(), self.peer_endpoint);
+        } else {
+            return;
+        }
+
+        let response_packet_builder =
+            PacketBuilder::ipv4(source_addr.octets(), destination_addr.octets(), 64);
+
+        let mut response_packet =
+            Vec::<u8>::with_capacity(response_packet_builder.size(parsed_packet.payload.len()));
+
+        match parsed_packet.transport.as_ref() {
+            Some(TransportSlice::Udp(udp)) => {
+                debug!("UDP: {}, {}", udp.length(), udp.destination_port());
+                let response_packet_builder =
+                    response_packet_builder.udp(source_port.unwrap(), destination_port.unwrap());
+                response_packet_builder
+                    .write(&mut response_packet, parsed_packet.payload)
+                    .unwrap();
+            }
+            Some(TransportSlice::Tcp(tcp)) => {
+                let response_packet_builder = response_packet_builder.tcp(
+                    destination_port.unwrap(),
+                    source_port.unwrap(),
+                    tcp.sequence_number(),
+                    tcp.window_size(),
+                );
+                response_packet_builder
+                    .write(&mut response_packet, parsed_packet.payload)
+                    .unwrap();
+            }
+            Some(TransportSlice::Icmpv4(icmp)) => {
+                info!("{:?}", icmp.icmp_type());
+                let response_packet_builder = response_packet_builder.icmpv4(icmp.icmp_type());
+                response_packet_builder
+                    .write(&mut response_packet, parsed_packet.payload)
+                    .unwrap();
+            }
+            None => {}
+            _ => unimplemented!(),
+        };
+
+        let encapsulated_response_packet = self.encapsulate_packet(&response_packet).await;
+        // let packet = Tunn::parse_incoming_packet(&response_packet).unwrap();
+        // info!("Sending {packet:?} to {addr}");
+        let sent = self
+            .udp
+            .send_to(&encapsulated_response_packet, self.peer_endpoint)
+            .await
+            .unwrap();
+        info!(
+            "[{}:{} ({sent})-> {}:{}] -> {}",
+            destination_addr,
+            destination_port.unwrap_or(0),
+            source_addr,
+            source_port.unwrap_or(0),
+            self.peer_endpoint
+        );
+    }
+
+    // TODO: extend to work with IPv6
+    pub async fn produce_eth(&self, packet_bytes: &[u8]) -> Vec<u8> {
+        let outgoing_packet = SlicedPacket::from_ip(packet_bytes).unwrap();
+        let (source_addr, destination_addr) = match outgoing_packet.ip.unwrap() {
+            InternetSlice::Ipv4(ip, _) => (ip.source_addr(), ip.destination_addr()),
+            _ => unimplemented!(),
+        };
+        let (source_port, destination_port, icmp_type) = match outgoing_packet.transport.as_ref() {
+            Some(TransportSlice::Tcp(tcp)) => {
+                (Some(tcp.source_port()), Some(tcp.destination_port()), None)
+            }
+            Some(TransportSlice::Udp(udp)) => {
+                (Some(udp.source_port()), Some(udp.destination_port()), None)
+            }
+            Some(TransportSlice::Icmpv4(icmp)) => (None, None, Some(icmp.icmp_type())),
+            Some(TransportSlice::Icmpv6(_)) => panic!("ICMPv6"),
+            Some(TransportSlice::Unknown(_)) => panic!("Unknown"),
+            None => panic!("No transport layer"),
+        };
+        info!(
+            "{:?}:{:?} -> {:?}:{:?} - ({:?})",
+            source_addr, source_port, destination_addr, destination_port, icmp_type
+        );
+        self.set_source_peer_addr(source_addr, source_port).await;
+        handle_l3_packet(packet_bytes, destination_addr)
+    }
+
+    /// WireGuard consumption task. Receives encrypted packets from the WireGuard peer,
+    /// decapsulates them, and dispatches newly received IP packets.
+    async fn consume_wg(&self, data: &[u8]) {
+        let mut send_buf = [0u8; MAX_PACKET];
+        let mut peer = self.peer().await;
+        match peer.decapsulate(None, data, &mut send_buf) {
+            TunnResult::WriteToNetwork(packet) => {
+                match self.udp.send_to(packet, self.peer_endpoint).await {
+                    Ok(_) => {}
+                    Err(e) => {
+                        error!("Failed to send decapsulation-instructed packet to WireGuard endpoint: {:?}", e);
+                    }
+                };
+                loop {
+                    let mut send_buf = [0u8; MAX_PACKET];
+                    match peer.decapsulate(None, &[], &mut send_buf) {
+                        TunnResult::WriteToNetwork(packet) => {
+                            match self.udp.send_to(packet, self.peer_endpoint).await {
+                                Ok(_) => {}
+                                Err(e) => {
+                                    error!("Failed to send decapsulation-instructed packet to WireGuard endpoint: {:?}", e);
+                                    break;
+                                }
+                            };
+                        }
+                        _ => {
+                            break;
+                        }
+                    }
+                }
+            }
+            TunnResult::WriteToTunnelV4(packet, _) | TunnResult::WriteToTunnelV6(packet, _) => {
+                info!(
+                    "WireGuard endpoint sent IP packet of {} bytes",
+                    packet.len()
+                );
+                let response = self.produce_eth(packet).await;
+                if !response.is_empty() {
+                    self.bus_tx.send(Event::IpPacket(response.into())).unwrap();
+                }
+            }
+            x => warn!("{x:?}"),
+        }
+    }
+
+    async fn encapsulate_packet(&self, payload: &[u8]) -> Vec<u8> {
+        let len = 148.max(payload.len() + 32);
+        let mut dst = vec![0; len];
+        let mut t = self.peer().await;
+        let packet = t.encapsulate(payload, &mut dst);
+        match packet {
+            TunnResult::WriteToNetwork(p) => p.to_vec(),
+            unexpected => {
+                error!("{:?}", unexpected);
+                vec![]
+            }
+        }
+    }
+
+    pub async fn peer(&self) -> tokio::sync::MutexGuard<'_, Tunn> {
+        self.peer.lock().await
+    }
+
+    pub async fn new(
+        peer_static_public: x25519_dalek::PublicKey,
+        udp: Arc<UdpSocket>,
+        peer_endpoint: SocketAddr,
+        bus_tx: tokio::sync::broadcast::Sender<Event>,
+    ) -> Self {
+        let peer = Arc::new(Mutex::new(Self::create_tunnel(peer_static_public)));
+
+        Self {
+            source_peer_addr: Arc::new(RwLock::new(None)),
+            peer,
+            udp,
+            peer_endpoint,
+            bus_rx: bus_tx.subscribe(),
+            bus_tx,
+        }
+    }
+
+    fn create_tunnel(peer_static_public: x25519_dalek::PublicKey) -> Tunn {
+        let secret_bytes: [u8; 32] = general_purpose::STANDARD
+            .decode("AEqXrLFT4qjYq3wmX0456iv94uM6nDj5ugp6Jedcflg=")
+            .unwrap()
+            .try_into()
+            .unwrap();
+
+        let private_key = StaticSecret::try_from(secret_bytes).unwrap();
+
+        Tunn::new(private_key, peer_static_public, None, None, 0, None).unwrap()
+    }
+
+    /// Encapsulates and sends an IP packet back to the WireGuard client.
+    pub async fn send_ip_packet(&self, packet: &[u8]) -> anyhow::Result<()> {
+        let mut send_buf = [0u8; MAX_PACKET];
+        match self.peer().await.encapsulate(packet, &mut send_buf) {
+            TunnResult::WriteToNetwork(packet) => {
+                self.udp.send_to(packet, self.peer_endpoint).await.unwrap();
+                debug!(
+                    "Sent {} bytes to WireGuard endpoint (encrypted IP packet)",
+                    packet.len()
+                );
+            }
+            TunnResult::Err(e) => {
+                error!("Failed to encapsulate IP packet: {:?}", e);
+            }
+            TunnResult::Done => {
+                // Ignored
+            }
+            other => {
+                error!(
+                    "Unexpected WireGuard state during encapsulation: {:?}",
+                    other
+                );
+            }
+        };
+        Ok(())
+    }
+
+    #[async_recursion]
+    async fn handle_routine_tun_result<'a: 'async_recursion>(&self, result: TunnResult<'a>) -> () {
+        match result {
+            TunnResult::WriteToNetwork(packet) => {
+                info!(
+                    "Sending routine packet of {} bytes to WireGuard endpoint",
+                    packet.len()
+                );
+                match self.udp.send_to(packet, self.peer_endpoint).await {
+                    Ok(_) => {}
+                    Err(e) => {
+                        error!(
+                            "Failed to send routine packet to WireGuard endpoint: {:?}",
+                            e
+                        );
+                    }
+                };
+            }
+            TunnResult::Err(WireGuardError::ConnectionExpired) => {
+                warn!("Wireguard handshake has expired!");
+
+                let mut buf = vec![0u8; MAX_PACKET];
+                let result = self
+                    .peer()
+                    .await
+                    .format_handshake_initiation(&mut buf[..], false);
+
+                self.handle_routine_tun_result(result).await
+            }
+            TunnResult::Err(e) => {
+                error!(
+                    "Failed to prepare routine packet for WireGuard endpoint: {:?}",
+                    e
+                );
+            }
+            TunnResult::Done => {
+                // Sleep for a bit
+                // tokio::time::sleep(Duration::from_millis(1)).await;
+            }
+            other => {
+                warn!("Unexpected WireGuard routine task state: {:?}", other);
+            }
+        };
+    }
+
+    // fn route_protocol(&self, packet: &[u8]) -> Option<Protocol> {
+    //     match IpVersion::of_packet(packet) {
+    //         Ok(IpVersion::Ipv4) => Ipv4Packet::new_checked(&packet)
+    //             .ok()
+    //             // Only care if the packet is destined for this tunnel
+    //             .filter(|packet| Ipv4Addr::from(packet.dst_addr()) == self.source_peer_ip)
+    //             .and_then(|packet| match packet.next_header() {
+    //                 IpProtocol::Tcp => Some(Protocol::Tcp),
+    //                 IpProtocol::Udp => Some(Protocol::Udp),
+    //                 // Unrecognized protocol, so we cannot determine where to route
+    //                 _ => None,
+    //             }),
+    //         Ok(IpVersion::Ipv6) => Ipv6Packet::new_checked(&packet)
+    //             .ok()
+    //             // Only care if the packet is destined for this tunnel
+    //             .filter(|packet| Ipv6Addr::from(packet.dst_addr()) == self.source_peer_ip)
+    //             .and_then(|packet| match packet.next_header() {
+    //                 IpProtocol::Tcp => Some(Protocol::Tcp),
+    //                 IpProtocol::Udp => Some(Protocol::Udp),
+    //                 // Unrecognized protocol, so we cannot determine where to route
+    //                 _ => None,
+    //             }),
+    //         _ => None,
+    //     }
+    // }
+}
@@ -0,0 +1,77 @@
+use base64::engine::general_purpose;
+use base64::Engine as _;
+use log::{error, info};
+use std::collections::HashSet;
+use std::sync::Arc;
+use tokio::net::UdpSocket;
+use tokio::sync::broadcast;
+use x25519_dalek::{PublicKey, StaticSecret};
+
+use crate::node::wg::events::Event;
+use crate::node::wg::WireGuardTunnel;
+
+pub async fn wireguard() {
+    let wg_address = "0.0.0.0:51820";
+    let sock = Arc::new(UdpSocket::bind(wg_address).await.unwrap());
+    info!("wg listening on {wg_address}");
+
+    // Secret key ofthe gateway, we'll need a way to generate this from the IdentityKey, might be enough to do some base58 -> base64 conversion
+    let secret_bytes: [u8; 32] = general_purpose::STANDARD
+        .decode("AEqXrLFT4qjYq3wmX0456iv94uM6nDj5ugp6Jedcflg=")
+        .unwrap()
+        .try_into()
+        .unwrap();
+
+    // Hardcoded peer public key, we'll need a way to register those, private key for that one is `aMUcuAgTiFCHQ/fHqEQRvpLWBxh8sKA7f7lSyWymrGE=`
+    // Wireguard configuration that works with this setup is below, this needs to be put into the wireguard client of choice.
+    // Working in this case means that they go through the handshake, and client
+    // starts sending data packets to the gateway.
+    //
+    // [Interface]
+    // PrivateKey = aMUcuAgTiFCHQ/fHqEQRvpLWBxh8sKA7f7lSyWymrGE=
+    // Address = 10.8.0.0/24
+    // DNS = 1.1.1.1
+    //
+    // [Peer]
+    // PublicKey = y6/iGYraJjON6pw9fcBa5vLRbGsQqprFLfWKyJQnlWs=
+    // AllowedIPs = 0.0.0.0/0
+    // Endpoint = 127.0.0.1:51820
+    let peer_public_bytes: [u8; 32] = general_purpose::STANDARD
+        .decode("mxV/mw7WZTe+0Msa0kvJHMHERDA/cSskiZWQce+TdEs=")
+        .unwrap()
+        .try_into()
+        .unwrap();
+    let peer_public = PublicKey::from(peer_public_bytes);
+    let secret = StaticSecret::try_from(secret_bytes).unwrap();
+    let public = PublicKey::from(&secret);
+    info!(
+        "wg public key: {}",
+        general_purpose::STANDARD.encode(public)
+    );
+
+    let mut buf = [0; 1024];
+    let mut peers = HashSet::new();
+
+    let (bus_tx, _) = broadcast::channel(128);
+
+    while let Ok((len, addr)) = sock.recv_from(&mut buf).await {
+        info!("Received {} bytes from {}", len, addr);
+        if peers.contains(&addr) {
+            bus_tx
+                .send(Event::WgPacket(buf[..len].to_vec().into()))
+                .map_err(|e| error!("{e}"))
+                .unwrap();
+        } else {
+            info!("New peer with endpoint {addr}");
+            let tun =
+                WireGuardTunnel::new(peer_public, Arc::clone(&sock), addr, bus_tx.clone()).await;
+            peers.insert(addr);
+            tokio::spawn(tun.spin_off());
+            bus_tx
+                .send(Event::WgPacket(buf[..len].to_vec().into()))
+                .map_err(|e| error!("{e}"))
+                .unwrap();
+        }
+    }
+    panic!("Not OK");
+}
@@ -3,7 +3,7 @@

 [package]
 name = "nym-mixnode"
-version = "1.1.22"
+version = "1.1.23"
 authors = [
    "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
    "Jędrzej Stuczyński <andrew@nymtech.net>",
@@ -3,7 +3,7 @@

 [package]
 name = "nym-api"
-version = "1.1.22"
+version = "1.1.23"
 authors = [
    "Dave Hrycyszyn <futurechimp@users.noreply.github.com>",
    "Jędrzej Stuczyński <andrew@nymtech.net>",
@@ -2,6 +2,12 @@

 ## [Unreleased]

+## [v1.1.13] (2023-06-20)
+
+- NymConnect - add sentry.io reporting ([#3421])
+
+[#3421]: https://github.com/nymtech/nym/issues/3421
+
 ## [v1.1.12] (2023-03-07)

 - NymConnect - Update display for selected Service Provider ([#3116])
@@ -54,7 +54,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "once_cell",
 "version_check",
 ]
@@ -783,7 +783,7 @@ dependencies = [
 "cosmos-sdk-proto",
 "ecdsa",
 "eyre",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "k256",
 "prost",
 "prost-types",
@@ -1894,9 +1894,9 @@ dependencies = [

 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
 "cfg-if",
 "js-sys",
@@ -2773,9 +2773,9 @@ dependencies = [

 [[package]]
 name = "libc"
-version = "0.2.140"
+version = "0.2.146"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c"
+checksum = "f92be4933c13fd498862a9e02a3055f8a8d9c039ce33db97306fd5a6caa7f29b"

 [[package]]
 name = "libdbus-sys"
@@ -3220,7 +3220,7 @@ dependencies = [

 [[package]]
 name = "nym-bin-common"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
 "atty",
 "clap",
@@ -3235,7 +3235,7 @@ dependencies = [

 [[package]]
 name = "nym-client-core"
-version = "1.1.14"
+version = "1.1.15"
 dependencies = [
 "async-trait",
 "base64 0.21.2",
@@ -3286,7 +3286,7 @@ dependencies = [
 "bs58",
 "digest 0.9.0",
 "ff 0.11.1",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "group 0.11.0",
 "itertools",
 "nym-dkg",
@@ -3365,6 +3365,7 @@ dependencies = [
 "nym-credential-storage",
 "nym-crypto",
 "nym-socks5-client-core",
+ "nym-sphinx",
 "nym-task",
 "pretty_env_logger",
 "rand 0.8.5",
@@ -3472,7 +3473,7 @@ name = "nym-gateway-client"
 version = "0.1.0"
 dependencies = [
 "futures",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "log",
 "nym-bandwidth-controller",
 "nym-coconut-interface",
@@ -3608,7 +3609,7 @@ dependencies = [
 "chacha20",
 "chacha20poly1305",
 "curve25519-dalek",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "log",
 "rand 0.7.3",
 "rayon",
@@ -3735,6 +3736,7 @@ dependencies = [
 "nym-pemstore",
 "nym-sphinx-addressing",
 "nym-sphinx-params",
+ "nym-sphinx-routing",
 "nym-sphinx-types",
 "nym-topology",
 "rand 0.7.3",
@@ -3760,6 +3762,7 @@ dependencies = [
 "nym-crypto",
 "nym-sphinx-addressing",
 "nym-sphinx-params",
+ "nym-sphinx-routing",
 "nym-sphinx-types",
 "nym-topology",
 "rand 0.7.3",
@@ -3790,6 +3793,7 @@ dependencies = [
 "nym-sphinx-chunking",
 "nym-sphinx-forwarding",
 "nym-sphinx-params",
+ "nym-sphinx-routing",
 "nym-sphinx-types",
 "nym-topology",
 "rand 0.7.3",
@@ -3906,6 +3910,7 @@ dependencies = [
 "nym-service-provider-directory-common",
 "nym-vesting-contract",
 "nym-vesting-contract-common",
+ "openssl",
 "prost",
 "reqwest",
 "serde",
@@ -4045,6 +4050,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"

+[[package]]
+name = "openssl-src"
+version = "111.26.0+1.1.1u"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efc62c9f12b22b8f5208c23a7200a442b2e5999f8bdf80233852122b5a4f6f37"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "openssl-sys"
 version = "0.9.82"
@@ -4054,6 +4068,7 @@ dependencies = [
 "autocfg",
 "cc",
 "libc",
+ "openssl-src",
 "pkg-config",
 "vcpkg",
 ]
@@ -4669,7 +4684,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 ]

 [[package]]
@@ -4743,7 +4758,7 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "redox_syscall",
 "thiserror",
 ]
@@ -6202,7 +6217,7 @@ dependencies = [
 "bytes",
 "flex-error",
 "futures",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "http",
 "hyper",
 "hyper-proxy",
@@ -6724,7 +6739,7 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1674845326ee10d37ca60470760d4288a6f80f304007d92e5c53bab78c9cfd79"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 ]

 [[package]]
@@ -6912,7 +6927,7 @@ name = "wasm-utils"
 version = "0.1.0"
 dependencies = [
 "futures",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "js-sys",
 "tungstenite",
 "wasm-bindgen",
@@ -53,6 +53,7 @@ nym-crypto = { path = "../../../common/crypto" }
 nym-credential-storage = { path = "../../../common/credential-storage" }
 nym-bin-common = { path = "../../../common/bin-common"}
 nym-socks5-client-core = { path = "../../../common/socks5-client-core" }
+nym-sphinx = { path = "../../../common/nymsphinx" }
 nym-task = { path = "../../../common/task" }

 [dev-dependencies]
@@ -73,7 +73,11 @@ pub fn socks5_config_id_appended_with(gateway_id: &str) -> String {
 impl Config {
    pub fn new<S: AsRef<str>>(id: S, provider_mix_address: S) -> Self {
        Config {
-            core: Socks5CoreConfig::new(id.as_ref(), provider_mix_address.as_ref()),
+            core: Socks5CoreConfig::new(
+                id.as_ref(),
+                env!("CARGO_PKG_VERSION"),
+                provider_mix_address.as_ref(),
+            ),
            storage_paths: NymConnectPaths::new_default(default_data_directory(id.as_ref())),
        }
    }
@@ -156,7 +160,11 @@ pub async fn init_socks5_config(provider_address: String, chosen_gateway_id: Str
        config.core.base.client.nym_api_urls = nym_config_common::parse_urls(&raw_validators);
    }

-    let gateway_setup = GatewaySetup::new_fresh(Some(chosen_gateway_id), None);
+    let gateway_setup = if register_gateway {
+        GatewaySetup::new_fresh(Some(chosen_gateway_id), None)
+    } else {
+        GatewaySetup::MustLoad
+    };

    // Setup gateway by either registering a new one, or reusing exiting keys
    let key_store = OnDiskKeys::new(config.storage_paths.common_paths.keys.clone());
@@ -25,6 +25,11 @@ mod tasks;
 mod window;

 fn main() {
+    if std::env::var("NYM_CONNECT_ENABLE_MEDIUM").is_ok() {
+        std::env::set_var("NYM_CONNECT_DISABLE_COVER", "1");
+        std::env::set_var("NYM_CONNECT_ENABLE_MIXED_SIZE_PACKETS", "1");
+        std::env::set_var("NYM_CONNECT_DISABLE_PER_HOP_DELAYS", "1");
+    }
    setup_env(None);
    println!("Starting up...");

@@ -4,8 +4,10 @@ use nym_client_core::client::base_client::storage::{MixnetClientStorage, OnDiskP
 use nym_client_core::{config::GatewayEndpointConfig, error::ClientCoreStatusMessage};
 use nym_socks5_client_core::NymClient as Socks5NymClient;
 use nym_socks5_client_core::Socks5ControlMessageSender;
+use nym_sphinx::params::PacketSize;
 use nym_task::manager::TaskStatus;
 use std::sync::Arc;
+use std::time::Duration;
 use tap::TapFallible;
 use tokio::sync::RwLock;

@@ -39,7 +41,7 @@ pub async fn start_nym_socks5_client(
    GatewayEndpointConfig,
 )> {
    log::info!("Loading config from file: {id}");
-    let config = Config::read_from_default_path(id)
+    let mut config = Config::read_from_default_path(id)
        .tap_err(|_| log::warn!("Failed to load configuration file"))?;

    let storage =
@@ -53,6 +55,21 @@ pub async fn start_nym_socks5_client(
        .expect("failed to load gateway details")
        .into();

+    // Disable both the loop cover traffic that runs in the background as well as the Poisson
+    // process that injects cover traffic into the traffic stream.
+    if std::env::var("NYM_CONNECT_DISABLE_COVER").is_ok() {
+        config.core.base.set_no_cover_traffic();
+    }
+
+    if std::env::var("NYM_CONNECT_ENABLE_MIXED_SIZE_PACKETS").is_ok() {
+        config.core.base.debug.traffic.secondary_packet_size = Some(PacketSize::ExtendedPacket16);
+    }
+
+    if std::env::var("NYM_CONNECT_DISABLE_PER_HOP_DELAY").is_ok() {
+        config.core.base.debug.traffic.average_packet_delay = Duration::ZERO;
+        config.core.base.debug.acknowledgements.average_ack_delay = Duration::ZERO;
+    }
+
    log::info!("Starting socks5 client");

    // Channel to send control messages to the socks5 client
@@ -102,7 +102,7 @@ dependencies {

    implementation 'androidx.core:core-ktx:1.10.1'
    implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.6.1'
-    implementation 'androidx.activity:activity-compose:1.5.1'
+    implementation 'androidx.activity:activity-compose:1.7.2'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
    implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.0'
@@ -0,0 +1,3 @@
+defaults.project=nym-connect-android
+defaults.org=nymtech
+# auth.token=xxx
@@ -1,7 +1,11 @@
 [package]
 name = "nym-outfox"
 version = "0.1.0"
-edition = "2018"
+description = "Outfox package format"
+edition = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+repository = { workspace = true }

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@@ -12,8 +16,7 @@ zeroize = "1.5"
 chacha20 = "0.9.0"
 curve25519-dalek = "3.2"
 chacha20poly1305 = "0.10.1"
-# Need this star over here to pull in js into getrandom
-getrandom = { version = "*", features = ["js"] }
+getrandom = { workspace = true, features = ["js"] }
 thiserror = "1"
 sphinx-packet = "0.1.0"
 rand = "0.7.3"
@@ -68,7 +68,7 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "once_cell",
 "version_check",
 ]
@@ -764,7 +764,7 @@ dependencies = [
 "cosmos-sdk-proto",
 "ecdsa",
 "eyre",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "k256",
 "prost",
 "prost-types",
@@ -1763,9 +1763,9 @@ dependencies = [

 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 dependencies = [
 "cfg-if",
 "js-sys",
@@ -2543,9 +2543,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.139"
+version = "0.2.146"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "201de327520df007757c1f0adce6e827fe8562fbc28bfd9c15571c66ca1f5f79"
+checksum = "f92be4933c13fd498862a9e02a3055f8a8d9c039ce33db97306fd5a6caa7f29b"

 [[package]]
 name = "libgit2-sys"
@@ -2915,7 +2915,7 @@ dependencies = [

 [[package]]
 name = "nym-bin-common"
-version = "0.5.0"
+version = "0.6.0"
 dependencies = [
 "atty",
 "clap",
@@ -2936,7 +2936,7 @@ dependencies = [
 "bs58",
 "digest 0.9.0",
 "ff",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "group",
 "itertools",
 "nym-dkg",
@@ -3111,7 +3111,7 @@ dependencies = [
 "chacha20",
 "chacha20poly1305",
 "curve25519-dalek",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "log",
 "rand 0.7.3",
 "rayon",
@@ -3156,7 +3156,7 @@ dependencies = [
 "aes-gcm",
 "argon2",
 "generic-array 0.14.7",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "rand 0.8.5",
 "serde",
 "serde_json",
@@ -3220,6 +3220,7 @@ dependencies = [
 "nym-service-provider-directory-common",
 "nym-vesting-contract",
 "nym-vesting-contract-common",
+ "openssl",
 "prost",
 "reqwest",
 "serde",
@@ -3297,7 +3298,7 @@ dependencies = [

 [[package]]
 name = "nym_wallet"
-version = "1.2.4"
+version = "1.2.5"
 dependencies = [
 "async-trait",
 "base64 0.13.1",
@@ -3447,6 +3448,15 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"

+[[package]]
+name = "openssl-src"
+version = "111.26.0+1.1.1u"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efc62c9f12b22b8f5208c23a7200a442b2e5999f8bdf80233852122b5a4f6f37"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "openssl-sys"
 version = "0.9.80"
@@ -3456,6 +3466,7 @@ dependencies = [
 "autocfg",
 "cc",
 "libc",
+ "openssl-src",
 "pkg-config",
 "vcpkg",
 ]
@@ -4051,7 +4062,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 ]

 [[package]]
@@ -4128,7 +4139,7 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "redox_syscall",
 "thiserror",
 ]
@@ -5292,7 +5303,7 @@ dependencies = [
 "bytes",
 "flex-error",
 "futures",
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 "http",
 "hyper",
 "hyper-proxy",
@@ -5750,7 +5761,7 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1674845326ee10d37ca60470760d4288a6f80f304007d92e5c53bab78c9cfd79"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.10",
 ]

 [[package]]
@@ -1,6 +1,6 @@
 {
  "name": "@nymproject/nym-wallet-app",
-  "version": "1.2.4",
+  "version": "1.2.5",
  "main": "index.js",
  "license": "MIT",
  "scripts": {
@@ -1,6 +1,6 @@
 [package]
 name = "nym_wallet"
-version = "1.2.4"
+version = "1.2.5"
 description = "Nym Native Wallet"
 authors = ["Nym Technologies SA"]
 license = ""
@@ -1,7 +1,7 @@
 {
  "package": {
    "productName": "nym-wallet",
-    "version": "1.2.4"
+    "version": "1.2.5"
  },
  "build": {
    "distDir": "../dist",
@@ -67,7 +67,11 @@ impl Config {
        S: AsRef<str>,
    {
        Config {
-            core: CoreConfig::new(id.as_ref(), provider_mix_address.as_ref()),
+            core: CoreConfig::new(
+                id.as_ref(),
+                env!("CARGO_PKG_VERSION"),
+                provider_mix_address.as_ref(),
+            ),
            storage_paths: storage_root.map(|storage_root| {
                MobileSocksClientPaths::new_default(data_directory_from_root(
                    storage_root,
@@ -0,0 +1,5 @@
+{
+  "name": "@nymproject/nym-client-wasm",
+  "version": "1.0.0",
+  "sideEffects": false
+}
@@ -24,6 +24,7 @@
    "prebuild": "yarn build:dependencies",
    "build": "yarn build:only-this",
    "build:only-this": "scripts/build-prod.sh",
+    "prebuild:dev": "yarn build:dependencies",
    "build:dev": "yarn build:dev:only-this",
    "build:dev:only-this": "scripts/build.sh"
  },
@@ -3,7 +3,7 @@

 [package]
 name = "nym-network-requester"
-version = "1.1.21"
+version = "1.1.22"
 authors.workspace = true
 edition.workspace = true
 rust-version = "1.65"
@@ -82,7 +82,7 @@ impl NymConfigTemplate for Config {
 impl Config {
    pub fn new<S: AsRef<str>>(id: S) -> Self {
        Config {
-            base: BaseClientConfig::new(id.as_ref()),
+            base: BaseClientConfig::new(id.as_ref(), env!("CARGO_PKG_VERSION")),
            network_requester: Default::default(),
            storage_paths: NetworkRequesterPaths::new_default(default_data_directory(id.as_ref())),
            network_requester_debug: Default::default(),
@@ -1,6 +1,6 @@
 [package]
 name = "nym-network-statistics"
-version = "1.1.21"
+version = "1.1.22"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -1,6 +1,6 @@
 [package]
 name = "nym-cli"
-version = "1.1.21"
+version = "1.1.22"
 authors.workspace = true
 edition = "2021"

@@ -0,0 +1,15 @@
+use nym_cli_commands::context::ClientArgs;
+use nym_network_defaults::NymNetworkDetails;
+
+pub(crate) async fn execute(
+    _global_args: ClientArgs,
+    identity_key: nym_cli_commands::validator::mixnet::operators::identity_key::MixnetOperatorsIdentityKey,
+    _network_details: &NymNetworkDetails,
+) -> anyhow::Result<()> {
+    let res = match identity_key.command {
+        nym_cli_commands::validator::mixnet::operators::identity_key::MixnetOperatorsIdentityKeyCommands::Sign(sign_args) => {
+            nym_cli_commands::validator::mixnet::operators::identity_key::sign(sign_args).await
+        }
+    };
+    Ok(res?)
+}
@@ -5,6 +5,7 @@ use nym_cli_commands::context::ClientArgs;
 use nym_network_defaults::NymNetworkDetails;

 pub(crate) mod gateways;
+pub(crate) mod identity_key;
 pub(crate) mod mixnodes;
 pub(crate) mod name;
 pub(crate) mod services;
@@ -23,5 +24,6 @@ pub(crate) async fn execute(
        ) => mixnodes::execute(global_args, mixnode, network_details).await,
        nym_cli_commands::validator::mixnet::operators::MixnetOperatorsCommands::ServiceProvider(service) => services::execute(global_args, service, network_details).await,
        nym_cli_commands::validator::mixnet::operators::MixnetOperatorsCommands::Name(name) => name::execute(global_args, name, network_details).await,
+        nym_cli_commands::validator::mixnet::operators::MixnetOperatorsCommands::IdentityKey(identity_key) => identity_key::execute(global_args, identity_key, network_details).await,
    }
 }
Author	SHA1	Message	Date
durch	8f0c427734	Dummy WG implementation - cleaned up	2023-08-30 12:47:48 +02:00
durch	7dfc396f4f	Each packet to its own thread	2023-07-25 17:18:06 +02:00
durch	2bf44db72f	Tun arc and mutex	2023-07-25 16:46:24 +02:00
durch	ebfecba933	Wireguard POC	2023-06-27 11:45:25 +02:00
pierre	0134030341	build(nc-android): fix release build (sentry)	2023-06-26 12:08:41 +02:00
pierre	97c775bc68	build(nc-android): fix release build (sentry)	2023-06-26 11:59:59 +02:00
pierre	bbce67902b	ci(nc-android): disable release apk (unused)	2023-06-22 15:36:30 +02:00
pierre	e6930046c4	ci(nc-android): disable release apk (unused)	2023-06-22 15:18:36 +02:00
pierre	0c9402503a	Merge branch 'feature/nyms5-android-sentry' into develop	2023-06-22 14:23:33 +02:00
Jon Häggblad	31bc439f65	Cargo.lock	2023-06-22 10:59:08 +02:00
Jon Häggblad	6479480cf7	Merge remote-tracking branch 'origin/release/v1.1.23' into develop	2023-06-22 10:57:52 +02:00
Jon Häggblad	4af70ef255	nym-connect: medium speed setting (#3585 ) * Lock files * Add flag to disable cover traffic * Add flag to disable per hop delays * Add flag to enable mixed size packets * Add meta flag to set medium speed * Special case zero averge hop delay to be exactly zero * Extract out generate_hop_delays function	2023-06-22 10:55:35 +02:00
Jędrzej Stuczyński	eba58f6451	NC: load old gateway configuration if we're not registering (#3586 )	2023-06-22 08:49:00 +01:00
Jon Häggblad	35206655e0	Lock files	2023-06-21 09:01:47 +02:00
Jon Häggblad	e14db00fc2	nym-cli: client identity signing support (#3575 ) * Add client identity key signing to nym-cli * Only load private key * rustfmt * Rename to identity key since it's generic * Rename client_key to identity_key	2023-06-20 14:48:53 +02:00
benedettadavico	72b92784cc	Merge remote-tracking branch 'origin/develop' into develop	2023-06-20 13:45:29 +02:00
benedettadavico	38b95c2673	nym connect version fix	2023-06-20 13:45:04 +02:00
Mark Sinclair	f0f9899f82	Update package.json to fix `build:dev` target	2023-06-20 12:12:03 +01:00
benedettadavico	09c46e3403	Merge remote-tracking branch 'origin/master' into develop	2023-06-20 10:36:06 +02:00
benedettadavico	9fbab5aaad	updating versions for release v1.1.22	2023-06-20 10:24:54 +02:00
benedettadavico	2032b3bdae	updating versions for release v1.1.22	2023-06-20 09:51:28 +02:00
Jędrzej Stuczyński	8f57919571	optional id argument for NymNodeTester (#3555 )	2023-06-16 11:19:40 +01:00
Jon Häggblad	3748ab77a1	Statically link openssl (#3504 ) * Statically link openssl * Fix wasm client build * Enable openssl for nyxd-client feature	2023-06-16 11:27:25 +02:00
pierre	9cbb3dfa0e	copy change	2023-06-16 11:19:44 +02:00
Pierre Dommerc	4071d30f3c	feat(nc-desktop): add error reporting and monitoring setting (#3553 )	2023-06-16 11:09:29 +02:00
Tommy Verrall	dd33052f0e	Merge pull request #3520 from nymtech/bugfix/incorrect-client-versions bugfix #3434	2023-06-14 17:23:11 +01:00
Jędrzej Stuczyński	a76a51e823	fixed config version of binaries depending on socks5 core configs	2023-06-14 17:16:07 +01:00
Jon Häggblad	b31d3c003f	Cargo.lock	2023-06-14 15:04:37 +02:00
Jon Häggblad	21e11c9221	Merge remote-tracking branch 'origin/master' into release/v1.1.22	2023-06-14 14:55:30 +02:00
Jon Häggblad	c9dcde0ee0	getrandom on workspace level	2023-06-14 13:26:09 +02:00
Jon Häggblad	3fcc16090a	Update nym-outfox Cargo.toml in prep for publish to crates.io	2023-06-14 13:15:40 +02:00
Jędrzej Stuczyński	31b7921c68	bugfix #3434	2023-06-09 15:12:56 +01:00
				`@@ -0,0 +1 @@`
				`gA3NCDl+xOorR3heFVB47FlGunsZgS4RDX2M0IY73lc=`
				`@@ -0,0 +1 @@`
				`mxV/mw7WZTe+0Msa0kvJHMHERDA/cSskiZWQce+TdEs=`
				`@@ -0,0 +1 @@`
				`AEqXrLFT4qjYq3wmX0456iv94uM6nDj5ugp6Jedcflg=`
				`@@ -0,0 +1 @@`
				`WM8s8bYegwMa0TJ+xIwhk+dImk2IpDUKslDBCZPizlE=`