wip

featurized InputMessage transformation
wip
2025-10-27 19:11:13 +01:00 · 2025-10-24 16:50:47 +02:00 · 2025-10-22 12:14:44 +02:00 · 2025-10-22 09:17:40 +02:00 · 2025-10-22 09:07:07 +02:00 · 2025-10-21 15:21:55 +02:00
346 changed files with 12211 additions and 18650 deletions
@@ -8,13 +8,10 @@ on:
      - 'gateway/**'
      - 'integrations/**'
      - 'nym-api/**'
-      - 'nym-authenticator-client/**'
      - 'nym-credential-proxy/**'
-      - 'nym-ip-packet-client/**'
      - 'nym-network-monitor/**'
      - 'nym-node/**'
      - 'nym-node-status-api/**'
-      - 'nym-registration-client/**'
      - 'nym-statistics-api/**'
      - 'nym-outfox/**'
      - 'nym-validator-rewarder/**'
@@ -6,14 +6,16 @@ on:
    paths:
      - "ts-packages/**"
      - "sdk/typescript/**"
+      - "nym-connect/desktop/src/**"
+      - "nym-connect/desktop/package.json"
      - "nym-wallet/src/**"
      - "nym-wallet/package.json"
-      - "explorer-v2/**"
+      - "explorer/**"
      - ".github/workflows/ci-lint-typescript.yml"

 jobs:
  build:
-    runs-on: arc-linux-latest
+    runs-on: ubuntu-22.04
    env:
      RUSTUP_PERMIT_COPY_RENAME: 1
    steps:
@@ -23,7 +25,6 @@ jobs:
      - uses: actions/setup-node@v4
        with:
          node-version: 20
-          
      - name: Setup yarn
        run: npm install -g yarn

@@ -36,12 +37,14 @@ jobs:
        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

      - name: Install wasm-opt
-        run: cargo install wasm-opt
+        uses: ./.github/actions/install-wasm-opt
+        with:
+          version: '116'

      - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
        with:
-          go-version: "1.24.6"
+          go-version: "1.23.7"

      - name: Install
        run: yarn
@@ -49,11 +52,7 @@ jobs:
      - name: Build packages
        run: yarn build:ci

-      - name: Install again
-        run: yarn
-
      - name: Lint
        run: yarn lint
-        
      - name: Typecheck with tsc
        run: yarn tsc
@@ -8,7 +8,7 @@ on:

 jobs:
  build:
-    runs-on: arc-linux-latest
+    runs-on: custom-linux
    steps:
      - uses: actions/checkout@v4

@@ -4,7 +4,7 @@ on:

 jobs:
  publish:
-    runs-on: ubuntu-latest
+    runs-on: arc-ubuntu-22.04
    steps:
      - uses: actions/checkout@v4

@@ -17,13 +17,10 @@ jobs:
      - name: Setup yarn
        run: npm install -g yarn

-      - name: Install rust toolchain
+      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
-          profile: minimal
          toolchain: stable
-          override: true
-          components: rustfmt, clippy

      - name: Install wasm-pack
        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
@@ -32,9 +29,9 @@ jobs:
        run: cargo install wasm-opt

      - name: Set up Go
-        uses: actions/setup-go@v6
+        uses: actions/setup-go@v5
        with:
-          go-version: "1.24.6"
+          go-version: "1.23.7"

      - name: Install dependencies
        run: yarn
@@ -3,6 +3,11 @@ name: Build and upload Node Status agent container to harbor.nymte.ch
 on:
  workflow_dispatch:
    inputs:
+      gateway_probe_git_ref:
+        type: string
+        default: nym-vpn-core-v1.4.0
+        required: true
+        description: Which gateway probe git ref to build the image with
      release_image:
        description: 'Tag image as a release'
        required: true
@@ -38,6 +43,16 @@ jobs:
          VERSION=$(yq -oy '.package.version' ${{ env.WORKING_DIRECTORY }}/Cargo.toml)
          echo "result=$VERSION" >> $GITHUB_OUTPUT

+      - name: cleanup-gateway-probe-ref
+        id: cleanup_gateway_probe_ref
+        run: |
+          GATEWAY_PROBE_GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }}
+          GIT_REF_SLUG="${GATEWAY_PROBE_GIT_REF//\//-}"
+          echo "git_ref=${GIT_REF_SLUG}" >> $GITHUB_OUTPUT
+
+      - name: Set GIT_TAG variable
+        run: echo "GIT_TAG=${{ env.WORKING_DIRECTORY }}-${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}" >> $GITHUB_ENV
+
      - name: Initialize RELEASE_TAG
        run: echo "RELEASE_TAG=" >> $GITHUB_ENV
      
@@ -46,12 +61,24 @@ jobs:
        run: echo "RELEASE_TAG=golden-" >> $GITHUB_ENV
      
      - name: Set IMAGE_NAME_AND_TAGS variable
-        run: echo "IMAGE_NAME_AND_TAGS=${{ env.CONTAINER_NAME }}:${{ env.RELEASE_TAG }}${{ steps.get_version.outputs.result }}" >> $GITHUB_ENV
+        run: echo "IMAGE_NAME_AND_TAGS=${{ env.CONTAINER_NAME }}:${{ env.RELEASE_TAG }}${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}" >> $GITHUB_ENV
        
      - name: New env vars
-        run: echo "RELEASE_TAG='$RELEASE_TAG' IMAGE_NAME_AND_TAGS='$IMAGE_NAME_AND_TAGS'"        
+        run: echo "RELEASE_TAG='$RELEASE_TAG' GIT_TAG='$GIT_TAG' IMAGE_NAME_AND_TAGS='$IMAGE_NAME_AND_TAGS'"        
+
+      # - name: Remove existing tag if exists
+      #   run: |
+      #     if git rev-parse $${{ env.GIT_TAG }} >/dev/null 2>&1; then
+      #       git push --delete origin $${{ env.GIT_TAG }}
+      #       git tag -d $${{ env.GIT_TAG }}
+      #     fi
+
+      # - name: Create tag
+      #   run: |
+      #     git tag -a $${{ env.GIT_TAG }} -m "Version ${{ steps.get_version.outputs.result }}-${{ steps.cleanup_gateway_probe_ref.outputs.git_ref }}"
+      #     git push origin $${{ env.GIT_TAG }}

      - name: BuildAndPushImageOnHarbor
        run: |
-          docker build -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.IMAGE_NAME_AND_TAGS }}
+          docker build --build-arg GIT_REF=${{ github.event.inputs.gateway_probe_git_ref }} -f ${{ env.WORKING_DIRECTORY }}/Dockerfile . -t harbor.nymte.ch/nym/${{ env.IMAGE_NAME_AND_TAGS }}
          docker push harbor.nymte.ch/nym/${{ env.CONTAINER_NAME }} --all-tags
@@ -4,46 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [2025.19-kase] (2025-10-30)
-
- update ns agent workflow ([#6154])
- Cherry pick - request #6143 from nymtech/bugfix/mix-tx-closed-v2 ([#6153])
- bugfix: nym-credential-proxy query params parsing regression ([#6121])
- bugfix: revert some dep updates introduced in #6043 ([#6120])
- Skip ipv6 metadata endpoint request ([#6118])
- update to no longer use 1mb files ([#6117])
- chore: restore pending dkg contract state migration ([#6116])
- Revert "Propagate cancel token to mixnet client" ([#6115])
- Update dirs to 6.0 ([#6109])
- Propagate cancel token to mixnet client ([#6105])
- bugfix: retrieve and update ticketbook in the same query ([#6101])
- bugfix: include network name in the default gateway probe config path ([#6100])
- Bugfix/incompatibility fixes ([#6099])
- [DOCs/operators] QUIC deployment script & docs ([#6098])
- bugfix: testnet manager 02sql migration ([#6096])
- feat: move gateway probe to monorepo (and update to rust edition 2024) ([#6094])
- bugfix: use custom topology provider for list of init gateways ([#6092])
- Max/fix wasm client + build commands ([#6043])
-
-[#6154]: https://github.com/nymtech/nym/pull/6154
-[#6153]: https://github.com/nymtech/nym/pull/6153
-[#6121]: https://github.com/nymtech/nym/pull/6121
-[#6120]: https://github.com/nymtech/nym/pull/6120
-[#6118]: https://github.com/nymtech/nym/pull/6118
-[#6117]: https://github.com/nymtech/nym/pull/6117
-[#6116]: https://github.com/nymtech/nym/pull/6116
-[#6115]: https://github.com/nymtech/nym/pull/6115
-[#6109]: https://github.com/nymtech/nym/pull/6109
-[#6105]: https://github.com/nymtech/nym/pull/6105
-[#6101]: https://github.com/nymtech/nym/pull/6101
-[#6100]: https://github.com/nymtech/nym/pull/6100
-[#6099]: https://github.com/nymtech/nym/pull/6099
-[#6098]: https://github.com/nymtech/nym/pull/6098
-[#6096]: https://github.com/nymtech/nym/pull/6096
-[#6094]: https://github.com/nymtech/nym/pull/6094
-[#6092]: https://github.com/nymtech/nym/pull/6092
-[#6043]: https://github.com/nymtech/nym/pull/6043
-
 ## [2025.18-jarlsberg] (2025-10-14)

 - ns-api: add descriptions to dVPN gateway responses ([#6102])
@@ -150,7 +150,7 @@ members = [
    "tools/internal/contract-state-importer/importer-cli",
    "tools/internal/contract-state-importer/importer-contract",
    "tools/internal/mixnet-connectivity-check",
-#    "tools/internal/sdk-version-bump",
+    # "tools/internal/sdk-version-bump",
    "tools/internal/ssl-inject",
    "tools/internal/testnet-manager",
    "tools/internal/testnet-manager/dkg-bypass-contract",
@@ -166,7 +166,7 @@ members = [
    "wasm/node-tester",
    "wasm/zknym-lib",
    "nym-gateway-probe"
-, "query-tester"]
+]

 default-members = [
    "clients/native",
@@ -215,6 +215,7 @@ base64 = "0.22.1"
 base85rs = "0.1.3"
 bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
+bit-vec = "0.7.0"                                     # can we unify those?
 bitvec = "1.0.0"
 blake3 = "1.7.0"
 bloomfilter = "3.0.1"
@@ -242,11 +243,13 @@ criterion = "0.5"
 csv = "1.3.1"
 ctr = "0.9.1"
 cupid = "0.6.1"
+curve25519-dalek = "4.1"
 dashmap = "5.5.3"
 # We want https://github.com/DefGuard/wireguard-rs/pull/64 , but there's no crates.io release being pushed out anymore
 defguard_wireguard_rs = { git = "https://github.com/DefGuard/wireguard-rs.git", rev = "v0.4.7" }
 digest = "0.10.7"
 dirs = "6.0"
+doc-comment = "0.3"
 dotenvy = "0.15.6"
 dyn-clone = "1.0.19"
 ecdsa = "0.16"
@@ -262,8 +265,11 @@ futures = "0.3.31"
 futures-util = "0.3"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
+getset = "0.1.5"
 handlebars = "3.5.5"
+headers = "0.4.0"
 hex = "0.4.3"
+hex-literal = "0.3.3"
 hickory-resolver = "0.25"
 hkdf = "0.12.3"
 hmac = "0.12.1"
@@ -287,18 +293,24 @@ lazy_static = "1.5.0"
 ledger-transport = "0.10.0"
 ledger-transport-hid = "0.10.0"
 log = "0.4"
+maxminddb = "0.23.0"
 mime = "0.3.17"
 moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
+okapi = "0.7.0"
 once_cell = "1.21.3"
-opentelemetry = "0.19.0"
-opentelemetry-jaeger = "0.18.0"
+opentelemetry = "0.30.0"
+opentelemetry-otlp = "0.30.0"
+opentelemetry-semantic-conventions = "0.30.0"
+opentelemetry_sdk = "0.30.0"
+opentelemetry-stdout = "0.30.0"
 parking_lot = "0.12.3"
 pem = "0.8"
 petgraph = "0.6.5"
 pin-project = "1.1"
 pnet_packet = "0.35.0"
+pin-project-lite = "0.2.16"
 publicsuffix = "2.3.0"
 proc_pidinfo = "0.1.3"
 quote = "1"
@@ -306,10 +318,13 @@ rand = "0.8.5"
 rand_chacha = "0.3"
 rand_core = "0.6.3"
 rand_distr = "0.4"
+rand_pcg = "0.3.1"
+rand_seeder = "0.2.3"
 rayon = "1.5.1"
 regex = "1.10.6"
 reqwest = { version = "0.12.15", default-features = false }
 rs_merkle = "1.5.0"
+safer-ffi = "0.1.13"
 schemars = "0.8.22"
 semver = "1.0.26"
 serde = "1.0.219"
@@ -348,15 +363,16 @@ toml = "0.8.22"
 tower = "0.5.2"
 tower-http = "0.5.2"
 tracing = "0.1.41"
+tracing-core = "0.1.33"
 tracing-log = "0.2"
-tracing-opentelemetry = "0.19.0"
+tracing-opentelemetry = "0.31.0"
+tracing-serde = "0.2.0"
 tracing-subscriber = "0.3.19"
 tracing-tree = "0.2.2"
 tracing-indicatif = "0.3.9"
 tracing-test = "0.2.5"
 ts-rs = "10.1.0"
 tungstenite = { version = "0.20.1", default-features = false }
-typed-builder = "0.23.0"
 uniffi = "0.29.2"
 uniffi_build = "0.29.0"
 url = "2.5"
@@ -453,11 +469,6 @@ opt-level = 'z'
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(tokio_unstable)'] }

 [workspace.lints.clippy]
-suspicious = "deny"
-complexity = "deny"
-perf = "deny"
-style = "deny"
-
 unwrap_used = "deny"
 expect_used = "deny"
 todo = "deny"
@@ -107,16 +107,16 @@ sdk-wasm-build:
 	$(MAKE) -C nym-browser-extension/storage wasm-pack
 	$(MAKE) -C wasm/client
 	$(MAKE) -C wasm/node-tester
-	$(MAKE) -C wasm/mix-fetch
+	# $(MAKE) -C wasm/mix-fetch
 	$(MAKE) -C wasm/zknym-lib
 	# $(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:
 	npx lerna run --scope @nymproject/sdk build --stream
-	npx lerna run --scope @nymproject/mix-fetch build --stream
-	npx lerna run --scope @nymproject/node-tester build --stream
-	yarn --cwd sdk/typescript/codegen/contract-clients build
+	# npx lerna run --scope @nymproject/mix-fetch build --stream
+	# npx lerna run --scope @nymproject/node-tester build --stream
+	# 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 zknym-lib
@@ -140,8 +140,7 @@ clippy: sdk-wasm-lint

 WASM_CONTRACT_DIR := contracts/target/wasm32-unknown-unknown/release
 # Find every direct contract folder that contains a Cargo.toml
-#CONTRACT_DIRS := $(shell find contracts -type f -name Cargo.toml \( ! -path "contracts/Cargo.toml" \) | grep -v integration-tests | xargs -n1 dirname | sort -u)
-CONTRACT_DIRS := contracts/example-contract
+CONTRACT_DIRS := $(shell find contracts -type f -name Cargo.toml \( ! -path "contracts/Cargo.toml" \) | grep -v integration-tests | xargs -n1 dirname | sort -u)

 CONTRACTS_OUT_DIR = contracts/artifacts

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.65"
+version = "1.1.64"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -46,7 +46,6 @@ nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-bin-common = { path = "../../common/bin-common", features = [
    "output_format",
    "clap",
-    "basic_tracing",
 ] }
 nym-client-core = { path = "../../common/client-core", features = [
    "fs-credentials-storage",
@@ -71,3 +70,11 @@ nym-client-websocket-requests = { path = "websocket-requests" }
 nym-id = { path = "../../common/nym-id" }

 [dev-dependencies]
+
+[features]
+default = []
+otel = [
+    "nym-client-core/otel",
+    "nym-bin-common/otel",
+    "nym-gateway-requests/otel",
+]
@@ -4,7 +4,7 @@
 use std::error::Error;

 use clap::{crate_name, crate_version, Parser};
-use nym_bin_common::logging::{maybe_print_banner, setup_tracing_logger};
+use nym_bin_common::logging::{maybe_print_banner, setup_no_otel_logger};
 use nym_network_defaults::setup_env;

 pub mod client;
@@ -20,7 +20,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    if !args.no_banner {
        maybe_print_banner(crate_name!(), crate_version!());
    }
-    setup_tracing_logger();
+    setup_no_otel_logger().expect("failed to initialize logging");

    if let Err(err) = commands::execute(args).await {
        log::error!("{err}");
@@ -184,7 +184,14 @@ impl Handler {
        });

        // the ack control is now responsible for chunking, etc.
-        let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type);
+        let input_msg = InputMessage::new_regular(
+            recipient,
+            message,
+            lane,
+            self.packet_type,
+            #[cfg(feature = "otel")]
+            None,
+        );
        if let Err(err) = self.msg_input.send(input_msg).await {
            if !self.shutdown_token.is_cancelled() {
                error!("Failed to send message to the input buffer: {err}");
@@ -216,8 +223,15 @@ impl Handler {
            TransmissionLane::ConnectionId(id)
        });

-        let input_msg =
-            InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type);
+        let input_msg = InputMessage::new_anonymous(
+            recipient,
+            message,
+            reply_surbs,
+            lane,
+            self.packet_type,
+            #[cfg(feature = "otel")]
+            None,
+        );
        if let Err(err) = self.msg_input.send(input_msg).await {
            if !self.shutdown_token.is_cancelled() {
                error!("Failed to send anonymous message to the input buffer: {err}");
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.65"
+version = "1.1.64"
 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"
@@ -27,7 +27,6 @@ zeroize = { workspace = true }
 nym-bin-common = { path = "../../common/bin-common", features = [
    "output_format",
    "clap",
-    "basic_tracing",
 ] }
 nym-client-core = { path = "../../common/client-core", features = [
    "fs-credentials-storage",
@@ -54,3 +53,7 @@ nym-validator-client = { path = "../../common/client-libs/validator-client", fea
 [features]
 default = []
 eth = []
+otel = [
+    "nym-socks5-client-core/otel",
+    "nym-bin-common/otel",
+]
@@ -4,7 +4,7 @@
 use std::error::Error;

 use clap::{crate_name, crate_version, Parser};
-use nym_bin_common::logging::{maybe_print_banner, setup_tracing_logger};
+use nym_bin_common::logging::{maybe_print_banner, setup_no_otel_logger};
 use nym_network_defaults::setup_env;

 mod commands;
@@ -19,7 +19,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    if !args.no_banner {
        maybe_print_banner(crate_name!(), crate_version!());
    }
-    setup_tracing_logger();
+    setup_no_otel_logger().expect("failed to initialize logging");

    if let Err(err) = commands::execute(args).await {
        log::error!("{err}");
@@ -8,24 +8,30 @@ license = { workspace = true }
 repository = { workspace = true }

 [dependencies]
+chrono = { workspace = true, optional = true }
+cfg-if = { workspace = true }
 clap = { workspace = true, features = ["derive"], optional = true }
 clap_complete = { workspace = true, optional = true }
 clap_complete_fig = { workspace = true, optional = true }
 const-str = { workspace = true }
-log = { workspace = true }
+opentelemetry = { workspace = true, optional = true }
+opentelemetry-otlp = { workspace = true,features=["metrics", "grpc-tonic", "tls",
+    "tls-webpki-roots"], optional = true }
+opentelemetry-semantic-conventions = { workspace = true, features = ["semconv_experimental"], optional = true }
+opentelemetry-stdout = { workspace = true, features = ["trace", "metrics"], optional = true }
+opentelemetry_sdk = { workspace = true, optional = true }
+rand = { workspace = true, optional = true }
 schemars = { workspace = true, features = ["preserve_order"], optional = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
-
-## tracing
-tracing-subscriber = { workspace = true, features = ["env-filter"], optional = true }
-tracing-tree = { workspace = true, optional = true }
-tracing = { workspace = true, optional = true }
-opentelemetry-jaeger = { workspace = true, features = ["rt-tokio", "collector_client", "isahc_collector_client"], optional = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+tracing-core = { workspace = true }
 tracing-opentelemetry = { workspace = true, optional = true }
+tracing-serde = { workspace = true }
+tracing-subscriber = { workspace = true, features = ["env-filter", "json"] }
+tracing-tree = { workspace = true }
 utoipa = { workspace = true, optional = true }
-opentelemetry = { workspace = true, features = ["rt-tokio"], optional = true }
-

 [build-dependencies]
 vergen = { workspace = true, features = ["build", "git", "gitcl", "rustc", "cargo"] }
@@ -35,13 +41,17 @@ default = []
 openapi = ["utoipa"]
 output_format = ["serde_json", "dep:clap"]
 bin_info_schema = ["schemars"]
-basic_tracing = ["dep:tracing", "tracing-subscriber"]
-tracing = [
-    "basic_tracing",
-    "tracing-tree",
-    "opentelemetry-jaeger",
+tokio-console = ["otel"]
+otel = [
+    "chrono",
    "tracing-opentelemetry",
    "opentelemetry",
+    "opentelemetry-otlp",
+    "opentelemetry-semantic-conventions",
+    "opentelemetry-stdout",
+    "opentelemetry_sdk",
+    "serde_json",
+    "rand",
 ]
 clap = ["dep:clap", "dep:clap_complete", "dep:clap_complete_fig"]
 models = []
@@ -4,6 +4,9 @@
 pub mod build_information;
 pub mod logging;

+#[cfg(feature = "otel")]
+pub mod opentelemetry;
+
 #[cfg(feature = "clap")]
 pub mod completions;

@@ -0,0 +1,20 @@
+// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+#[cfg(feature = "otel")]
+use opentelemetry_otlp::ExporterBuildError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum TracingError {
+    #[error("tracing logger already initialised")]
+    TracingLoggerAlreadyInitialised,
+
+    #[error("Logging error: {0}")]
+    TracingTryInitError(tracing_subscriber::util::TryInitError),
+
+    #[cfg(feature = "otel")]
+    #[error("{0}")]
+    TracingExporterBuildError(#[from] ExporterBuildError),
+
+    #[error("{0}")]
+    TracingFilterParseError(#[from] tracing_subscriber::filter::ParseError),
+}
@@ -1,19 +1,12 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+pub mod error;
+
+use error::TracingError;
 use serde::{Deserialize, Serialize};
 use std::io::IsTerminal;
-
-#[cfg(feature = "tracing")]
-pub use opentelemetry;
-#[cfg(feature = "tracing")]
-pub use opentelemetry_jaeger;
-#[cfg(feature = "tracing")]
-pub use tracing_opentelemetry;
-#[cfg(feature = "tracing")]
-pub use tracing_subscriber;
-#[cfg(feature = "tracing")]
-pub use tracing_tree;
+use tracing_subscriber::{filter::Directive, layer::SubscriberExt, util::SubscriberInitExt};

 #[derive(Debug, Default, Copy, Clone, Deserialize, PartialEq, Eq, Serialize)]
 #[serde(deny_unknown_fields)]
@@ -22,7 +15,6 @@ pub struct LoggingSettings {
 }

 // don't call init so that we could attach additional layers
-#[cfg(feature = "basic_tracing")]
 pub fn build_tracing_logger() -> impl tracing_subscriber::layer::SubscriberExt {
    use tracing_subscriber::prelude::*;

@@ -31,7 +23,6 @@ pub fn build_tracing_logger() -> impl tracing_subscriber::layer::SubscriberExt {
        .with(default_tracing_env_filter())
 }

-#[cfg(feature = "basic_tracing")]
 pub fn default_tracing_env_filter() -> tracing_subscriber::filter::EnvFilter {
    if ::std::env::var("RUST_LOG").is_ok() {
        tracing_subscriber::filter::EnvFilter::from_default_env()
@@ -43,7 +34,6 @@ pub fn default_tracing_env_filter() -> tracing_subscriber::filter::EnvFilter {
    }
 }

-#[cfg(feature = "basic_tracing")]
 pub fn default_tracing_fmt_layer<S, W>(
    writer: W,
 ) -> impl tracing_subscriber::Layer<S> + Sync + Send + 'static
@@ -63,45 +53,47 @@ where
        .with_target(false)
 }

-#[cfg(feature = "basic_tracing")]
-pub fn setup_tracing_logger() {
-    use tracing_subscriber::util::SubscriberInitExt;
-    build_tracing_logger().init()
+/// Creates a tracing filter that sets more granular log levels for specific crates.
+/// This allows for finer control over logging verbosity.
+pub(crate) fn granual_filtered_env() -> Result<tracing_subscriber::filter::EnvFilter, TracingError>
+{
+    fn directive_checked(directive: impl Into<String>) -> Result<Directive, TracingError> {
+        directive.into().parse().map_err(From::from)
+    }
+
+    let mut filter = default_tracing_env_filter();
+
+    // these crates are more granularly filtered
+    let filter_crates = ["defguard_wireguard_rs"];
+    for crate_name in filter_crates {
+        filter = filter.add_directive(directive_checked(format!("{crate_name}=warn"))?);
+    }
+    Ok(filter)
+}
+
+pub fn setup_no_otel_logger() -> Result<(), TracingError> {
+    // Only set up if not already initialized
+    if tracing::dispatcher::has_been_set() {
+        // It shouldn't be - this is really checking that it is torn down between async command executions
+        return Err(TracingError::TracingLoggerAlreadyInitialised);
+    }
+
+    let registry = tracing_subscriber::registry()
+        .with(default_tracing_fmt_layer(std::io::stderr))
+        .with(granual_filtered_env()?);
+
+    registry
+        .try_init()
+        .map_err(|e| TracingError::TracingTryInitError(e))?;
+
+    Ok(())
 }

 // TODO: This has to be a macro, running it as a function does not work for the file_appender for some reason
-#[cfg(feature = "tracing")]
 #[macro_export]
 macro_rules! setup_tracing {
    ($service_name: expr) => {
-        use nym_bin_common::logging::tracing_subscriber::layer::SubscriberExt;
-        use nym_bin_common::logging::tracing_subscriber::util::SubscriberInitExt;
-
-        let registry = nym_bin_common::logging::tracing_subscriber::Registry::default()
-            .with(nym_bin_common::logging::tracing_subscriber::EnvFilter::from_default_env())
-            .with(
-                nym_bin_common::logging::tracing_tree::HierarchicalLayer::new(4)
-                    .with_targets(true)
-                    .with_bracketed_fields(true),
-            );
-
-        let tracer = nym_bin_common::logging::opentelemetry_jaeger::new_collector_pipeline()
-            .with_endpoint("http://44.199.230.10:14268/api/traces")
-            .with_service_name($service_name)
-            .with_isahc()
-            .with_trace_config(
-                nym_bin_common::logging::opentelemetry::sdk::trace::config().with_sampler(
-                    nym_bin_common::logging::opentelemetry::sdk::trace::Sampler::TraceIdRatioBased(
-                        0.1,
-                    ),
-                ),
-            )
-            .install_batch(nym_bin_common::logging::opentelemetry::runtime::Tokio)
-            .expect("Could not init tracer");
-
-        let telemetry = nym_bin_common::logging::tracing_opentelemetry::layer().with_tracer(tracer);
-
-        registry.with(telemetry).init();
+        setup_no_otel_logger()
    };
 }

@@ -0,0 +1,47 @@
+use opentelemetry::trace::{SpanId, TraceId};
+use opentelemetry_sdk::trace::IdGenerator;
+use rand::RngCore;
+
+#[derive(Clone, Debug)]
+pub struct Compact13BytesIdGenerator;
+
+impl IdGenerator for Compact13BytesIdGenerator {
+    fn new_trace_id(&self) -> TraceId {
+        let mut rng = rand::thread_rng();
+        let mut bytes = [0u8; 16];
+
+        // Fill the first 13 bytes with random data
+        rng.fill_bytes(&mut bytes[0..12]);
+        // Set the last 4 bytes to zero
+        bytes[12] = 0;
+        bytes[13] = 0;
+        bytes[14] = 0;
+        bytes[15] = 0;
+
+        TraceId::from_bytes(bytes)
+    }
+
+    fn new_span_id(&self) -> SpanId {
+        let mut rng = rand::thread_rng();
+        let mut bytes = [0u8; 8];
+        rng.fill_bytes(&mut bytes);
+
+        SpanId::from_bytes(bytes)
+    }
+}
+
+pub fn compress_trace_id(trace_id: &TraceId) -> [u8; 12] {
+    let bytes = trace_id.to_bytes();
+
+    let mut compressed = [0u8; 12];
+    compressed.copy_from_slice(&bytes[0..12]);
+
+    compressed
+}
+
+pub fn decompress_trace_id(compressed: &[u8; 12]) -> [u8; 16] {
+    let mut bytes = [0u8; 16];
+    bytes[0..12].copy_from_slice(compressed);
+    bytes[12..].copy_from_slice(&[0u8; 4]);
+    bytes
+}
@@ -0,0 +1,155 @@
+use opentelemetry::propagation::{Extractor, Injector, TextMapPropagator};
+use opentelemetry::trace::{SpanContext, TraceContextExt, TraceId};
+use opentelemetry::{Context, TraceFlags};
+use opentelemetry_sdk::{propagation::TraceContextPropagator, trace::IdGenerator};
+use std::collections::HashMap;
+use std::fmt::Display;
+use tracing::instrument;
+use tracing_opentelemetry::OpenTelemetrySpanExt;
+
+/// Make a Carrier for context propagation
+pub struct ContextCarrier {
+    data: HashMap<String, String>,
+}
+
+impl ContextCarrier {
+    pub fn new_empty() -> Self {
+        ContextCarrier {
+            data: HashMap::new(),
+        }
+    }
+
+    pub fn new_with_data(data: HashMap<String, String>) -> Self {
+        if data.is_empty() {
+            return ContextCarrier::new_empty();
+        }
+
+        ContextCarrier { data }
+    }
+
+    pub fn new_with_current_context(context: Context) -> Self {
+        let mut carrier = ContextCarrier::new_empty();
+        let propagator = TraceContextPropagator::new();
+        propagator.inject_context(&context, &mut carrier);
+        carrier
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&String, &String)> {
+        self.data.iter()
+    }
+
+    pub fn from_map(data: HashMap<String, String>) -> Self {
+        ContextCarrier { data }
+    }
+
+    pub fn into_map(self) -> HashMap<String, String> {
+        self.data
+    }
+
+    pub fn extract_trace_id(&self) -> Option<TraceId> {
+        self.get("traceparent").and_then(|tp| {
+            let parts: Vec<&str> = tp.split('-').collect();
+            if parts.len() == 4 {
+                TraceId::from_hex(parts[1]).ok()
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn extract_trace_id_into_bytes(&self) -> Option<[u8; 16]> {
+        self.extract_trace_id().map(|id| id.to_bytes())
+    }
+
+    pub fn extract_traceparent(&self) -> Option<String> {
+        self.get("traceparent").map(|s| s.to_string())
+    }
+}
+
+impl Injector for ContextCarrier {
+    fn set(&mut self, key: &str, value: String) {
+        self.data.insert(key.to_string(), value);
+    }
+}
+
+impl Extractor for ContextCarrier {
+    fn get(&self, key: &str) -> Option<&str> {
+        self.data.get(key).map(|s| s.as_str())
+    }
+
+    fn keys(&self) -> Vec<&str> {
+        self.data.keys().map(|k| k.as_str()).collect()
+    }
+}
+
+impl Display for ContextCarrier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.data)
+    }
+}
+
+pub struct ManualContextPropagator {
+    pub root_span: tracing::Span,
+    pub trace_id: TraceId,
+}
+
+impl ManualContextPropagator {
+    #[instrument(skip_all, level = "debug")]
+    pub fn new(name: &str, context: HashMap<String, String>) -> Self {
+        let carrier = ContextCarrier::new_with_data(context);
+        let trace_id = match carrier.extract_trace_id() {
+            Some(id) => id,
+            None => Context::current().span().span_context().trace_id(),
+        };
+
+        let root_span_builder = new_span_context_with_id(trace_id.clone());
+
+        let root_span = tracing::info_span!("trace_root", name = %name, trace_id = %trace_id);
+        root_span.set_parent(root_span_builder);
+
+        ManualContextPropagator {
+            root_span,
+            trace_id,
+        }
+    }
+
+    #[instrument(skip_all, level = "debug")]
+    pub fn new_from_tid(name: &str, trace_id: TraceId) -> Self {
+        let root_span_builder = new_span_context_with_id(trace_id.clone());
+
+        let root_span = tracing::info_span!("trace_root", name = %name, trace_id = %trace_id);
+        root_span.set_parent(root_span_builder);
+
+        ManualContextPropagator {
+            root_span,
+            trace_id,
+        }
+    }
+
+    pub fn root_span(&self) -> &tracing::Span {
+        &self.root_span
+    }
+}
+
+#[instrument(skip_all, level = "debug")]
+pub fn new_span_context_with_id(trace_id: TraceId) -> Context {
+    let id_gen = opentelemetry_sdk::trace::RandomIdGenerator::default();
+    let span_id = id_gen.new_span_id();
+    let span_context = SpanContext::new(
+        trace_id,
+        span_id,
+        TraceFlags::SAMPLED,
+        true,
+        Default::default(),
+    );
+
+    Context::current().with_remote_span_context(span_context)
+}
+
+#[instrument(skip_all, level = "debug")]
+pub fn extract_trace_id_from_tracing_cx() -> TraceId {
+    let cx = tracing::Span::current().context();
+    let binding = cx.span();
+    let trace_id = binding.span_context().trace_id();
+    trace_id
+}
@@ -0,0 +1,186 @@
+pub mod compact_id_generator;
+pub mod context;
+mod trace_id_format;
+
+use tracing::{Level, info};
+use tracing_subscriber::filter::Directive;
+use tracing_subscriber::fmt;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::util::SubscriberInitExt;
+
+use crate::logging::default_tracing_env_filter;
+use crate::logging::error::TracingError;
+use crate::opentelemetry::compact_id_generator::Compact13BytesIdGenerator;
+use opentelemetry::trace::TracerProvider;
+use opentelemetry::{KeyValue, global};
+use opentelemetry_otlp::tonic_types::metadata::MetadataMap;
+use opentelemetry_otlp::tonic_types::transport::ClientTlsConfig;
+use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
+use opentelemetry_sdk::metrics::{MeterProviderBuilder, PeriodicReader, SdkMeterProvider};
+use opentelemetry_sdk::trace::SdkTracerProvider;
+use opentelemetry_sdk::{Resource, trace::Sampler};
+use opentelemetry_semantic_conventions::SCHEMA_URL;
+use opentelemetry_semantic_conventions::resource::{DEPLOYMENT_ENVIRONMENT_NAME, SERVICE_VERSION};
+use tracing_opentelemetry::{MetricsLayer, OpenTelemetryLayer};
+use tracing_subscriber::fmt::format::FmtSpan;
+
+pub struct TracerProviderGuard(Option<SdkTracerProvider>);
+
+impl Drop for TracerProviderGuard {
+    fn drop(&mut self) {
+        if let Some(tracer_provider) = self.0.take() {
+            // Ensure all spans are flushed before exit
+            if let Err(e) = tracer_provider.shutdown() {
+                eprintln!("Error shutting down tracer provider: {:?}", e);
+            }
+        }
+    }
+}
+
+pub(crate) fn granual_filtered_env() -> Result<tracing_subscriber::filter::EnvFilter, TracingError>
+{
+    fn directive_checked(directive: impl Into<String>) -> Result<Directive, TracingError> {
+        directive.into().parse().map_err(From::from)
+    }
+
+    let mut filter = default_tracing_env_filter();
+
+    // these crates are more granularly filtered
+    let filter_crates = ["defguard_wireguard_rs"];
+    for crate_name in filter_crates {
+        filter = filter.add_directive(directive_checked(format!("{crate_name}=warn"))?);
+    }
+    Ok(filter)
+}
+
+pub fn setup_tracing_logger(service_name: String) -> Result<TracerProviderGuard, TracingError> {
+    if tracing::dispatcher::has_been_set() {
+        // It shouldn't be - this is really checking that it is torn down between async command executions
+        return Err(TracingError::TracingLoggerAlreadyInitialised);
+    }
+
+    // define ingestion points
+    let endpoint = std::env::var("SIGNOZ_ENDPOINT").expect("SIGNOZ_ENDPOINT not set");
+    let key = std::env::var("SIGNOZ_INGESTION_KEY").expect("SIGNOZ_INGESTION_KEY not set");
+    let mut metadata = MetadataMap::new();
+    metadata.insert(
+        "signoz-ingestion-key",
+        key.parse().expect("Could not parse signoz ingestion key"),
+    );
+
+    // Build resources
+    let resource = build_resource(&service_name);
+
+    // Initialize tracer and meter providers
+    let tracer_provider = init_tracer_provider(&endpoint, metadata.clone(), resource.clone())?;
+    let meter_provider = init_meter_provider(&endpoint, metadata.clone(), resource.clone())?;
+
+    // Bridge tracing and opentelemetry
+    let tracer = tracer_provider.tracer("otel-subscriber");
+    let fmt_layer = fmt::layer()
+        .json()
+        .with_writer(std::io::stderr)
+        .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
+        .with_span_list(false)
+        .with_current_span(true)
+        .event_format(trace_id_format::TraceIdFormat);
+
+    let registry = tracing_subscriber::registry()
+        .with(fmt_layer)
+        .with(granual_filtered_env()?)
+        .with(tracing_subscriber::filter::LevelFilter::from_level(
+            Level::INFO,
+        ))
+        .with(MetricsLayer::new(meter_provider.clone()))
+        .with(OpenTelemetryLayer::new(tracer));
+
+    registry
+        .try_init()
+        .map_err(TracingError::TracingTryInitError)?;
+
+    global::set_tracer_provider(tracer_provider.clone());
+    global::set_meter_provider(meter_provider.clone());
+
+    info!("Tracing initialized with service name: {}", service_name);
+
+    Ok(TracerProviderGuard(Some(tracer_provider)))
+}
+
+fn build_resource(service_name: &str) -> Resource {
+    Resource::builder()
+        .with_service_name(service_name.to_string())
+        .with_schema_url(
+            [
+                KeyValue::new(SERVICE_VERSION, env!("CARGO_PKG_VERSION")),
+                KeyValue::new(DEPLOYMENT_ENVIRONMENT_NAME, "develop"),
+            ],
+            SCHEMA_URL,
+        )
+        .build()
+}
+
+fn init_tracer_provider(
+    endpoint: &str,
+    metadata: MetadataMap,
+    resource: Resource,
+) -> Result<SdkTracerProvider, TracingError> {
+    let mut exporter_builder = opentelemetry_otlp::SpanExporter::builder()
+        .with_tonic()
+        .with_metadata(metadata)
+        .with_endpoint(endpoint);
+
+    if endpoint.starts_with("https://") {
+        exporter_builder =
+            exporter_builder.with_tls_config(ClientTlsConfig::new().with_enabled_roots());
+    }
+
+    let exporter = exporter_builder.build()?;
+
+    let tracer = SdkTracerProvider::builder()
+        .with_sampler(Sampler::ParentBased(Box::new(Sampler::TraceIdRatioBased(
+            1.0,
+        ))))
+        .with_id_generator(Compact13BytesIdGenerator)
+        .with_resource(resource)
+        .with_batch_exporter(exporter)
+        .build();
+
+    global::set_tracer_provider(tracer.clone());
+    Ok(tracer)
+}
+
+fn init_meter_provider(
+    endpoint: &str,
+    metadata: MetadataMap,
+    resource: Resource,
+) -> Result<SdkMeterProvider, TracingError> {
+    let mut exporter_builder = opentelemetry_otlp::MetricExporter::builder()
+        .with_tonic()
+        .with_metadata(metadata)
+        .with_endpoint(endpoint)
+        .with_temporality(opentelemetry_sdk::metrics::Temporality::default());
+
+    if endpoint.starts_with("https://") {
+        exporter_builder =
+            exporter_builder.with_tls_config(ClientTlsConfig::new().with_enabled_roots());
+    }
+
+    let exporter = exporter_builder.build()?;
+
+    let reader = PeriodicReader::builder(exporter)
+        .with_interval(std::time::Duration::from_secs(30))
+        .build();
+
+    let stdout_reader =
+        PeriodicReader::builder(opentelemetry_stdout::MetricExporter::default()).build();
+
+    let meter_provider = MeterProviderBuilder::default()
+        .with_resource(resource)
+        .with_reader(reader)
+        .with_reader(stdout_reader)
+        .build();
+
+    global::set_meter_provider(meter_provider.clone());
+
+    Ok(meter_provider)
+}
@@ -0,0 +1,88 @@
+use chrono::Utc;
+use opentelemetry::trace::TraceContextExt;
+use opentelemetry::{SpanId, TraceId};
+use serde::ser::{SerializeMap, Serializer as _};
+use std::io;
+use tracing::{Event, Subscriber};
+use tracing_opentelemetry::OpenTelemetrySpanExt;
+use tracing_serde::AsSerde;
+use tracing_serde::fields::AsMap;
+use tracing_subscriber::fmt::format::Writer;
+use tracing_subscriber::fmt::{FmtContext, FormatEvent, FormatFields};
+use tracing_subscriber::registry::LookupSpan;
+
+pub struct WriteAdaptor<'a> {
+    fmt_write: &'a mut dyn std::fmt::Write,
+}
+
+impl<'a> WriteAdaptor<'a> {
+    pub fn new(fmt_write: &'a mut dyn std::fmt::Write) -> Self {
+        Self { fmt_write }
+    }
+}
+
+impl<'a> io::Write for WriteAdaptor<'a> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let s =
+            std::str::from_utf8(buf).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        self.fmt_write
+            .write_str(s)
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+        Ok(s.as_bytes().len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+pub struct TraceIdFormat;
+
+impl<S, N> FormatEvent<S, N> for TraceIdFormat
+where
+    S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+    N: for<'writer> FormatFields<'writer> + 'static,
+{
+    fn format_event(
+        &self,
+        _ctx: &FmtContext<'_, S, N>,
+        mut writer: Writer<'_>,
+        event: &Event<'_>,
+    ) -> std::fmt::Result
+    where
+        S: Subscriber + for<'a> LookupSpan<'a>,
+    {
+        let meta = event.metadata();
+
+        let mut visit = || {
+            let mut serializer = serde_json::Serializer::new(WriteAdaptor::new(&mut writer));
+            let mut serializer = serializer.serialize_map(None)?;
+            serializer.serialize_entry("timestamp", &Utc::now().to_rfc3339())?;
+            serializer.serialize_entry("level", &meta.level().as_serde())?;
+            serializer.serialize_entry("fields", &event.field_map())?;
+            serializer.serialize_entry("target", meta.target())?;
+
+            let current_span = tracing::Span::current();
+            let context = current_span.context();
+            let span_ref = context.span();
+            let span_context = span_ref.span_context();
+
+            let trace_id = span_context.trace_id();
+            if trace_id != TraceId::INVALID {
+                serializer.serialize_entry("trace_id", &trace_id.to_string())?;
+
+                let span_id = span_context.span_id();
+                if span_id != SpanId::INVALID {
+                    serializer.serialize_entry("span_id", &span_id.to_string())?;
+                }
+            }
+
+            serializer.end()
+        };
+
+        visit().map_err(|_| std::fmt::Error)?;
+        writeln!(writer)
+    }
+}
@@ -36,7 +36,7 @@ nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-crypto = { path = "../crypto" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 nym-gateway-requests = { path = "../gateway-requests" }
-nym-http-api-client = { path = "../http-api-client", features = ["network-defaults"] }
+nym-http-api-client = { path = "../http-api-client" }
 nym-nonexhaustive-delayqueue = { path = "../nonexhaustive-delayqueue" }
 nym-sphinx = { path = "../nymsphinx" }
 nym-statistics-common = { path = "../statistics" }
@@ -126,6 +126,7 @@ cli = ["clap", "comfy-table"]
 fs-credentials-storage = ["nym-credential-storage/persistent-storage"]
 fs-surb-storage = ["nym-client-core-surb-storage/fs-surb-storage"]
 fs-gateways-storage = ["nym-client-core-gateways-storage/fs-gateways-storage"]
+otel = ["nym-sphinx/otel"]
 wasm = ["nym-gateway-client/wasm"]
 metrics-server = []

@@ -67,16 +67,13 @@ use std::path::Path;
 use std::sync::Arc;
 use time::OffsetDateTime;
 use tokio::sync::mpsc::Sender;
+use tracing::instrument;
 use url::Url;

 #[cfg(target_arch = "wasm32")]
 #[cfg(debug_assertions)]
 use wasm_utils::console_log;

-/// Default number of retries for Nym API requests when using network details with domain fronting.
-/// This allows the client to try alternative URLs if the primary endpoint is unavailable.
-const DEFAULT_NYM_API_RETRIES: usize = 3;
-
 #[cfg(all(
    not(target_arch = "wasm32"),
    feature = "fs-surb-storage",
@@ -125,6 +122,7 @@ pub struct ClientOutput {
 }

 impl ClientOutput {
+    #[instrument(name = "ClientOutput::register_receiver", skip_all)]
    pub fn register_receiver(
        &mut self,
    ) -> Result<mpsc::UnboundedReceiver<Vec<ReconstructedMessage>>, ClientCoreError> {
@@ -216,9 +214,6 @@ pub struct BaseClientBuilder<C, S: MixnetClientStorage> {
    client_store: S,
    dkg_query_client: Option<C>,

-    // Optional API URLs for domain fronting support
-    nym_api_urls: Option<Vec<nym_network_defaults::ApiUrl>>,
-
    wait_for_gateway: bool,
    custom_topology_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
    custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
@@ -248,7 +243,6 @@ where
            config: base_config,
            client_store,
            dkg_query_client,
-            nym_api_urls: None,
            wait_for_gateway: false,
            custom_topology_provider: None,
            custom_gateway_transceiver: None,
@@ -271,16 +265,6 @@ where
        self
    }

-    /// Set Nym API URLs for domain fronting support.
-    ///
-    /// When provided, the client will use these API URLs (which include front_hosts)
-    /// to construct HTTP clients with domain fronting enabled.
-    #[must_use]
-    pub fn with_nym_api_urls(mut self, nym_api_urls: Vec<nym_network_defaults::ApiUrl>) -> Self {
-        self.nym_api_urls = Some(nym_api_urls);
-        self
-    }
-
    #[must_use]
    pub fn with_forget_me(mut self, forget_me: &ForgetMe) -> Self {
        self.config.debug.forget_me = *forget_me;
@@ -402,6 +386,7 @@ where
    }

    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all)]
    fn start_real_traffic_controller(
        controller_config: real_messages_control::Config,
        key_rotation_config: KeyRotationConfig,
@@ -493,6 +478,7 @@ where

    // buffer controlling all messages fetched from provider
    // required so that other components would be able to use them (say the websocket)
+    #[instrument(skip_all)]
    fn start_received_messages_buffer_controller(
        local_encryption_keypair: Arc<x25519::KeyPair>,
        query_receiver: ReceivedBufferRequestReceiver,
@@ -525,6 +511,7 @@ where
    }

    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all)]
    async fn start_gateway_client(
        config: &Config,
        initialisation_result: InitialisationResult,
@@ -631,6 +618,7 @@ where
    }

    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all)]
    async fn setup_gateway_transceiver(
        custom_gateway_transceiver: Option<Box<dyn GatewayTransceiver + Send>>,
        config: &Config,
@@ -788,7 +776,7 @@ where
            shutdown_tracker,
        )
    }
-
+    #[instrument(skip_all)]
    fn start_mix_traffic_controller(
        gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
        shutdown_tracker: &ShutdownTracker,
@@ -801,7 +789,7 @@ where
            event_tx,
        );

-        let mix_tx = mix_traffic_controller.mix_tx();
+        let mix_tx = mix_traffic_controller.mix_rx();
        let client_tx = mix_traffic_controller.client_tx();

        shutdown_tracker.try_spawn_named(
@@ -881,67 +869,21 @@ where
    }

    fn construct_nym_api_client(
-        nym_api_urls: Option<&Vec<nym_network_defaults::ApiUrl>>,
        config: &Config,
        user_agent: Option<UserAgent>,
    ) -> Result<nym_http_api_client::Client, ClientCoreError> {
-        tracing::debug!(
-            "construct_nym_api_client called with nym_api_urls: {}",
-            nym_api_urls.is_some()
-        );
-
-        // If API URLs are provided, use new_with_fronted_urls() which handles domain fronting
-        if let Some(nym_api_urls) = nym_api_urls {
-            if nym_api_urls.is_empty() {
-                tracing::warn!("Provided nym_api_urls is empty, falling back to config endpoints");
-            } else {
-                tracing::info!(
-                    "Building nym-api client from provided URLs (with domain fronting support): {} URLs",
-                    nym_api_urls.len()
-                );
-
-                let mut builder =
-                    nym_http_api_client::ClientBuilder::new_with_fronted_urls(nym_api_urls.clone())
-                        .map_err(ClientCoreError::from)?
-                        .with_retries(DEFAULT_NYM_API_RETRIES);
-
-                if let Some(user_agent) = user_agent {
-                    builder = builder.with_user_agent(user_agent);
-                }
-
-                return builder.build().map_err(ClientCoreError::from);
-            }
-        }
-
-        // Fallback to basic client for backwards compatibility
-        tracing::debug!("Building basic nym-api HTTP client from config endpoints");
-
        let mut nym_api_urls = config.get_nym_api_endpoints();
-        if nym_api_urls.is_empty() {
-            tracing::warn!("No API endpoints configured in config, this may cause issues");
-        }
        nym_api_urls.shuffle(&mut thread_rng());

-        // Convert config URLs to ApiUrl format for consistency
-        let api_urls: Vec<nym_network_defaults::ApiUrl> = nym_api_urls
-            .into_iter()
-            .map(|url| nym_network_defaults::ApiUrl {
-                url: url.to_string(),
-                front_hosts: None,
-            })
-            .collect();
-
-        tracing::debug!("Using {} config API endpoints", api_urls.len());
-
-        let mut builder = nym_http_api_client::ClientBuilder::new_with_fronted_urls(api_urls)
-            .map_err(ClientCoreError::from)?
-            .with_retries(DEFAULT_NYM_API_RETRIES)
-            .with_bincode();
+        let mut builder = nym_http_api_client::Client::builder(nym_api_urls[0].clone())
+            .map_err(ClientCoreError::from)?;

        if let Some(user_agent) = user_agent {
            builder = builder.with_user_agent(user_agent);
        }

+        builder = builder.with_bincode();
+
        builder.build().map_err(ClientCoreError::from)
    }

@@ -951,6 +893,7 @@ where
        Ok(client.get_key_rotation_info().await?.into())
    }

+    #[instrument(skip_all)]
    pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>
    where
        S::ReplyStore: Send + Sync,
@@ -1004,8 +947,8 @@ where
        // Create a shutdown tracker for this client - either as a child of provided tracker
        // or get one from the registry
        let shutdown_tracker = match self.shutdown {
-            Some(parent_tracker) => parent_tracker.clone(),
-            None => nym_task::create_sdk_shutdown_tracker()?,
+            Some(parent_tracker) => parent_tracker.child_tracker(),
+            None => nym_task::get_sdk_shutdown_tracker()?,
        };

        Self::start_event_control(self.event_tx, event_receiver, &shutdown_tracker);
@@ -1025,11 +968,7 @@ where
            .dkg_query_client
            .map(|client| BandwidthController::new(credential_store, client));

-        let nym_api_client = Self::construct_nym_api_client(
-            self.nym_api_urls.as_ref(),
-            &self.config,
-            self.user_agent.clone(),
-        )?;
+        let nym_api_client = Self::construct_nym_api_client(&self.config, self.user_agent.clone())?;
        let key_rotation_config = Self::determine_key_rotation_state(&nym_api_client).await?;

        let topology_provider = Self::setup_topology_provider(
@@ -1044,7 +983,7 @@ where
            self.user_agent.clone(),
            generate_client_stats_id(*self_address.identity()),
            input_sender.clone(),
-            &shutdown_tracker.clone(),
+            &shutdown_tracker.child_tracker(),
        );

        // needs to be started as the first thing to block if required waiting for the gateway
@@ -1054,7 +993,7 @@ where
            shared_topology_accessor.clone(),
            self_address.gateway(),
            self.wait_for_gateway,
-            &shutdown_tracker.clone(),
+            &shutdown_tracker.child_tracker(),
        )
        .await?;

@@ -1074,7 +1013,7 @@ where
            stats_reporter.clone(),
            #[cfg(unix)]
            self.connection_fd_callback,
-            &shutdown_tracker.clone(),
+            &shutdown_tracker.child_tracker(),
        )
        .await?;
        let gateway_ws_fd = gateway_transceiver.ws_fd();
@@ -1082,7 +1021,7 @@ where
        let reply_storage = Self::setup_persistent_reply_storage(
            reply_storage_backend,
            key_rotation_config,
-            &shutdown_tracker.clone(),
+            &shutdown_tracker.child_tracker(),
        )
        .await?;

@@ -1093,7 +1032,7 @@ where
            reply_storage.key_storage(),
            reply_controller_sender.clone(),
            stats_reporter.clone(),
-            &shutdown_tracker.clone(),
+            &shutdown_tracker.child_tracker(),
        );

        // The message_sender is the transmitter for any component generating sphinx packets
@@ -1103,7 +1042,7 @@ where

        let (message_sender, client_request_sender) = Self::start_mix_traffic_controller(
            gateway_transceiver,
-            &shutdown_tracker.clone(),
+            &shutdown_tracker.child_tracker(),
            EventSender(event_sender),
        );

@@ -1134,7 +1073,7 @@ where
            shared_lane_queue_lengths.clone(),
            client_connection_rx,
            stats_reporter.clone(),
-            &shutdown_tracker.clone(),
+            &shutdown_tracker.child_tracker(),
        );

        if !self
@@ -1150,7 +1089,7 @@ where
                shared_topology_accessor.clone(),
                message_sender,
                stats_reporter.clone(),
-                &shutdown_tracker.clone(),
+                &shutdown_tracker.child_tracker(),
            );
        }

@@ -1204,53 +1143,3 @@ pub struct BaseClient {
    pub forget_me: ForgetMe,
    pub remember_me: RememberMe,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use nym_network_defaults::{ApiUrl, NymNetworkDetails};
-
-    #[test]
-    fn test_network_details_with_multiple_urls() {
-        // Verify that network details can be configured with multiple API URLs
-        let mut network_details = NymNetworkDetails::new_empty();
-        network_details.nym_api_urls = Some(vec![
-            ApiUrl {
-                url: "https://validator.nymtech.net/api/".to_string(),
-                front_hosts: None,
-            },
-            ApiUrl {
-                url: "https://nym-frontdoor.vercel.app/api/".to_string(),
-                front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
-            },
-        ]);
-
-        assert_eq!(network_details.nym_api_urls.as_ref().unwrap().len(), 2);
-        assert!(network_details.nym_api_urls.as_ref().unwrap()[1]
-            .front_hosts
-            .is_some());
-    }
-
-    #[test]
-    fn test_network_details_with_front_hosts() {
-        // Verify that ApiUrl can store domain fronting configuration
-        let api_url = ApiUrl {
-            url: "https://nym-frontdoor.vercel.app/api/".to_string(),
-            front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
-        };
-
-        assert_eq!(api_url.url, "https://nym-frontdoor.vercel.app/api/");
-        assert_eq!(api_url.front_hosts.as_ref().unwrap().len(), 2);
-        assert!(api_url
-            .front_hosts
-            .as_ref()
-            .unwrap()
-            .contains(&"vercel.app".to_string()));
-    }
-
-    #[test]
-    fn test_default_nym_api_retries_constant() {
-        // Verify the retry constant is set correctly
-        assert_eq!(DEFAULT_NYM_API_RETRIES, 3);
-    }
-}
@@ -205,7 +205,7 @@ impl LoopCoverTrafficStream<OsRng> {
                TrySendError::Full(_) => {
                    // This isn't a problem, if the channel is full means we're already sending the
                    // max amount of messages downstream can handle.
-                    tracing::trace!("Failed to send cover message - channel full");
+                    tracing::debug!("Failed to send cover message - channel full");
                }
                TrySendError::Closed(_) => {
                    tracing::warn!("Failed to send cover message - channel closed");
@@ -29,6 +29,8 @@ pub enum InputMessage {
        data: Vec<u8>,
        lane: TransmissionLane,
        max_retransmissions: Option<u32>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    },

    /// Creates a message used for a duplex anonymous communication where the recipient
@@ -45,6 +47,8 @@ pub enum InputMessage {
        reply_surbs: u32,
        lane: TransmissionLane,
        max_retransmissions: Option<u32>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    },

    /// Attempt to use our internally received and stored `ReplySurb` to send the message back
@@ -90,12 +94,16 @@ impl InputMessage {
        data: Vec<u8>,
        lane: TransmissionLane,
        packet_type: Option<PacketType>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Self {
        let message = InputMessage::Regular {
            recipient,
            data,
            lane,
            max_retransmissions: None,
+            #[cfg(feature = "otel")]
+            trace_id,
        };
        if let Some(packet_type) = packet_type {
            InputMessage::new_wrapper(message, packet_type)
@@ -110,6 +118,8 @@ impl InputMessage {
        reply_surbs: u32,
        lane: TransmissionLane,
        packet_type: Option<PacketType>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Self {
        let message = InputMessage::Anonymous {
            recipient,
@@ -117,6 +127,8 @@ impl InputMessage {
            reply_surbs,
            lane,
            max_retransmissions: None,
+            #[cfg(feature = "otel")]
+            trace_id,
        };
        if let Some(packet_type) = packet_type {
            InputMessage::new_wrapper(message, packet_type)
@@ -185,4 +197,14 @@ impl InputMessage {
        self.set_max_retransmissions(max_retransmissions);
        self
    }
+
+    #[cfg(feature = "otel")]
+    pub fn trace_id(&self) -> Option<[u8; 12]> {
+        match self {
+            InputMessage::Regular { trace_id, .. } => *trace_id,
+            InputMessage::Anonymous { trace_id, .. } => *trace_id,
+            InputMessage::Premade { .. } | InputMessage::Reply { .. } => None,
+            InputMessage::MessageWrapper { message, .. } => message.trace_id(),
+        }
+    }
 }
@@ -20,10 +20,7 @@ pub mod transceiver;

 // We remind ourselves that 32 x 32kb = 1024kb, a reasonable size for a network buffer.
 pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
-
-/// Reduced from 100 to 20 to fail fast (~1-2 seconds instead of ~6 seconds).
-/// If we can't send 20 packets in a row, the gateway is unreachable.
-const MAX_FAILURE_COUNT: usize = 20;
+const MAX_FAILURE_COUNT: usize = 100;

 // that's also disgusting.
 pub struct Empty;
@@ -87,7 +84,7 @@ impl MixTrafficController {
        self.client_tx.clone()
    }

-    pub fn mix_tx(&self) -> BatchMixMessageSender {
+    pub fn mix_rx(&self) -> BatchMixMessageSender {
        self.mix_tx.clone()
    }

@@ -159,11 +156,6 @@ impl MixTrafficController {
                            // Do we need to handle the embedded mixnet client case
                            // separately?
                            self.event_tx.send(MixnetClientEvent::Traffic(MixTrafficEvent::FailedSendingSphinx));
-                            // IMO it shouldn't be signalled from there but it is how it is
-                            // TODO : report the failure upwards and shutdown from upwards
-                            // Gateway is dead, we have to shut down currently
-                            error!("Signalling shutdown from the MixTrafficController");
-                            self.shutdown_token.cancel();
                            break;
                        }
                    }
@@ -70,6 +70,7 @@ where
                .send_reply(recipient_tag, data, lane, max_retransmissions);
    }

+    #[instrument(skip_all)]
    async fn handle_plain_message(
        &mut self,
        recipient: Recipient,
@@ -77,16 +78,27 @@ where
        lane: TransmissionLane,
        packet_type: PacketType,
        max_retransmissions: Option<u32>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_plain_message(recipient, content, lane, packet_type, max_retransmissions)
+            .try_send_plain_message(
+                recipient,
+                content,
+                lane,
+                packet_type,
+                max_retransmissions,
+                #[cfg(feature = "otel")]
+                trace_id,
+            )
            .await
        {
            warn!("failed to send a plain message - {err}")
        }
    }

+    #[instrument(skip_all)]
    async fn handle_repliable_message(
        &mut self,
        recipient: Recipient,
@@ -95,6 +107,8 @@ where
        lane: TransmissionLane,
        packet_type: PacketType,
        max_retransmissions: Option<u32>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) {
        if let Err(err) = self
            .message_handler
@@ -105,6 +119,8 @@ where
                lane,
                packet_type,
                max_retransmissions,
+                #[cfg(feature = "otel")]
+                trace_id,
            )
            .await
        {
@@ -113,20 +129,36 @@ where
    }

    #[allow(clippy::panic)]
+    #[instrument(skip_all)]
    async fn on_input_message(&mut self, msg: InputMessage) {
+        #[cfg(feature = "otel")]
+        let trace_id = msg.trace_id();
+        #[cfg(feature = "otel")]
+        if let Some(tid) = trace_id {
+            tracing::info!("Processing input message with trace_id: {:?}", tid);
+        }
+
        match msg {
            InputMessage::Regular {
                recipient,
                data,
                lane,
                max_retransmissions,
+                ..
            } => {
+                #[cfg(feature = "otel")]
+                info!(
+                    "Handling regular input message with trace_id: {:?}",
+                    trace_id
+                );
                self.handle_plain_message(
                    recipient,
                    data,
                    lane,
                    PacketType::Mix,
                    max_retransmissions,
+                    #[cfg(feature = "otel")]
+                    trace_id,
                )
                .await
            }
@@ -136,7 +168,13 @@ where
                reply_surbs,
                lane,
                max_retransmissions,
+                ..
            } => {
+                #[cfg(feature = "otel")]
+                tracing::info!(
+                    "Handling anonymous input message with trace_id: {:?}",
+                    trace_id
+                );
                self.handle_repliable_message(
                    recipient,
                    data,
@@ -144,6 +182,8 @@ where
                    lane,
                    PacketType::Mix,
                    max_retransmissions,
+                    #[cfg(feature = "otel")]
+                    trace_id,
                )
                .await
            }
@@ -153,6 +193,8 @@ where
                lane,
                max_retransmissions,
            } => {
+                #[cfg(feature = "otel")]
+                info!("Handling reply input message with trace_id: {:?}", trace_id);
                self.handle_reply(recipient_tag, data, lane, max_retransmissions)
                    .await;
            }
@@ -166,13 +208,21 @@ where
                    data,
                    lane,
                    max_retransmissions,
+                    ..
                } => {
+                    #[cfg(feature = "otel")]
+                    tracing::info!(
+                        "Handling regular input message with trace_id: {:?}",
+                        trace_id
+                    );
                    self.handle_plain_message(
                        recipient,
                        data,
                        lane,
                        packet_type,
                        max_retransmissions,
+                        #[cfg(feature = "otel")]
+                        trace_id,
                    )
                    .await
                }
@@ -182,6 +232,7 @@ where
                    reply_surbs,
                    lane,
                    max_retransmissions,
+                    ..
                } => {
                    self.handle_repliable_message(
                        recipient,
@@ -190,6 +241,8 @@ where
                        lane,
                        packet_type,
                        max_retransmissions,
+                        #[cfg(feature = "otel")]
+                        trace_id,
                    )
                    .await
                }
@@ -213,6 +266,7 @@ where
        };
    }

+    #[instrument(skip_all)]
    pub(crate) async fn run(&mut self, shutdown_token: ShutdownToken) {
        debug!("Started InputMessageListener with graceful shutdown support");

@@ -60,7 +60,13 @@ where

        // TODO: Figure out retransmission packet type signaling
        self.message_handler
-            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, packet_type)
+            .try_prepare_single_chunk_for_sending(
+                packet_recipient,
+                chunk_data,
+                packet_type,
+                #[cfg(feature = "otel")]
+                None
+            )
            .await
    }

@@ -27,7 +27,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
 use thiserror::Error;
-use tracing::{debug, error, info, trace, warn};
+use tracing::{debug, error, info, instrument, trace, warn};

 // TODO: move that error elsewhere since it seems to be contaminating different files
 #[derive(Debug, Error)]
@@ -476,6 +476,7 @@ where
        self.forward_messages(msgs, lane).await;
    }

+    #[instrument(skip_all)]
    pub(crate) async fn try_send_plain_message(
        &mut self,
        recipient: Recipient,
@@ -483,6 +484,8 @@ where
        lane: TransmissionLane,
        packet_type: PacketType,
        max_retransmissions: Option<u32>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Result<(), PreparationError> {
        let message = NymMessage::new_plain(message);
        self.try_split_and_send_non_reply_message(
@@ -491,10 +494,13 @@ where
            lane,
            packet_type,
            max_retransmissions,
+            #[cfg(feature = "otel")]
+            trace_id,
        )
        .await
    }

+    #[instrument(skip_all)]
    pub(crate) async fn try_split_and_send_non_reply_message(
        &mut self,
        message: NymMessage,
@@ -502,6 +508,8 @@ where
        lane: TransmissionLane,
        packet_type: PacketType,
        max_retransmissions: Option<u32>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Result<(), PreparationError> {
        debug!("Sending non-reply message with packet type {packet_type}");
        // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
@@ -534,6 +542,8 @@ where
                &self.config.ack_key,
                &recipient,
                packet_type,
+                #[cfg(feature = "otel")]
+                trace_id,
            )?;

            let real_message = RealMessage::new(
@@ -585,6 +595,8 @@ where
            TransmissionLane::AdditionalReplySurbs,
            packet_type,
            max_retransmissions,
+            #[cfg(feature = "otel")]
+            None,
        )
        .await?;

@@ -602,6 +614,8 @@ where
        lane: TransmissionLane,
        packet_type: PacketType,
        max_retransmissions: Option<u32>,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Result<(), SurbWrappedPreparationError> {
        debug!("Sending message with reply SURBs with packet type {packet_type}");
        let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -625,6 +639,8 @@ where
            lane,
            packet_type,
            max_retransmissions,
+            #[cfg(feature = "otel")]
+            trace_id,
        )
        .await?;

@@ -639,6 +655,8 @@ where
        recipient: Recipient,
        chunk: Fragment,
        packet_type: PacketType,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Result<PreparedFragment, PreparationError> {
        debug!("Sending single chunk with packet type {packet_type}");
        let topology_permit = self.topology_access.get_read_permit().await;
@@ -650,6 +668,8 @@ where
            &self.config.ack_key,
            &recipient,
            packet_type,
+            #[cfg(feature = "otel")]
+            trace_id,
        )?;

        Ok(prepared_fragment)
@@ -298,8 +298,6 @@ where
                        "failed to send mixnet packet due to closed channel (outside of shutdown!)"
                    );
                }
-                // Early return to avoid further processing when channel is closed
-                return;
            }
            Ok(_) => {
                let event = if fragment_id.is_some() {
@@ -80,6 +80,8 @@ impl StatisticsControl {
            stats_report.into(),
            TransmissionLane::General,
            None,
+            #[cfg(feature = "otel")]
+            None,
        );
        if let Err(err) = self.report_tx.send(report_message).await {
            tracing::error!("Failed to report client stats: {err:?}");
@@ -151,7 +151,7 @@ pub async fn gateways_for_init(
    }

    let retry_count = retry_count.unwrap_or(DEFAULT_NYM_API_RETRIES);
-    let mut builder = nym_http_api_client::ClientBuilder::new_with_urls(nym_api_urls.clone())?
+    let mut builder = nym_http_api_client::ClientBuilder::new_with_urls(nym_api_urls.clone())
        .with_retries(retry_count)
        .with_bincode();

@@ -441,7 +441,7 @@ mod tests {

    #[test]
    fn test_multiple_urls_prepared_for_retries() {
-        let urls = [
+        let urls = vec![
            Url::parse("https://api1.nym.com").unwrap(),
            Url::parse("https://api2.nym.com").unwrap(),
            Url::parse("https://api3.nym.com").unwrap(),
@@ -1043,6 +1043,12 @@ impl<C, St> GatewayClient<C, St> {
    }

    // Note: this requires prior authentication
+    #[instrument(skip_all,
+        fields(
+            gateway = %self.gateway_identity,
+            gateway_address = %self.gateway_address
+        )
+    )]
    pub fn start_listening_for_mixnet_messages(&mut self) -> Result<(), GatewayClientError> {
        if !self.authenticated {
            return Err(GatewayClientError::NotAuthenticated);
@@ -267,6 +267,7 @@ impl Client {
 }

 impl SendWithoutResponse for Client {
+    #[instrument(skip(self, packet))]
    fn send_without_response(&self, packet: MixPacket) -> io::Result<()> {
        let address = packet.next_hop_address();
        trace!("Sending packet to {address}");
@@ -241,28 +241,23 @@ impl Epoch {
 //
 // Note: It's important that the variant ordering is not changed otherwise it would mess up the derived `PartialOrd`
 #[cw_serde]
-#[derive(Copy, Default)]
+#[derive(Copy)]
 pub enum EpochState {
-    #[default]
    WaitingInitialisation,
-    PublicKeySubmission {
-        resharing: bool,
-    },
-    DealingExchange {
-        resharing: bool,
-    },
-    VerificationKeySubmission {
-        resharing: bool,
-    },
-    VerificationKeyValidation {
-        resharing: bool,
-    },
-    VerificationKeyFinalization {
-        resharing: bool,
-    },
+    PublicKeySubmission { resharing: bool },
+    DealingExchange { resharing: bool },
+    VerificationKeySubmission { resharing: bool },
+    VerificationKeyValidation { resharing: bool },
+    VerificationKeyFinalization { resharing: bool },
    InProgress,
 }

+impl Default for EpochState {
+    fn default() -> Self {
+        Self::WaitingInitialisation
+    }
+}
+
 impl Display for EpochState {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
@@ -8,7 +8,7 @@ async fn main() -> anyhow::Result<()> {
    use sqlx::{Connection, SqliteConnection};
    use std::env;

-    let out_dir = env::var("OUT_DIR").context("missing OUT_DIR env variable")?;
+    let out_dir = env::var("OUT_DIR")?;
    let database_path = format!("{out_dir}/nym-credential-proxy-example.sqlite");

    // remove the db file if it already existed from previous build
@@ -127,13 +127,6 @@ pub enum CredentialProxyError {
    #[error("failed to create deposit")]
    DepositFailure,

-    #[error("failed to load jwt signing key from {path}: {err}")]
-    JWTSigningKeyLoadFailure {
-        path: String,
-        #[source]
-        err: std::io::Error,
-    },
-
    #[error("can't obtain sufficient number of credential shares due to unavailable quorum")]
    UnavailableSigningQuorum,

@@ -7,9 +7,9 @@ use crate::ticketbook_manager::TicketbookManager;
 use nym_compact_ecash::Base58;
 use nym_credential_proxy_requests::api::v1::ticketbook::models::{
    CurrentEpochResponse, DepositResponse, GlobalDataParams, MasterVerificationKeyResponse,
-    ObtainTicketBookSharesAsyncResponse, PartialVerificationKey, PartialVerificationKeysResponse,
-    TicketbookAsyncRequest, TicketbookObtainParams, TicketbookRequest,
-    TicketbookWalletSharesAsyncResponse, TicketbookWalletSharesResponse,
+    PartialVerificationKey, PartialVerificationKeysResponse, TicketbookAsyncRequest,
+    TicketbookObtainParams, TicketbookRequest, TicketbookWalletSharesAsyncResponse,
+    TicketbookWalletSharesResponse,
 };
 use time::OffsetDateTime;
 use tracing::{Instrument, Level, error, info, span, warn};
@@ -65,7 +65,7 @@ impl TicketbookManager {
        uuid: Uuid,
        request: TicketbookAsyncRequest,
        params: TicketbookObtainParams,
-    ) -> Result<ObtainTicketBookSharesAsyncResponse, CredentialProxyError> {
+    ) -> Result<TicketbookWalletSharesAsyncResponse, CredentialProxyError> {
        let requested_on = OffsetDateTime::now_utc();
        let span = span!(Level::INFO, "[async] obtain ticketboook", uuid = %uuid);
        async move {
@@ -110,7 +110,7 @@ impl TicketbookManager {
            }

            // 4. in the meantime, return the id to the user
-            Ok(TicketbookWalletSharesAsyncResponse { id, uuid }.into())
+            Ok(TicketbookWalletSharesAsyncResponse { id, uuid })
        }
        .instrument(span)
        .await
@@ -246,7 +246,7 @@ mod tests {
        let _exp_date_sigs = generate_expiration_date_signatures(
            sig_req.expiration_date.ecash_unix_timestamp(),
            &[signing_keys.secret_key()],
-            &[signing_keys.verification_key()],
+            &vec![signing_keys.verification_key()],
            &signing_keys.verification_key(),
            &[1],
        )?;
@@ -263,7 +263,7 @@ mod tests {

        let wallet = issuance.aggregate_signature_shares(
            &signing_keys.verification_key(),
-            &[partial_wallet],
+            &vec![partial_wallet],
            sig_req,
        )?;

@@ -36,11 +36,7 @@ nym-sphinx-types = { path = "../nymsphinx/types", version = "0.2.0", default-fea
 nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }

 [dev-dependencies]
-anyhow = { workspace = true }
 rand_chacha = { workspace = true }
-serde_json = { workspace = true }
-nym-test-utils = { path = "../test-utils" }
-

 [features]
 default = []
@@ -17,51 +17,6 @@ pub mod bs58_ed25519_pubkey {
    }
 }

-pub mod vec_bs58_ed25519_pubkey {
-    use super::*;
-    use serde::{Deserialize, Deserializer, Serializer, ser::SerializeSeq};
-
-    pub fn serialize<S: Serializer>(
-        keys: &Vec<PublicKey>,
-        serializer: S,
-    ) -> Result<S::Ok, S::Error> {
-        let mut seq = serializer.serialize_seq(Some(keys.len()))?;
-        for key in keys {
-            seq.serialize_element(&Bs58KeyWrapper(*key))?;
-        }
-        seq.end()
-    }
-
-    pub fn deserialize<'de, D: Deserializer<'de>>(
-        deserializer: D,
-    ) -> Result<Vec<PublicKey>, D::Error> {
-        let wrapped = Vec::<Bs58KeyWrapper>::deserialize(deserializer)?;
-        Ok(wrapped.into_iter().map(|k| k.0).collect())
-    }
-
-    struct Bs58KeyWrapper(PublicKey);
-
-    impl serde::Serialize for Bs58KeyWrapper {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            bs58_ed25519_pubkey::serialize(&self.0, serializer)
-        }
-    }
-
-    impl<'de> Deserialize<'de> for Bs58KeyWrapper {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            Ok(Bs58KeyWrapper(bs58_ed25519_pubkey::deserialize(
-                deserializer,
-            )?))
-        }
-    }
-}
-
 pub mod bs58_ed25519_signature {
    use crate::asymmetric::ed25519::Signature;
    use serde::{Deserialize, Deserializer, Serializer};
@@ -78,53 +33,3 @@ pub mod bs58_ed25519_signature {
        Signature::from_base58_string(s).map_err(serde::de::Error::custom)
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use jwt_simple::reexports::{anyhow, serde_json};
-    use nym_test_utils::helpers::deterministic_rng;
-    use serde::{Deserialize, Serialize};
-
-    #[test]
-    fn vec_bs58_ed25519_pubkey_json() -> anyhow::Result<()> {
-        #[derive(Serialize, Deserialize, Debug, PartialEq)]
-        struct KeysWrapper(#[serde(with = "vec_bs58_ed25519_pubkey")] Vec<PublicKey>);
-
-        use crate::asymmetric::ed25519;
-        let mut rng = deterministic_rng();
-        let empty = KeysWrapper(vec![]);
-        let single_key = KeysWrapper(vec![PublicKey::from_base58_string(
-            "Be9wH7xuXBRJAuV1pC7MALZv6a61RvWQ3SypsNarqTt",
-        )?]);
-        let three_keys = KeysWrapper(vec![
-            ed25519::KeyPair::new(&mut rng).public_key,
-            ed25519::KeyPair::new(&mut rng).public_key,
-            ed25519::KeyPair::new(&mut rng).public_key,
-        ]);
-
-        let se_empty = serde_json::to_string(&empty)?;
-        let se_single_key = serde_json::to_string(&single_key)?;
-        let se_three_keys = serde_json::to_string(&three_keys)?;
-
-        assert_eq!(se_empty, r#"[]"#);
-        assert_eq!(
-            se_single_key,
-            r#"["Be9wH7xuXBRJAuV1pC7MALZv6a61RvWQ3SypsNarqTt"]"#
-        );
-        assert_eq!(
-            se_three_keys,
-            r#"["HmgHDV79LpnEaSUp8QZQwSroxVvS4RewF7yM9e7qu8y3","311xRh859qCd5MVqoPRCoNx26eYhLknGwtjzkkTJFGhf","A5BMp8WJ6Uk91U4JpWRv2Bc6X35AaRaSEy8QEWeAkaBv"]"#
-        );
-
-        let empty_de = serde_json::from_str::<KeysWrapper>(&se_empty)?;
-        let single_key_de = serde_json::from_str::<KeysWrapper>(&se_single_key)?;
-        let three_keys_de = serde_json::from_str::<KeysWrapper>(&se_three_keys)?;
-
-        assert_eq!(empty, empty_de);
-        assert_eq!(single_key, single_key_de);
-        assert_eq!(three_keys, three_keys_de);
-
-        Ok(())
-    }
-}
@@ -19,11 +19,11 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 strum = { workspace = true }
 thiserror = { workspace = true }
-tracing = { workspace = true, features = ["log"] }
 time = { workspace = true }
 subtle = { workspace = true }
 zeroize = { workspace = true }

+nym-bin-common = { path = "../bin-common" }
 nym-crypto = { path = "../crypto", features = ["aead", "hashing"] }
 nym-pemstore = { path = "../pemstore" }
 nym-sphinx = { path = "../nymsphinx" }
@@ -34,6 +34,11 @@ nym-task = { path = "../task" }
 nym-credentials = { path = "../credentials" }
 nym-credentials-interface = { path = "../credentials-interface" }

+opentelemetry = { workspace = true, features = ["trace"], optional = true }
+opentelemetry_sdk = { workspace = true, optional = true }
+tracing-opentelemetry = { workspace = true, optional = true }
+tracing = { workspace = true, features = ["std", "attributes", "tracing-attributes"] }
+
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
 workspace = true
 features = ["time"]
@@ -51,3 +56,12 @@ anyhow = { workspace = true }
 nym-compact-ecash = { path = "../nym_offline_compact_ecash" } # we need specific imports in tests
 nym-test-utils = { path = "../test-utils" }
 tokio = { workspace = true, features = ["full"] }
+
+[features]
+default = []
+otel = [
+    "nym-bin-common/otel",
+    "opentelemetry",
+    "opentelemetry_sdk",
+    "tracing-opentelemetry",
+]
@@ -82,7 +82,7 @@ mod tests {
        let exp_date_sigs = generate_expiration_date_signatures(
            sig_req.expiration_date.ecash_unix_timestamp(),
            &[keypair.secret_key()],
-            &[keypair.verification_key()],
+            &vec![keypair.verification_key()],
            &keypair.verification_key(),
            &[keypair.index.unwrap()],
        )
@@ -106,14 +106,14 @@ mod tests {
            .unwrap();

        let wallet = issuance
-            .aggregate_signature_shares(&keypair.verification_key(), &[partial_wallet], sig_req)
+            .aggregate_signature_shares(&keypair.verification_key(), &vec![partial_wallet], sig_req)
            .unwrap();

        let mut issued = issuance.into_issued_ticketbook(wallet, 1);
        let coin_indices_signatures = generate_coin_indices_signatures(
            nym_credentials_interface::ecash_parameters(),
            &[keypair.secret_key()],
-            &[keypair.verification_key()],
+            &vec![keypair.verification_key()],
            &keypair.verification_key(),
            &[keypair.index.unwrap()],
        )
@@ -4,6 +4,7 @@
 use crate::{AuthenticationFailure, GatewayRequestsError, SharedGatewayKey};
 use nym_crypto::asymmetric::ed25519;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::iter;
 use std::time::Duration;
 use subtle::ConstantTimeEq;
@@ -16,6 +17,9 @@ pub struct AuthenticateRequest {
    pub content: AuthenticateRequestContent,

    pub request_signature: ed25519::Signature,
+
+    #[serde(default)]
+    pub otel_context: Option<HashMap<String, String>>,
 }

 impl AuthenticateRequest {
@@ -23,6 +27,7 @@ impl AuthenticateRequest {
        protocol_version: u8,
        shared_key: &SharedGatewayKey,
        identity_keys: &ed25519::KeyPair,
+        otel_context: Option<HashMap<String, String>>,
    ) -> Result<AuthenticateRequest, GatewayRequestsError> {
        let content = AuthenticateRequestContent::new(
            protocol_version,
@@ -35,6 +40,7 @@ impl AuthenticateRequest {
        Ok(AuthenticateRequest {
            content,
            request_signature,
+            otel_context,
        })
    }

@@ -8,12 +8,16 @@ use crate::{
    AUTHENTICATE_V2_PROTOCOL_VERSION, CREDENTIAL_UPDATE_V2_PROTOCOL_VERSION,
    INITIAL_PROTOCOL_VERSION,
 };
+#[cfg(feature = "otel")]
+use nym_bin_common::opentelemetry::context::ContextCarrier;
 use nym_credentials_interface::CredentialSpendingData;
 use nym_crypto::asymmetric::ed25519;
 use nym_sphinx::DestinationAddressBytes;
 use nym_statistics_common::types::SessionType;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use std::str::FromStr;
+use tracing::{instrument, warn};
 use tungstenite::Message;

 pub mod authenticate;
@@ -76,6 +80,10 @@ pub enum ClientControlRequest {
        address: String,
        enc_address: String,
        iv: String,
+        /// this is a trace id that is used in testing and performance verification
+        /// in mainnet, this will always be set to None
+        #[serde(default)]
+        otel_context: Option<HashMap<String, String>>,
    },

    AuthenticateV2(Box<AuthenticateRequest>),
@@ -127,14 +135,25 @@ impl ClientControlRequest {
        let nonce = shared_key.random_nonce_or_iv();
        let ciphertext = shared_key.encrypt_naive(address.as_bytes_ref(), Some(&nonce))?;

+        #[cfg(feature = "otel")]
+        let context_carrier = {
+            let context = opentelemetry::Context::current();
+            ContextCarrier::new_with_current_context(context).into_map()
+        };
+
        Ok(ClientControlRequest::Authenticate {
            protocol_version,
            address: address.as_base58_string(),
            enc_address: bs58::encode(&ciphertext).into_string(),
            iv: bs58::encode(&nonce).into_string(),
+            #[cfg(feature = "otel")]
+            otel_context: Some(context_carrier),
+            #[cfg(not(feature = "otel"))]
+            otel_context: None,
        })
    }

+    #[instrument(skip_all)]
    pub fn new_authenticate_v2(
        shared_key: &SharedGatewayKey,
        identity_keys: &ed25519::KeyPair,
@@ -142,8 +161,25 @@ impl ClientControlRequest {
        // if we're using v2 authentication, we must announce at least that protocol version
        let protocol_version = AUTHENTICATE_V2_PROTOCOL_VERSION;

+        #[cfg(feature = "otel")]
+        let context_carrier = {
+            use nym_bin_common::opentelemetry::context::extract_trace_id_from_tracing_cx;
+            use tracing_opentelemetry::OpenTelemetrySpanExt;
+
+            let current_span = tracing::Span::current();
+            let otel_context = current_span.context();
+            ContextCarrier::new_with_current_context(otel_context).into_map()
+        };
+        #[cfg(not(feature = "otel"))]
+        let context_carrier: HashMap<String, String> = HashMap::new();
+
        Ok(ClientControlRequest::AuthenticateV2(Box::new(
-            AuthenticateRequest::new(protocol_version, shared_key, identity_keys)?,
+            AuthenticateRequest::new(
+                protocol_version,
+                shared_key,
+                identity_keys,
+                Some(context_carrier),
+            )?,
        )))
    }

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

 [features]
+# TODO: Remove otel from default before release
 default=["tunneling"]
 tunneling=[]
 network-defaults = ["dep:nym-network-defaults"]
+otel = ["nym-bin-common/otel", "opentelemetry", "opentelemetry_sdk"]
 debug-inventory = ["nym-http-api-client-macro/debug-inventory"]

 [dependencies]
@@ -24,6 +26,8 @@ reqwest = { workspace = true, features = ["json", "gzip", "deflate", "brotli", "
 http.workspace = true
 url = { workspace = true }
 once_cell = { workspace = true }
+opentelemetry = { workspace = true, optional = true }
+opentelemetry_sdk = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true}
@@ -53,4 +57,3 @@ features = ["tokio"]

 [dev-dependencies]
 tokio = { workspace = true, features = ["rt", "macros"] }
-
@@ -296,9 +296,6 @@ impl std::error::Error for ReqwestErrorWrapper {}
 #[derive(Debug, Error)]
 #[allow(missing_docs)]
 pub enum HttpClientError {
-    #[error("did not provide any valid client URLs")]
-    NoUrlsProvided,
-
    #[error("failed to construct inner reqwest client: {source}")]
    ReqwestBuildError {
        #[source]
@@ -585,29 +582,24 @@ impl ClientBuilder {
            Self::new(alt)
        } else {
            let url = url.to_url()?;
-            Self::new_with_urls(vec![url])
+            Ok(Self::new_with_urls(vec![url]))
        }
    }

    /// Create a client builder from network details with sensible defaults
    #[cfg(feature = "network-defaults")]
-    // deprecating function since it's not clear from its signature whether the client
-    // would be constructed using `nym_api_urls` or `nym_vpn_api_urls`
-    #[deprecated(note = "use explicit Self::new_with_fronted_urls instead")]
    pub fn from_network(
        network: &nym_network_defaults::NymNetworkDetails,
    ) -> Result<Self, HttpClientError> {
-        let urls = network.nym_api_urls.as_ref().cloned().unwrap_or_default();
-        Self::new_with_fronted_urls(urls.clone())
-    }
-
-    /// Create a client builder using the provided set of domain-fronted URLs
-    #[cfg(feature = "network-defaults")]
-    pub fn new_with_fronted_urls(
-        urls: Vec<nym_network_defaults::ApiUrl>,
-    ) -> Result<Self, HttpClientError> {
-        let urls = urls
-            .into_iter()
+        let urls = network
+            .nym_api_urls
+            .as_ref()
+            .ok_or_else(|| {
+                HttpClientError::GenericRequestFailure(
+                    "No API URLs configured in network details".to_string(),
+                )
+            })?
+            .iter()
            .map(|api_url| {
                // Convert ApiUrl to our Url type with fronting support
                let mut url = Url::parse(&api_url.url)?;
@@ -619,19 +611,15 @@ impl ClientBuilder {
                        .iter()
                        .map(|host| format!("https://{}", host))
                        .collect();
-                    url = Url::new(api_url.url.clone(), Some(fronts)).map_err(|source| {
-                        HttpClientError::MalformedUrl {
-                            raw: api_url.url.clone(),
-                            source,
-                        }
-                    })?;
+                    url = Url::new(api_url.url.clone(), Some(fronts))
+                        .map_err(|e| HttpClientError::GenericRequestFailure(e.to_string()))?;
                }

                Ok(url)
            })
            .collect::<Result<Vec<_>, HttpClientError>>()?;

-        let mut builder = Self::new_with_urls(urls)?;
+        let mut builder = Self::new_with_urls(urls);

        // Enable domain fronting by default (on retry)
        #[cfg(feature = "tunneling")]
@@ -643,11 +631,7 @@ impl ClientBuilder {
    }

    /// Constructs a new http `ClientBuilder` from a valid url.
-    pub fn new_with_urls(urls: Vec<Url>) -> Result<Self, HttpClientError> {
-        if urls.is_empty() {
-            return Err(HttpClientError::NoUrlsProvided);
-        }
-
+    pub fn new_with_urls(urls: Vec<Url>) -> Self {
        let urls = Self::check_urls(urls);

        #[cfg(target_arch = "wasm32")]
@@ -656,7 +640,7 @@ impl ClientBuilder {
        #[cfg(not(target_arch = "wasm32"))]
        let reqwest_client_builder = default_builder();

-        Ok(ClientBuilder {
+        ClientBuilder {
            urls,
            timeout: None,
            custom_user_agent: false,
@@ -667,7 +651,7 @@ impl ClientBuilder {

            retry_limit: 0,
            serialization: SerializationFormat::Json,
-        })
+        }
    }

    /// Add an additional URL to the set usable by this constructed `Client`
@@ -902,8 +886,6 @@ impl Client {

        if self.base_urls.len() > 1 {
            let orig = self.current_idx.load(Ordering::Relaxed);
-
-            #[allow(unused_mut)]
            let mut next = (orig + 1) % self.base_urls.len();

            // if fronting is enabled we want to update to a host that has fronts configured
@@ -966,13 +948,13 @@ impl Client {

                    return (url.as_str(), url.front_str());
                } else {
-                    tracing::debug!(
-                        "Domain fronting is enabled, but no host_url is defined for current URL"
+                    warn!(
+                        "Domain fronting is enabled, but no host_url is defined! Domain fronting WILL NOT WORK"
                    )
                }
            } else {
-                tracing::debug!(
-                    "Domain fronting is enabled, but current URL has no front_hosts configured"
+                warn!(
+                    "Domain fronting is enabled, but no front_url is defined! Domain fronting WILL NOT WORK"
                )
            }
        }
@@ -1004,6 +986,21 @@ impl ApiClientCore for Client {

        self.apply_hosts_to_req(&mut req);

+        // if opentelemetry is activated add the current trace context to the request
+        #[cfg(feature = "otel")]
+        {
+            use nym_bin_common::opentelemetry::context::ContextCarrier;
+            use opentelemetry::Context;
+
+            let carrier = ContextCarrier::new_with_current_context(Context::current());
+
+            if let Some(traceparent) = carrier.extract_traceparent() {
+                if let Ok(header_value) = HeaderValue::from_str(&traceparent) {
+                    req.headers_mut().insert("traceparent", header_value);
+                }
+            }
+        }
+
        let mut rb = RequestBuilder::from_parts(self.reqwest_client.clone(), req);

        rb = rb
@@ -21,10 +21,6 @@ inventory::collect!(ConfigRecord);
 /// Returns the default builder with all registered configurations applied.
 pub fn default_builder() -> ReqwestClientBuilder {
    let mut b = ReqwestClientBuilder::new();
-
-    #[cfg(feature = "debug-inventory")]
-    let mut test_client = ReqwestClientBuilder::new();
-
    let mut records: Vec<&'static ConfigRecord> =
        inventory::iter::<ConfigRecord>.into_iter().collect();
    records.sort_by_key(|r| r.priority); // lower runs first
@@ -39,10 +35,6 @@ pub fn default_builder() -> ReqwestClientBuilder {

    for r in records {
        b = (r.apply)(b);
-        #[cfg(feature = "debug-inventory")]
-        {
-            test_client = (r.apply)(test_client);
-        }
    }

    #[cfg(feature = "debug-inventory")]
@@ -55,7 +47,7 @@ pub fn default_builder() -> ReqwestClientBuilder {
        eprintln!("[HTTP-INVENTORY] Building test client to verify configuration...");

        // Try to build a client to see if it works
-        match test_client.build() {
+        match b.try_clone().unwrap().build() {
            Ok(client) => {
                eprintln!("[HTTP-INVENTORY] ✓ Client built successfully");
                eprintln!("[HTTP-INVENTORY] Client debug info: {:#?}", client);
@@ -2,77 +2,77 @@ use super::*;

 #[test]
 fn sanitizing_urls() {
-    let base_url: Url = "http://api.test".parse().unwrap();
+    let base_url: Url = "http://foomp.com".parse().unwrap();

    // works with a full string
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, "/foo//bar/", NO_PARAMS).as_str()
    );

    // (and leading slash doesn't matter)
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, "foo//bar/", NO_PARAMS).as_str()
    );

    // works with 1 segment
    assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
        sanitize_url(&base_url, &["foo"], NO_PARAMS).as_str()
    );

    // works with 2 segments
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, &["foo", "bar"], NO_PARAMS).as_str()
    );

    // works with leading slash
    assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
        sanitize_url(&base_url, &["/foo"], NO_PARAMS).as_str()
    );
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, &["/foo", "bar"], NO_PARAMS).as_str()
    );
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, &["foo", "/bar"], NO_PARAMS).as_str()
    );

    // works with trailing slash
    assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
        sanitize_url(&base_url, &["foo/"], NO_PARAMS).as_str()
    );
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, &["foo/", "bar"], NO_PARAMS).as_str()
    );
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, &["foo", "bar/"], NO_PARAMS).as_str()
    );

    // works with both leading and trailing slash
    assert_eq!(
-        "http://api.test/foo",
+        "http://foomp.com/foo",
        sanitize_url(&base_url, &["/foo/"], NO_PARAMS).as_str()
    );
    assert_eq!(
-        "http://api.test/foo/bar",
+        "http://foomp.com/foo/bar",
        sanitize_url(&base_url, &["/foo/", "/bar/"], NO_PARAMS).as_str()
    );

    // adds params
    assert_eq!(
-        "http://api.test/foo/bar?foomp=baz",
+        "http://foomp.com/foo/bar?foomp=baz",
        sanitize_url(&base_url, &["foo", "bar"], &[("foomp", "baz")]).as_str()
    );
    assert_eq!(
-        "http://api.test/foo/bar?arg1=val1&arg2=val2",
+        "http://foomp.com/foo/bar?arg1=val1&arg2=val2",
        sanitize_url(
            &base_url,
            &["/foo/", "/bar/"],
@@ -91,87 +91,83 @@ fn sanitizing_urls() {
 #[tokio::test]
 async fn api_client_retry() -> Result<(), Box<dyn std::error::Error>> {
    let client = ClientBuilder::new_with_urls(vec![
-        "http://broken.nym.test".parse()?,         // This will fail
-        "https://httpbin.org/status/200".parse()?, // This will succeed
-    ])?
+        "http://broken.nym.badurl".parse()?,
+        "http://example.com/".parse()?,
+    ])
    .with_retries(3)
    .build()?;

-    let req = client.create_get_request(&[], NO_PARAMS).unwrap();
+    let req = client.create_get_request(&["/"], NO_PARAMS).unwrap();
    let resp = client.send(req).await?;

-    // The main test is that we successfully retried and switched to the working URL
-    // We accept any response from the working endpoint since external services can be unreliable
-    assert_eq!(
-        client.current_url().as_str(),
-        "https://httpbin.org/status/200"
-    );
+    assert_eq!(resp.status(), 200);

-    println!("Response status: {}", resp.status());
+    // check that the url was updated
+    assert_eq!(client.current_url().as_str(), "http://example.com/");

    Ok(())
 }

 #[test]
 fn host_updating() {
-    let url = Url::new("http://nym-api1.test", None).unwrap();
+    let url = Url::new("http://example.com", None).unwrap();
    let mut client = ClientBuilder::new(url).unwrap().build().unwrap();

    // check that the url is set correctly
    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api1.test/");
+    assert_eq!(current_url.as_str(), "http://example.com/");
    assert_eq!(current_url.front_str(), None);

    // update the url
    client.update_host();

    // check that the url is still the same since there is one URL
-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");

    // =======================================
    // we rotate through urls when available

    let new_urls = vec![
-        Url::new("http://nym-api1.test", None).unwrap(),
-        Url::new("http://nym-api2.test", None).unwrap(),
+        Url::new("http://example.com", None).unwrap(),
+        Url::new("http://example.org", None).unwrap(),
    ];
    client.change_base_urls(new_urls);
-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");

    client.update_host();

    // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://nym-api2.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.org/");
    assert_eq!(client.current_url().front_str(), None);

    client.update_host();
-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");

    // =======================================
    // we rotate through urls when available if fronting is disabled

    let new_urls = vec![
        Url::new(
-            "http://nym-api1.test",
-            Some(vec!["http://cdn1.test", "http://cdn2.test"]),
+            "http://example.com",
+            Some(vec!["http://front1.com", "http://front2.com"]),
        )
        .unwrap(),
-        Url::new("http://nym-api2.test", None).unwrap(),
+        Url::new("http://example.org", None).unwrap(),
    ];
    client.change_base_urls(new_urls);

-    assert_eq!(client.current_url().as_str(), "http://nym-api1.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.com/");

    client.update_host();

    // check that the url got updated now that there are multiple URLs
-    assert_eq!(client.current_url().as_str(), "http://nym-api2.test/");
+    assert_eq!(client.current_url().as_str(), "http://example.org/");
 }

 #[test]
 #[cfg(feature = "tunneling")]
 fn fronted_host_updating() {
-    let url = Url::new("http://nym-api.test", Some(vec!["http://cdn1.test"])).unwrap();
+    let url = Url::new("http://example.com", Some(vec!["http://front1.com"])).unwrap();
    let mut client = ClientBuilder::new(url)
        .unwrap()
        .with_fronting(crate::fronted::FrontPolicy::Always)
@@ -180,103 +176,46 @@ fn fronted_host_updating() {

    // check that the url is set correctly
    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));

    // update the url
    client.update_host();

    // check that the url is still the same since there is one URL and one front
    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));

    // =======================================
    // we rotate through front urls when available if fronting is enabled

    let new_urls = vec![
        Url::new(
-            "http://nym-api.test",
-            Some(vec!["http://cdn1.test", "http://cdn2.test"]),
+            "http://example.com",
+            Some(vec!["http://front1.com", "http://front2.com"]),
        )
        .unwrap(),
-        Url::new("http://nym-api2.test", None).unwrap(),
+        Url::new("http://example.org", None).unwrap(),
    ];
    client.change_base_urls(new_urls);

    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));

    // update the url - this should keep the same host but change the front
    client.update_host();

    let current_url = client.current_url();
    // check that the url is still the same since there is one URL
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn2.test"));
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front2.com"));

    // update the url - this should wrap around to the first front as the second url is not fronted
    client.update_host();

    let current_url = client.current_url();
-    assert_eq!(current_url.as_str(), "http://nym-api.test/");
-    assert_eq!(current_url.front_str(), Some("cdn1.test"));
-}
-
-#[test]
-#[cfg(feature = "network-defaults")]
-fn from_network_configures_multiple_urls_and_retries() {
-    use nym_network_defaults::{ApiUrl, NymNetworkDetails};
-
-    // Create network details with multiple URLs and fronting
-    let mut network_details = NymNetworkDetails::new_empty();
-    network_details.nym_api_urls = Some(vec![
-        ApiUrl {
-            url: "https://validator.nymtech.net/api/".to_string(),
-            front_hosts: None,
-        },
-        ApiUrl {
-            url: "https://nym-frontdoor.vercel.app/api/".to_string(),
-            front_hosts: Some(vec!["vercel.app".to_string(), "vercel.com".to_string()]),
-        },
-        ApiUrl {
-            url: "https://nym-frontdoor.global.ssl.fastly.net/api/".to_string(),
-            front_hosts: Some(vec!["yelp.global.ssl.fastly.net".to_string()]),
-        },
-    ]);
-
-    // Build client from network details
-    let client = ClientBuilder::new_with_fronted_urls(
-        network_details.nym_api_urls.clone().unwrap_or_default(),
-    )
-    .expect("Failed to create client from network")
-    .build()
-    .expect("Failed to build client");
-
-    // Verify all URLs were configured
-    assert_eq!(
-        client.base_urls().len(),
-        3,
-        "Expected 3 URLs to be configured from network details"
-    );
-
-    // Verify the URLs have fronting configured where appropriate
-    assert_eq!(
-        client.base_urls()[0].as_str(),
-        "https://validator.nymtech.net/api/"
-    );
-    assert!(client.base_urls()[0].front_str().is_none());
-
-    assert_eq!(
-        client.base_urls()[1].as_str(),
-        "https://nym-frontdoor.vercel.app/api/"
-    );
-    assert!(client.base_urls()[1].front_str().is_some());
-
-    assert_eq!(
-        client.base_urls()[2].as_str(),
-        "https://nym-frontdoor.global.ssl.fastly.net/api/"
-    );
-    assert!(client.base_urls()[2].front_str().is_some());
+    assert_eq!(current_url.as_str(), "http://example.com/");
+    assert_eq!(current_url.front_str(), Some("front1.com"));
 }
@@ -18,6 +18,7 @@ bytes = { workspace = true, optional = true }
 colored = { workspace = true, optional = true }
 futures = { workspace = true, optional = true }
 mime = { workspace = true, optional = true }
+nym-bin-common = { path = "../bin-common" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true, optional = true }
@@ -49,6 +50,8 @@ middleware = [
    "zeroize"
 ]

+otel = ["nym-bin-common/otel"]
+
 utoipa = ["dep:utoipa"]

 [lints]
@@ -56,6 +56,16 @@ async fn log_request(

    let host = header_map(request.headers().get(HOST), "Unknown Host".to_string());

+    // Extract traceparent from headers if it exists
+    #[cfg(feature = "otel")]
+    let traceparent = request
+        .headers()
+        .get("traceparent")
+        .and_then(|h| h.to_str().ok())
+        .map(|s| s.to_string());
+    #[cfg(not(feature = "otel"))]
+    let traceparent: Option<String> = None;
+
    let start = Instant::now();
    // run request through all middleware, incl. extractors
    let res = next.run(request).await;
@@ -82,10 +92,10 @@ async fn log_request(

    match level {
        LogLevel::Debug => debug!(
-            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent}"
+            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent} traceparent: {traceparent:?}",
        ),
        LogLevel::Info => info!(
-            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent}"
+            "[{addr} -> {host}] {method} '{uri}': {print_status} {time_taken} {agent_str}: {agent} traceparent: {traceparent:?}"
        ),
    }

@@ -124,8 +124,6 @@ impl NymNetworkDetails {
            }
        }

-        let nym_api = var(var_names::NYM_API).expect("nym api not set");
-
        NymNetworkDetails::new_empty()
            .with_network_name(var(var_names::NETWORK_NAME).expect("network name not set"))
            .with_bech32_account_prefix(
@@ -151,7 +149,7 @@ impl NymNetworkDetails {
            })
            .with_additional_validator_endpoint(ValidatorDetails::new(
                var(var_names::NYXD).expect("nyxd validator not set"),
-                Some(nym_api.clone()),
+                Some(var(var_names::NYM_API).expect("nym api not set")),
                get_optional_env(var_names::NYXD_WEBSOCKET),
            ))
            .with_mixnet_contract(get_optional_env(var_names::MIXNET_CONTRACT_ADDRESS))
@@ -161,10 +159,6 @@ impl NymNetworkDetails {
            .with_multisig_contract(get_optional_env(var_names::MULTISIG_CONTRACT_ADDRESS))
            .with_coconut_dkg_contract(get_optional_env(var_names::COCONUT_DKG_CONTRACT_ADDRESS))
            .with_nym_vpn_api_url(get_optional_env(var_names::NYM_VPN_API))
-            .with_nym_api_urls(Some(vec![ApiUrl {
-                url: nym_api,
-                front_hosts: None,
-            }]))
    }

    pub fn new_mainnet() -> Self {
@@ -354,12 +348,6 @@ impl NymNetworkDetails {
        self
    }

-    #[must_use]
-    pub fn with_nym_api_urls(mut self, urls: Option<Vec<ApiUrl>>) -> Self {
-        self.nym_api_urls = urls;
-        self
-    }
-
    pub fn nym_vpn_api_url(&self) -> Option<Url> {
        self.nym_vpn_api_url.as_ref().map(|url| {
            url.parse()
@@ -30,3 +30,7 @@ workspace = true
 ## wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
 path = "../wasm/utils"
+
+[ features ]
+default = []
+otel = ["nym-sphinx/otel"]
@@ -231,6 +231,8 @@ where
            &address,
            &address,
            PacketType::Mix,
+            #[cfg(feature = "otel")]
+            None,
        )?)
    }

@@ -8,12 +8,14 @@ license = { workspace = true }
 repository = { workspace = true }

 [dependencies]
+sphinx-packet = { workspace = true }
 tracing = { workspace = true }
 rand = { workspace = true }
 rand_distr = { workspace = true }
 rand_chacha = { workspace = true }
 thiserror = { workspace = true }

+nym-bin-common = { path = "../bin-common" }
 nym-sphinx-acknowledgements = { path = "acknowledgements" }
 nym-sphinx-addressing = { path = "addressing" }
 nym-sphinx-anonymous-replies = { path = "anonymous-replies" }
@@ -55,3 +57,11 @@ outfox = [
    "nym-sphinx-params/outfox",
    "nym-sphinx-types/outfox",
 ]
+
+otel = [
+    "nym-bin-common/otel",
+    "nym-sphinx-acknowledgements/otel",
+    "nym-sphinx-addressing/otel",
+    "nym-sphinx-cover/otel",
+    "nym-sphinx-anonymous-replies/otel",
+] 
@@ -24,3 +24,4 @@ nym-topology = { path = "../../topology" }

 [features]
 serde = ["dep:serde", "generic-array"]
+otel = ["nym-sphinx-addressing/otel"]
@@ -61,7 +61,10 @@ impl SurbAck {
        };

        let delays = nym_sphinx_routing::generate_hop_delays(average_delay, route.len());
+        #[cfg(not(feature = "otel"))]
        let destination = recipient.as_sphinx_destination();
+        #[cfg(feature = "otel")]
+        let destination = recipient.as_sphinx_destination(None);

        let surb_ack_payload = prepare_identifier(rng, ack_key, marshaled_fragment_id);
        let packet_size = match packet_type {
@@ -8,14 +8,20 @@ license = { workspace = true }
 repository = { workspace = true }

 [dependencies]
+nym-bin-common = { path = "../../bin-common", features = ["opentelemetry"] } # for trace id compression/decompression
 nym-crypto = { path = "../../crypto", features = ["asymmetric", "sphinx"] } # all addresses are expressed in terms on their crypto keys
 nym-sphinx-types = { path = "../types", features = ["sphinx"] } # we need to be able to refer to some types defined inside sphinx crate
 serde = { workspace = true } # implementing serialization/deserialization for some types, like `Recipient`
 thiserror = { workspace = true }
+tracing = { workspace = true }

 [dev-dependencies]
 rand = { workspace = true }
 nym-crypto = { path = "../../crypto", features = ["rand"] }
 bincode = { workspace = true }
 serde_json = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
+serde = { workspace = true, features = ["derive"] }
+
+[features]
+default = []
+otel = ["nym-bin-common/otel"]
@@ -153,12 +153,28 @@ impl Recipient {
    // TODO: Currently the `DestinationAddress` is equivalent to `ClientIdentity`, but perhaps
    // it shouldn't be? Maybe it should be (for example) H(`ClientIdentity || ClientEncryptionKey`)
    // instead? That is an open question.
-    pub fn as_sphinx_destination(&self) -> Destination {
+    pub fn as_sphinx_destination(
+        &self,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>
+    ) -> Destination {
+        #[cfg(feature = "otel")]
+        use nym_bin_common::opentelemetry::compact_id_generator::decompress_trace_id;
+        #[cfg(feature = "otel")]
+        let trace_id_16 = if let Some(trace_id) = trace_id {
+            decompress_trace_id(&trace_id)
+        } else {
+            decompress_trace_id(&[0u8; 12])
+        };
+
        // since the nym mix network differs slightly in design from loopix, we do not care
        // about "surb_id" field at all and just use the default value.
        Destination::new(
            self.client_identity.derive_destination_address(),
-            Default::default(),
+            #[cfg(not(feature = "otel"))]
+            [0u8; 16],
+            #[cfg(feature = "otel")]
+            trace_id_16
        )
    }

@@ -25,3 +25,7 @@ workspace = true

 [dev-dependencies]
 rand_chacha = { workspace = true }
+
+[ features ]
+default = []
+otel = ["nym-sphinx-addressing/otel"]
@@ -82,6 +82,9 @@ impl ReplySurb {
            topology.random_route_to_egress(rng, recipient.gateway())?
        };
        let delays = nym_sphinx_routing::generate_hop_delays(average_delay, route.len());
+        #[cfg(feature = "otel")]
+        let destination = recipient.as_sphinx_destination(None);
+        #[cfg(not(feature = "otel"))]
        let destination = recipient.as_sphinx_destination();

        let mut surb_material = SURBMaterial::new(route, delays, destination);
@@ -20,3 +20,6 @@ nym-sphinx-params = { path = "../params" }
 nym-sphinx-routing = { path = "../routing" }
 nym-sphinx-types = { path = "../types" }
 nym-topology = { path = "../../topology" }
+
+[features]
+otel = ["nym-sphinx-addressing/otel"]
@@ -125,7 +125,10 @@ where

    let route = topology.random_route_to_egress(rng, full_address.gateway())?;
    let delays = nym_sphinx_routing::generate_hop_delays(average_packet_delay, route.len());
+    #[cfg(not(feature = "otel"))]
    let destination = full_address.as_sphinx_destination();
+    #[cfg(feature = "otel")]
+    let destination = full_address.as_sphinx_destination(None);

    let rotation_id = topology.current_key_rotation();
    let sphinx_key_rotation = SphinxKeyRotation::from(rotation_id);
@@ -11,8 +11,10 @@ repository = { workspace = true }
 bytes = { workspace = true }
 tokio-util = { workspace = true, features = ["codec"] }
 thiserror = { workspace = true }
+opentelemetry = { workspace = true }
 tracing = { workspace = true }

+nym-bin-common = { path = "../../bin-common" }
 nym-sphinx-types = { path = "../types", features = ["sphinx", "outfox"] }
 nym-sphinx-params = { path = "../params", features = ["sphinx", "outfox"] }
 nym-sphinx-forwarding = { path = "../forwarding" }
@@ -21,3 +23,7 @@ nym-sphinx-acknowledgements = { path = "../acknowledgements" }

 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }
+
+[features]
+default = []
+otel = ["nym-bin-common/otel"]
@@ -2,6 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::packet::FramedNymPacket;
+#[cfg(feature = "otel")]
+use nym_bin_common::opentelemetry::{
+    compact_id_generator::decompress_trace_id, context::ManualContextPropagator,
+};
+
 use nym_sphinx_acknowledgements::surb_ack::{SurbAck, SurbAckRecoveryError};
 use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, NymNodeRoutingAddressError};
 use nym_sphinx_forwarding::packet::MixPacket;
@@ -14,7 +19,9 @@ use nym_sphinx_types::{
 };
 use std::fmt::Display;
 use thiserror::Error;
-use tracing::{debug, error, info, trace};
+#[cfg(feature = "otel")]
+use tracing::warn_span;
+use tracing::{debug, error, info, instrument, trace, warn};

 #[derive(Debug)]
 pub enum MixProcessingResultData {
@@ -154,6 +161,7 @@ impl PartiallyUnwrappedPacket {
        })
    }

+    #[instrument(skip_all)]
    pub fn finalise_unwrapping(self) -> Result<MixProcessingResult, PacketProcessingError> {
        let packet_size = self.received_data.packet_size();
        let packet_type = self.received_data.packet_type();
@@ -236,6 +244,7 @@ fn perform_framed_packet_processing(
    })
 }

+#[instrument(skip_all)]
 fn wrap_processed_sphinx_packet(
    packet: nym_sphinx_types::ProcessedPacket,
    packet_size: PacketSize,
@@ -258,15 +267,38 @@ fn wrap_processed_sphinx_packet(
        // sphinx all together?
        ProcessedPacketData::FinalHop {
            destination,
-            identifier: _,
+            #[cfg(feature = "otel")]
+            identifier,
+            #[cfg(not(feature = "otel"))]
+                identifier: _,
            payload,
-        } => process_final_hop(
-            destination,
-            payload.recover_plaintext()?,
-            packet_size,
-            packet_type,
-            key_rotation,
-        ),
+        } => {
+            // if we have a trace id in the destination, we log it for easier correlation later on
+            #[cfg(feature = "otel")]
+            let span = match identifier[0..12].try_into().map(|b: [u8; 12]| b) {
+                Ok(trace_bytes) if !trace_bytes.iter().all(|b| *b == 0) => {
+                    let full_trace_id_bytes = decompress_trace_id(&trace_bytes);
+                    let full_trace_id =
+                        opentelemetry::trace::TraceId::from_bytes(full_trace_id_bytes);
+                    let context_propagator =
+                        ManualContextPropagator::new_from_tid("final_hop", full_trace_id);
+                    tracing::info_span!(parent: &context_propagator.root_span, "final_hop_processing", trace_id=%full_trace_id)
+                }
+                _ => {
+                    tracing::debug_span!("final_hop_processing")
+                }
+            };
+            #[cfg(feature = "otel")]
+            let _entered_span = span.enter();
+
+            process_final_hop(
+                destination,
+                payload.recover_plaintext()?,
+                packet_size,
+                packet_type,
+                key_rotation,
+            )
+        }
    }?;

    Ok(MixProcessingResult {
@@ -312,6 +344,7 @@ fn wrap_processed_outfox_packet(
    }
 }

+#[instrument(skip_all)]
 fn perform_final_processing(
    packet: NymProcessedPacket,
    packet_size: PacketSize,
@@ -163,19 +163,6 @@ pub trait FragmentPreparer {
        })
    }

-    /// Tries to convert this [`Fragment`] into a [`SphinxPacket`] that can be sent through the Nym mix-network,
-    /// such that it contains required SURB-ACK and public component of the ephemeral key used to
-    /// derive the shared key.
-    /// Also all the data, apart from the said public component, is encrypted with an ephemeral shared key.
-    /// This method can fail if the provided network topology is invalid.
-    /// It returns total expected delay as well as the [`SphinxPacket`] (including first hop address)
-    /// to be sent through the network.
-    ///
-    /// The procedure is as follows:
-    /// For each fragment:
-    /// - compute SURB_ACK
-    /// - generate (x, g^x)
-    /// - compute k = KDF(remote encryption key ^ x) this is equivalent to KDF( dh(remote, x) )
    /// - compute v_b = AES-128-CTR(k, serialized_fragment)
    /// - compute vk_b = g^x || v_b
    /// - compute sphinx_plaintext = SURB_ACK || g^x || v_b
@@ -189,6 +176,8 @@ pub trait FragmentPreparer {
        packet_sender: &Recipient,
        packet_recipient: &Recipient,
        packet_type: PacketType,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Result<PreparedFragment, NymTopologyError> {
        debug!("Preparing chunk for sending");
        // each plain or repliable packet (i.e. not a reply) attaches an ephemeral public key so that the recipient
@@ -249,6 +238,16 @@ pub trait FragmentPreparer {
            topology.random_route_to_egress(&mut rng, destination)?
        };

+        #[cfg(feature = "otel")]
+        let destination = packet_recipient.as_sphinx_destination(trace_id);
+
+        #[cfg(feature = "otel")]
+        tracing::info!(
+            "Packet destination with trace id: {:?}",
+            &destination.identifier
+        );
+        
+        #[cfg(not(feature = "otel"))]
        let destination = packet_recipient.as_sphinx_destination();

        // including set of delays
@@ -274,6 +273,7 @@ pub trait FragmentPreparer {
            )?,
        };

+        // - compute k = KDF(remote encryption key ^ x) this is equivalent to KDF( dh(remote, x) )
        // from the previously constructed route extract the first hop
        let first_hop_address =
            NymNodeRoutingAddress::try_from(route.first().unwrap().address).unwrap();
@@ -428,6 +428,8 @@ where
        ack_key: &AckKey,
        packet_recipient: &Recipient,
        packet_type: PacketType,
+        #[cfg(feature = "otel")]
+        trace_id: Option<[u8; 12]>,
    ) -> Result<PreparedFragment, NymTopologyError> {
        let sender = self.sender_address;

@@ -439,6 +441,8 @@ where
            &sender,
            packet_recipient,
            packet_type,
+            #[cfg(feature = "otel")]
+            trace_id,
        )
    }

@@ -10,6 +10,8 @@ repository = { workspace = true }
 [dependencies]
 sphinx-packet = { workspace = true, optional = true }
 nym-outfox = { path = "../../../nym-outfox", optional = true }
+# TODO add optional
+nym-bin-common = { path = "../../../common/bin-common" }
 thiserror = { workspace = true }

 [features]
@@ -32,8 +32,6 @@ tracing.workspace = true
 url.workspace = true


-# TEMP
-#nym-bin-common = { path = "../bin-common", features = ["basic_tracing"]}


 [build-dependencies]
@@ -37,3 +37,4 @@ nym-validator-client = { path = "../client-libs/validator-client" }

 [features]
 default = []
+otel = ["nym-sphinx/otel"]
@@ -350,6 +350,8 @@ impl SocksClient {
            self.config.connection_start_surbs,
            TransmissionLane::ConnectionId(self.connection_id),
            self.packet_type,
+            #[cfg(feature = "otel")]
+            None,
        );
        self.input_sender
            .send(input_message)
@@ -373,6 +375,8 @@ impl SocksClient {
            msg.into_bytes(),
            TransmissionLane::ConnectionId(self.connection_id),
            self.packet_type,
+            #[cfg(feature = "otel")]
+            None,
        );
        self.input_sender
            .send(input_message)
@@ -439,6 +443,8 @@ impl SocksClient {
                    per_request_surbs,
                    lane,
                    packet_type,
+                    #[cfg(feature = "otel")]
+                    None,
                )
            } else {
                InputMessage::new_regular(
@@ -446,6 +452,8 @@ impl SocksClient {
                    provider_message.into_bytes(),
                    lane,
                    packet_type,
+                    #[cfg(feature = "otel")]
+                    None,
                )
            }
        })
@@ -24,6 +24,6 @@ pub use crate::runtime_registry::RegistryAccessError;

 /// Get or create a ShutdownTracker for SDK use.
 /// This provides automatic task management without requiring manual setup.
-pub fn create_sdk_shutdown_tracker() -> Result<ShutdownTracker, RegistryAccessError> {
-    Ok(runtime_registry::RuntimeRegistry::create_sdk()?.shutdown_tracker_owned())
+pub fn get_sdk_shutdown_tracker() -> Result<ShutdownTracker, RegistryAccessError> {
+    Ok(runtime_registry::RuntimeRegistry::get_or_create_sdk()?.shutdown_tracker_owned())
 }
@@ -19,45 +19,30 @@ pub(crate) struct RuntimeRegistry {
 pub enum RegistryAccessError {
    #[error("the runtime registry is poisoned")]
    Poisoned,
-
-    #[error("The SDK ShutdownManager already exists")]
-    ExistingShutdownManager,
-
-    #[error("No existing SDK ShutdownManager")]
-    MissingShutdownManager,
 }

 impl RuntimeRegistry {
-    /// Create a ShutdownManager for SDK use.
+    /// Get or create a ShutdownManager for SDK use.
    /// This manager doesn't listen to OS signals, making it suitable for library use.
-    /// This function overwrite any existing manager!
-    pub(crate) fn create_sdk() -> Result<Arc<ShutdownManager>, RegistryAccessError> {
-        let mut guard = REGISTRY
-            .sdk_manager
-            .write()
-            .map_err(|_| RegistryAccessError::Poisoned)?;
-
-        Ok(guard
-            .insert(Arc::new(
-                ShutdownManager::new_without_signals().with_cancel_on_panic(),
-            ))
-            .clone())
-    }
-
-    /// Get the  ShutdownManager for SDK use.
-    /// This manager doesn't listen to OS signals, making it suitable for library use.
-    /// Not yet used, but maybe in the future
-    #[allow(dead_code)]
-    pub(crate) fn get_sdk() -> Result<Arc<ShutdownManager>, RegistryAccessError> {
+    pub(crate) fn get_or_create_sdk() -> Result<Arc<ShutdownManager>, RegistryAccessError> {
        let guard = REGISTRY
            .sdk_manager
            .read()
            .map_err(|_| RegistryAccessError::Poisoned)?;
        if let Some(manager) = guard.as_ref() {
-            Ok(manager.clone())
-        } else {
-            Err(RegistryAccessError::MissingShutdownManager)
+            return Ok(manager.clone());
        }
+        drop(guard);
+
+        let mut guard = REGISTRY
+            .sdk_manager
+            .write()
+            .map_err(|_| RegistryAccessError::Poisoned)?;
+        Ok(guard
+            .get_or_insert_with(|| {
+                Arc::new(ShutdownManager::new_without_signals().with_cancel_on_panic())
+            })
+            .clone())
    }

    /// Check if an SDK manager has been created.
@@ -100,13 +85,10 @@ mod tests {

        assert!(!RuntimeRegistry::has_sdk_manager().unwrap());

-        // Error if nothing was created
-        assert!(RuntimeRegistry::get_sdk().is_err());
-
-        let manager1 = RuntimeRegistry::create_sdk().unwrap();
+        let manager1 = RuntimeRegistry::get_or_create_sdk().unwrap();
        assert!(RuntimeRegistry::has_sdk_manager().unwrap());

-        let manager2 = RuntimeRegistry::get_sdk().unwrap();
+        let manager2 = RuntimeRegistry::get_or_create_sdk().unwrap();
        // Should return the same instance
        assert!(Arc::ptr_eq(&manager1, &manager2));

@@ -29,6 +29,7 @@ x25519-dalek = { workspace = true, features = ["static_secrets"] }
 cosmwasm-std = { workspace = true }
 cosmrs = { workspace = true }

+nym-bin-common = { path = "../../common/bin-common" }
 nym-validator-client = { path = "../../common/client-libs/validator-client" }
 nym-mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../../common/cosmwasm-smart-contracts/vesting-contract" }
@@ -15,10 +15,9 @@ jwt-simple = { workspace = true }
 reqwest = { workspace = true, features = ["rustls-tls"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-time = { workspace = true, features = ["serde", "formatting", "parsing"] }
+time = { workspace = true, features = ["serde"] }
 thiserror = { workspace = true }
 tracing = { workspace = true }
-utoipa = { workspace = true, optional = true }

 nym-http-api-client = { path = "../http-api-client", default-features = false }
 nym-crypto = { path = "../crypto", features = ["asymmetric", "serde", "naive_jwt"] }
@@ -26,12 +25,6 @@ nym-crypto = { path = "../crypto", features = ["asymmetric", "serde", "naive_jwt
 [dev-dependencies]
 anyhow = { workspace = true }
 time = { workspace = true, features = ["macros"] }
-nym-test-utils = { path = "../test-utils" }
-nym-crypto = { path = "../crypto", features = ["rand"] }
-
-
-[features]
-openapi = ["utoipa"]

 [lints]
 workspace = true
@@ -1,43 +1,31 @@
 // Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::UpgradeModeCheckError;
 use nym_crypto::asymmetric::ed25519;
+use nym_http_api_client::generate_user_agent;
 use serde::{Deserialize, Serialize};
+use std::time::Duration;
 use time::OffsetDateTime;

-#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Copy)]
 pub struct UpgradeModeAttestation {
    #[serde(flatten)]
    pub content: UpgradeModeAttestationContent,

    #[serde(with = "ed25519::bs58_ed25519_signature")]
-    #[cfg_attr(feature = "openapi", schema(value_type = String))]
    pub signature: ed25519::Signature,
 }

-impl UpgradeModeAttestation {
-    pub fn authorised_to_issue_jwt(&self, key: &ed25519::PublicKey) -> bool {
-        self.content.authorised_jwt_issuers.contains(key)
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone, Copy)]
 #[serde(tag = "type")]
 #[serde(rename = "upgrade_mode")]
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 pub struct UpgradeModeAttestationContent {
-    #[serde(with = "time::serde::rfc3339")]
-    #[cfg_attr(feature = "openapi", schema(value_type = String))]
+    #[serde(with = "time::serde::timestamp")]
    pub starting_time: OffsetDateTime,

    #[serde(with = "ed25519::bs58_ed25519_pubkey")]
-    #[cfg_attr(feature = "openapi", schema(value_type = String))]
    pub attester_public_key: ed25519::PublicKey,
-
-    #[serde(with = "ed25519::vec_bs58_ed25519_pubkey")]
-    #[cfg_attr(feature = "openapi", schema(value_type = Vec<String>))]
-    pub authorised_jwt_issuers: Vec<ed25519::PublicKey>,
 }

 impl UpgradeModeAttestation {
@@ -57,26 +45,17 @@ impl UpgradeModeAttestationContent {
    }
 }

-pub fn generate_new_attestation(
-    key: &ed25519::PrivateKey,
-    authorised_jwt_issuers: Vec<ed25519::PublicKey>,
-) -> UpgradeModeAttestation {
-    generate_new_attestation_with_starting_time(
-        key,
-        authorised_jwt_issuers,
-        OffsetDateTime::now_utc(),
-    )
+pub fn generate_new_attestation(key: &ed25519::PrivateKey) -> UpgradeModeAttestation {
+    generate_new_attestation_with_starting_time(key, OffsetDateTime::now_utc())
 }

 pub fn generate_new_attestation_with_starting_time(
    key: &ed25519::PrivateKey,
-    authorised_jwt_issuers: Vec<ed25519::PublicKey>,
    starting_time: OffsetDateTime,
 ) -> UpgradeModeAttestation {
    let content = UpgradeModeAttestationContent {
        starting_time,
        attester_public_key: key.into(),
-        authorised_jwt_issuers,
    };
    UpgradeModeAttestation {
        signature: key.sign(content.as_json()),
@@ -84,19 +63,17 @@ pub fn generate_new_attestation_with_starting_time(
    }
 }

-#[cfg(not(target_arch = "wasm32"))]
-pub async fn attempt_retrieve_attestation(
+pub async fn attempt_retrieve(
    url: &str,
-    user_agent: Option<nym_http_api_client::UserAgent>,
-) -> Result<Option<UpgradeModeAttestation>, crate::UpgradeModeCheckError> {
-    let retrieval_failure = |source| crate::UpgradeModeCheckError::AttestationRetrievalFailure {
+) -> Result<Option<UpgradeModeAttestation>, UpgradeModeCheckError> {
+    let retrieval_failure = |source| UpgradeModeCheckError::AttestationRetrievalFailure {
        url: url.to_string(),
        source,
    };

    let attestation = reqwest::ClientBuilder::new()
-        .user_agent(user_agent.unwrap_or_else(|| nym_http_api_client::generate_user_agent!()))
-        .timeout(std::time::Duration::from_secs(5))
+        .user_agent(generate_user_agent!())
+        .timeout(Duration::from_secs(5))
        .build()
        .map_err(retrieval_failure)?
        .get(url)
@@ -124,20 +101,13 @@ mod tests {
            163, 122, 170, 79, 198, 87, 85, 36, 29, 243, 92, 64, 161,
        ])?;

-        let authorised_jwt_issuers = vec![ed25519::PublicKey::from_base58_string(
-            "Be9wH7xuXBRJAuV1pC7MALZv6a61RvWQ3SypsNarqTt",
-        )?];
-        let attestation = generate_new_attestation_with_starting_time(
-            &key,
-            authorised_jwt_issuers,
-            starting_time,
-        );
+        let attestation = generate_new_attestation_with_starting_time(&key, starting_time);

        let attestation_json = serde_json::to_string(&attestation)?;
        let attestation_content_json = attestation.content.as_json();

-        let expected_attestation = r#"{"type":"upgrade_mode","starting_time":"2021-08-23T12:00:00Z","attester_public_key":"3pkFcBXCEmbmXBT2G8CkFMuKisJcH54mbBGvncHaDibt","authorised_jwt_issuers":["Be9wH7xuXBRJAuV1pC7MALZv6a61RvWQ3SypsNarqTt"],"signature":"5Kt9dfwvnkdnDcENbwNyitrxghyckWUYycBv8jUUn7hJUMohWEMc6otb3scXQfCrAGSE7FD5m7kr6auBmkAmfczY"}"#;
-        let expected_content = r#"{"type":"upgrade_mode","starting_time":"2021-08-23T12:00:00Z","attester_public_key":"3pkFcBXCEmbmXBT2G8CkFMuKisJcH54mbBGvncHaDibt","authorised_jwt_issuers":["Be9wH7xuXBRJAuV1pC7MALZv6a61RvWQ3SypsNarqTt"]}"#;
+        let expected_attestation = r#"{"type":"upgrade_mode","starting_time":1629720000,"attester_public_key":"3pkFcBXCEmbmXBT2G8CkFMuKisJcH54mbBGvncHaDibt","signature":"5rWUr2ypaDTtrMKegMP3tQkkZGFAuhNTnEVCVe5Azv6QqvLzoGdQiMkFmeyhDd1XSfoXpL9fFM58rsdA1kf4GYMM"}"#;
+        let expected_content = r#"{"type":"upgrade_mode","starting_time":1629720000,"attester_public_key":"3pkFcBXCEmbmXBT2G8CkFMuKisJcH54mbBGvncHaDibt"}"#;

        assert_eq!(attestation_content_json, expected_content);
        assert_eq!(attestation_json, expected_attestation);
@@ -12,9 +12,6 @@ pub enum UpgradeModeCheckError {
    #[error("the jwt metadata didn't contain explicit public key")]
    MissingTokenPublicKey,

-    #[error("the jwt signer does not appear in the authorised attestation set")]
-    UnauthorisedIssuer,
-
    #[error("the attached public key was not valid ed25519 public key")]
    MalformedEd25519PublicKey { source: Ed25519RecoveryError },

@@ -65,12 +65,6 @@ pub fn validate_upgrade_mode_jwt(
        .map_err(|source| UpgradeModeCheckError::JwtVerificationFailure { source })?
        .custom;

-    // jwt itself is cryptographically valid,
-    // but let's see if this entity has been permitted to issue the token in the first place
-    if !attestation.authorised_to_issue_jwt(&ed25519_pub_key) {
-        return Err(UpgradeModeCheckError::UnauthorisedIssuer);
-    }
-
    Ok(attestation)
 }

@@ -79,7 +73,6 @@ mod tests {
    use super::*;
    use crate::generate_new_attestation;
    use nym_crypto::asymmetric::ed25519;
-    use nym_test_utils::helpers::deterministic_rng;

    #[test]
    fn generate_and_validate_jwt() {
@@ -93,25 +86,15 @@ mod tests {
            2, 52, 215, 241, 219, 200, 18, 159, 241, 76, 111, 42, 32,
        ])
        .unwrap();
-        let jwt_keys = ed25519::KeyPair::from(jwt_key);
+        let keys = ed25519::KeyPair::from(jwt_key);

-        let mut rng = deterministic_rng();
-        let unauthorised_jwt_keys = ed25519::KeyPair::new(&mut rng);
-
-        let attestation = generate_new_attestation(&attestation_key, vec![*jwt_keys.public_key()]);
+        let attestation = generate_new_attestation(&attestation_key);
        let jwt_issuer = generate_jwt_for_upgrade_mode_attestation(
-            attestation.clone(),
+            attestation,
            Duration::from_secs(60 * 60),
-            &jwt_keys,
+            &keys,
            Some("nym-credential-proxy"),
        );
-        let unauthorised_jwt = generate_jwt_for_upgrade_mode_attestation(
-            attestation.clone(),
-            Duration::from_secs(60 * 60),
-            &unauthorised_jwt_keys,
-            Some("nym-credential-proxy"),
-        );
-
        // we expect 'nym-credential-proxy' issuer
        assert!(validate_upgrade_mode_jwt(&jwt_issuer, Some("nym-credential-proxy")).is_ok());

@@ -121,15 +104,10 @@ mod tests {
        // we expect another-issuer
        assert!(validate_upgrade_mode_jwt(&jwt_issuer, Some("another-issuer")).is_err());

-        // the key is not in the authorised set inside the attestation
-        assert!(
-            validate_upgrade_mode_jwt(&unauthorised_jwt, Some("nym-credential-proxy")).is_err()
-        );
-
        let jwt_no_issuer = generate_jwt_for_upgrade_mode_attestation(
            attestation,
            Duration::from_secs(60 * 60),
-            &jwt_keys,
+            &keys,
            None,
        );
        // we expect 'nym-credential-proxy' issuer
@@ -6,10 +6,8 @@ pub(crate) mod error;
 pub(crate) mod jwt;

 pub use attestation::{
-    UpgradeModeAttestation, generate_new_attestation, generate_new_attestation_with_starting_time,
+    UpgradeModeAttestation, attempt_retrieve, generate_new_attestation,
+    generate_new_attestation_with_starting_time,
 };
 pub use error::UpgradeModeCheckError;
 pub use jwt::{generate_jwt_for_upgrade_mode_attestation, validate_upgrade_mode_jwt};
-
-#[cfg(not(target_arch = "wasm32"))]
-pub use attestation::attempt_retrieve_attestation;
@@ -832,15 +832,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"

-[[package]]
-name = "example-contract"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-std",
- "cw-storage-plus",
- "serde",
-]
-
 [[package]]
 name = "ff"
 version = "0.13.0"
@@ -9,7 +9,7 @@ members = [
    "multisig/cw3-flex-multisig",
    "multisig/cw4-group",
    "vesting",
-    "performance", "example-contract",
+    "performance",
 ]

 [workspace.package]
@@ -110,7 +110,7 @@ pub fn try_transfer_ownership(
    DEALERS_INDICES.save(deps.storage, &transfer_to, &current_index)?;
    DEALERS_INDICES.remove(deps.storage, &info.sender);

-    // update registration detail and share information for every epoch the current dealer has participated in the protocol
+    // update registration detail for every epoch the current dealer has participated in the protocol
    // ideally, we'd have only updated the current epoch, but the way the contract is constructed
    // forbids that otherwise we'd have introduced inconsistency
    for epoch_id in 0..=epoch.epoch_id {
@@ -118,11 +118,6 @@ pub fn try_transfer_ownership(
            EPOCH_DEALERS_MAP.remove(deps.storage, (epoch_id, &info.sender));
            EPOCH_DEALERS_MAP.save(deps.storage, (epoch_id, &transfer_to), &details)?;
        }
-        if let Some(mut vk_share) = vk_shares().may_load(deps.storage, (&info.sender, epoch_id))? {
-            vk_shares().remove(deps.storage, (&info.sender, epoch_id))?;
-            vk_share.owner = transfer_to.clone();
-            vk_shares().save(deps.storage, (&transfer_to, epoch_id), &vk_share)?;
-        }
    }

    let Some(transaction_info) = env.transaction else {
@@ -267,7 +262,6 @@ mod tests_with_mock {
        contract.run_initial_dummy_dkg();
        let old_index = DEALERS_INDICES.load(&contract, &group_member)?;
        let old_details = EPOCH_DEALERS_MAP.load(&contract, (0, &group_member))?;
-        let old_share = vk_shares().load(&contract, (&group_member, 0))?;

        let not_group_member = contract.addr_make("not_group_member");
        let (deps, env) = contract.deps_mut_env();
@@ -297,20 +291,13 @@ mod tests_with_mock {
        assert!(EPOCH_DEALERS_MAP
            .may_load(&contract, (0, &group_member))?
            .is_none());
-        assert!(vk_shares()
-            .may_load(&contract, (&group_member, 0))?
-            .is_none());

        let new_index = DEALERS_INDICES.load(&contract, &new_group_member)?;
        let new_details = EPOCH_DEALERS_MAP.load(&contract, (0, &new_group_member))?;
-        let new_share = vk_shares().load(&contract, (&new_group_member, 0))?;

        // the underlying info hasn't changed
        assert_eq!(old_index, new_index);
        assert_eq!(old_details, new_details);
-        assert_ne!(old_share, new_share);
-        assert_eq!(old_share.owner, group_member);
-        assert_eq!(new_share.owner, new_group_member);

        assert_eq!(
            OWNERSHIP_TRANSFER_LOG.load(
@@ -1,30 +0,0 @@
-[package]
-name = "example-contract"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-
-exclude = [
-    # Those files are rust-optimizer artifacts. You might want to commit them for convenience but they should not be part of the source code publication.
-    "contract.wasm",
-    "hash.txt",
-    "artifacts",
-]
-
-[lib]
-name = "example_contract"
-crate-type = ["cdylib", "rlib"]
-
-
-[dependencies]
-cosmwasm-std = { workspace = true }
-cw-storage-plus = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-
-
-[lints]
-workspace = true
@@ -1,5 +0,0 @@
-wasm:
-	RUSTFLAGS='-C link-arg=-s' cargo build --release --target wasm32-unknown-unknown
-
-generate-schema:
-	cargo schema
@@ -1,123 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_std::{
-    entry_point, to_json_binary, Addr, Coin, Deps, DepsMut, Env, Event, MessageInfo, QueryResponse,
-    Response,
-};
-use cw_storage_plus::Item;
-use serde::{Deserialize, Serialize};
-
-pub(crate) const COUNTER: Item<u32> = Item::new("counter");
-
-#[derive(Serialize, Deserialize)]
-pub struct InstantiateMsg {
-    initial_counter: u32,
-}
-
-#[derive(Serialize, Deserialize)]
-pub enum ExecuteMsg {
-    IncrementCounter {},
-    DecrementCounter {},
-    SetCounter { to: u32 },
-}
-
-#[derive(Serialize, Deserialize)]
-pub enum QueryMsg {
-    GetCounter {},
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct MigrateMsg {}
-
-#[entry_point]
-pub fn instantiate(
-    mut deps: DepsMut<'_>,
-    env: Env,
-    info: MessageInfo,
-    msg: InstantiateMsg,
-) -> Result<Response, String> {
-    COUNTER
-        .save(deps.storage, &msg.initial_counter)
-        .map_err(|err| err.to_string())?;
-    Ok(Response::default())
-}
-
-#[entry_point]
-pub fn execute(
-    deps: DepsMut<'_>,
-    env: Env,
-    info: MessageInfo,
-    msg: ExecuteMsg,
-) -> Result<Response, String> {
-    match msg {
-        ExecuteMsg::IncrementCounter {} => {
-            let current_value = COUNTER.load(deps.storage).map_err(|err| err.to_string())?;
-            COUNTER
-                .save(deps.storage, &(current_value + 1))
-                .map_err(|err| err.to_string())?;
-        }
-        ExecuteMsg::DecrementCounter {} => {
-            let current_value = COUNTER.load(deps.storage).map_err(|err| err.to_string())?;
-            COUNTER
-                .save(deps.storage, &(current_value - 1))
-                .map_err(|err| err.to_string())?;
-        }
-        ExecuteMsg::SetCounter { to } => {
-            COUNTER
-                .save(deps.storage, &(to))
-                .map_err(|err| err.to_string())?;
-        }
-    }
-    Ok(Response::new().add_event(Event::new("my-amazing-event").add_attribute("key1", "value1")))
-}
-
-#[entry_point]
-pub fn query(deps: Deps<'_>, env: Env, msg: QueryMsg) -> Result<QueryResponse, String> {
-    let query_res = match msg {
-        QueryMsg::GetCounter {} => {
-            to_json_binary(&COUNTER.load(deps.storage).map_err(|err| err.to_string())?)
-        }
-    };
-
-    Ok(query_res.map_err(|err| err.to_string())?)
-}
-
-#[entry_point]
-pub fn migrate(mut deps: DepsMut<'_>, _env: Env, msg: MigrateMsg) -> Result<Response, String> {
-    Ok(Response::default())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use cosmwasm_std::from_json;
-    use cosmwasm_std::testing::{message_info, mock_dependencies, mock_env};
-
-    #[test]
-    fn it_works() {
-        let mut deps = mock_dependencies();
-        let env = mock_env();
-
-        let init_msg = InstantiateMsg {
-            initial_counter: 123,
-        };
-
-        let sender = message_info(&deps.api.addr_make("mock-sender"), &[]);
-        instantiate(deps.as_mut(), env, sender, init_msg).unwrap();
-
-        assert_eq!(COUNTER.load(deps.as_ref().storage).unwrap(), 123);
-
-        let msg = ExecuteMsg::IncrementCounter {};
-        let sender = message_info(&deps.api.addr_make("mock-sender"), &[]);
-
-        execute(deps.as_mut(), mock_env(), sender, msg).unwrap();
-        assert_eq!(COUNTER.load(deps.as_ref().storage).unwrap(), 124);
-
-        let msg = QueryMsg::GetCounter {};
-        let query_res = query(deps.as_ref(), mock_env(), msg).unwrap();
-        println!("raw binary: {:?}", query_res);
-        println!("string: {:?}", String::from_utf8_lossy(&query_res));
-        println!("deserialised: {:?}", from_json::<u32>(query_res).unwrap());
-    }
-}
@@ -1 +0,0 @@
-pub mod contract;
@@ -1,26 +1,27 @@
-```tsx copy filename="mixFetchExample.tsx"
-import React, { useState } from "react";
-import CircularProgress from "@mui/material/CircularProgress";
-import Button from "@mui/material/Button";
-import TextField from "@mui/material/TextField";
-import Typography from "@mui/material/Typography";
-import Box from "@mui/material/Box";
-import { mixFetch } from "@nymproject/mix-fetch-full-fat";
-import Stack from "@mui/material/Stack";
-import Paper from "@mui/material/Paper";
-import type { SetupMixFetchOps } from "@nymproject/mix-fetch-full-fat";
+```ts copy filename="mixFetchExample.tsx"
+import React, { useState } from 'react';
+import CircularProgress from '@mui/material/CircularProgress';
+import Button from '@mui/material/Button';
+import TextField from '@mui/material/TextField';
+import Typography from '@mui/material/Typography';
+import Box from '@mui/material/Box';
+import { mixFetch } from '@nymproject/mix-fetch-full-fat';
+import Stack from '@mui/material/Stack';
+import Paper from '@mui/material/Paper';
+import type { SetupMixFetchOps } from '@nymproject/mix-fetch';

-const defaultUrl = "https://nymtech.net/.wellknown/network-requester/exit-policy.txt";
-const args = { mode: "unsafe-ignore-cors" };
+const defaultUrl = 'https://nym.com/favicon.svg';
+const args = { mode: 'unsafe-ignore-cors' };

 const mixFetchOptions: SetupMixFetchOps = {
-  preferredGateway: "2xU4CBE6QiiYt6EyBXSALwxkNvM7gqJfjHXaMkjiFmYW", // with WSS
-  // preferredNetworkRequester:
-  //   "CTDxrcXgrZHWyCWnuCgjpJPghQUcEVz1HkhUr5mGdFnT.3UAww1YWNyVNYNWFQL1LaHYouQtDiXBGK5GiDZgpXkTK@2RFtU5BwxvJJXagAWAEuaPgb5ZVPRoy2542TT93Edw6v",
+  preferredGateway: '6Gb7ftQdKveMjPyrxDXeAtfYAX7Zg5mVZHtnRC5MmZ1B', // with WSS
+  preferredNetworkRequester:
+    '8rRGWy54oC8drFL9DepMegBt2DLrsqQwCoHMXt9nsnTo.2XjCPVbb4FpQ9hNRcXwb9mTzEAVVk1zf1tcch3wdtNEA@6Gb7ftQdKveMjPyrxDXeAtfYAX7Zg5mVZHtnRC5MmZ1B',
  mixFetchOverride: {
    requestTimeoutMs: 60_000,
  },
  forceTls: true, // force WSS
+  extra: {},
 };

 export const MixFetch = () => {
@@ -44,7 +45,7 @@ export const MixFetch = () => {
  };

  return (
-    <div style={{ marginTop: "1rem" }}>
+    <div style={{ marginTop: '1rem' }}>
      <Stack direction="row">
        <TextField
          disabled={busy}
@@ -55,12 +56,7 @@ export const MixFetch = () => {
          defaultValue={defaultUrl}
          onChange={(e) => setUrl(e.target.value)}
        />
-        <Button
-          variant="outlined"
-          disabled={busy}
-          sx={{ marginLeft: "1rem" }}
-          onClick={handleFetch}
-        >
+        <Button variant="outlined" disabled={busy} sx={{ marginLeft: '1rem' }} onClick={handleFetch}>
          Fetch
        </Button>
      </Stack>
@@ -1,19 +1,15 @@
 ```ts copy filename="MixnetWASMClientExample.tsx"
-import React, { useEffect, useState } from "react";
-import {
-  createNymMixnetClient,
-  NymMixnetClient,
-  Payload,
-} from "@nymproject/sdk-full-fat";
-import Box from "@mui/material/Box";
-import CircularProgress from "@mui/material/CircularProgress";
-import Paper from "@mui/material/Paper";
-import Typography from "@mui/material/Typography";
-import Stack from "@mui/material/Stack";
-import TextField from "@mui/material/TextField";
-import Button from "@mui/material/Button";
+import React, { useEffect, useState } from 'react';
+import { createNymMixnetClient, NymMixnetClient, Payload } from '@nymproject/sdk-full-fat';
+import Box from '@mui/material/Box';
+import CircularProgress from '@mui/material/CircularProgress';
+import Paper from '@mui/material/Paper';
+import Typography from '@mui/material/Typography';
+import Stack from '@mui/material/Stack';
+import TextField from '@mui/material/TextField';
+import Button from '@mui/material/Button';

-const nymApiUrl = "https://validator.nymtech.net/api";
+const nymApiUrl = 'https://validator.nymtech.net/api';

 export const Traffic = () => {
  const [nym, setNym] = useState<NymMixnetClient>();
@@ -21,31 +17,27 @@ export const Traffic = () => {
  const [recipient, setRecipient] = useState<string>();
  const [payload, setPayload] = useState<Payload>();
  const [receivedMessage, setReceivedMessage] = useState<string>();
-  const [buttonEnabled, setButtonEnabled] = useState<boolean>(false);

  const init = async () => {
    const client = await createNymMixnetClient();
    setNym(client);

-    // start the client and connect to a gateway
    await client?.client.start({
      clientId: crypto.randomUUID(),
      nymApiUrl,
      forceTls: true, // force WSS
    });

-    // check when is connected and set the self address
    client?.events.subscribeToConnected((e) => {
      const { address } = e.args;
      setSelfAddress(address);
    });

-    // show whether the client is ready or not
    client?.events.subscribeToLoaded((e) => {
-      console.log("Client ready: ", e.args);
+      console.log('Client ready: ', e.args);
    });

-    // show message payload content when received
+
    client?.events.subscribeToTextMessageReceivedEvent((e) => {
      console.log(e.args.payload);
      setReceivedMessage(e.args.payload);
@@ -56,8 +48,7 @@ export const Traffic = () => {
    await nym?.client.stop();
  };

-  const send = () =>
-    payload && recipient && nym?.client.send({ payload, recipient });
+  const send = () => nym.client.send({ payload, recipient });

  useEffect(() => {
    init();
@@ -66,17 +57,9 @@ export const Traffic = () => {
    };
  }, []);

-  useEffect(() => {
-    if (recipient && payload) {
-      setButtonEnabled(true);
-    } else {
-      setButtonEnabled(false);
-    }
-  }, [recipient, payload]);
-
  if (!nym || !selfAddress) {
    return (
-      <Box sx={{ display: "flex" }}>
+      <Box sx={{ display: 'flex' }}>
        <CircularProgress />
      </Box>
    );
@@ -84,10 +67,10 @@ export const Traffic = () => {

  return (
    <Box padding={3}>
-      <Paper style={{ marginTop: "1rem", padding: "2rem" }}>
+      <Paper style={{ marginTop: '1rem', padding: '2rem' }}>
        <Stack spacing={3}>
          <Typography variant="body1">My self address is:</Typography>
-          <Typography variant="body1">{selfAddress || "loading"}</Typography>
+          <Typography variant="body1">{selfAddress || 'loading'}</Typography>
          <Typography variant="h5">Communication through the Mixnet</Typography>
          <TextField
            type="text"
@@ -100,22 +83,15 @@ export const Traffic = () => {
            placeholder="Message to send"
            multiline
            rows={4}
-            onChange={(e) =>
-              setPayload({ message: e.target.value, mimeType: "text/plain" })
-            }
+            onChange={(e) => setPayload({ message: e.target.value, mimeType: 'text/plain' })}
            size="small"
          />
-          <Button
-            variant="outlined"
-            onClick={() => send()}
-            disabled={!buttonEnabled}
-            sx={{ width: "fit-content" }}
-          >
+          <Button variant="outlined" onClick={() => send()} disabled={!payload || !recipient} sx={{width: 'fit-content'}}>
            Send
          </Button>
        </Stack>
        {receivedMessage && (
-          <Stack spacing={3} style={{ marginTop: "1rem" }}>
+          <Stack spacing={3} style={{ marginTop: '1rem' }}>
            <Typography variant="h5">Message Received!</Typography>
            <Typography fontFamily="monospace">{receivedMessage}</Typography>
          </Stack>
@@ -9,13 +9,13 @@ import Stack from "@mui/material/Stack";
 import Paper from "@mui/material/Paper";
 import type { SetupMixFetchOps } from "@nymproject/mix-fetch-full-fat";

-const defaultUrl = "https://nymtech.net/.wellknown/network-requester/exit-policy.txt";
+const defaultUrl = "https://nym.com/favicon.svg";
 const args = { mode: "unsafe-ignore-cors" };

 const mixFetchOptions: SetupMixFetchOps = {
-  preferredGateway: "2xU4CBE6QiiYt6EyBXSALwxkNvM7gqJfjHXaMkjiFmYW", // with WSS
-  // preferredNetworkRequester:
-  //   "CTDxrcXgrZHWyCWnuCgjpJPghQUcEVz1HkhUr5mGdFnT.3UAww1YWNyVNYNWFQL1LaHYouQtDiXBGK5GiDZgpXkTK@2RFtU5BwxvJJXagAWAEuaPgb5ZVPRoy2542TT93Edw6v",
+  preferredGateway: "6Gb7ftQdKveMjPyrxDXeAtfYAX7Zg5mVZHtnRC5MmZ1B", // with WSS
+  preferredNetworkRequester:
+    "8rRGWy54oC8drFL9DepMegBt2DLrsqQwCoHMXt9nsnTo.2XjCPVbb4FpQ9hNRcXwb9mTzEAVVk1zf1tcch3wdtNEA@6Gb7ftQdKveMjPyrxDXeAtfYAX7Zg5mVZHtnRC5MmZ1B",
  mixFetchOverride: {
    requestTimeoutMs: 60_000,
  },
@@ -1,2 +0,0 @@
-export const ICMP =
-  "ICMP (Internet Control Message Protocol) is a network layer protocol used for sending error messages and operational information regarding network conditions. It is commonly utilized for diagnostic purposes, such as sending ping requests to check the reachability of a host. ICMP helps in managing and controlling network traffic by providing feedback about issues in the communication environment.";
@@ -1,3 +0,0 @@
-export const IPR =
-  "IPR (IP Packet Router) is a component that routes packets to the Internet on behalf of clients within the Nym network. It uses multiplexed streams, NAT, and SURBs for anonymity.";
-
@@ -1,93 +0,0 @@
-import { Callout } from 'nextra/components';
-
-
-## Mixnet: Node Performance Calculation
-
-Performance is a value between `0` and `1`. The final performance number is a result of multiplying [config score](#config-score-calculation) and [routing score](#routing-score-calculation).
-
-<Callout type="info" emoji="📌">
-> **node_performance = config_score \* routing_score**
-</Callout>
-
-Performance value is an average of last 24h.
-
-<Callout>
-All parameters regarding performance score can be browsed or pull live from:
-
-`https://validator.nymtech.net/api/v1/nym-nodes/annotation/<NODE_ID>`
-
-In case you don't know your nodes `NODE_ID`, it's easy to find as long as your node is bonded. Visit [validator.nymtech.net/api/v1/nym-nodes/bonded](https://validator.nymtech.net/api/v1/nym-nodes/bonded) and search your node using `identity_key` or bonding Nyx account address (denoted as `owner`).
-</Callout>
-
-### Config Score Calculation
-
-Config score is in place to ensure that the node configuration is done properly so the node is eligible for taking part in Nym network. The API looks into these paramteres:
-
-1. If the node binary is `nym-node` (not legacy `nym-mixnode` or `nym-gateway`): `1` if `True`, `0` if `False`
-2. If [Terms & Conditions](/operators/nodes/nym-node/setup.mdx#terms--conditions) are accepted: `1` if `True`, `0` if `False`
-3. If the nodes self described endpoint is available: `1` if `True`, `0` if `False`
-4. Version of `nym-node` binary: decreasing weight for outdated versions, as [explained below](#versions-behind-calculation)
-
-**The `config_score` calculation formula:**
-
-<Callout type="info" emoji="📌">
-> **config_score = is_tc_accepted \* is_nym-node_binary \* self_described_api_available \* ( 0.995 ^ ( ( X * versions_behind) ^ 1.65 ) )**
-</Callout>
-
-First three points have binary values of either `0` or `1`, with a following logic:
-
-| **Run `nym-node` binary** | **T&C's accepted** | **Self described available** | **Value** |
-| :--                       | :--                | :--                          | ---:      |
-| **True**                  | **True**           | **True**                     | **1**     |
-| True                      | False              | False                        | 0         |
-| True                      | True               | False                        | 0         |
-| False                     | True               | True                         | 0         |
-| False                     | False              | True                         | 0         |
-| True                      | False              | True                         | 0         |
-| False                     | False              | False                        | 0         |
-| False                     | True               | False                        | 0         |
-
-**Only if ALL conditions above are `True` the node can have any chance to be selected, as otherwise the probability will always be 0.**
-
-<Callout type="info" emoji="ℹ️">
-Besides these values, the API also checks whether the node is bonded in Mixnet smart contract as a Nym Node or legacy node (Mixnode or Gateway). **Only nodes bonded as Nym Node in Mixnet smart contract can be selected to the Rewrded set. Thus, if you haven't migrated your node yet, please [follow these steps](/operators/nodes/nym-node/bonding#migrate-to-nym-node-in-mixnet-smart-contract)!**
-</ Callout>
-
-#### Versions Behind Calculation
-
-From release `2024.14-crunch` (`nym-node v1.2.0`), the `config_score` parameter takes into account also nodes version (denoted as `versions_behind`). The "current version" is the one marked as `Latest` in the [repository](https://github.com/nymtech/nym/releases/). The parameter `versions_behind` indicates the number of versions between the `Latest` version and the version run by the node, and it is factored into the config score with this formula:
-
-<Callout type="info" emoji="📌">
-> **0.995 ^ ( ( X * versions_behind ) ^ 1.65 )**
->
-> where: <br />
-> **X = 1;       for patches** <br />
-> **X = 10;      for minor versions** <br />
-> **X = 100;     for major versions**
-</Callout>
-
-> The exact parameters are live accessible on [`/v1/status/config-score-details`](https://validator.nymtech.net/api/swagger/index.html#/Status/config_score_details).
-
-Our versioning convention is: `major_version . minor_version . patch`
-
-For example `nym-node` on version `1.2.0` is on 1st major version, 2nd minor and 0 patches.
-
-Note that the `X` multiplier heavily lowers the `config_score` when nodes are outdated with respect to more significant updates. See the the table and graph below:
-
-| **Version behind**  | **Patches (X = 1)** | **Minor versions (X = 10)** | **Major versions (X = 100)** |
-| :--                 | --:       | --: | --: |
-| 0 (current version) | 1.0 | 1.0 | 1.0 |
-| 1 | 0.995 | 0.7994 | 0.0000 |
-| 2 | 0.9844 | 0.4953 | 0.0000 |
-| 3 | 0.9698 | 0.2536 | 0.0000 |
-| 4 | 0.9518 | 0.1102 | 0.0000 |
-| 5 | 0.9311 | 0.0413 | 0.0000 |
-
-
-![](/images/operators/tokenomics/reward_version_graph.png)
-
-As you can see above, the algorithm is designed to give maximum selection score (`1`) to the latest version, while non-upgraded nodes receive a lower score. The score decreases faster when the node has failed to make a major version upgrade, and slower when the node is behind only with minor updates. This scoring de-prioritizes the selection of outdated nodes, even if their saturation and performance are high. Nodes are selected probabilistically in each epoch (60 min), according to their scores, to be part of the Rewarded set. This scoring mechanism gives priority to the operators running up-to-date nodes, ensuring that the network is as updated as possible.
-
-### Routing Score Calculation
-
-Routing score is measured by Nym Network Monitor which sends thousands of packages through different routes every 15 minutes and measures how many were dropped on the way. Test result represents percentage of packets succesfully returned which are then converted into floats bettween `0` and `1`.
@@ -1,223 +0,0 @@
-import { Callout } from 'nextra/components';
-import { Steps } from 'nextra/components';
-import { Green, Yellow, Red, Gray } from 'components/severity.jsx'
-import { IPR } from 'components/operators/snippets/ipr.js';
-import { ICMP } from 'components/operators/snippets/icmp.js';
-
-## WireGuard: Gateways Performance Calculation
-
-> If you are looking for a page with a guide to run your own `gateway-probe` instance, go [here](/operators/performance-and-testing/gateway-probe).
-
-<Callout type="info" emoji="ℹ️">
-**Note that there is only one binary `nym-node` for [all network functionalities](/operators/nodes/nym-node/setup#functionality-mode) (defined by a positional argument `--mode`).**
-
-When we say *Exit Gateway* in connection to Wireguard, we talk about a `nym-node` running in a mode Exit Gateway (`--mode exit-gateway`) with Wireguard enabled. Such node is listed in [NymVPN application](https://nym.com) as an Exit Gateway and an Entry Gateway for both dVPN (2-hop) and Mixnet (5-hop) options. That's because every Exit Gateway can serve as an Entry, not vice versa for Mixnet and every Gateway with Wireguard enabled option (`--wireguard-enabled true`) can always serve as both Entry and Exit for dVPN (provided that they are correctly [configured](/operators/nodes/nym-node/configuration)).
-</Callout>
-
-**Please note that even the most perfectly configured Gateway, running on the strongest machine may not always be listed as a suggested node in the app. If you are interested to learn the details why, check out the [Gateway Probe Details page](/operators/performance-and-testing/gateway-probe-details).**
-
-### Summary
-
-A simplified explanation of node performance measuring is that the [Node Status API](https://node-status.nym.com) runs [gateway probes](/operators/performance-and-testing/gateway-probe) that connect to gateways to:
-
- Check the configuration of gateways
-  - Checks a list of capabilities (e.g. can route IPv4 traffic in mixnet mode)
-  - Checks a list of configuration (e.g. runs <abbr title={IPR}>IPR</abbr>, has exit policy)
- Acts like a user:
-  - Registers a mixnet client
-  - Registers a wireguard peer and tops up bandwidth with a zk-nym
-  - Sends <abbr title={ICMP}>ICMP</abbr> ping packets
-  - Downloads files
-
-The results are collected and stored in the [Node Status API](https://node-status.nym.com) and can be also veiwed per node in [Node Status Observatory](https://harbourmaster.nymtech.net).
-
-The [NymVPN API directory](https://nymvpn.com/api/public/v1/directory/gateways) cache uses the output of the gateway probes to calculate and display hints to users about the contention on each gateway and what they might expect if they use the gateway. The section [*Gateway Roles & Requirements* below](#gateway-roles--requirements) explains how are these stats measured and what is their significance.
-
-### Performance Score
-
-Gateways are listed in NymVPN application displaying various stats.
-
-![](/images/operators/nym-vpn-sceenshots/nym-vpn-score1.png)
-
-There are four colored score bars.
-
-![](/images/operators/nym-vpn-sceenshots/nym-vpn-score2.png)
-
-This is how they are defined:
-
-<Steps>
-
-###### 1. Overall performance: 
-
-Calculated by mixnet performance score multiplied by WireGuard performance, this is the formula: 
-<Callout type="info" emoji="📌">
-> **mixnet_performance * (download_speed_score * ping_ips_performance_v4)**
-</Callout>
- <Green>High</Green>: `> 75%`
- <Yellow>Medium</Yellow>: `> 50%`
- <Red>Low</Red>: > `10%`
- <Gray>Offline</Gray>: `≤ 10%`
-
- **Download speed scoring:** 
-<Callout type="info" emoji="📌">
-> **\> 5 Mbps = 1.0** <br />
-> **\> 2 Mbps = 0.75** <br />
-> **\> 1 Mbps = 0.5** <br />
-> **\> 0.5 Mbps = 0.25** <br />
-> **otherwise = 0.1**
-</Callout>
-
-###### 2. Server Load:
-
-A load indicator based on ping success
-
- <Green>Low</Green>: `> 80%` ping success (low load)
- <Yellow>Medium</Yellow>: `> 40%` ping success (medium load)
- <Red>High</Red>: `≤ 40%` ping success (node under stress, high load)
-
-###### 3. Uptime:
-
-A routing score of Mixnet (5-hop) is indicated this way:
- <Green>High</Green>: `> 80%` mixnet packet delivery success
- <Yellow>Medium</Yellow>: `> 60%` mixnet packet delivery success
- <Red>Low</Red>: `> 10%` mixnet packet delivery success
- <Gray>Offline</Gray>: `≤ 10%` mixnet packet delivery success
-
-</Steps>
-
-Note that there are caches in place to keep various dept of details to provide info for different pieces of the software. Their timing differs and it can lead to small discrepancies of outcome in between multiple clients observed by users at the same time.
-
-See the [*Gateway Roles & Requirements*](#gateway-roles--requirements) to understand how these stats get measured.
-
-<Callout>
-You can find more details [directly in the code](https://github.com/nymtech/nym-vpn-client/blob/develop/nym-vpn-app/src/hooks/useScore.ts#L10).
-</Callout>
-
-### Gateway Roles & Requirements
-
-A node configuration break down coming alongside basic [server configuration](/operators/nodes/preliminary-steps/vps-setup) required for the nodes in specific roles:
-
- **Entry Gateway - Mixnet:**
-    - Node configured (running with `--mode` argument) as `entry-gateway` or `exit-gateway` (as Exit works as Entry too)
-    - `WS/WSS` ports (9000/9001) accessible
-    - [IPv6 configured](/operators/nodes/nym-node/configuration#quick-ipv6-check)
- **Exit Gateway - Mixnet:**
-    - Node configured (running with `--mode` argument) as `exit-gateway`, that configuration ensures that:
-        - <abbr title={IPR}>IPR</abbr> address present
-        - NR address present
-    - [IPv6 configured](/operators/nodes/nym-node/configuration#quick-ipv6-check)
-    - NymTun configured - using [NetworkTunnelManager](/operators/nodes/nym-node/configuration#routing-configuration)
-
- **Entry & Exit Gateway - dVPN (WireGuard mode):**
-    - Node configured as Wireguard node: `--wireguard-enabled true`
-    - Authenticator address present
-    - NymWG configured - using [NetworkTunnelManager](/operators/nodes/nym-node/configuration#routing-configuration)
-    - [Metadata port open for WG](/operators/nodes/nym-node/configuration#fixing-metadata-port-showing-not-open-in-probe-results)
-    - Wireguard exit policy [configured](/operators/nodes/nym-node/configuration#wireguard-exit-policy-configuration)
-    - [IPv6 configured](/operators/nodes/nym-node/configuration#quick-ipv6-check)
-    - Recommended: [QUIC bridge setup](/operators/nodes/nym-node/configuration#quic-transport-bridge-deployment)
-
-### How Probe Works
-
-Nym Gateway probe is perfomance measurement program running tests through various routes. Operators can run their [local instance of Gateway probe](/operators/performance-and-testing/gateway-probe) or use visit of our dashboards to conveniently see probe results.
-
- [Node Status dashboard](https://node-status.nym.com/dvpn): Shows latest probe results on one board
- [Nym Node Status Observatory](https://harbourmaster.nymtech.net): New version of a good old Nym Harbourmaster, allowing operators preview stats of each node
-
-The following sections explain what is measured in order to collect stats to the [API enpoint](https://nymvpn.com/api/public/v1/directory/gateways) and in the section [*Complete Setup Checklist*](#complete-setup-checklist) below you can see the order of measurements.
-
-#### Entry Gateway - Mixnet (5-hop)
-
-**Tests:**
-
- `can_connect`: Can connect to client WS/WSS endpoint (ports 9000/9001)
- `can_route`: Entry gateway correctly forwards packets into the mixnet
-
-**To Pass:**
-
- Expose correct `WS` and or `WSS` ports (`9000`/ `9001`)
- Ensure DNS A/AAAA records resolve correctly
- Verify IPv6 is actually reachable (not just in DNS)
- Keep node online and monitor packet loss
-
-#### Exit Gateway (IPR) - Mixnet (5-hop)
-
-**Tests:**
-
- `can_connect`: Can connect to <abbr title={IPR}>IPR</abbr>
- `can_route_ip_v4`: IPv4 routing works
- `can_route_ip_external_v4`: IPv4 routing to external internet works
- `can_route_ip_v6`: IPv6 routing works
- `can_route_ip_external_v6`: IPv6 routing to external internet works
-
-**To Pass:**
-
- Ensure upstream routing and NAT allow both IPv4 and IPv6 traffic to external internet
- Check system firewall rules (bidirectional)
- Confirm outbound reachability to common external hosts on both stacks
- Run node with `mode=exit-gateway` - this by default includes entry-gateway mode.
-
-#### Gateways - WireGuard (dVPN / 2-hop)
-
-**Tests:**
-
- `can_register`: Authentication flow completes successfully
- `can_handshake`: WireGuard handshake succeeds
- `can_resolve_dns`: DNS resolution works
- `can_query_metadata_v4`: Can query metadata endpoint
- `ping_hosts_performance` / `ping_ips_performance`: Latency and packet loss metrics
-
-**To Pass:**
-
- Open WireGuard UDP port `51822` (public)
- Ensure metadata TCP port `51830` is accessible inside the WireGuard tunnel (at `10.1.0.1:51830`) for bandwidth queries/topup
- Keep QUIC bridge (`UDP 4443`) healthy if deployed
- Reduce server latency/jitter (depends on provider and location)
- Ensure DNS resolvers are reliable
- Pass the `--wireguard-enabled true` flag in the node config
-
-### Probe Freshness
-
- Probes run continuously; each node is typically tested every ~2 hours
- If a probe fails or times out, the gateway will have stale probe data until the next successful probe completes
- `last_updated_utc`: Timestamp indicating when the last successful probe test completed
-
-See [*Complete Setup Checklist*](#complete-setup-checklist) to understand the order of tests.
-
-### Complete Setup Checklist
-
-**If one test fails, the following points don't get checked!**
-
-#### On-Chain & Configuration
-
- [ ] [Bonded on-chain](/operators/nodes/nym-node/bonding) with [correct role](/operators/nodes/nym-node/setup#functionality-mode) (`exit-gateway`) and correct ports opened exposed
- [ ] Self-description endpoint is reachable
- [ ] [T&Cs accepted](/operators/nodes/nym-node/setup#terms--conditions)
-
-#### Network & Ports
-
- [ ] **Mixnet**: Port `1789` (mixnet) accessible; ports `9000` (`WS`) and `9001` (`WSS`) accessible with valid [TLS for WSS](/operators/nodes/nym-node/configuration/proxy-configuration#reverse-proxy-configuration)
- [ ] [**QUIC bridge**](/operators/nodes/nym-node/configuration#quic-transport-bridge-deployment) (if used): UDP 4443 with valid addresses and SNI host
- [ ] [**WireGuard**](/operators/nodes/nym-node/configuration#routing-configuration): `UDP 51822` open (public); `TCP 51830` accessible [inside WireGuard tunnel](/operators/nodes/nym-node/configuration#fixing-metadata-port-showing-not-open-in-probe-results) (`10.1.0.1:51830`); `--wireguard-enabled true` set in node config
- [ ] **Exit (<abbr title={IPR}>IPR</abbr>)**: [IPv4 and IPv6](/operators/nodes/nym-node/configuration#routing-configuration) routing to external internet configured
- [ ] **DNS**: A/AAAA records correct; IPv6 actually reachable (test, don't just add DNS)
-
-#### Performance Targets
-
- [ ] Achieve `≥ 60%` mixnet performance (Medium)
- [ ] Aim for `≥ 80%` (High) for optimal visibility
- [ ] Keep latency and packet loss low (excessive load reduces performance scores)
- [ ] Keep uptime high (network monitor tracks this)
-
-#### Probe Results (Verify All Pass)
-
- [ ] Entry: `can_connect=true` and `can_route=true`
- [ ] Exit: `can_connect=true` and all v4/v6 routing flags are `true`
- [ ] WireGuard: `can_register`, `can_handshake`, `can_resolve_dns`, and `can_query_metadata_v4` all pass; ping metrics good
-
-#### Recommended
-
- [ ] [WSS enabled](/operators/nodes/nym-node/configuration/proxy-configuration) (connections may fail on clients if only WS is available)
- [ ] [QUIC bridge](/operators/nodes/nym-node/configuration#quic-transport-bridge-deployment) operational (ensures your node appears when users enable QUIC only filter on the app)
- [ ] Accurate geo/IP information (country/region/residential filters rely on this)
- [ ] Stay on most recent supported binary version - [old versions are penalised](/operators/performance-and-testing#versions-behind-calculation)
@@ -3,7 +3,7 @@ import { Callout } from 'nextra/components';
 import { AccordionTemplate } from 'components/accordion-template.tsx';

 <Callout type="info" emoji="ℹ️">
-**QUIC bridge is a requirement for all nodes which enable Wireguard functionality. Note that it this feature is compatible with nodes from `v1.19.0` (platform release [`v2025.18-jarlsberg`](https://github.com/nymtech/nym/releases/tag/nym-binaries-v2025.17-isabirra)) and newer!**
+**QUIC bridge is a requirement for all nodes which enable Wireguard functionality. Note that it this feature is compatible with nodes from `v1.18.0` (platform release [`v2025.17-isabirra`](https://github.com/nymtech/nym/releases/tag/nym-binaries-v2025.17-isabirra)) and newer!**
 </ Callout>

 Nym Network uses various [transport bridges](https://github.com/nymtech/nym-bridges/blob/main/README.md) for routing the packets. Right now operators need to configure [our implementation](https://github.com/nymtech/nym-bridges/tree/main/nym-bridge) of general-purpose transport layer network protocol called [QUIC](https://en.wikipedia.org/wiki/QUIC).
@@ -12,43 +12,36 @@ Operators can use [Nym Bridge Configuration Tool](https://github.com/nymtech/nym

 **We recommend a more convenient QUIC bridge deployment using a script [`quic_bridge_deployment.sh`](https://github.com/nymtech/nym/blob/develop/scripts/nym-node-setup/quic_bridge_deployment.sh), following the steps below.**

-<Callout type="warning" emoji="⚠️">
-This script assumes that you follow the convention of running a `nym-node` as `root`. In case you run as a [non-root user](/operators/nodes/nym-node/configuration#running-nym-node-as-a-non-root), please follow [manual QUIC bridge setup](https://github.com/nymtech/nym-bridges/blob/main/README.md) and ask for support in the [Matrix channel](https://matrix.to/#/#operators:nymtech.chat).
-</Callout>
-
 <Steps>
 ###### 1. Download [`quic_bridge_deployment.sh`](https://github.com/nymtech/nym/blob/develop/scripts/nym-node-setup/quic_bridge_deployment.sh) script
 - SSH to your server
- **Run as root**
 - Download the script and make executable
 ```sh
-curl -L https://raw.githubusercontent.com/nymtech/nym/refs/heads/develop/scripts/nym-node-setup/quic_bridge_deployment.sh -o quic_bridge_deployment.sh && \
+wget https://raw.githubusercontent.com/nymtech/nym/refs/heads/develop/scripts/nym-node-setup/quic_bridge_deployment.sh && \
 chmod +x quic_bridge_deployment.sh
 ```

+
 ###### 2. Run the script with `full_bridge_setup` command
 - Optional: open `tmux` in case you will need to run another commands on the VPS
 - Run the script with a command `full_bridge_setup`
 ```sh
-./quic_bridge_deployment.sh full_bridge_setup
+./nym-node-setup/quic_bridge_deployment.sh full_bridge_setup
 ```

 ###### 3. Follow the interactive prompts
- Make sure you don't just press enter to insert default values if your setup is different, for example in case of path to the config file
+- When you are asked for bridge binary URL, look here for one to match your system: [builds.ci.nymte.ch/QUIC](https://builds.ci.nymte.ch/QUIC/)
+- When you are asked to enter forward address, it's your IPv4 used for bonding the node, alongside port `:51822` (an example: `172.232.238.161:51822`)
+- To find out your IP address you can always run:
+    - IPv4: `curl -4 https://ifconfig.co/ip`
+    - IPv6: `curl -6 https://ifconfig.co/ip`
+- **For all prompts with default options, we highly recommend to stick to default (press enter)**

-###### 4. Validate
-
- After running the script, ensure that the bridges are running correctly:
-```sh
-systemctl status nym-bridge.service
-```
-
-###### 5. Restart `nym-node` service
+###### 4. Restart the node service
 - When done with the deployment, please restart your node systemd service
 ```sh
 service nym-node restart && journalctl -u nym-node.service -f --all
 ```
-
 </Steps>

 Congratulation, you deployed QUIC transport bridge! The script offers a standalone tweaks and checks, you can always run it without any argument to see all the options:
@@ -59,27 +52,51 @@ Congratulation, you deployed QUIC transport bridge! The script offers a standalo
 <AccordionTemplate name="Command output">
 ```shell
 root@localhost:~# ./quic_bridge_deployment.sh
-Logs are being saved locally to: /var/log/nym-bridge-helper.log
-These logs never leave your machine.
+iptables-persistent is already installed.
+Usage: ./quic_bridge_deployment.sh [command] [options]

+Nym QUIC Bridge Deployment Helper Script

-Usage: ./quic_bridge_deployment.sh [command]
+Bridge Installation & Configuration:
+  check_bridge_installation       - Check bridge installation status
+  show_bridge_config              - Display bridge configuration files
+  show_bridge_keys                - Display bridge key information
+  show_bridge_info                - Show comprehensive bridge information
+  verify_bridge_prerequisites     - Verify all prerequisites are met

-Commands:
-  full_bridge_setup            - Run full setup
-  install_bridge_binary        - Install nym-bridge (.deb; falls back to source build if libc too old)
-  install_bridge_cfg_tool      - Install bridge-cfg (prebuilt; falls back to source build if libc too old)
-  run_bridge_cfg_generate      - Generate bridges.toml
-  create_bridge_service        - Setup systemd service (respects .deb-provided service)
-  adjust_ip_forwarding         - Enable forwarding
-  apply_bridge_iptables_rules  - NAT rules
-  configure_dns_and_icmp       - Allow ICMP/DNS
+Bridge Setup Commands:
+  install_bridge_binary           - Download and install nym-bridge binary
+  generate_bridge_keys            - Generate ED25519 bridge identity keys
+  create_client_params            - Create client_bridge_params.json
+  create_bridge_config            - Create bridges.toml configuration
+  create_bridge_service           - Create systemd service file
+  full_bridge_setup               - Interactive full bridge setup wizard

+Network Configuration Commands:
+  adjust_ip_forwarding            - Enable IPv4 and IPv6 forwarding
+  apply_bridge_iptables_rules     - Apply iptables rules for QUIC bridge (nymwg)
+  configure_dns_and_icmp          - Allow ICMP ping tests and configure DNS
+  remove_duplicate_bridge_rules   - Remove duplicate iptables rules for nymwg

------------------------------------------
-Script exited with errors (code: 1).
-Check the log at: /var/log/nym-bridge-helper.log
------------------------------------------
+Network Inspection Commands:
+  fetch_and_display_ipv6          - Show IPv6 on default network device
+  fetch_wg_ipv6_address           - Fetch IPv6 for nymwg interface
+  check_bridge_iptables           - Check iptables rules for nymwg
+  check_ipv6_ipv4_forwarding      - Check IPv4 and IPv6 forwarding status
+  check_ip_routing                - Display IP routing tables
+
+Testing Commands:
+  perform_pings                   - Test IPv4 and IPv6 connectivity
+  test_bridge_connectivity        - Comprehensive bridge connectivity test
+
+Service Management Commands:
+  check_bridge_service_status     - Check nym-bridge and nym-node service status
+  show_bridge_logs [lines]        - Show recent nym-bridge logs (default: 50 lines)
+
+Quick Start:
+  1. Run 'verify_bridge_prerequisites' to check prerequisites
+  2. Run 'check_bridge_installation' to verify installation
+  3. Run 'test_bridge_connectivity' to test connectivity
 ```
 </AccordionTemplate>

@@ -87,9 +104,7 @@ Check the log at: /var/log/nym-bridge-helper.log
 If you have followed the steps outlined above, but the metadata port is not shown as open in either the Node Status API's probe results or an explorer that gets its data from the API, see below:

 <Steps>
-**Run as root**
-
-###### 1. Confirm correct `config.toml` private IPv4 address
+###### 1.
 Ensure that in your `config.toml` file, this value is set to the default one - any other value here will cause the metadata endpoint to fail:

 ```
@@ -100,7 +115,7 @@ private_ipv4 = '10.1.0.1'

 Then restart your node.

-###### 2. Open the needed port
+###### 2.
 Run this command if not already done:
 ```
 ufw allow in on nymwg to any port 51830 proto tcp
@@ -116,7 +131,7 @@ Then ensure the metadata endpoint is listening from the correct address with:
 netstat -an | egrep LISTEN | egrep "51830"
 ```

-###### 3. Validate the setup
+###### 3.
 Once the Node Status API has run a probe on your node, the probe results will reflect this - `can_query_metadata_v4` will have `true` as a value.

 The quickest way to check this is by using the [NymVPN API](https://nymvpn.com/api/public/v1/directory/gateways?show_vpn_only=true) and checking the same field:
@@ -5,7 +5,7 @@
  },
  "mixmining_reserve": {
    "denom": "unym",
-    "amount": "178754510529387"
+    "amount": "180875972213757"
  },
  "vesting_tokens": {
    "denom": "unym",
@@ -13,6 +13,6 @@
  },
  "circulating_supply": {
    "denom": "unym",
-    "amount": "821245489470613"
+    "amount": "819124027786243"
  }
 }
@@ -1 +1 @@
-821_245_489
+819_124_027
@@ -1 +1 @@
-4_965
+5_024
@@ -1 +1 @@
-251_263
+250_614
@@ -1 +1 @@
-60_303_169
+60_147_392
@@ -1 +1 @@
-60_303_168
+60_147_391
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Floriane TUERNAL SABOTINOV	8aa5e61ba6	wip	2025-10-27 19:11:13 +01:00
Floriane TUERNAL SABOTINOV	3bda29aed7	featurized InputMessage transformation	2025-10-24 16:50:47 +02:00
Floriane TUERNAL SABOTINOV	69bba68060	wip	2025-10-22 12:14:44 +02:00
Floriane TUERNAL SABOTINOV	c2a06298d1	fmt	2025-10-22 09:17:40 +02:00
Floriane TUERNAL SABOTINOV	2831f4ae55	wip	2025-10-22 09:07:07 +02:00
Floriane TUERNAL SABOTINOV	2344a43f62	rebase reconciliation	2025-10-21 15:21:55 +02:00
Floriane TUERNAL SABOTINOV	8427b09ed7	cleanup final	2025-10-21 14:18:57 +02:00
Floriane TUERNAL SABOTINOV	ec09c7e807	cleanup and PR ready	2025-10-21 14:18:57 +02:00
Floriane TUERNAL SABOTINOV	6eab87fe05	refactor init tracer and use of tracing_opentelemetry span for async tracing	2025-10-21 14:18:57 +02:00
Floriane TUERNAL SABOTINOV	9c13fe534b	featurized otel	2025-10-21 14:18:55 +02:00
Floriane TUERNAL SABOTINOV	ad431e8b09	cleanup and add guard to keep the tracer provider alive	2025-10-21 14:16:21 +02:00
Floriane TUERNAL SABOTINOV	b292c4a624	continue trace)id propagation into sphinx	2025-10-21 14:16:19 +02:00
Floriane TUERNAL SABOTINOV	9a96be3d41	add trace_id to sphinx packet	2025-10-21 14:13:38 +02:00
Floriane TUERNAL SABOTINOV	8e771c3530	otel adaptation for sphinx instrumentation	2025-10-21 14:09:04 +02:00
Floriane TUERNAL SABOTINOV	47e1e912f5	traceparent injection into headers	2025-10-21 14:09:04 +02:00
Floriane TUERNAL SABOTINOV	4116bb321a	add traceparent to http headers	2025-10-21 14:09:02 +02:00
Floriane TUERNAL SABOTINOV	60cde66451	websocket otel trace handling correction	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	be37715552	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	f05c5d2eae	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	e9cbd0aff5	add instrument to sdk send message	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	36b07b1bcf	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	827591631d	debug node	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	682feac75e	add manual spans to handle_request functions	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	28058944f2	cleanup	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	ca9b1d656c	use otel span to parent tracing span	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	2955e506de	add context to message handling	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	254a414c49	change context propagation method to trace_id sharing to go accros async move barrier	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	7d087996b4	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	c5e66687b6	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	faaafbeae4	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	32d7328c7b	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	6ba20e7f54	context extraction	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	74c064135b	parent/chil propagation explicitation	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	1fef24a6ba	try debug panic when using parent span	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	2ae73b7f31	rm clone because panic	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	b93779850b	propagation to parent function	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	651d0bb578	wip	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	4af1835dbd	add method to extract trace_id from ContextCarrier	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	f1bf9861cd	use attach() instead of creating new span	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	15f56bccb1	forget to enter span	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	26da5da44f	verify existence of context	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	b9a2efe0c9	use authenticatev2 and not authenticate	2025-10-21 14:08:12 +02:00
Floriane TUERNAL SABOTINOV	8492c7161c	manual propagators for context from client to node	2025-10-21 14:08:10 +02:00
Floriane TUERNAL SABOTINOV	76770fa30c	wip	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	9d774860e5	experiment do I preserve trace_id with with method	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	7d7bebacd2	try debug with otel specific tools	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	cfe8c08ca6	print debug trace	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	9d8c328ce1	establishing initial authentication common trace_id	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	c4543c83d5	context propagation helpers	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	1fa615991b	Revert "broken: context won't satisfy spawn async move" This reverts commit 2b11479ad4801e1efa8ab0aca4ca577bd3f195fe.	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	9f3061a2eb	broken: context won't satisfy spawn async move	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	953f930c4b	try debug fresh handler context	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	c2b620de92	debug surb_reply client	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	d55fce1917	try debug client gets stuck	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	bda45b405c	try keep context accross async call	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	bb9f0540e8	instrumentation of nym-node to nym-gateway workflow	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	e3569ccc16	fixed trace_id distibuted from sdk to gateway	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	5c9d58bad3	fix trace_id propagation from sdk to mix-node	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	6c03ab69fb	try debug difference trace_id otel by use async for gateway and attach it to span in surb_reply	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	89329ab3ee	add context propagation	2025-10-21 14:07:01 +02:00
Floriane TUERNAL SABOTINOV	fee2ae5964	change surb_reply to test relation with nym-node + basic instrumentation	2025-10-21 14:06:59 +02:00
Floriane TUERNAL SABOTINOV	f56edf63b5	fix signoz ingestion	2025-10-21 13:59:59 +02:00
Floriane TUERNAL SABOTINOV	dacd35470d	configure format for sending logs to signoz	2025-10-21 13:59:59 +02:00
Floriane TUERNAL SABOTINOV	acc11e8776	setup otel for surb_reply	2025-10-21 13:59:59 +02:00
Floriane TUERNAL SABOTINOV	a11de8eb74	fix otel panic	2025-10-21 13:59:59 +02:00
Floriane TUERNAL SABOTINOV	fa603be538	setup otel from run to forward_sphinx_packet	2025-10-21 13:59:59 +02:00
Floriane TUERNAL SABOTINOV	2447520010	revert changes from previous commit	2025-10-21 13:59:59 +02:00
Mark Sinclair	5888102359	wip: sdk surb-reply example add otel tracing	2025-10-21 13:59:59 +02:00
Mark Sinclair	7d7acc2691	wip: tracing in nym-node	2025-10-21 13:59:59 +02:00
Mark Sinclair	20e6243738	add opentelemetry for debugging and testing behind `otel` feature flag	2025-10-21 13:59:55 +02:00
@@ -1 +1 @@
 _965
 _024
@@ -1 +1 @@
 _263
 _614