Merge branch 'develop' into benny/gas-multiplier-fix

Update mod.rs
2023-12-19 19:53:56 +01:00 · 2023-12-15 12:36:05 +01:00
787 changed files with 24728 additions and 20144 deletions
@@ -4,18 +4,18 @@ on:
  workflow_dispatch:
  pull_request:
    paths:
-      - "clients/**"
-      - "common/**"
-      - "explorer-api/**"
-      - "gateway/**"
-      - "integrations/**"
-      - "mixnode/**"
-      - "sdk/rust/nym-sdk/**"
-      - "service-providers/**"
-      - "nym-api/**"
-      - "nym-outfox/**"
-      - "tools/nym-cli/**"
-      - "tools/ts-rs-cli/**"
+      - 'clients/**'
+      - 'common/**'
+      - 'explorer-api/**'
+      - 'gateway/**'
+      - 'integrations/**'
+      - 'mixnode/**'
+      - 'sdk/rust/nym-sdk/**'
+      - 'service-providers/**'
+      - 'nym-api/**'
+      - 'nym-outfox/**'
+      - 'tools/nym-cli/**'
+      - 'tools/ts-rs-cli/**'

 jobs:
  publish-nym:
@@ -53,16 +53,6 @@ jobs:
          command: build
          args: --workspace --release

-      - name: Install cargo-deb
-        uses: actions-rs/cargo@v1
-        with:
-          command: install
-          args: cargo-deb
-
-      - name: Build deb packages
-        shell: bash
-        run: make deb
-
      - name: Prepare build output
        shell: bash
        env:
@@ -77,7 +67,6 @@ jobs:
          cp target/release/nym-network-statistics $OUTPUT_DIR
          cp target/release/nym-cli $OUTPUT_DIR
          cp target/release/explorer-api $OUTPUT_DIR
-          cp target/debian/*.deb $OUTPUT_DIR

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -1,8 +1,5 @@
 name: ci-cargo-deny
-on:
-  workflow_dispatch:
-  pull_request:
-
+on: [workflow_dispatch]
 jobs:
  cargo-deny:
    runs-on: ubuntu-22.04
@@ -10,7 +7,10 @@ jobs:
      matrix:
        checks:
          # - advisories
-          - licenses bans sources
+          - licenses
+          - bans sources
+
+    continue-on-error: ${{ matrix.checks == 'licenses' }}

    steps:
    - uses: actions/checkout@v3
@@ -17,9 +17,6 @@ jobs:
    steps:
      - uses: actions/checkout@v2

-      - name: install yarn in root
-        run: cd ../.. && yarn install
-
      - name: Install npm
        run: npm install

@@ -0,0 +1,40 @@
+name: ci-nym-vpn-ui-js
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - 'nym-vpn/ui/src/**'
+      - 'nym-vpn/ui/package.json'
+      - 'nym-vpn/ui/index.html'
+
+jobs:
+  check:
+    runs-on: custom-linux
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install Node
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Install Yarn
+        run: npm install -g yarn
+      - name: Install dependencies
+        working-directory: nym-vpn/ui
+        run: yarn
+      - name: Type-check
+        working-directory: nym-vpn/ui
+        run: yarn typecheck
+      - name: Check lint
+        working-directory: nym-vpn/ui
+        run: yarn lint
+      - name: Check formatting
+        working-directory: nym-vpn/ui
+        run: yarn fmt:check
+#      - name: Run tests
+#        working-directory: nym-vpn/ui
+#        run: yarn test
+      - name: Check build
+        working-directory: nym-vpn/ui
+        run: yarn build
@@ -0,0 +1,63 @@
+name: ci-nym-vpn-ui-rust
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - 'nym-vpn/ui/src-tauri/**'
+
+jobs:
+  build:
+    runs-on: custom-linux
+    env:
+      CARGO_TERM_COLOR: always
+      CARGOTOML_PATH: ./nym-vpn/ui/src-tauri/Cargo.toml
+    steps:
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools libayatana-appindicator3-dev
+        continue-on-error: true
+
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+
+      - name: Prepare build
+        run: mkdir nym-vpn/ui/dist
+
+      - name: Build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --features custom-protocol
+
+#      - name: Run all tests
+#        uses: actions-rs/cargo@v1
+#        with:
+#          command: test
+#          args: --manifest-path ${{ env.CARGOTOML_PATH }}
+
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --all -- --check
+
+      - name: Annotate with clippy checks
+        uses: actions-rs/clippy-check@v1
+        continue-on-error: true
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --all-features
+
+      - name: Clippy
+        uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: --manifest-path ${{ env.CARGOTOML_PATH }} --all-features --all-targets -- -D warnings
@@ -67,7 +67,6 @@ members = [
    "common/nymsphinx/params",
    "common/nymsphinx/routing",
    "common/nymsphinx/types",
-    "common/nyxd-scraper",
    "common/pemstore",
    "common/socks5-client-core",
    "common/socks5/proxy-helpers",
@@ -102,7 +101,6 @@ members = [
    "nym-node",
    "nym-node/nym-node-requests",
    "nym-outfox",
-    "nym-validator-rewarder",
    "tools/internal/ssl-inject",
    "tools/internal/sdk-version-bump",
    "tools/nym-cli",
@@ -125,10 +123,9 @@ default-members = [
    "nym-api",
    "tools/nymvisor",
    "explorer-api",
-    "nym-validator-rewarder",
 ]

-exclude = ["explorer", "contracts", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "nym-vpn/ui/src-tauri", "cpu-cycles", "sdk/ffi/cpp"]
+exclude = ["explorer", "contracts", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "nym-vpn/ui/src-tauri", "cpu-cycles"]

 [workspace.package]
 authors = ["Nym Technologies SA"]
@@ -162,7 +159,6 @@ reqwest = "0.11.22"
 schemars = "0.8.1"
 serde = "1.0.152"
 serde_json = "1.0.91"
-sqlx = "0.6.3"
 tap = "1.0.1"
 time = "0.3.30"
 thiserror = "1.0.48"
@@ -203,12 +199,9 @@ cw-controllers = { version = "=1.1.0" }

 # cosmrs-related
 bip32 = "0.5.1"
-
-# temporarily using a fork again (yay.) because we need staking and slashing support
-cosmrs = { git = "https://github.com/jstuczyn/cosmos-rust", branch ="nym-temp/all-validator-features" }
-#cosmrs = {  git = "https://github.com/jstuczyn/cosmos-rust", branch = "nym-temp/all-validator-features" } # unfortuntely we need a fork by yours truly to get the staking support
-tendermint = "0.34" # same version as used by cosmrs
+cosmrs = "=0.15.0"
 tendermint-rpc = "0.34" # same version as used by cosmrs
+tendermint = "0.34" # same version as used by cosmrs
 prost = "0.12"

 # wasm-related dependencies
@@ -12,7 +12,6 @@ help:
 	@echo "  clippy: run clippy for all workspaces"
 	@echo "  test: run clippy, unit tests, and formatting."
 	@echo "  test-all: like test, but also includes the expensive tests"
-	@echo "  deb: build debian packages

 # -----------------------------------------------------------------------------
 # Meta targets
@@ -158,12 +157,6 @@ build-explorer-api:
 build-nym-cli:
 	cargo build -p nym-cli --release

-build-nym-gateway:
-	cargo build -p nym-gateway --release
-
-build-nym-mixnode:
-	cargo build -p nym-mixnode --release
-
 # -----------------------------------------------------------------------------
 # Misc
 # -----------------------------------------------------------------------------
@@ -176,13 +169,6 @@ run-api-tests:
 	cd nym-api/tests/functional_test && yarn test:qa

 # Build debian package, and update PPA
-deb-mixnode: build-nym-mixnode
-	cargo deb -p nym-mixnode 
-
-deb-gateway: build-nym-gateway
-	cargo deb -p nym-gateway
-
-deb-cli: build-nym-cli
-	cargo deb -p nym-cli
-
-deb: deb-mixnode deb-gateway deb-cli
+# Requires base64 encode GPG key to be set up in environment PPA_SIGNING_KEY
+deb:
+	scripts/ppa.sh
@@ -1,70 +0,0 @@
-<html>
-
-<head>
-    <style>
-        @media (prefers-color-scheme: dark) {
-            body {
-                background: #333;
-                color: white;
-            }
-            a {
-                color: skyblue;
-            }
-        }
-        .container {
-            font-family: sans-serif;
-            max-width: 800px;
-            margin: 0 auto;
-        }
-        .intro {
-            text-align: center;
-        }
-        .licenses-list {
-            list-style-type: none;
-            margin: 0;
-            padding: 0;
-        }
-        .license-used-by {
-            margin-top: -10px;
-        }
-        .license-text {
-            max-height: 200px;
-            overflow-y: scroll;
-            white-space: pre-wrap;
-        }
-    </style>
-</head>
-
-<body>
-    <main class="container">
-        <div class="intro">
-            <h1>Third Party Licenses</h1>
-            <p>This page lists the licenses of the projects used in cargo-about.</p>
-        </div>
-    
-        <h2>Overview of licenses:</h2>
-        <ul class="licenses-overview">
-            {{#each overview}}
-            <li><a href="#{{id}}">{{name}}</a> ({{count}})</li>
-            {{/each}}
-        </ul>
-
-        <h2>All license text:</h2>
-        <ul class="licenses-list">
-            {{#each licenses}}
-            <li class="license">
-                <h3 id="{{id}}">{{name}}</h3>
-                <h4>Used by:</h4>
-                <ul class="license-used-by">
-                    {{#each used_by}}
-                    <li><a href="{{#if crate.repository}} {{crate.repository}} {{else}} https://crates.io/crates/{{crate.name}} {{/if}}">{{crate.name}} {{crate.version}}</a></li>
-                    {{/each}}
-                </ul>
-                <pre class="license-text">{{text}}</pre>
-            </li>
-            {{/each}}
-        </ul>
-    </main>
-</body>
-
-</html>
@@ -1,19 +0,0 @@
-private = { ignore = true }
-
-accepted = [
-    "0BSD",
-    "Apache-2.0",
-    "BSD-2-Clause",
-    "BSD-3-Clause",
-    "CC0-1.0",
-    "ISC",
-    "MIT",
-    "MPL-2.0",
-    "Unicode-DFS-2016",
-    "OpenSSL",
-]
-
-workarounds = [
-    "ring",
-    "rustls",
-]
@@ -5,7 +5,6 @@ authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej St
 description = "Implementation of the Nym Client"
 edition = "2021"
 rust-version = "1.65"
-license.workspace = true

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

@@ -1667,9 +1667,9 @@
      }
    },
    "node_modules/follow-redirects": {
-      "version": "1.15.4",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
-      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
+      "version": "1.14.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz",
+      "integrity": "sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==",
      "dev": true,
      "funding": [
        {
@@ -5800,9 +5800,9 @@
      }
    },
    "follow-redirects": {
-      "version": "1.15.4",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
-      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
+      "version": "1.14.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz",
+      "integrity": "sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==",
      "dev": true
    },
    "forwarded": {
@@ -51,7 +51,7 @@ impl InitialisableClient for NativeClientInit {
    }
 }

-#[derive(Args, Clone, Debug)]
+#[derive(Args, Clone)]
 pub(crate) struct Init {
    #[command(flatten)]
    common_args: CommonClientInitArgs,
@@ -3,7 +3,6 @@ name = "nym-client-websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

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

@@ -5,7 +5,6 @@ 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"
 rust-version = "1.56"
-license.workspace = true

 [dependencies]
 clap = { workspace = true, features = ["cargo", "derive"] }
@@ -51,7 +51,7 @@ impl InitialisableClient for Socks5ClientInit {
    }
 }

-#[derive(Args, Clone, Debug)]
+#[derive(Args, Clone)]
 pub(crate) struct Init {
    #[command(flatten)]
    common_args: CommonClientInitArgs,
@@ -1,4 +0,0 @@
-module.exports = {
-    ConfigHandler: require('./config/configHandler.ts'),
-    RestClient: require('./restClient/RestClient.ts')
-  };
@@ -2,7 +2,6 @@
 name = "async-file-watcher"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -2,7 +2,6 @@
 name = "nym-bandwidth-controller"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -9,7 +9,6 @@ repository = { workspace = true }

 [dependencies]
 atty = "0.2"
-const-str = "0.5.6"
 clap = { workspace = true, features = ["derive"] }
 clap_complete = "4.0"
 clap_complete_fig = "4.0"
@@ -36,10 +35,9 @@ opentelemetry = { version = "0.19.0", optional = true, features = ["rt-tokio"] }


 [build-dependencies]
-vergen = { version = "=8.2.6", default-features = false, features = [
+vergen = { version = "=7.4.3", default-features = false, features = [
    "build",
    "git",
-    "gitcl",
    "rustc",
    "cargo",
 ] }
@@ -1,14 +1,13 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use vergen::EmitBuilder;
+use vergen::{vergen, Config};

 fn main() {
-    EmitBuilder::builder()
-        .all_build()
-        .all_git()
-        .all_rustc()
-        .all_cargo()
-        .emit()
-        .expect("failed to extract build metadata");
+    let mut config = Config::default();
+    if std::env::var("DOCS_RS").is_ok() {
+        // If we don't have access to git information, such as in a docs.rs build, don't error
+        *config.git_mut().skip_if_error_mut() = true;
+    }
+    vergen(config).expect("failed to extract build metadata");
 }
@@ -40,22 +40,14 @@ pub struct BinaryBuildInformation {
    /// Provides the rustc channel that was used for the build, for example `nightly`.
    pub rustc_channel: &'static str,

-    // VERGEN_CARGO_DEBUG
-    /// Provides the cargo debug mode that was used for the build.
-    // NOTE: keep the old name cargo_profile instead of cargo_debug for backwards compatibility
+    // VERGEN_CARGO_PROFILE
+    /// Provides the cargo profile that was used for the build, for example `debug`.
    pub cargo_profile: &'static str,
 }

 impl BinaryBuildInformation {
    // explicitly require the build_version to be passed as it's binary specific
    pub const fn new(binary_name: &'static str, build_version: &'static str) -> Self {
-        let cargo_debug = env!("VERGEN_CARGO_DEBUG");
-        let cargo_profile = if const_str::equal!(cargo_debug, "true") {
-            "debug"
-        } else {
-            "release"
-        };
-
        BinaryBuildInformation {
            binary_name,
            build_timestamp: env!("VERGEN_BUILD_TIMESTAMP"),
@@ -65,7 +57,7 @@ impl BinaryBuildInformation {
            commit_branch: env!("VERGEN_GIT_BRANCH"),
            rustc_version: env!("VERGEN_RUSTC_SEMVER"),
            rustc_channel: env!("VERGEN_RUSTC_CHANNEL"),
-            cargo_profile,
+            cargo_profile: env!("VERGEN_CARGO_PROFILE"),
        }
    }

@@ -123,9 +115,8 @@ pub struct BinaryBuildInformationOwned {
    /// Provides the rustc channel that was used for the build, for example `nightly`.
    pub rustc_channel: String,

-    // VERGEN_CARGO_DEBUG
-    /// Provides the cargo debug mode that was used for the build.
-    // NOTE: keep the old name cargo_profile instead of cargo_debug for backwards compatibility
+    // VERGEN_CARGO_PROFILE
+    /// Provides the cargo profile that was used for the build, for example `debug`.
    pub cargo_profile: String,
 }

@@ -4,7 +4,6 @@ version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
-license.workspace = true

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

@@ -46,7 +45,6 @@ nym-validator-client = { path = "../client-libs/validator-client", default-featu
 nym-task = { path = "../task" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-network-defaults = { path = "../network-defaults" }
-si-scale = "0.2.2"

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
 version = "0.1.11"
@@ -60,7 +58,7 @@ features = ["time"]
 version = "0.20.1"

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
-workspace = true
+version = "0.6.2"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
 optional = true

@@ -91,7 +89,7 @@ tempfile = "3.1.0"

 [build-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
+sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }

 [features]
 default = []
@@ -109,8 +109,6 @@ pub async fn initialise_client<C>(
 ) -> Result<InitResultsWithConfig<C::Config>, C::Error>
 where
    C: InitialisableClient,
-    <C as InitialisableClient>::Config: std::fmt::Debug,
-    <C as InitialisableClient>::InitArgs: std::fmt::Debug,
 {
    info!("initialising {} client", C::NAME);

@@ -142,32 +140,17 @@ where

    // Attempt to use a user-provided gateway, if possible
    let user_chosen_gateway_id = common_args.gateway;
-    log::debug!("User chosen gateway id: {user_chosen_gateway_id:?}");
-
    let selection_spec = GatewaySelectionSpecification::new(
        user_chosen_gateway_id.map(|id| id.to_base58_string()),
        Some(common_args.latency_based_selection),
        false,
    );
-    log::debug!("Gateway selection specification: {selection_spec:?}");

    // Load and potentially override config
-    log::debug!("Init arguments: {init_args:#?}");
    let config = C::construct_config(&init_args);
-    log::debug!("Constructed config: {config:#?}");
    let paths = config.common_paths();
    let core = config.core_config();

-    log::info!(
-        "Using nym-api: {}",
-        core.client
-            .nym_api_urls
-            .iter()
-            .map(|url| url.as_str())
-            .collect::<Vec<&str>>()
-            .join(",")
-    );
-
    // Setup gateway by either registering a new one, or creating a new config from the selected
    // one but with keys kept, or reusing the gateway configuration.
    let key_store = OnDiskKeys::new(paths.keys.clone());
@@ -1,7 +1,6 @@
 // Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use super::packet_statistics_control::PacketStatisticsReporter;
 use super::received_buffer::ReceivedBufferMessage;
 use super::topology_control::geo_aware_provider::GeoAwareTopologyProvider;
 use crate::client::base_client::storage::gateway_details::GatewayDetailsStore;
@@ -11,7 +10,6 @@ use crate::client::inbound_messages::{InputMessage, InputMessageReceiver, InputM
 use crate::client::key_manager::persistence::KeyStore;
 use crate::client::mix_traffic::transceiver::{GatewayReceiver, GatewayTransceiver, RemoteGateway};
 use crate::client::mix_traffic::{BatchMixMessageSender, MixTrafficController};
-use crate::client::packet_statistics_control::PacketStatisticsControl;
 use crate::client::real_messages_control;
 use crate::client::real_messages_control::RealMessagesController;
 use crate::client::received_buffer::{
@@ -256,7 +254,6 @@ where
        self_address: Recipient,
        topology_accessor: TopologyAccessor,
        mix_tx: BatchMixMessageSender,
-        stats_tx: PacketStatisticsReporter,
        shutdown: TaskClient,
    ) {
        info!("Starting loop cover traffic stream...");
@@ -269,7 +266,6 @@ where
            topology_accessor,
            debug_config.traffic,
            debug_config.cover_traffic,
-            stats_tx,
        );

        stream.start_with_shutdown(shutdown);
@@ -289,7 +285,6 @@ where
        client_connection_rx: ConnectionCommandReceiver,
        shutdown: TaskClient,
        packet_type: PacketType,
-        stats_tx: PacketStatisticsReporter,
    ) {
        info!("Starting real traffic stream...");

@@ -304,7 +299,6 @@ where
            reply_controller_receiver,
            lane_queue_lengths,
            client_connection_rx,
-            stats_tx,
        )
        .start_with_shutdown(shutdown, packet_type);
    }
@@ -318,7 +312,6 @@ where
        reply_key_storage: SentReplyKeys,
        reply_controller_sender: ReplyControllerSender,
        shutdown: TaskClient,
-        packet_statistics_control: PacketStatisticsReporter,
    ) {
        info!("Starting received messages buffer controller...");
        let controller: ReceivedMessagesBufferController<SphinxMessageReceiver> =
@@ -328,7 +321,6 @@ where
                mixnet_receiver,
                reply_key_storage,
                reply_controller_sender,
-                packet_statistics_control,
            );
        controller.start_with_shutdown(shutdown)
    }
@@ -514,13 +506,6 @@ where
        Ok(())
    }

-    fn start_packet_statistics_control(shutdown: TaskClient) -> PacketStatisticsReporter {
-        info!("Starting packet statistics control...");
-        let (packet_statistics_control, packet_stats_reporter) = PacketStatisticsControl::new();
-        packet_statistics_control.start_with_shutdown(shutdown);
-        packet_stats_reporter
-    }
-
    fn start_mix_traffic_controller(
        gateway_transceiver: Box<dyn GatewayTransceiver + Send>,
        shutdown: TaskClient,
@@ -648,9 +633,6 @@ where
        )
        .await?;

-        let packet_stats_reporter =
-            Self::start_packet_statistics_control(shutdown.fork("packet_statistics_control"));
-
        let gateway_packet_router = PacketRouter::new(
            ack_sender,
            mixnet_messages_sender,
@@ -680,7 +662,6 @@ where
            reply_storage.key_storage(),
            reply_controller_sender.clone(),
            shutdown.fork("received_messages_buffer"),
-            packet_stats_reporter.clone(),
        );

        // The message_sender is the transmitter for any component generating sphinx packets
@@ -719,7 +700,6 @@ where
            client_connection_rx,
            shutdown.fork("real_traffic_controller"),
            self.config.debug.traffic.packet_type,
-            packet_stats_reporter.clone(),
        );

        if !self
@@ -734,7 +714,6 @@ where
                self_address,
                shared_topology_accessor.clone(),
                message_sender,
-                packet_stats_reporter,
                shutdown.fork("cover_traffic_stream"),
            );
        }
@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::mix_traffic::BatchMixMessageSender;
-use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
 use crate::client::topology_control::TopologyAccessor;
 use crate::{config, spawn_future};
 use futures::task::{Context, Poll};
@@ -62,8 +61,6 @@ where
    secondary_packet_size: Option<PacketSize>,

    packet_type: PacketType,
-
-    stats_tx: PacketStatisticsReporter,
 }

 impl<R> Stream for LoopCoverTrafficStream<R>
@@ -100,8 +97,7 @@ where
 // obviously when we finally make shared rng that is on 'higher' level, this should become
 // generic `R`
 impl LoopCoverTrafficStream<OsRng> {
-    #[allow(clippy::too_many_arguments)]
-    pub(crate) fn new(
+    pub fn new(
        ack_key: Arc<AckKey>,
        average_ack_delay: Duration,
        mix_tx: BatchMixMessageSender,
@@ -109,7 +105,6 @@ impl LoopCoverTrafficStream<OsRng> {
        topology_access: TopologyAccessor,
        traffic_config: config::Traffic,
        cover_config: config::CoverTraffic,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let rng = OsRng;

@@ -127,7 +122,6 @@ impl LoopCoverTrafficStream<OsRng> {
            primary_packet_size: traffic_config.primary_packet_size,
            secondary_packet_size: traffic_config.secondary_packet_size,
            packet_type: traffic_config.packet_type,
-            stats_tx,
        }
    }

@@ -197,10 +191,6 @@ impl LoopCoverTrafficStream<OsRng> {
                    log::warn!("Failed to send cover message - channel closed");
                }
            }
-        } else {
-            self.stats_tx.report(PacketStatisticsEvent::CoverPacketSent(
-                cover_traffic_packet_size.size(),
-            ));
        }

        // TODO: I'm not entirely sure whether this is really required, because I'm not 100%
@@ -1,8 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-#![allow(unused_imports)]
-
 use std::time::Duration;

 pub use wasmtimer::{std::Instant, tokio::*};
@@ -7,7 +7,6 @@ pub(crate) mod helpers;
 pub mod inbound_messages;
 pub mod key_manager;
 pub mod mix_traffic;
-pub(crate) mod packet_statistics_control;
 pub mod real_messages_control;
 pub mod received_buffer;
 pub mod replies;
@@ -1,498 +0,0 @@
-use std::{
-    collections::VecDeque,
-    time::{Duration, Instant},
-};
-
-use si_scale::helpers::bibytes2;
-
-use crate::spawn_future;
-
-// Time interval between reporting packet statistics
-const PACKET_REPORT_INTERVAL_SECS: u64 = 2;
-// Interval for taking snapshots of the packet statistics
-const SNAPSHOT_INTERVAL_MS: u64 = 500;
-// When computing rates, we include snapshots that are up to this old. We set it to some odd number
-// a tad larger than an integer number of snapshot intervals, so that we don't have to worry about
-// threshold effects.
-// Also, set it larger than the packet report interval so that we don't miss notable singular events
-const RECORDING_WINDOW_MS: u64 = 2300;
-
-#[derive(Default, Debug, Clone)]
-struct PacketStatistics {
-    // Sent
-    real_packets_sent: u64,
-    real_packets_sent_size: usize,
-    cover_packets_sent: u64,
-    cover_packets_sent_size: usize,
-
-    // Received
-    real_packets_received: u64,
-    real_packets_received_size: usize,
-    cover_packets_received: u64,
-    cover_packets_received_size: usize,
-
-    // Acks
-    total_acks_received: u64,
-    total_acks_received_size: usize,
-    real_acks_received: u64,
-    real_acks_received_size: usize,
-    cover_acks_received: u64,
-    cover_acks_received_size: usize,
-
-    // Types of packets queued
-    // TODO: track the type sent instead
-    real_packets_queued: u64,
-    retransmissions_queued: u64,
-    reply_surbs_queued: u64,
-    additional_reply_surbs_queued: u64,
-}
-
-impl PacketStatistics {
-    fn handle_event(&mut self, event: PacketStatisticsEvent) {
-        match event {
-            PacketStatisticsEvent::RealPacketSent(packet_size) => {
-                self.real_packets_sent += 1;
-                self.real_packets_sent_size += packet_size;
-            }
-            PacketStatisticsEvent::CoverPacketSent(packet_size) => {
-                self.cover_packets_sent += 1;
-                self.cover_packets_sent_size += packet_size;
-            }
-            PacketStatisticsEvent::RealPacketReceived(packet_size) => {
-                self.real_packets_received += 1;
-                self.real_packets_received_size += packet_size;
-            }
-            PacketStatisticsEvent::CoverPacketReceived(packet_size) => {
-                self.cover_packets_received += 1;
-                self.cover_packets_received_size += packet_size;
-            }
-            PacketStatisticsEvent::AckReceived(packet_size) => {
-                self.total_acks_received += 1;
-                self.total_acks_received_size += packet_size;
-            }
-            PacketStatisticsEvent::RealAckReceived(packet_size) => {
-                self.real_acks_received += 1;
-                self.real_acks_received_size += packet_size;
-            }
-            PacketStatisticsEvent::CoverAckReceived(packet_size) => {
-                self.cover_acks_received += 1;
-                self.cover_acks_received_size += packet_size;
-            }
-            PacketStatisticsEvent::RealPacketQueued => {
-                self.real_packets_queued += 1;
-            }
-            PacketStatisticsEvent::RetransmissionQueued => {
-                self.retransmissions_queued += 1;
-            }
-            PacketStatisticsEvent::ReplySurbRequestQueued => {
-                self.reply_surbs_queued += 1;
-            }
-            PacketStatisticsEvent::AdditionalReplySurbRequestQueued => {
-                self.additional_reply_surbs_queued += 1;
-            }
-        }
-    }
-
-    fn summary(&self) -> (String, String) {
-        (
-            format!(
-                "packets sent: {} (real: {}, cover: {}, retransmissions: {})",
-                self.real_packets_sent + self.cover_packets_sent,
-                self.real_packets_sent,
-                self.cover_packets_sent,
-                self.retransmissions_queued,
-            ),
-            format!(
-                "packets received: {}, (real: {}, cover: {}, acks: {}, acks for cover: {})",
-                self.real_packets_received + self.cover_packets_received,
-                self.real_packets_received,
-                self.cover_packets_received,
-                self.real_acks_received,
-                self.cover_acks_received,
-            ),
-        )
-    }
-}
-
-impl std::ops::Sub for PacketStatistics {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self {
-            real_packets_sent: self.real_packets_sent - rhs.real_packets_sent,
-            real_packets_sent_size: self.real_packets_sent_size - rhs.real_packets_sent_size,
-            cover_packets_sent: self.cover_packets_sent - rhs.cover_packets_sent,
-            cover_packets_sent_size: self.cover_packets_sent_size - rhs.cover_packets_sent_size,
-
-            real_packets_received: self.real_packets_received - rhs.real_packets_received,
-            real_packets_received_size: self.real_packets_received_size
-                - rhs.real_packets_received_size,
-            cover_packets_received: self.cover_packets_received - rhs.cover_packets_received,
-            cover_packets_received_size: self.cover_packets_received_size
-                - rhs.cover_packets_received_size,
-
-            total_acks_received: self.total_acks_received - rhs.total_acks_received,
-            total_acks_received_size: self.total_acks_received_size - rhs.total_acks_received_size,
-            real_acks_received: self.real_acks_received - rhs.real_acks_received,
-            real_acks_received_size: self.real_acks_received_size - rhs.real_acks_received_size,
-            cover_acks_received: self.cover_acks_received - rhs.cover_acks_received,
-            cover_acks_received_size: self.cover_acks_received_size - rhs.cover_acks_received_size,
-
-            real_packets_queued: self.real_packets_queued - rhs.real_packets_queued,
-            retransmissions_queued: self.retransmissions_queued - rhs.retransmissions_queued,
-            reply_surbs_queued: self.reply_surbs_queued - rhs.reply_surbs_queued,
-            additional_reply_surbs_queued: self.additional_reply_surbs_queued
-                - rhs.additional_reply_surbs_queued,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-struct PacketRates {
-    real_packets_sent: f64,
-    real_packets_sent_size: f64,
-    cover_packets_sent: f64,
-    cover_packets_sent_size: f64,
-
-    real_packets_received: f64,
-    real_packets_received_size: f64,
-    cover_packets_received: f64,
-    cover_packets_received_size: f64,
-
-    total_acks_received: f64,
-    total_acks_received_size: f64,
-    real_acks_received: f64,
-    real_acks_received_size: f64,
-    cover_acks_received: f64,
-    cover_acks_received_size: f64,
-
-    real_packets_queued: f64,
-    retransmissions_queued: f64,
-    reply_surbs_queued: f64,
-    additional_reply_surbs_queued: f64,
-}
-
-impl From<PacketStatistics> for PacketRates {
-    fn from(stats: PacketStatistics) -> Self {
-        Self {
-            real_packets_sent: stats.real_packets_sent as f64,
-            real_packets_sent_size: stats.real_packets_sent_size as f64,
-            cover_packets_sent: stats.cover_packets_sent as f64,
-            cover_packets_sent_size: stats.cover_packets_sent_size as f64,
-
-            real_packets_received: stats.real_packets_received as f64,
-            real_packets_received_size: stats.real_packets_received_size as f64,
-            cover_packets_received: stats.cover_packets_received as f64,
-            cover_packets_received_size: stats.cover_packets_received_size as f64,
-
-            total_acks_received: stats.total_acks_received as f64,
-            total_acks_received_size: stats.total_acks_received_size as f64,
-            real_acks_received: stats.real_acks_received as f64,
-            real_acks_received_size: stats.real_acks_received_size as f64,
-            cover_acks_received: stats.cover_acks_received as f64,
-            cover_acks_received_size: stats.cover_acks_received_size as f64,
-
-            real_packets_queued: stats.real_packets_queued as f64,
-            retransmissions_queued: stats.retransmissions_queued as f64,
-            reply_surbs_queued: stats.reply_surbs_queued as f64,
-            additional_reply_surbs_queued: stats.additional_reply_surbs_queued as f64,
-        }
-    }
-}
-
-impl std::ops::Sub for PacketRates {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self {
-            real_packets_sent: self.real_packets_sent - rhs.real_packets_sent,
-            real_packets_sent_size: self.real_packets_sent_size - rhs.real_packets_sent_size,
-            cover_packets_sent: self.cover_packets_sent - rhs.cover_packets_sent,
-            cover_packets_sent_size: self.cover_packets_sent_size - rhs.cover_packets_sent_size,
-
-            real_packets_received: self.real_packets_received - rhs.real_packets_received,
-            real_packets_received_size: self.real_packets_received_size
-                - rhs.real_packets_received_size,
-            cover_packets_received: self.cover_packets_received - rhs.cover_packets_received,
-            cover_packets_received_size: self.cover_packets_received_size
-                - rhs.cover_packets_received_size,
-
-            total_acks_received: self.total_acks_received - rhs.total_acks_received,
-            total_acks_received_size: self.total_acks_received_size - rhs.total_acks_received_size,
-            real_acks_received: self.real_acks_received - rhs.real_acks_received,
-            real_acks_received_size: self.real_acks_received_size - rhs.real_acks_received_size,
-            cover_acks_received: self.cover_acks_received - rhs.cover_acks_received,
-            cover_acks_received_size: self.cover_acks_received_size - rhs.cover_acks_received_size,
-
-            real_packets_queued: self.real_packets_queued - rhs.real_packets_queued,
-            retransmissions_queued: self.retransmissions_queued - rhs.retransmissions_queued,
-            reply_surbs_queued: self.reply_surbs_queued - rhs.reply_surbs_queued,
-            additional_reply_surbs_queued: self.additional_reply_surbs_queued
-                - rhs.additional_reply_surbs_queued,
-        }
-    }
-}
-
-impl std::ops::Div<f64> for PacketRates {
-    type Output = Self;
-
-    fn div(self, rhs: f64) -> Self::Output {
-        Self {
-            real_packets_sent: self.real_packets_sent / rhs,
-            real_packets_sent_size: self.real_packets_sent_size / rhs,
-            cover_packets_sent: self.cover_packets_sent / rhs,
-            cover_packets_sent_size: self.cover_packets_sent_size / rhs,
-
-            real_packets_received: self.real_packets_received / rhs,
-            real_packets_received_size: self.real_packets_received_size / rhs,
-            cover_packets_received: self.cover_packets_received / rhs,
-            cover_packets_received_size: self.cover_packets_received_size / rhs,
-
-            total_acks_received: self.total_acks_received / rhs,
-            total_acks_received_size: self.total_acks_received_size / rhs,
-            real_acks_received: self.real_acks_received / rhs,
-            real_acks_received_size: self.real_acks_received_size / rhs,
-            cover_acks_received: self.cover_acks_received / rhs,
-            cover_acks_received_size: self.cover_acks_received_size / rhs,
-
-            real_packets_queued: self.real_packets_queued / rhs,
-            retransmissions_queued: self.retransmissions_queued / rhs,
-            reply_surbs_queued: self.reply_surbs_queued / rhs,
-            additional_reply_surbs_queued: self.additional_reply_surbs_queued / rhs,
-        }
-    }
-}
-
-impl PacketRates {
-    fn summary(&self) -> String {
-        format!(
-            "rx: {}/s (real: {}/s), tx: {}/s (real: {}/s)",
-            bibytes2(self.real_packets_received_size + self.cover_packets_received_size),
-            bibytes2(self.real_packets_received_size),
-            bibytes2(self.real_packets_sent_size + self.cover_packets_sent_size),
-            bibytes2(self.real_packets_sent_size),
-        )
-    }
-
-    fn detailed_summary(&self) -> String {
-        format!(
-            "RX: {:.1} mixpkt/s, {}/s (real: {}/s, acks: {}/s), TX: {:.1} mixpkt/s, {}/s (real: {}/s)",
-            self.real_packets_received + self.cover_packets_received,
-            bibytes2(self.real_packets_received_size + self.cover_packets_received_size),
-            bibytes2(self.real_packets_received_size),
-            bibytes2(self.total_acks_received_size),
-            self.real_packets_sent + self.cover_packets_sent,
-            bibytes2(self.real_packets_sent_size + self.cover_packets_sent_size),
-            bibytes2(self.real_packets_sent_size),
-        )
-    }
-}
-
-pub(crate) enum PacketStatisticsEvent {
-    // The real packets sent. Recall that acks are sent by the gateway, so it's not included here.
-    RealPacketSent(usize),
-    // The cover packets sent
-    CoverPacketSent(usize),
-
-    // Real packets received
-    RealPacketReceived(usize),
-    // Cover packets received
-    CoverPacketReceived(usize),
-
-    // Ack of any type received. This is mostly used as a consistency check, and should be the sum
-    // of real and cover acks received.
-    AckReceived(usize),
-    // Out of the total acks received, this is the subset of those that were real
-    RealAckReceived(usize),
-    // Out of the total acks received, this is the subset of those that were for cover traffic
-    CoverAckReceived(usize),
-
-    // Types of packets queued
-    RealPacketQueued,
-    RetransmissionQueued,
-    ReplySurbRequestQueued,
-    AdditionalReplySurbRequestQueued,
-}
-
-type PacketStatisticsReceiver = tokio::sync::mpsc::UnboundedReceiver<PacketStatisticsEvent>;
-
-#[derive(Clone)]
-pub(crate) struct PacketStatisticsReporter {
-    stats_tx: tokio::sync::mpsc::UnboundedSender<PacketStatisticsEvent>,
-}
-
-impl PacketStatisticsReporter {
-    pub(crate) fn new(stats_tx: tokio::sync::mpsc::UnboundedSender<PacketStatisticsEvent>) -> Self {
-        Self { stats_tx }
-    }
-
-    pub(crate) fn report(&self, event: PacketStatisticsEvent) {
-        self.stats_tx.send(event).unwrap_or_else(|err| {
-            log::error!("Failed to report packet stat: {:?}", err);
-        });
-    }
-}
-
-pub(crate) struct PacketStatisticsControl {
-    // Incoming packet stats events from other tasks
-    stats_rx: PacketStatisticsReceiver,
-
-    // Keep track of packet statistics over time
-    stats: PacketStatistics,
-
-    // We keep snapshots of the statistics over time so we can compute rates, and also keeping the
-    // full history allows for some more fancy averaging if we want to do that.
-    history: VecDeque<(Instant, PacketStatistics)>,
-
-    // Keep previous rates so that we can detect notable events
-    rates: VecDeque<(Instant, PacketRates)>,
-}
-
-impl PacketStatisticsControl {
-    pub(crate) fn new() -> (Self, PacketStatisticsReporter) {
-        let (stats_tx, stats_rx) = tokio::sync::mpsc::unbounded_channel();
-
-        (
-            Self {
-                stats_rx,
-                stats: PacketStatistics::default(),
-                history: VecDeque::new(),
-                rates: VecDeque::new(),
-            },
-            PacketStatisticsReporter::new(stats_tx),
-        )
-    }
-
-    // Add the current stats to the history, and remove old ones.
-    fn update_history(&mut self) {
-        // Update latest
-        self.history.push_back((Instant::now(), self.stats.clone()));
-
-        // Filter out old ones
-        let recording_window = Instant::now() - Duration::from_millis(RECORDING_WINDOW_MS);
-        while self
-            .history
-            .front()
-            .map_or(false, |&(t, _)| t < recording_window)
-        {
-            self.history.pop_front();
-        }
-    }
-
-    fn compute_rates(&self) -> Option<PacketRates> {
-        // NOTE: consider changing this to compute rates over the history instead of using current
-        // stats. Currently it should not make much of a difference since we call this just after
-        // updating the history, but it seems like it could be more internally consistent to do it
-        // that way.
-
-        // Do basic averaging over the entire history, which just uses the first and last
-        if let Some((start, start_stats)) = self.history.front() {
-            let duration_secs = Instant::now().duration_since(*start).as_secs_f64();
-            let delta = self.stats.clone() - start_stats.clone();
-            let rates = PacketRates::from(delta) / duration_secs;
-            Some(rates)
-        } else {
-            None
-        }
-    }
-
-    fn update_rates(&mut self) {
-        // Update latest
-        if let Some(rates) = self.compute_rates() {
-            self.rates.push_back((Instant::now(), rates));
-        }
-
-        // Filter out old ones
-        let recording_window = Instant::now() - Duration::from_millis(RECORDING_WINDOW_MS);
-        while self
-            .rates
-            .front()
-            .map_or(false, |&(t, _)| t < recording_window)
-        {
-            self.rates.pop_front();
-        }
-    }
-
-    fn report_rates(&self) {
-        if let Some((_, rates)) = self.rates.back() {
-            log::info!("{}", rates.summary());
-            log::debug!("{}", rates.detailed_summary());
-        }
-    }
-
-    fn report_counters(&self) {
-        log::trace!("packet statistics: {:?}", &self.stats);
-        let (summary_sent, summary_recv) = self.stats.summary();
-        log::debug!("{}", summary_sent);
-        log::debug!("{}", summary_recv);
-    }
-
-    fn check_for_notable_events(&self) {
-        let Some((_, latest_rates)) = self.rates.back() else {
-            return;
-        };
-
-        // If we get a burst of retransmissions
-        // TODO: consider making this the number of retransmissions since last report instead.
-        if latest_rates.retransmissions_queued > 0.0 {
-            log::debug!(
-                "retransmissions: {:.2} pkt/s",
-                latest_rates.retransmissions_queued
-            );
-
-            // Check what the number of retransmissions was during the recording window
-            if let Some((_, start_stats)) = self.history.front() {
-                let delta = self.stats.clone() - start_stats.clone();
-                log::info!("retransmissions: {}", delta.retransmissions_queued,);
-            } else {
-                log::warn!("Unable to check retransmissions during recording window");
-            }
-        }
-
-        // IDEA: if there is a burst of acks, that could indicate tokio task starvation.
-    }
-
-    pub(crate) async fn run_with_shutdown(&mut self, mut shutdown: nym_task::TaskClient) {
-        log::debug!("Started PacketStatisticsControl with graceful shutdown support");
-
-        let report_interval = Duration::from_secs(PACKET_REPORT_INTERVAL_SECS);
-        let mut report_interval = tokio::time::interval(report_interval);
-        let snapshot_interval = Duration::from_millis(SNAPSHOT_INTERVAL_MS);
-        let mut snapshot_interval = tokio::time::interval(snapshot_interval);
-
-        loop {
-            tokio::select! {
-                stats_event = self.stats_rx.recv() => match stats_event {
-                    Some(stats_event) => {
-                        log::trace!("PacketStatisticsControl: Received stats event");
-                        self.stats.handle_event(stats_event);
-                    },
-                    None => {
-                        log::trace!("PacketStatisticsControl: stopping since stats channel was closed");
-                        break;
-                    }
-                },
-                _ = snapshot_interval.tick() => {
-                    self.update_history();
-                    self.update_rates();
-                }
-                _ = report_interval.tick() => {
-                    self.report_rates();
-                    self.check_for_notable_events();
-                    self.report_counters();
-                }
-                _ = shutdown.recv_with_delay() => {
-                    log::trace!("PacketStatisticsControl: Received shutdown");
-                    break;
-                },
-            }
-        }
-        log::debug!("PacketStatisticsControl: Exiting");
-    }
-
-    pub(crate) fn start_with_shutdown(mut self, task_client: nym_task::TaskClient) {
-        spawn_future(async move {
-            self.run_with_shutdown(task_client).await;
-        })
-    }
-}
@@ -1,8 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
-
 use super::action_controller::{AckActionSender, Action};
 use futures::StreamExt;
 use log::*;
@@ -19,7 +17,6 @@ pub(super) struct AcknowledgementListener {
    ack_key: Arc<AckKey>,
    ack_receiver: AcknowledgementReceiver,
    action_sender: AckActionSender,
-    stats_tx: PacketStatisticsReporter,
 }

 impl AcknowledgementListener {
@@ -27,21 +24,16 @@ impl AcknowledgementListener {
        ack_key: Arc<AckKey>,
        ack_receiver: AcknowledgementReceiver,
        action_sender: AckActionSender,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        AcknowledgementListener {
            ack_key,
            ack_receiver,
            action_sender,
-            stats_tx,
        }
    }

    async fn on_ack(&mut self, ack_content: Vec<u8>) {
        trace!("Received an ack");
-        self.stats_tx
-            .report(PacketStatisticsEvent::AckReceived(ack_content.len()));
-
        let frag_id = match recover_identifier(&self.ack_key, &ack_content)
            .map(FragmentIdentifier::try_from_bytes)
        {
@@ -56,14 +48,11 @@ impl AcknowledgementListener {
        // because nothing was inserted in the first place
        if frag_id == COVER_FRAG_ID {
            trace!("Received an ack for a cover message - no need to do anything");
-            self.stats_tx
-                .report(PacketStatisticsEvent::CoverAckReceived(ack_content.len()));
            return;
        }

        trace!("Received {} from the mix network", frag_id);
-        self.stats_tx
-            .report(PacketStatisticsEvent::RealAckReceived(ack_content.len()));
+
        self.action_sender
            .unbounded_send(Action::new_remove(frag_id))
            .unwrap();
@@ -8,7 +8,6 @@ use self::{
    sent_notification_listener::SentNotificationListener,
 };
 use crate::client::inbound_messages::InputMessageReceiver;
-use crate::client::packet_statistics_control::PacketStatisticsReporter;
 use crate::client::real_messages_control::message_handler::MessageHandler;
 use crate::client::replies::reply_controller::ReplyControllerSender;
 use crate::spawn_future;
@@ -209,7 +208,6 @@ where
        connectors: AcknowledgementControllerConnectors,
        message_handler: MessageHandler<R>,
        reply_controller_sender: ReplyControllerSender,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let (retransmission_tx, retransmission_rx) = mpsc::unbounded();

@@ -226,7 +224,6 @@ where
            Arc::clone(&ack_key),
            connectors.ack_receiver,
            connectors.ack_action_sender.clone(),
-            stats_tx,
        );

        // will listen for any new messages from the client
@@ -35,8 +35,6 @@ use crate::client::replies::reply_controller;
 use crate::config;
 pub(crate) use acknowledgement_control::{AckActionSender, Action};

-use super::packet_statistics_control::PacketStatisticsReporter;
-
 pub(crate) mod acknowledgement_control;
 pub(crate) mod message_handler;
 pub(crate) mod real_traffic_stream;
@@ -145,7 +143,6 @@ impl RealMessagesController<OsRng> {
        reply_controller_receiver: ReplyControllerReceiver,
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        let rng = OsRng;

@@ -184,7 +181,6 @@ impl RealMessagesController<OsRng> {
            ack_controller_connectors,
            message_handler.clone(),
            reply_controller_sender,
-            stats_tx.clone(),
        );

        let reply_control = ReplyController::new(
@@ -203,7 +199,6 @@ impl RealMessagesController<OsRng> {
            topology_access,
            lane_queue_lengths,
            client_connection_rx,
-            stats_tx,
        );

        RealMessagesController {
@@ -3,7 +3,6 @@

 use self::sending_delay_controller::SendingDelayController;
 use crate::client::mix_traffic::BatchMixMessageSender;
-use crate::client::packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter};
 use crate::client::real_messages_control::acknowledgement_control::SentPacketNotificationSender;
 use crate::client::topology_control::TopologyAccessor;
 use crate::client::transmission_buffer::TransmissionBuffer;
@@ -114,9 +113,6 @@ where

    /// Report queue lengths so that upstream can backoff sending data, and keep connections open.
    lane_queue_lengths: LaneQueueLengths,
-
-    /// Channel used for sending statistics events to `PacketStatisticsControl`.
-    stats_tx: PacketStatisticsReporter,
 }

 #[derive(Debug)]
@@ -175,7 +171,6 @@ where
        topology_access: TopologyAccessor,
        lane_queue_lengths: LaneQueueLengths,
        client_connection_rx: ConnectionCommandReceiver,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        OutQueueControl {
            config,
@@ -189,7 +184,6 @@ where
            transmission_buffer: TransmissionBuffer::new(),
            client_connection_rx,
            lane_queue_lengths,
-            stats_tx,
        }
    }

@@ -220,7 +214,7 @@ where
    async fn on_message(&mut self, next_message: StreamMessage) {
        trace!("created new message");

-        let (next_message, fragment_id, packet_size) = match next_message {
+        let (next_message, fragment_id) = match next_message {
            StreamMessage::Cover => {
                let cover_traffic_packet_size = self.loop_cover_message_size();
                trace!("the next loop cover message will be put in a {cover_traffic_packet_size} packet");
@@ -256,28 +250,15 @@ where
                        "Somehow failed to generate a loop cover message with a valid topology",
                    ),
                    None,
-                    cover_traffic_packet_size.size(),
                )
            }
            StreamMessage::Real(real_message) => {
-                let packet_size = real_message.packet_size();
-                (
-                    real_message.mix_packet,
-                    real_message.fragment_id,
-                    packet_size,
-                )
+                (real_message.mix_packet, real_message.fragment_id)
            }
        };

        if let Err(err) = self.mix_tx.send(vec![next_message]).await {
            log::error!("Failed to send: {err}");
-        } else {
-            let event = if fragment_id.is_some() {
-                PacketStatisticsEvent::RealPacketSent(packet_size)
-            } else {
-                PacketStatisticsEvent::CoverPacketSent(packet_size)
-            };
-            self.stats_tx.report(event);
        }

        // notify ack controller about sending our message only after we actually managed to push it
@@ -359,28 +340,6 @@ where
        let lane_length = self.transmission_buffer.lane_length(&lane);
        self.lane_queue_lengths.set(&lane, lane_length);

-        // This is the last step in the pipeline where we know the type of the message, so
-        // lets count the number of retransmissions and reply surb messages sent here.
-        let stat_event = match lane {
-            TransmissionLane::General => None,
-            TransmissionLane::ConnectionId(_) => None,
-            TransmissionLane::ReplySurbRequest => {
-                Some(PacketStatisticsEvent::ReplySurbRequestQueued)
-            }
-            TransmissionLane::AdditionalReplySurbs => {
-                Some(PacketStatisticsEvent::AdditionalReplySurbRequestQueued)
-            }
-            TransmissionLane::Retransmission => Some(PacketStatisticsEvent::RetransmissionQueued),
-        };
-        if let Some(stat_event) = stat_event {
-            self.stats_tx.report(stat_event);
-        }
-        // To avoid comparing apples to oranges when presenting the fraction of packets that are
-        // retransmissions, we also need to keep track to the total number of real messages queued,
-        // even though we also track the actual number of messages sent later in the pipeline.
-        self.stats_tx
-            .report(PacketStatisticsEvent::RealPacketQueued);
-
        Some(real_next)
    }

@@ -474,13 +433,6 @@ where
            Poll::Ready(Some((real_messages, conn_id))) => {
                log::trace!("handling real_messages: size: {}", real_messages.len());

-                // This is the last step in the pipeline where we know the type of the message, so
-                // lets count the number of retransmissions here.
-                if conn_id == TransmissionLane::Retransmission {
-                    self.stats_tx
-                        .report(PacketStatisticsEvent::RetransmissionQueued);
-                }
-
                // First store what we got for the given connection id
                self.transmission_buffer.store(&conn_id, real_messages);
                let real_next = self.pop_next_message().expect("we just added one");
@@ -519,10 +471,10 @@ where
        let mult = self.sending_delay_controller.current_multiplier();
        let delay = self.current_average_message_sending_delay().as_millis();
        let status_str = if self.config.traffic.disable_main_poisson_packet_distribution {
-            format!("Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, no delay")
+            format!("Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), no delay")
        } else {
            format!(
-                "Packet backlog: {backlog:.2} kiB ({packets}), {lanes} lanes, avg delay: {delay}ms ({mult})"
+                "Status: {lanes} lanes, backlog: {backlog:.2} kiB ({packets}), avg delay: {delay}ms ({mult})"
            )
        };
        if packets > 1000 {
@@ -1,10 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::client::{
-    packet_statistics_control::{PacketStatisticsEvent, PacketStatisticsReporter},
-    replies::{reply_controller::ReplyControllerSender, reply_storage::SentReplyKeys},
-};
+use crate::client::replies::reply_controller::ReplyControllerSender;
+use crate::client::replies::reply_storage::SentReplyKeys;
 use crate::spawn_future;
 use futures::channel::mpsc;
 use futures::lock::Mutex;
@@ -45,33 +43,15 @@ struct ReceivedMessagesBufferInner<R: MessageReceiver> {
    // but perhaps it should be changed to include timestamps of when the message was reconstructed
    // and every now and then remove ids older than X
    recently_reconstructed: HashSet<i32>,
-
-    stats_tx: PacketStatisticsReporter,
 }

 impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
-    fn recover_from_fragment(
-        &mut self,
-        fragment_data: &[u8],
-        fragment_data_size: usize,
-    ) -> Option<NymMessage> {
+    fn recover_from_fragment(&mut self, fragment_data: &[u8]) -> Option<NymMessage> {
        if nym_sphinx::cover::is_cover(fragment_data) {
            trace!("The message was a loop cover message! Skipping it");
-            // NOTE: it's important to note that there is quite a bit of difference in size of
-            // received and sent packets due to the sphinx layers being removed by the exit gateway
-            // before it reaches the mixnet client.
-            self.stats_tx
-                .report(PacketStatisticsEvent::CoverPacketReceived(
-                    fragment_data_size,
-                ));
            return None;
        }

-        self.stats_tx
-            .report(PacketStatisticsEvent::RealPacketReceived(
-                fragment_data_size,
-            ));
-
        let fragment = match self.message_receiver.recover_fragment(fragment_data) {
            Err(err) => {
                warn!("failed to recover fragment from raw data: {err}. The whole underlying message might be corrupted and unrecoverable!");
@@ -123,17 +103,15 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
        reply_ciphertext: &mut [u8],
        reply_key: SurbEncryptionKey,
    ) -> Result<Option<NymMessage>, MessageRecoveryError> {
-        let reply_ciphertext_size = reply_ciphertext.len();
        // note: this performs decryption IN PLACE without extra allocation
        self.message_receiver
            .recover_plaintext_from_reply(reply_ciphertext, reply_key)?;
        let fragment_data = reply_ciphertext;

-        Ok(self.recover_from_fragment(fragment_data, reply_ciphertext_size))
+        Ok(self.recover_from_fragment(fragment_data))
    }

    fn process_received_regular_packet(&mut self, mut raw_fragment: Vec<u8>) -> Option<NymMessage> {
-        let raw_fragment_size = raw_fragment.len();
        let fragment_data = match self.message_receiver.recover_plaintext_from_regular_packet(
            self.local_encryption_keypair.private_key(),
            &mut raw_fragment,
@@ -145,7 +123,7 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
            Ok(frag_data) => frag_data,
        };

-        self.recover_from_fragment(fragment_data, raw_fragment_size)
+        self.recover_from_fragment(fragment_data)
    }
 }

@@ -163,7 +141,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
        local_encryption_keypair: Arc<encryption::KeyPair>,
        reply_key_storage: SentReplyKeys,
        reply_controller_sender: ReplyControllerSender,
-        stats_tx: PacketStatisticsReporter,
    ) -> Self {
        ReceivedMessagesBuffer {
            inner: Arc::new(Mutex::new(ReceivedMessagesBufferInner {
@@ -172,7 +149,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                message_receiver: R::new(),
                message_sender: None,
                recently_reconstructed: HashSet::new(),
-                stats_tx,
            })),
            reply_key_storage,
            reply_controller_sender,
@@ -377,7 +353,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                };

            if let Some(completed) = completed_message {
-                debug!("received {completed}");
+                info!("received {completed}");
                completed_messages.push(completed)
            }
        }
@@ -504,13 +480,11 @@ impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferControll
        mixnet_packet_receiver: MixnetMessageReceiver,
        reply_key_storage: SentReplyKeys,
        reply_controller_sender: ReplyControllerSender,
-        packet_statistics_reporter: PacketStatisticsReporter,
    ) -> Self {
        let received_buffer = ReceivedMessagesBuffer::new(
            local_encryption_keypair,
            reply_key_storage,
            reply_controller_sender,
-            packet_statistics_reporter,
        );

        ReceivedMessagesBufferController {
@@ -65,7 +65,7 @@ pub async fn current_gateways<R: Rng>(
        .ok_or(ClientCoreError::ListOfNymApisIsEmpty)?;
    let client = nym_validator_client::client::NymApiClient::new(nym_api.clone());

-    log::debug!("Fetching list of gateways from: {nym_api}");
+    log::trace!("Fetching list of gateways from: {nym_api}");

    let gateways = client.get_cached_described_gateways().await?;
    log::debug!("Found {} gateways", gateways.len());
@@ -178,7 +178,7 @@ impl<T> From<PersistedGatewayDetails<T>> for GatewayDetails<T> {
    }
 }

-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum GatewaySelectionSpecification<T = EmptyCustomDetails> {
    /// Uniformly choose a random remote gateway.
    UniformRemote { must_use_tls: bool },
@@ -3,7 +3,6 @@ name = "nym-gateway-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

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

@@ -3,7 +3,6 @@ name = "nym-mixnet-client"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

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

@@ -4,7 +4,6 @@ version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
 rust-version = "1.56"
-license.workspace = true

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

@@ -42,14 +42,6 @@ pub struct Config {
    nyxd_config: nyxd::Config,
 }

-impl TryFrom<NymNetworkDetails> for Config {
-    type Error = ValidatorClientError;
-
-    fn try_from(value: NymNetworkDetails) -> Result<Self, Self::Error> {
-        Config::try_from_nym_network_details(&value)
-    }
-}
-
 impl Config {
    pub fn try_from_nym_network_details(
        details: &NymNetworkDetails,
@@ -5,24 +5,21 @@ use crate::nym_api::error::NymAPIError;
 use crate::nym_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use async_trait::async_trait;
 use http_api_client::{ApiClient, NO_PARAMS};
-pub use nym_api_requests::{
-    coconut::{
-        models::{
-            EpochCredentialsResponse, IssuedCredential, IssuedCredentialBody,
-            IssuedCredentialResponse, IssuedCredentialsResponse,
-        },
-        BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody,
-        VerifyCredentialBody, VerifyCredentialResponse,
-    },
-    models::{
-        ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
-        GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
-        MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
-        MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
-        StakeSaturationResponse, UptimeResponse,
-    },
+use nym_api_requests::coconut::models::{
+    EpochCredentialsResponse, IssuedCredentialResponse, IssuedCredentialsResponse,
 };
-pub use nym_coconut_dkg_common::types::EpochId;
+use nym_api_requests::coconut::{
+    BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody, VerifyCredentialBody,
+    VerifyCredentialResponse,
+};
+use nym_api_requests::models::{
+    ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
+    GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
+    MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
+    MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
+    StakeSaturationResponse, UptimeResponse,
+};
+use nym_coconut_dkg_common::types::EpochId;
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use nym_name_service_common::response::NamesListResponse;
@@ -8,8 +8,6 @@ use cosmwasm_std::{Fraction, Uint128};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::Div;
-use std::str::FromStr;
-use thiserror::Error;

 #[derive(Serialize, Deserialize, Clone, Copy, Default, Debug, PartialEq, Eq)]
 pub struct MismatchedDenoms;
@@ -128,37 +126,6 @@ impl From<CosmWasmCoin> for Coin {
    }
 }

-// unfortunately cosmwasm didn't re-export this correct so we just redefine its
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum CoinFromStrError {
-    #[error("Missing denominator")]
-    MissingDenom,
-    #[error("Missing amount or non-digit characters in amount")]
-    MissingAmount,
-    #[error("Invalid amount: {0}")]
-    InvalidAmount(#[from] std::num::ParseIntError),
-}
-
-impl FromStr for Coin {
-    type Err = CoinFromStrError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let pos = s
-            .find(|c: char| !c.is_ascii_digit())
-            .ok_or(CoinFromStrError::MissingDenom)?;
-        let (amount, denom) = s.split_at(pos);
-
-        if amount.is_empty() {
-            return Err(CoinFromStrError::MissingAmount);
-        }
-
-        Ok(Coin {
-            amount: amount.parse::<u128>()?,
-            denom: denom.to_string(),
-        })
-    }
-}
-
 pub trait CoinConverter {
    type Target;

@@ -7,12 +7,12 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use nym_coconut_dkg_common::{
-    dealer::{ContractDealing, DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse},
-    msg::QueryMsg as DkgQueryMsg,
-    types::{DealerDetails, Epoch, EpochId, InitialReplacementData},
-    verification_key::{ContractVKShare, PagedVKSharesResponse},
+use nym_coconut_dkg_common::dealer::{
+    ContractDealing, DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
 };
+use nym_coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
+use nym_coconut_dkg_common::types::{DealerDetails, Epoch, EpochId, InitialReplacementData};
+use nym_coconut_dkg_common::verification_key::{ContractVKShare, PagedVKSharesResponse};
 use serde::Deserialize;

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -52,6 +52,10 @@ use wasmtimer::tokio::sleep;
 pub const DEFAULT_BROADCAST_POLLING_RATE: Duration = Duration::from_secs(4);
 pub const DEFAULT_BROADCAST_TIMEOUT: Duration = Duration::from_secs(60);

+#[cfg(feature = "http-client")]
+#[async_trait]
+impl CosmWasmClient for cosmrs::rpc::HttpClient {}
+
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait CosmWasmClient: TendermintRpcClient {
@@ -518,7 +522,3 @@ pub trait CosmWasmClient: TendermintRpcClient {
        res.try_into()
    }
 }
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<T> CosmWasmClient for T where T: TendermintRpcClient {}
@@ -425,7 +425,7 @@ where
                    amount: amount.into_iter().map(Into::into).collect(),
                }
                .to_any()
-                .map_err(|_| NyxdError::SerializationError("MsgSend".to_owned()))
+                .map_err(|_| NyxdError::SerializationError("MsgExecuteContract".to_owned()))
            })
            .collect::<Result<_, _>>()?;

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

-use crate::nyxd::cosmwasm_client::client_traits::SigningCosmWasmClient;
+use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
 use crate::nyxd::error::NyxdError;
 use crate::nyxd::{Config, GasPrice, Hash, Height};
 use crate::rpc::TendermintRpcClient;
@@ -26,7 +26,6 @@ use cosmrs::rpc::{HttpClient, HttpClientUrl};
 pub mod client_traits;
 mod helpers;
 pub mod logs;
-pub mod module_traits;
 pub mod types;

 #[derive(Debug)]
@@ -330,6 +329,14 @@ where
    }
 }

+#[async_trait]
+impl<C, S> CosmWasmClient for MaybeSigningClient<C, S>
+where
+    C: TendermintRpcClient + Send + Sync,
+    S: Send + Sync,
+{
+}
+
 #[async_trait]
 impl<C, S> SigningCosmWasmClient for MaybeSigningClient<C, S>
 where
@@ -1,8 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod slashing;
-pub mod staking;
-
-pub use staking::query::StakingQueryClient;
-// pub use slashing::query
@@ -1,4 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod query;
@@ -1,2 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
@@ -1,8 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod query;
-
-pub use cosmrs::staking::{
-    QueryHistoricalInfoResponse, QueryValidatorResponse, QueryValidatorsResponse, Validator,
-};
@@ -1,78 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::{QueryHistoricalInfoResponse, QueryValidatorResponse, QueryValidatorsResponse};
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{CosmWasmClient, PageRequest};
-use async_trait::async_trait;
-use cosmrs::proto::cosmos::staking::v1beta1::{
-    QueryHistoricalInfoRequest as ProtoQueryHistoricalInfoRequest,
-    QueryHistoricalInfoResponse as ProtoQueryHistoricalInfoResponse,
-    QueryValidatorRequest as ProtoQueryValidatorRequest,
-    QueryValidatorResponse as ProtoQueryValidatorResponse,
-    QueryValidatorsRequest as ProtoQueryValidatorsRequest,
-    QueryValidatorsResponse as ProtoQueryValidatorsResponse,
-};
-use cosmrs::staking::{QueryHistoricalInfoRequest, QueryValidatorRequest, QueryValidatorsRequest};
-use cosmrs::AccountId;
-
-// TODO: change trait restriction from `CosmWasmClient` to `TendermintRpcClient`
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait StakingQueryClient: CosmWasmClient {
-    async fn historical_info(&self, height: i64) -> Result<QueryHistoricalInfoResponse, NyxdError> {
-        let path = Some("/cosmos.staking.v1beta1.Query/HistoricalInfo".to_owned());
-
-        let req = QueryHistoricalInfoRequest { height };
-
-        let res = self
-            .make_abci_query::<ProtoQueryHistoricalInfoRequest, ProtoQueryHistoricalInfoResponse>(
-                path,
-                req.into(),
-            )
-            .await?;
-
-        Ok(res.try_into()?)
-    }
-
-    async fn validator(
-        &self,
-        validator_addr: AccountId,
-    ) -> Result<QueryValidatorResponse, NyxdError> {
-        let path = Some("/cosmos.staking.v1beta1.Query/Validator".to_owned());
-
-        let req = QueryValidatorRequest { validator_addr };
-
-        let res = self
-            .make_abci_query::<ProtoQueryValidatorRequest, ProtoQueryValidatorResponse>(
-                path,
-                req.into(),
-            )
-            .await?;
-
-        Ok(res.try_into()?)
-    }
-
-    async fn validators(
-        &self,
-        status: String,
-        pagination: Option<PageRequest>,
-    ) -> Result<QueryValidatorsResponse, NyxdError> {
-        let path = Some("/cosmos.staking.v1beta1.Query/Validators".to_owned());
-
-        let req = QueryValidatorsRequest { status, pagination };
-
-        let res = self
-            .make_abci_query::<ProtoQueryValidatorsRequest, ProtoQueryValidatorsResponse>(
-                path,
-                req.into(),
-            )
-            .await?;
-
-        Ok(res.try_into()?)
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<T> StakingQueryClient for T where T: CosmWasmClient {}
@@ -11,7 +11,7 @@ pub mod gas_price;

 pub type GasAdjustment = f32;

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

 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AutoFeeGrant {
@@ -29,30 +29,23 @@ use tendermint_rpc::endpoint::*;
 use tendermint_rpc::{Error as TendermintRpcError, Order};
 use url::Url;

-pub use crate::nyxd::{
-    cosmwasm_client::{
-        client_traits::{CosmWasmClient, SigningCosmWasmClient},
-        module_traits::{self, StakingQueryClient},
-    },
-    fee::Fee,
-};
+pub use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
+pub use crate::nyxd::fee::Fee;
 pub use crate::rpc::TendermintRpcClient;
 pub use coin::Coin;
-pub use cosmrs::{
-    bank::MsgSend,
-    bip32,
-    crypto::PublicKey,
-    query::{PageRequest, PageResponse},
-    tendermint::{
-        abci::{response::DeliverTx, types::ExecTxResult, Event, EventAttribute},
-        block::Height,
-        hash::{self, Algorithm, Hash},
-        validator::Info as TendermintValidatorInfo,
-        Time as TendermintTime,
-    },
-    tx::{self, Msg},
-    AccountId, Any, Coin as CosmosCoin, Denom, Gas,
+pub use cosmrs::bank::MsgSend;
+pub use cosmrs::tendermint::abci::{
+    response::DeliverTx, types::ExecTxResult, Event, EventAttribute,
 };
+pub use cosmrs::tendermint::block::Height;
+pub use cosmrs::tendermint::hash::{self, Algorithm, Hash};
+pub use cosmrs::tendermint::validator::Info as TendermintValidatorInfo;
+pub use cosmrs::tendermint::Time as TendermintTime;
+pub use cosmrs::tx::Msg;
+pub use cosmrs::tx::{self};
+pub use cosmrs::Coin as CosmosCoin;
+pub use cosmrs::Gas;
+pub use cosmrs::{bip32, AccountId, Denom};
 pub use cosmwasm_std::Coin as CosmWasmCoin;
 pub use cw2;
 pub use cw3;
@@ -62,8 +55,9 @@ pub use fee::{gas_price::GasPrice, GasAdjustable, GasAdjustment};
 pub use tendermint_rpc::{
    endpoint::{tx::Response as TxResponse, validators::Response as ValidatorResponse},
    query::Query,
-    Paging, Request, Response, SimpleRequest,
+    Paging,
 };
+pub use tendermint_rpc::{Request, Response, SimpleRequest};

 #[cfg(feature = "http-client")]
 use crate::http_client;
@@ -103,14 +97,6 @@ impl Config {
    }
 }

-impl TryFrom<NymNetworkDetails> for Config {
-    type Error = NyxdError;
-
-    fn try_from(value: NymNetworkDetails) -> Result<Self, Self::Error> {
-        Config::try_from_nym_network_details(&value)
-    }
-}
-
 #[derive(Debug)]
 pub struct NyxdClient<C, S = NoSigner> {
    client: MaybeSigningClient<C, S>,
@@ -742,7 +728,7 @@ where
    where
        H: Into<Height> + Send,
    {
-        TendermintRpcClient::validators(&self.client, height, paging).await
+        self.client.validators(height, paging).await
    }

    async fn latest_consensus_params(
@@ -817,6 +803,14 @@ where
    }
 }

+#[async_trait]
+impl<C, S> CosmWasmClient for NyxdClient<C, S>
+where
+    C: TendermintRpcClient + Send + Sync,
+    S: Send + Sync,
+{
+}
+
 impl<C, S> OfflineSigner for NyxdClient<C, S>
 where
    S: OfflineSigner,
@@ -3,7 +3,6 @@ name = "nym-coconut-interface"
 version = "0.1.0"
 edition = "2021"
 description = "Crutch library until there is proper SerDe support for coconut structs"
-license.workspace = true

 [dependencies]
 bs58 = "0.4.0"
@@ -3,7 +3,6 @@ name = "nym-cli-commands"
 version = "1.0.0"
 authors.workspace = true
 edition = "2021"
-license.workspace = true

 [dependencies]
 anyhow = { workspace = true }
@@ -3,7 +3,6 @@ name = "nym-config"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

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

@@ -18,4 +17,4 @@ url = { workspace = true }
 nym-network-defaults = { path = "../network-defaults" }

 [features]
-default = ["dirs"]
+default = ["dirs"]
@@ -73,7 +73,7 @@ where
    P: AsRef<Path>,
 {
    let path = path.as_ref();
-    log::info!("saving config file to {}", path.display());
+    log::debug!("trying to save config file to {}", path.display());

    if let Some(parent) = path.parent() {
        create_dir_all(parent)?;
@@ -2,7 +2,6 @@
 name = "nym-coconut-bandwidth-contract-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -13,4 +12,4 @@ cw2 = { workspace = true, optional = true }
 nym-multisig-contract-common = { path = "../multisig-contract" }

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -2,7 +2,6 @@
 name = "nym-coconut-dkg-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -15,4 +14,4 @@ contracts-common = { path = "../contracts-common", package = "nym-contracts-comm
 nym-multisig-contract-common = { path = "../multisig-contract" }

 [features]
-schema = []
+schema = []
@@ -226,8 +226,4 @@ impl EpochState {
    pub fn is_final(&self) -> bool {
        *self == EpochState::InProgress
    }
-
-    pub fn is_in_progress(&self) -> bool {
-        matches!(self, EpochState::InProgress)
-    }
 }
@@ -2,7 +2,6 @@
 name = "nym-ephemera-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -14,4 +13,4 @@ cw-utils = { workspace = true }
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }

 [features]
-schema = []
+schema = []
@@ -2,7 +2,6 @@
 name = "nym-group-contract-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -2,7 +2,6 @@
 name = "nym-multisig-contract-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -2,7 +2,6 @@
 name = "nym-name-service-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -17,4 +16,4 @@ serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -2,7 +2,6 @@
 name = "nym-service-provider-directory-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -16,4 +15,4 @@ nym-contracts-common = { path = "../contracts-common", version = "0.5.0" }
 thiserror = { workspace = true }

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -2,7 +2,6 @@
 name = "nym-credential-storage"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -14,14 +13,14 @@ thiserror = { workspace = true }
 tokio = { version = "1.24.1", features = ["sync"]}

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
-workspace = true
+version = "0.5"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-workspace = true
+version = "1.24.1"
 features = [ "rt-multi-thread", "net", "signal", "fs" ]


 [build-dependencies]
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
+sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }
@@ -2,7 +2,6 @@
 name = "nym-credential-utils"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -2,7 +2,6 @@
 name = "nym-credentials"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -3,7 +3,6 @@ name = "nym-dkg"
 version = "0.1.0"
 edition = "2021"
 resolver = "2"
-license.workspace = true

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

@@ -2,7 +2,6 @@
 name = "nym-execute"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

 [lib]
 proc-macro = true
@@ -81,15 +81,6 @@ ExitPolicy accept6 *6:119
 ExitPolicy accept *4:120
 ExitPolicy reject6 [FC00::]/7:*

-# Portless
-ExitPolicy accept *:0
-ExitPolicy accept *4:0
-ExitPolicy accept *6:0
-
-ExitPolicy reject *:0
-ExitPolicy reject *4:0
-ExitPolicy reject *6:0
-
 #ExitPolicy accept *:8080 #and another comment here

 ExitPolicy reject FE80:0000:0000:0000:0202:B3FF:FE1E:8329:*
@@ -193,60 +184,6 @@ ExitPolicy reject *:*
            },
        );

-        // ExitPolicy accept *:0
-        expected.push(
-            Accept,
-            AddressPortPattern {
-                ip_pattern: IpPattern::Star,
-                ports: PortRange::new_zero(),
-            },
-        );
-
-        // ExitPolicy accept *4:0
-        expected.push(
-            Accept,
-            AddressPortPattern {
-                ip_pattern: IpPattern::V4Star,
-                ports: PortRange::new_zero(),
-            },
-        );
-
-        // ExitPolicy accept *6:0
-        expected.push(
-            Accept,
-            AddressPortPattern {
-                ip_pattern: IpPattern::V6Star,
-                ports: PortRange::new_zero(),
-            },
-        );
-
-        // ExitPolicy reject *:0
-        expected.push(
-            Reject,
-            AddressPortPattern {
-                ip_pattern: IpPattern::Star,
-                ports: PortRange::new_zero(),
-            },
-        );
-
-        // ExitPolicy reject *4:0
-        expected.push(
-            Reject,
-            AddressPortPattern {
-                ip_pattern: IpPattern::V4Star,
-                ports: PortRange::new_zero(),
-            },
-        );
-
-        // ExitPolicy reject *6:0
-        expected.push(
-            Reject,
-            AddressPortPattern {
-                ip_pattern: IpPattern::V6Star,
-                ports: PortRange::new_zero(),
-            },
-        );
-
        // ExitPolicy FE80:0000:0000:0000:0202:B3FF:FE1E:8329:*
        expected.push(
            Reject,
@@ -264,13 +264,7 @@ mod stringified_ip_pattern {
 impl AddressPortPattern {
    /// Return true iff this pattern matches a given address and port.
    pub fn matches(&self, addr: &IpAddr, port: u16) -> bool {
-        // For backward compatibility, we treat port 0 as a wildcard until all gateways have
-        // upgraded, at which point we can add *:0 to the policy list.
-        if port == 0 {
-            self.ip_pattern.matches(addr)
-        } else {
-            self.ip_pattern.matches(addr) && self.ports.contains(port)
-        }
+        self.ip_pattern.matches(addr) && self.ports.contains(port)
    }

    /// As matches, but accept a SocketAddr.
@@ -401,9 +395,19 @@ fn parse_addr(s: &str) -> Result<IpAddr, PolicyError> {
    })
 }

+/// Helper: try to parse a port making sure it's non-zero
 fn parse_port(s: &str) -> Result<u16, PolicyError> {
-    s.parse::<u16>()
-        .map_err(|_| PolicyError::InvalidPort { raw: s.to_string() })
+    let port = s
+        .parse::<u16>()
+        .map_err(|_| PolicyError::InvalidPort { raw: s.to_string() })?;
+
+    if port == 0 {
+        Err(PolicyError::InvalidPort {
+            raw: port.to_string(),
+        })
+    } else {
+        Ok(port)
+    }
 }

 impl FromStr for IpPattern {
@@ -490,10 +494,6 @@ impl PortRange {
        PortRange::new_unchecked(1, 65535)
    }

-    pub fn new_zero() -> Self {
-        PortRange { start: 0, end: 0 }
-    }
-
    /// Create a new PortRange.
    ///
    /// The Portrange contains all ports between `start` and `end` inclusive.
@@ -574,7 +574,6 @@ mod test {

        check("marzipan:80");
        check("1.2.3.4:90-80");
-        check("1.2.3.4:0-80");
        check("1.2.3.4/100:8888");
        check("[1.2.3.4]/16:80");
        check("[::1]/130:8888");
@@ -613,22 +612,6 @@ mod test {

        check("0.0.0.0/0:*", &["127.0.0.1:80"], &["[f00b::]:80"]);
        check("[::]/0:*", &["[f00b::]:80"], &["127.0.0.1:80"]);
-
-        check(
-            "*:0",
-            &["1.2.3.4:0", "[::1]:0", "9.0.0.0:0"],
-            &["1.2.3.4:443", "[::1]:500", "9.0.0.0:80", "[::1]:80"],
-        );
-        check(
-            "*4:0",
-            &["1.2.3.4:0", "9.0.0.0:0"],
-            &["1.2.3.4:443", "9.0.0.0:80", "[::1]:0", "[::1]:80"],
-        );
-        check(
-            "*6:0",
-            &["[::1]:0"],
-            &["[::1]:80", "1.2.3.4:0", "1.2.3.4:443"],
-        );
    }

    #[test]
@@ -637,7 +620,6 @@ mod test {
        policy.push(AddressPolicyAction::Accept, "*:443".parse()?);
        policy.push(AddressPolicyAction::Accept, "[::1]:80".parse()?);
        policy.push(AddressPolicyAction::Reject, "*:80".parse()?);
-        policy.push(AddressPolicyAction::Accept, "*:0".parse()?);

        let policy = policy; // drop mut
        assert!(policy
@@ -658,9 +640,6 @@ mod test {
        assert!(policy
            .allows_sockaddr(&"127.0.0.1:66".parse().unwrap())
            .is_none());
-        assert!(policy
-            .allows_sockaddr(&"127.0.0.1:0".parse().unwrap())
-            .unwrap());
        Ok(())
    }

@@ -693,6 +672,7 @@ mod test {
        assert_eq!("*".parse::<PortRange>().unwrap(), PortRange::new_all());

        assert!("hello".parse::<PortRange>().is_err());
+        assert!("0".parse::<PortRange>().is_err());
        assert!("65536".parse::<PortRange>().is_err());
        assert!("65537".parse::<PortRange>().is_err());
        assert!("1-2-3".parse::<PortRange>().is_err());
@@ -700,9 +680,6 @@ mod test {
        assert!("1-".parse::<PortRange>().is_err());
        assert!("-2".parse::<PortRange>().is_err());
        assert!("-".parse::<PortRange>().is_err());
-
-        assert_eq!("0".parse::<PortRange>().unwrap(), PortRange::new_zero(),);
-        assert!("0-1".parse::<PortRange>().is_err());
    }

    #[test]
@@ -2,7 +2,6 @@
 name = "ledger"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -11,4 +10,4 @@ bip32 = "0.5.1"
 k256 = { workspace = true }
 ledger-transport = "0.10.0"
 ledger-transport-hid = "0.10.0"
-thiserror = { workspace = true }
+thiserror = { workspace = true }
@@ -3,7 +3,6 @@ name = "nym-mixnode-common"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

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

@@ -11,7 +11,6 @@ repository.workspace = true
 cfg-if = { workspace = true }
 dotenvy = { workspace = true }
 hex-literal = "0.3.3"
-log = { workspace = true }
 once_cell = { workspace = true }
 schemars = { workspace = true, features = ["preserve_order"] }
 serde = { workspace = true, features = ["derive"]}
@@ -111,7 +111,6 @@ impl NymNetworkDetails {
            .with_additional_validator_endpoint(ValidatorDetails::new(
                var(var_names::NYXD).expect("nyxd validator not set"),
                Some(var(var_names::NYM_API).expect("nym api not set")),
-                get_optional_env(var_names::NYXD_WEBSOCKET),
            ))
            .with_mixnet_contract(Some(
                var(var_names::MIXNET_CONTRACT_ADDRESS).expect("mixnet contract not set"),
@@ -341,9 +340,6 @@ impl DenomDetailsOwned {
 pub struct ValidatorDetails {
    // it is assumed those values are always valid since they're being provided in our defaults file
    pub nyxd_url: String,
-    //
-    pub websocket_url: Option<String>,
-
    // Right now api_url is optional as we are not running the api reliably on all validators
    // however, later on it should be a mandatory field
    pub api_url: Option<String>,
@@ -351,10 +347,9 @@ pub struct ValidatorDetails {
 }

 impl ValidatorDetails {
-    pub fn new<S: Into<String>>(nyxd_url: S, api_url: Option<S>, websocket_url: Option<S>) -> Self {
+    pub fn new<S: Into<String>>(nyxd_url: S, api_url: Option<S>) -> Self {
        ValidatorDetails {
            nyxd_url: nyxd_url.into(),
-            websocket_url: websocket_url.map(Into::into),
            api_url: api_url.map(Into::into),
        }
    }
@@ -362,7 +357,6 @@ impl ValidatorDetails {
    pub fn new_nyxd_only<S: Into<String>>(nyxd_url: S) -> Self {
        ValidatorDetails {
            nyxd_url: nyxd_url.into(),
-            websocket_url: None,
            api_url: None,
        }
    }
@@ -378,12 +372,6 @@ impl ValidatorDetails {
            .as_ref()
            .map(|url| url.parse().expect("the provided api url is invalid!"))
    }
-
-    pub fn websocket_url(&self) -> Option<Url> {
-        self.websocket_url
-            .as_ref()
-            .map(|url| url.parse().expect("the provided websocket url is invalid!"))
-    }
 }

 fn fix_deprecated_environmental_variables() {
@@ -400,25 +388,11 @@ fn fix_deprecated_environmental_variables() {
    }
 }

-// Read the variables from the file and log what the corresponding values in the environment are.
-fn print_env_vars_with_keys_in_file<P: AsRef<Path> + Copy>(config_env_file: P) {
-    let items = dotenvy::from_path_iter(config_env_file)
-        .expect("Invalid path to environment configuration file");
-    for item in items {
-        let (key, val) = item.expect("Invalid item in environment configuration file");
-        log::debug!("{}: {}", key, val);
-    }
-}
-
 pub fn setup_env<P: AsRef<Path>>(config_env_file: Option<P>) {
    match std::env::var(var_names::CONFIGURED) {
        // if the configuration is not already set in the env vars
        Err(std::env::VarError::NotPresent) => {
-            if let Some(config_env_file) = &config_env_file {
-                log::debug!(
-                    "Loading environment variables from {:?}",
-                    config_env_file.as_ref()
-                );
+            if let Some(config_env_file) = config_env_file {
                dotenvy::from_path(config_env_file)
                    .expect("Invalid path to environment configuration file");
                fix_deprecated_environmental_variables();
@@ -426,25 +400,17 @@ pub fn setup_env<P: AsRef<Path>>(config_env_file: Option<P>) {
                // if nothing is set, the use mainnet defaults
                // if the user has not set `CONFIGURED`, then even if they set any of the env variables,
                // overwrite them
-                log::debug!("Loading mainnet defaults");
                crate::mainnet::export_to_env();
            }
        }
-        Err(_) => {
-            log::debug!("Environment variables already set. Using them");
-            crate::mainnet::export_to_env()
-        }
+        Err(_) => crate::mainnet::export_to_env(),
        _ => {
            fix_deprecated_environmental_variables();
        }
    }

    // if we haven't explicitly defined any of the constants, fallback to defaults
-    crate::mainnet::export_to_env_if_not_set();
-
-    if let Some(config_env_file) = &config_env_file {
-        print_env_vars_with_keys_in_file(config_env_file);
-    }
+    crate::mainnet::export_to_env_if_not_set()
 }

 // Name of the event triggered by the eth contract. If the event name is changed,
@@ -3,7 +3,6 @@

 use crate::var_names;
 use crate::{DenomDetails, ValidatorDetails};
-use std::str::FromStr;

 pub const NETWORK_NAME: &str = "mainnet";

@@ -26,7 +25,6 @@ pub const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772
 pub const STATISTICS_SERVICE_DOMAIN_ADDRESS: &str = "https://mainnet-stats.nymte.ch:8090/";
 pub const NYXD_URL: &str = "https://rpc.nymtech.net";
 pub const NYM_API: &str = "https://validator.nymtech.net/api/";
-pub const NYXD_WS: &str = "wss://rpc.nymtech.net/websocket";
 pub const EXPLORER_API: &str = "https://explorer.nymtech.net/api/";

 // I'm making clippy mad on purpose, because that url HAS TO be updated and deployed before merging
@@ -34,11 +32,7 @@ pub const EXIT_POLICY_URL: &str =
    "https://nymtech.net/.wellknown/network-requester/exit-policy.txt";

 pub(crate) fn validators() -> Vec<ValidatorDetails> {
-    vec![ValidatorDetails::new(
-        NYXD_URL,
-        Some(NYM_API),
-        Some(NYXD_WS),
-    )]
+    vec![ValidatorDetails::new(NYXD_URL, Some(NYM_API))]
 }

 const DEFAULT_SUFFIX: &str = "_MAINNET_DEFAULT";
@@ -66,12 +60,6 @@ pub fn read_var_if_not_default(var: &str) -> Option<String> {
    }
 }

-pub fn read_parsed_var_if_not_default<T: FromStr>(var: &str) -> Option<Result<T, T::Err>> {
-    read_var_if_not_default(var)
-        .as_deref()
-        .map(FromStr::from_str)
-}
-
 pub fn export_to_env() {
    set_var_to_default(var_names::CONFIGURED, "true");
    set_var_to_default(var_names::NETWORK_NAME, NETWORK_NAME);
@@ -116,7 +104,6 @@ pub fn export_to_env() {
    );
    set_var_to_default(var_names::NYXD, NYXD_URL);
    set_var_to_default(var_names::NYM_API, NYM_API);
-    set_var_to_default(var_names::NYXD_WEBSOCKET, NYXD_WS);
    set_var_to_default(var_names::EXPLORER_API, EXPLORER_API);
    set_var_to_default(var_names::EXIT_POLICY_URL, EXIT_POLICY_URL);
 }
@@ -165,7 +152,6 @@ pub fn export_to_env_if_not_set() {
    );
    set_var_conditionally_to_default(var_names::NYXD, NYXD_URL);
    set_var_conditionally_to_default(var_names::NYM_API, NYM_API);
-    set_var_conditionally_to_default(var_names::NYXD_WEBSOCKET, NYXD_WS);
    set_var_conditionally_to_default(var_names::EXPLORER_API, EXPLORER_API);
    set_var_conditionally_to_default(var_names::EXIT_POLICY_URL, EXIT_POLICY_URL);
 }
@@ -26,7 +26,6 @@ pub const SERVICE_PROVIDER_DIRECTORY_CONTRACT_ADDRESS: &str =
 pub const NAME_SERVICE_CONTRACT_ADDRESS: &str = "NAME_SERVICE_CONTRACT_ADDRESS";
 pub const NYXD: &str = "NYXD";
 pub const NYM_API: &str = "NYM_API";
-pub const NYXD_WEBSOCKET: &str = "NYXD_WS";
 pub const EXPLORER_API: &str = "EXPLORER_API";
 pub const EXIT_POLICY_URL: &str = "EXIT_POLICY";

@@ -2,7 +2,6 @@
 name = "nym-node-tester-utils"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true

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

@@ -3,7 +3,6 @@ name = "nym-nonexhaustive-delayqueue"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true

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

@@ -3,7 +3,6 @@ name = "nym-coconut"
 version = "0.5.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>", "Ania Piotrowska <ania@nymtech.net>"]
 edition = "2021"
-license.workspace = true

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

@@ -255,7 +255,7 @@ fn bench_coconut(c: &mut Criterion) {
            b.iter(|| {
                verify_partial_blind_signature(
                    &params,
-                    blind_sign_request.get_private_attributes_pedersen_commitments(),
+                    &blind_sign_request,
                    &public_attributes,
                    random_blind_signature,
                    partial_verification_key,
@@ -43,5 +43,3 @@ mod utils;
 pub type Attribute = bls12_381::Scalar;
 pub type PrivateAttribute = Attribute;
 pub type PublicAttribute = Attribute;
-
-pub use bls12_381::G1Projective;
@@ -362,12 +362,12 @@ pub fn blind_sign(
 /// The function returns `true` if the partial blind signature is valid, and `false` otherwise.
 pub fn verify_partial_blind_signature(
    params: &Parameters,
-    private_attribute_commitments: &[G1Projective],
+    blind_sign_request: &BlindSignRequest,
    public_attributes: &[&Attribute],
    blind_sig: &BlindedSignature,
    partial_verification_key: &VerificationKey,
 ) -> bool {
-    let num_private_attributes = private_attribute_commitments.len();
+    let num_private_attributes = blind_sign_request.private_attributes_commitments.len();
    if num_private_attributes + public_attributes.len() > partial_verification_key.beta_g2.len() {
        return false;
    }
@@ -388,7 +388,8 @@ pub fn verify_partial_blind_signature(
    ];

    // for each private attribute, add (cm_i, beta_i) to the miller terms
-    for (private_attr_commit, beta_g2) in private_attribute_commitments
+    for (private_attr_commit, beta_g2) in blind_sign_request
+        .private_attributes_commitments
        .iter()
        .zip(&partial_verification_key.beta_g2)
    {
@@ -421,7 +422,7 @@ pub fn verify_partial_blind_signature(
    // is equivalent to checking e(a, b) • e(c, d)^{-1} == id
    // and thus to e(a, b) • e(c^{-1}, d) == id
    //
-    // compute e(c^{-1}, g2) • e(s, alpha) • e(cm_0, beta_0) • e(cm_i, beta_i) • (s^pub_0, beta_{i+1}) (s^pub_j, beta_{i + j})
+    // compute e(c^1, g2) • e(s, alpha) • e(cm_0, beta_0) • e(cm_i, beta_i) • (s^pub_0, beta_{i+1}) (s^pub_j, beta_{i + j})
    multi_miller_loop(&terms_refs)
        .final_exponentiation()
        .is_identity()
@@ -518,7 +519,7 @@ mod tests {

        assert!(verify_partial_blind_signature(
            &params,
-            &request.private_attributes_commitments,
+            &request,
            &public_attributes,
            &blind_sig,
            validator_keypair.verification_key()
@@ -538,7 +539,7 @@ mod tests {

        assert!(verify_partial_blind_signature(
            &params,
-            &request.private_attributes_commitments,
+            &request,
            &[],
            &blind_sig,
            validator_keypair.verification_key()
@@ -567,7 +568,7 @@ mod tests {
        // this assertion should fail, as we try to verify with a wrong validator key
        assert!(!verify_partial_blind_signature(
            &params,
-            &request.private_attributes_commitments,
+            &request,
            &public_attributes,
            &blind_sig,
            validator2_keypair.verification_key()
@@ -108,17 +108,6 @@ pub fn transpose_matrix<T: Debug>(matrix: Vec<Vec<T>>) -> Vec<Vec<T>> {
        .collect::<Vec<_>>()
 }

-#[macro_export]
-macro_rules! random_scalars_refs {
-    ( $x: ident, $params: expr, $n: expr ) => {
-        let _vec = $params.n_random_scalars($n);
-        #[allow(clippy::map_identity)]
-        let $x = _vec.iter().collect::<Vec<_>>();
-    };
-}
-
-pub use random_scalars_refs;
-
 #[cfg(test)]
 pub mod tests {
    use super::*;
@@ -181,3 +170,14 @@ pub mod tests {
            .collect()
    }
 }
+
+#[macro_export]
+macro_rules! random_scalars_refs {
+    ( $x: ident, $params: expr, $n: expr ) => {
+        let _vec = $params.n_random_scalars($n);
+        #[allow(clippy::map_identity)]
+        let $x = _vec.iter().collect::<Vec<_>>();
+    };
+}
+
+pub use random_scalars_refs;
@@ -239,15 +239,8 @@ impl NymMessage {
        let (packets_used, space_left) =
            chunking::number_of_required_fragments(total_required_bytes, plaintext_per_packet);

-        let wasted_space_percentage =
-            (space_left as f32 / (bytes.len() + 1 + space_left) as f32) * 100.0;
-        log::trace!(
-            "Padding {self_display}: {} of raw plaintext bytes are required. \
-            They're going to be put into {packets_used} sphinx packets with {space_left} bytes \
-            of leftover space. {wasted_space_percentage:.1}% of packet capacity is going to \
-            be wasted.",
-            bytes.len() + 1
-        );
+        let wasted_space = space_left as f32 / (bytes.len() + 1 + space_left) as f32;
+        log::trace!("Padding {self_display}: {} of raw plaintext bytes are required. They're going to be put into {packets_used} sphinx packets with {space_left} bytes of leftover space. {wasted_space}% of packet capacity is going to be wasted.", bytes.len() + 1);

        bytes
            .into_iter()
@@ -1,37 +0,0 @@
-[package]
-name = "nyxd-scraper"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-async-trait.workspace = true
-const_format = "0.2.32"
-cosmrs.workspace = true
-eyre = "0.6.9"
-futures.workspace = true
-sha2 = "0.10.8"
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate", "time"] }
-tendermint.workspace = true
-tendermint-rpc = { workspace = true, features = ["websocket-client", "http-client"] }
-thiserror.workspace = true
-tokio = { workspace = true, features = ["full"] }
-tokio-stream = "0.1.14"
-tokio-util = { version = "0.7.10", features = ["rt"]}
-tracing.workspace = true
-url.workspace = true
-
-
-# TEMP
-nym-bin-common = { path = "../bin-common", features = ["basic_tracing"]}
-
-
-[build-dependencies]
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
-tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
@@ -1,28 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#[tokio::main]
-async fn main() {
-    use sqlx::{Connection, SqliteConnection};
-    use std::env;
-
-    let out_dir = env::var("OUT_DIR").unwrap();
-    let database_path = format!("{out_dir}/scraper-example.sqlite");
-
-    let mut conn = SqliteConnection::connect(&format!("sqlite://{database_path}?mode=rwc"))
-        .await
-        .expect("Failed to create SQLx database connection");
-
-    sqlx::migrate!("./sql_migrations")
-        .run(&mut conn)
-        .await
-        .expect("Failed to perform SQLx migrations");
-
-    #[cfg(target_family = "unix")]
-    println!("cargo:rustc-env=DATABASE_URL=sqlite://{}", &database_path);
-
-    #[cfg(target_family = "windows")]
-    // for some strange reason we need to add a leading `/` to the windows path even though it's
-    // not a valid windows path... but hey, it works...
-    println!("cargo:rustc-env=DATABASE_URL=sqlite:///{}", &database_path);
-}
@@ -1,10 +0,0 @@
-/*
- * Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-CREATE TABLE METADATA
-(
-    id                    INTEGER PRIMARY KEY CHECK (id = 0),
-    last_processed_height INTEGER NOT NULL
-);
@@ -1,76 +0,0 @@
-CREATE TABLE validator
-(
-    consensus_address TEXT NOT NULL PRIMARY KEY, /* Validator consensus address */
-    consensus_pubkey  TEXT NOT NULL UNIQUE /* Validator consensus public key */
-);
-
-CREATE TABLE pre_commit
-(
-    validator_address TEXT                        NOT NULL REFERENCES validator (consensus_address),
-    height            BIGINT                      NOT NULL,
-    timestamp         TIMESTAMP WITHOUT TIME ZONE NOT NULL,
-    voting_power      BIGINT                      NOT NULL,
-    proposer_priority BIGINT                      NOT NULL,
-    UNIQUE (validator_address, timestamp)
-);
-CREATE INDEX pre_commit_validator_address_index ON pre_commit (validator_address);
-CREATE INDEX pre_commit_height_index ON pre_commit (height);
-
-CREATE TABLE block
-(
-    height           BIGINT  UNIQUE PRIMARY KEY,
-    hash             TEXT    NOT NULL UNIQUE,
-    num_txs          INTEGER DEFAULT 0,
-    total_gas        BIGINT  DEFAULT 0,
-    proposer_address TEXT REFERENCES validator (consensus_address),
-    timestamp        TIMESTAMP WITHOUT TIME ZONE NOT NULL
-);
-CREATE INDEX block_height_index ON block (height);
-CREATE INDEX block_hash_index ON block (hash);
-CREATE INDEX block_proposer_address_index ON block (proposer_address);
-
-- no JSONB in sqlite (yet) : )
-CREATE TABLE "transaction"
-(
-    hash         TEXT    UNIQUE NOT NULL,
-    height       BIGINT  NOT NULL REFERENCES block (height),
-    "index"      INTEGER NOT NULL,
-    success      BOOLEAN NOT NULL,
-
-    /* Body */
-    num_messages INTEGER NOT NULL,
--     messages     JSONB   NOT NULL,-- DEFAULT '[]'::JSONB,
-    memo         TEXT,
--     signatures   TEXT[]  NOT NULL,
-
-    /* AuthInfo */
--     signer_infos JSONB   NOT NULL,-- DEFAULT '[]'::JSONB,
--     fee          JSONB   NOT NULL,-- DEFAULT '{}'::JSONB,
-
-    /* Tx response */
-    gas_wanted   BIGINT           DEFAULT 0,
-    gas_used     BIGINT           DEFAULT 0,
-    raw_log      TEXT
--     logs         JSONB
-);
-CREATE INDEX transaction_hash_index ON "transaction" (hash);
-CREATE INDEX transaction_height_index ON "transaction" (height);
-
-CREATE TABLE message
-(
-    transaction_hash            TEXT   NOT NULL REFERENCES "transaction" (hash),
-    "index"                       BIGINT NOT NULL,
-    type                        TEXT   NOT NULL,
--     value                       JSONB  NOT NULL,
--     involved_accounts_addresses TEXT[] NOT NULL,
-
-    height                      BIGINT NOT NULL,
-    CONSTRAINT unique_message_per_tx UNIQUE (transaction_hash, "index")
-);
-CREATE INDEX message_transaction_hash_index ON message (transaction_hash);
-CREATE INDEX message_type_index ON message (type);
-
-CREATE TABLE pruning
-(
-    last_pruned_height BIGINT NOT NULL
-);
@@ -1,65 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::block_processor::MAX_RANGE_SIZE;
-use std::cmp::min;
-use std::collections::VecDeque;
-use std::ops::Range;
-
-pub(crate) fn split_request_range(request_range: Range<u32>) -> VecDeque<Range<u32>> {
-    let mut requests = VecDeque::new();
-
-    let mut start = request_range.start;
-    let mut end = min(request_range.end, start + MAX_RANGE_SIZE as u32);
-
-    loop {
-        requests.push_back(start..end);
-        start = min(start + MAX_RANGE_SIZE as u32, request_range.end);
-        end = min(end + MAX_RANGE_SIZE as u32, request_range.end);
-
-        if start == end {
-            break;
-        }
-    }
-
-    requests
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn splitting_request_range() {
-        let range = 0..100;
-        let mut expected = VecDeque::new();
-        expected.push_back(0..30);
-        expected.push_back(30..60);
-        expected.push_back(60..90);
-        expected.push_back(90..100);
-        assert_eq!(expected, split_request_range(range));
-
-        let range = 0..30;
-        let mut expected = VecDeque::new();
-        expected.push_back(0..30);
-        assert_eq!(expected, split_request_range(range));
-
-        let range = 0..60;
-        let mut expected = VecDeque::new();
-        expected.push_back(0..30);
-        expected.push_back(30..60);
-        assert_eq!(expected, split_request_range(range));
-
-        let range = 0..5;
-        let mut expected = VecDeque::new();
-        expected.push_back(0..5);
-        assert_eq!(expected, split_request_range(range));
-
-        let range = 123..200;
-        let mut expected = VecDeque::new();
-        expected.push_back(123..153);
-        expected.push_back(153..183);
-        expected.push_back(183..200);
-        assert_eq!(expected, split_request_range(range));
-    }
-}
@@ -1,332 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::block_processor::helpers::split_request_range;
-use crate::block_processor::types::BlockToProcess;
-use crate::block_requester::BlockRequest;
-use crate::error::ScraperError;
-use crate::modules::{BlockModule, MsgModule, TxModule};
-use crate::rpc_client::RpcClient;
-use crate::storage::{persist_block, ScraperStorage};
-use futures::StreamExt;
-use std::collections::{BTreeMap, HashSet, VecDeque};
-use std::ops::{Add, Range};
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::sync::mpsc::{Sender, UnboundedReceiver};
-use tokio::sync::Notify;
-use tokio::time::{interval_at, Instant};
-use tokio_stream::wrappers::UnboundedReceiverStream;
-use tokio_util::sync::CancellationToken;
-use tracing::{debug, error, info, warn};
-
-mod helpers;
-pub(crate) mod types;
-
-const MISSING_BLOCKS_CHECK_INTERVAL: Duration = Duration::from_secs(30);
-const MAX_MISSING_BLOCKS_DELAY: Duration = Duration::from_secs(15);
-const MAX_RANGE_SIZE: usize = 30;
-
-#[derive(Debug, Default)]
-struct PendingSync {
-    request_in_flight: HashSet<u32>,
-    queued_requests: VecDeque<Range<u32>>,
-}
-
-impl PendingSync {
-    fn is_empty(&self) -> bool {
-        self.request_in_flight.is_empty() && self.queued_requests.is_empty()
-    }
-}
-
-pub struct BlockProcessor {
-    cancel: CancellationToken,
-    synced: Arc<Notify>,
-    last_processed_height: u32,
-    last_processed_at: Instant,
-    pending_sync: PendingSync,
-    queued_blocks: BTreeMap<u32, BlockToProcess>,
-
-    rpc_client: RpcClient,
-    incoming: UnboundedReceiverStream<BlockToProcess>,
-    block_requester: Sender<BlockRequest>,
-    storage: ScraperStorage,
-
-    // future work: rather than sending each msg to every msg module,
-    // let them subscribe based on `type_url` inside the message itself
-    // (like "/cosmwasm.wasm.v1.MsgExecuteContract")
-    block_modules: Vec<Box<dyn BlockModule + Send>>,
-    tx_modules: Vec<Box<dyn TxModule + Send>>,
-    msg_modules: Vec<Box<dyn MsgModule + Send>>,
-}
-
-impl BlockProcessor {
-    pub async fn new(
-        cancel: CancellationToken,
-        synced: Arc<Notify>,
-        incoming: UnboundedReceiver<BlockToProcess>,
-        block_requester: Sender<BlockRequest>,
-        storage: ScraperStorage,
-        rpc_client: RpcClient,
-    ) -> Result<Self, ScraperError> {
-        let last_processed = storage.get_last_processed_height().await?;
-
-        Ok(BlockProcessor {
-            cancel,
-            synced,
-            last_processed_height: last_processed.try_into().unwrap_or_default(),
-            last_processed_at: Instant::now(),
-            pending_sync: Default::default(),
-            queued_blocks: Default::default(),
-            rpc_client,
-            incoming: incoming.into(),
-            block_requester,
-            storage,
-            block_modules: vec![],
-            tx_modules: vec![],
-            msg_modules: vec![],
-        })
-    }
-
-    async fn process_block(&mut self, block: BlockToProcess) -> Result<(), ScraperError> {
-        info!("processing block at height {}", block.height);
-
-        let full_info = self.rpc_client.try_get_full_details(block).await?;
-
-        debug!(
-            "this block has {} transaction(s)",
-            full_info.transactions.len()
-        );
-        for tx in &full_info.transactions {
-            debug!("{} has {} message(s)", tx.hash, tx.tx.body.messages.len());
-            for (index, msg) in tx.tx.body.messages.iter().enumerate() {
-                debug!("{index}: {:?}", msg.type_url)
-            }
-        }
-
-        // process the entire block as a transaction so that if anything fails,
-        // we won't end up with a corrupted storage.
-        let mut tx = self.storage.begin_processing_tx().await?;
-
-        persist_block(&full_info, &mut tx).await?;
-
-        // let the modules do whatever they want
-        // the ones wanting the full block:
-        for block_module in &mut self.block_modules {
-            block_module.handle_block(&full_info, &mut tx).await?;
-        }
-
-        // the ones wanting transactions:
-        for block_tx in full_info.transactions {
-            for tx_module in &mut self.tx_modules {
-                tx_module.handle_tx(&block_tx, &mut tx).await?;
-            }
-            // the ones concerned with individual messages
-            for (index, msg) in block_tx.tx.body.messages.iter().enumerate() {
-                for msg_module in &mut self.msg_modules {
-                    msg_module
-                        .handle_msg(index, msg, &block_tx, &mut tx)
-                        .await?
-                }
-            }
-        }
-
-        tx.commit()
-            .await
-            .map_err(|source| ScraperError::StorageTxCommitFailure { source })?;
-
-        self.last_processed_height = full_info.block.header.height.value() as u32;
-        self.last_processed_at = Instant::now();
-
-        Ok(())
-    }
-
-    pub fn set_block_modules(&mut self, modules: Vec<Box<dyn BlockModule + Send>>) {
-        self.block_modules = modules;
-    }
-
-    pub fn set_tx_modules(&mut self, modules: Vec<Box<dyn TxModule + Send>>) {
-        self.tx_modules = modules;
-    }
-
-    pub fn set_msg_modules(&mut self, modules: Vec<Box<dyn MsgModule + Send>>) {
-        self.msg_modules = modules;
-    }
-
-    async fn maybe_request_missing_blocks(&mut self) -> Result<(), ScraperError> {
-        // we're still processing, so we're good
-        if self.last_processed_at.elapsed() < MAX_MISSING_BLOCKS_DELAY {
-            debug!("no need to request missing blocks");
-            return Ok(());
-        }
-
-        if self.try_request_pending().await {
-            return Ok(());
-        }
-
-        // TODO: properly fill in the gaps later with BlockRequest::Specific,
-        let request_range = if let Some((next_available, _)) = self.queued_blocks.first_key_value()
-        {
-            self.last_processed_height + 1..*next_available
-        } else {
-            let current_height = self.rpc_client.current_block_height().await? as u32;
-            self.last_processed_height + 1..current_height + 1
-        };
-
-        self.request_missing_blocks(request_range).await?;
-
-        Ok(())
-    }
-
-    async fn request_missing_blocks(
-        &mut self,
-        request_range: Range<u32>,
-    ) -> Result<(), ScraperError> {
-        let request_range = if request_range.len() > MAX_RANGE_SIZE {
-            let mut split = split_request_range(request_range);
-
-            // SAFETY: we know that after the split of a non-empty range we have AT LEAST one value
-            #[allow(clippy::unwrap_used)]
-            let first = split.pop_front().unwrap();
-            self.pending_sync.queued_requests = split;
-            self.pending_sync.request_in_flight = first.clone().collect();
-
-            first
-        } else {
-            request_range
-        };
-
-        self.send_blocks_request(request_range).await
-    }
-
-    // technically we're not mutating self here,
-    // but we need it to help the compiler figure out the future is `Send`
-    async fn send_blocks_request(&mut self, request_range: Range<u32>) -> Result<(), ScraperError> {
-        debug!("requesting missing blocks: {request_range:?}");
-
-        self.block_requester
-            .send(BlockRequest::Range(request_range))
-            .await?;
-        Ok(())
-    }
-
-    async fn next_incoming(&mut self, block: BlockToProcess) {
-        let height = block.height;
-
-        self.pending_sync.request_in_flight.remove(&height);
-
-        if self.last_processed_height == 0 {
-            // this is the first time we've started up the process
-            debug!("setting up initial processing height");
-            self.last_processed_height = height - 1
-        }
-
-        if height <= self.last_processed_height {
-            warn!("we have already processed block for height {height}");
-            return;
-        }
-
-        if self.last_processed_height + 1 != height {
-            if self.queued_blocks.insert(height, block).is_some() {
-                warn!("we have already queued up block for height {height}");
-            }
-            return;
-        }
-
-        if let Err(err) = self.process_block(block).await {
-            error!("failed to process block at height {height}: {err}");
-            return;
-        }
-
-        // process as much as we can from the queue
-        let mut next = height + 1;
-        while let Some(next_block) = self.queued_blocks.remove(&next) {
-            if let Err(err) = self.process_block(next_block).await {
-                error!("failed to process queued-up block at height {next}: {err}")
-            }
-            next += 1;
-        }
-
-        self.try_request_pending().await;
-
-        if self.pending_sync.is_empty() {
-            self.synced.notify_one();
-        }
-    }
-
-    async fn try_request_pending(&mut self) -> bool {
-        if self.pending_sync.request_in_flight.is_empty() {
-            if let Some(next_sync) = self.pending_sync.queued_requests.pop_front() {
-                debug!(
-                    "current request range has been resolved. requesting another bunch of blocks"
-                );
-                if let Err(err) = self.send_blocks_request(next_sync.clone()).await {
-                    error!("failed to request resync blocks: {err}");
-                    self.pending_sync.queued_requests.push_front(next_sync);
-                } else {
-                    self.pending_sync.request_in_flight = next_sync.collect()
-                }
-
-                return true;
-            }
-        }
-
-        false
-    }
-
-    // technically we're not mutating self here,
-    // but we need it to help the compiler figure out the future is `Send`
-    async fn startup_resync(&mut self) -> Result<(), ScraperError> {
-        assert!(self.pending_sync.is_empty());
-
-        let latest_block = self.rpc_client.current_block_height().await? as u32;
-        if latest_block > self.last_processed_height && self.last_processed_height != 0 {
-            let request_range = self.last_processed_height + 1..latest_block + 1;
-            info!("we need to request {request_range:?} to resync");
-            self.request_missing_blocks(request_range).await?;
-        }
-
-        Ok(())
-    }
-
-    pub(crate) async fn run(&mut self) {
-        info!("starting processing loop");
-
-        // sure, we could be more efficient and reset it on every processed block,
-        // but the overhead is so minimal that it doesn't matter
-        let mut missing_check_interval = interval_at(
-            Instant::now().add(MISSING_BLOCKS_CHECK_INTERVAL),
-            MISSING_BLOCKS_CHECK_INTERVAL,
-        );
-
-        if let Err(err) = self.startup_resync().await {
-            error!("failed to perform startup sync: {err}");
-            self.cancel.cancel();
-            return;
-        };
-
-        loop {
-            tokio::select! {
-                _ = self.cancel.cancelled() => {
-                    info!("received cancellation token");
-                    break
-                }
-                _ = missing_check_interval.tick() => {
-                    if let Err(err) = self.maybe_request_missing_blocks().await {
-                        error!("failed to request missing blocks: {err}")
-                    }
-                }
-                block = self.incoming.next() => {
-                    match block {
-                        Some(block) => self.next_incoming(block).await,
-                        None => {
-                            warn!("stopped receiving new blocks");
-                            self.cancel.cancel();
-                            break
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
@@ -1,121 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::error::ScraperError;
-use crate::helpers;
-use tendermint::{abci, block, tx, Block, Hash};
-use tendermint_rpc::endpoint::{block as block_endpoint, block_results, validators};
-use tendermint_rpc::event::{Event, EventData};
-
-// just get all everything out of tx::Response, but parse raw `tx` bytes
-#[derive(Clone, Debug)]
-pub struct ParsedTransactionResponse {
-    /// The hash of the transaction.
-    ///
-    /// Deserialized from a hex-encoded string (there is a discrepancy between
-    /// the format used for the request and the format used for the response in
-    /// the Tendermint RPC).
-    pub hash: Hash,
-
-    pub height: block::Height,
-
-    pub index: u32,
-
-    pub tx_result: abci::types::ExecTxResult,
-
-    pub tx: cosmrs::tx::Tx,
-
-    pub proof: Option<tx::Proof>,
-}
-
-#[derive(Debug)]
-pub struct FullBlockInformation {
-    /// Basic block information, including its signers.
-    pub block: Block,
-
-    /// All of the emitted events alongside any tx results.
-    pub results: block_results::Response,
-
-    /// Validator set for this particular block
-    pub validators: validators::Response,
-
-    /// Transaction results from this particular block
-    pub transactions: Vec<ParsedTransactionResponse>,
-}
-
-impl FullBlockInformation {
-    pub fn ensure_proposer(&self) -> Result<(), ScraperError> {
-        let block_proposer = self.block.header.proposer_address;
-        if !self
-            .validators
-            .validators
-            .iter()
-            .any(|v| v.address == block_proposer)
-        {
-            let proposer = helpers::validator_consensus_address(block_proposer)?;
-            return Err(ScraperError::BlockProposerNotInValidatorSet {
-                height: self.block.header.height.value() as u32,
-                proposer: proposer.to_string(),
-            });
-        }
-        Ok(())
-    }
-}
-
-pub(crate) struct BlockToProcess {
-    pub(crate) height: u32,
-    pub(crate) block: Block,
-}
-
-impl From<Block> for BlockToProcess {
-    fn from(block: Block) -> Self {
-        BlockToProcess {
-            height: block.header.height.value() as u32,
-            block,
-        }
-    }
-}
-
-impl TryFrom<Event> for BlockToProcess {
-    type Error = ScraperError;
-
-    fn try_from(event: Event) -> Result<Self, Self::Error> {
-        let query = event.query.clone();
-
-        // TODO: we're losing `result_begin_block` and `result_end_block` here but maybe that's fine?
-        let maybe_block = match event.data {
-            // we don't care about `NewBlock` until CometBFT 0.38, i.e. until we upgrade to wasmd 0.50
-            EventData::NewBlock { .. } => {
-                return Err(ScraperError::InvalidSubscriptionEvent {
-                    query,
-                    kind: "NewBlock".to_string(),
-                })
-            }
-            EventData::LegacyNewBlock { block, .. } => block,
-            EventData::Tx { .. } => {
-                return Err(ScraperError::InvalidSubscriptionEvent {
-                    query,
-                    kind: "Tx".to_string(),
-                })
-            }
-            EventData::GenericJsonEvent(_) => {
-                return Err(ScraperError::InvalidSubscriptionEvent {
-                    query,
-                    kind: "GenericJsonEvent".to_string(),
-                })
-            }
-        };
-
-        let Some(block) = maybe_block else {
-            return Err(ScraperError::EmptyBlockData { query });
-        };
-
-        Ok((*block).into())
-    }
-}
-
-impl From<block_endpoint::Response> for BlockToProcess {
-    fn from(value: block_endpoint::Response) -> Self {
-        value.block.into()
-    }
-}
@@ -1,91 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::block_processor::types::BlockToProcess;
-use crate::error::ScraperError;
-use crate::rpc_client::RpcClient;
-use futures::StreamExt;
-use std::ops::Range;
-use tokio::sync::mpsc::{Receiver, UnboundedSender};
-use tokio_stream::wrappers::ReceiverStream;
-use tokio_util::sync::CancellationToken;
-use tracing::{error, info, instrument, warn};
-
-#[derive(Debug)]
-pub enum BlockRequest {
-    Range(Range<u32>),
-
-    // UNIMPLEMENTED:
-    #[allow(dead_code)]
-    Specific(Vec<u32>),
-}
-
-pub(crate) struct BlockRequester {
-    cancel: CancellationToken,
-    rpc_client: RpcClient,
-    requests: ReceiverStream<BlockRequest>,
-    blocks: UnboundedSender<BlockToProcess>,
-}
-
-impl BlockRequester {
-    pub(crate) fn new(
-        cancel: CancellationToken,
-        rpc_client: RpcClient,
-        requests: Receiver<BlockRequest>,
-        blocks: UnboundedSender<BlockToProcess>,
-    ) -> Self {
-        BlockRequester {
-            cancel,
-            rpc_client,
-            requests: requests.into(),
-            blocks,
-        }
-    }
-
-    async fn request_and_send(&self, height: u32) -> Result<(), ScraperError> {
-        let block = self.rpc_client.get_basic_block_details(height).await?;
-        self.blocks.send(block.into())?;
-        Ok(())
-    }
-
-    async fn request_blocks<I: IntoIterator<Item = u32>>(&self, heights: I) {
-        futures::stream::iter(heights)
-            .for_each_concurrent(4, |height| async move {
-                if let Err(err) = self.request_and_send(height).await {
-                    error!("failed to request block data: {err}")
-                }
-            })
-            .await
-    }
-
-    #[instrument(skip(self))]
-    async fn handle_blocks_request(&self, request: BlockRequest) {
-        info!("received request for missed blocks");
-
-        match request {
-            BlockRequest::Range(range) => self.request_blocks(range).await,
-            BlockRequest::Specific(heights) => self.request_blocks(heights).await,
-        }
-    }
-
-    pub(crate) async fn run(&mut self) {
-        loop {
-            tokio::select! {
-               _ = self.cancel.cancelled() => {
-                    info!("received cancellation token");
-                    break
-                }
-                maybe_request = self.requests.next() => {
-                    match maybe_request {
-                        Some(request) => self.handle_blocks_request(request).await,
-                        None => {
-                            warn!("stopped receiving new requests");
-                            self.cancel.cancel();
-                            break
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
@@ -1,47 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use const_format::concatcp;
-
-// TODO: make those configurable via 'NymNetworkDetails'
-
-// BECH32_PREFIX defines the main SDK Bech32 prefix of an account's address
-pub const BECH32_PREFIX: &str = "n";
-
-// ACCOUNT_PREFIX is the prefix for account keys
-pub const ACCOUNT_PREFIX: &str = "acc";
-// VALIDATOR_PREFIX is the prefix for validator keys
-pub const VALIDATOR_PREFIX: &str = "val";
-// CONSENSUS_PREFIX is the prefix for consensus keys
-pub const CONSENSUS_PREFIX: &str = "cons";
-// PUBKEY_PREFIX is the prefix for public keys
-pub const PUBKEY_PREFIX: &str = "pub";
-// OPERATOR_PREFIX is the prefix for operator keys
-pub const OPERATOR_PREFIX: &str = "oper";
-// ADDRESS_PREFIX is the prefix for addresses
-pub const ADDRESS_PREFIX: &str = "addr";
-
-// BECH32_ACCOUNT_ADDRESS_PREFIX defines the Bech32 prefix of an account's address
-pub const BECH32_ACCOUNT_ADDRESS_PREFIX: &str = BECH32_PREFIX;
-// BECH32_ACCOUNT_PUBKEY_PREFIX defines the Bech32 prefix of an account's public key
-pub const BECH32_ACCOUNT_PUBKEY_PREFIX: &str = concatcp!(BECH32_PREFIX, PUBKEY_PREFIX);
-// BECH32_VALIDATOR_ADDRESS_PREFIX defines the Bech32 prefix of a validator's operator address
-pub const BECH32_VALIDATOR_ADDRESS_PREFIX: &str =
-    concatcp!(BECH32_PREFIX, VALIDATOR_PREFIX, OPERATOR_PREFIX);
-// BECH32_VALIDATOR_PUBKEY_PREFIX defines the Bech32 prefix of a validator's operator public key
-pub const BECH32_VALIDATOR_PUBKEY_PREFIX: &str = concatcp!(
-    BECH32_PREFIX,
-    VALIDATOR_PREFIX,
-    OPERATOR_PREFIX,
-    PUBKEY_PREFIX
-);
-// BECH32_CONSENSUS_ADDRESS_PREFIX defines the Bech32 prefix of a consensus node address
-pub const BECH32_CONSENSUS_ADDRESS_PREFIX: &str =
-    concatcp!(BECH32_PREFIX, VALIDATOR_PREFIX, CONSENSUS_PREFIX);
-// BECH32_CONESNSUS_PUBKEY_PREFIX defines the Bech32 prefix of a consensus node public key
-pub const BECH32_CONESNSUS_PUBKEY_PREFIX: &str = concatcp!(
-    BECH32_PREFIX,
-    VALIDATOR_PREFIX,
-    CONSENSUS_PREFIX,
-    PUBKEY_PREFIX
-);
@@ -1,131 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use tendermint::Hash;
-use thiserror::Error;
-use tokio::sync::mpsc::error::SendError;
-
-#[derive(Debug, Error)]
-pub enum ScraperError {
-    #[error("experienced internal database error: {0}")]
-    InternalDatabaseError(#[from] sqlx::Error),
-
-    #[error("failed to perform startup SQL migration: {0}")]
-    StartupMigrationFailure(#[from] sqlx::migrate::MigrateError),
-
-    #[error("can't add any modules to the scraper as it's already running")]
-    ScraperAlreadyRunning,
-
-    #[error("failed to establish websocket connection to {url}: {source}")]
-    WebSocketConnectionFailure {
-        url: String,
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("failed to establish rpc connection to {url}: {source}")]
-    HttpConnectionFailure {
-        url: String,
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("failed to create chain subscription: {source}")]
-    ChainSubscriptionFailure {
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("could not obtain basic block information at height: {height}: {source}")]
-    BlockQueryFailure {
-        height: u32,
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("could not obtain block results information at height: {height}: {source}")]
-    BlockResultsQueryFailure {
-        height: u32,
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("could not obtain validators information at height: {height}: {source}")]
-    ValidatorsQueryFailure {
-        height: u32,
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("could not obtain tx results for tx: {hash}: {source}")]
-    TxResultsQueryFailure {
-        hash: Hash,
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("could not obtain current abci info: {source}")]
-    AbciInfoQueryFailure {
-        #[source]
-        source: tendermint_rpc::Error,
-    },
-
-    #[error("could not parse tx {hash}: {source}")]
-    TxParseFailure {
-        hash: Hash,
-        #[source]
-        source: cosmrs::ErrorReport,
-    },
-
-    #[error("received an invalid chain subscription event of kind {kind} while we were waiting for new block data (query: '{query}')")]
-    InvalidSubscriptionEvent { query: String, kind: String },
-
-    #[error("received block data was empty (query: '{query}')")]
-    EmptyBlockData { query: String },
-
-    #[error("reached maximum number of allowed errors for subscription events")]
-    MaximumSubscriptionFailures,
-
-    #[error("failed to begin storage tx: {source}")]
-    StorageTxBeginFailure {
-        #[source]
-        source: sqlx::Error,
-    },
-
-    #[error("failed to commit storage tx: {source}")]
-    StorageTxCommitFailure {
-        #[source]
-        source: sqlx::Error,
-    },
-
-    #[error("failed to send on a closed channel")]
-    ClosedChannelError,
-
-    #[error("failed to parse validator's address: {source}")]
-    MalformedValidatorAddress {
-        #[source]
-        source: eyre::Report,
-    },
-
-    #[error("failed to parse validator's address: {source}")]
-    MalformedValidatorPubkey {
-        #[source]
-        source: eyre::Report,
-    },
-
-    #[error(
-        "could not find the block proposer ('{proposer}') for height {height} in the validator set"
-    )]
-    BlockProposerNotInValidatorSet { height: u32, proposer: String },
-
-    #[error(
-        "could not find validator information for {address}; the validator has signed a commit"
-    )]
-    MissingValidatorInfoCommitted { address: String },
-}
-
-impl<T> From<SendError<T>> for ScraperError {
-    fn from(_: SendError<T>) -> Self {
-        ScraperError::ClosedChannelError
-    }
-}
@@ -1,46 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::block_processor::types::ParsedTransactionResponse;
-use crate::constants::{BECH32_CONESNSUS_PUBKEY_PREFIX, BECH32_CONSENSUS_ADDRESS_PREFIX};
-use crate::error::ScraperError;
-use cosmrs::AccountId;
-use sha2::{Digest, Sha256};
-use tendermint::{account, PublicKey};
-use tendermint::{validator, Hash};
-use tendermint_rpc::endpoint::validators;
-
-pub(crate) fn tx_hash<M: AsRef<[u8]>>(raw_tx: M) -> Hash {
-    Hash::Sha256(Sha256::digest(raw_tx).into())
-}
-
-pub(crate) fn validator_pubkey_to_bech32(pubkey: PublicKey) -> Result<AccountId, ScraperError> {
-    // TODO: this one seem to attach additional prefix to they pubkeys, is that what we want instead maybe?
-    // Ok(pubkey.to_bech32(BECH32_CONESNSUS_PUBKEY_PREFIX))
-    AccountId::new(BECH32_CONESNSUS_PUBKEY_PREFIX, &pubkey.to_bytes())
-        .map_err(|source| ScraperError::MalformedValidatorPubkey { source })
-}
-
-pub(crate) fn validator_consensus_address(id: account::Id) -> Result<AccountId, ScraperError> {
-    AccountId::new(BECH32_CONSENSUS_ADDRESS_PREFIX, id.as_ref())
-        .map_err(|source| ScraperError::MalformedValidatorAddress { source })
-}
-
-pub(crate) fn tx_gas_sum(txs: &[ParsedTransactionResponse]) -> i64 {
-    txs.iter().map(|tx| tx.tx_result.gas_used).sum()
-}
-
-pub(crate) fn validator_info(
-    id: account::Id,
-    validators: &validators::Response,
-) -> Result<&validator::Info, ScraperError> {
-    match validators.validators.iter().find(|v| v.address == id) {
-        Some(info) => Ok(info),
-        None => {
-            let addr = validator_consensus_address(id)?;
-            Err(ScraperError::MissingValidatorInfoCommitted {
-                address: addr.to_string(),
-            })
-        }
-    }
-}
@@ -1,19 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#![warn(clippy::expect_used)]
-#![warn(clippy::unwrap_used)]
-
-pub(crate) mod block_processor;
-pub(crate) mod block_requester;
-pub mod constants;
-pub mod error;
-pub(crate) mod helpers;
-pub mod modules;
-pub(crate) mod rpc_client;
-pub(crate) mod scraper;
-pub mod storage;
-
-pub use modules::{BlockModule, MsgModule, TxModule};
-pub use scraper::{Config, NyxdScraper};
-pub use storage::models;
@@ -1,16 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::block_processor::types::FullBlockInformation;
-use crate::error::ScraperError;
-use crate::storage::StorageTransaction;
-use async_trait::async_trait;
-
-#[async_trait]
-pub trait BlockModule {
-    async fn handle_block(
-        &mut self,
-        block: &FullBlockInformation,
-        storage_tx: &mut StorageTransaction,
-    ) -> Result<(), ScraperError>;
-}
@@ -1,10 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-mod block_module;
-mod msg_module;
-mod tx_module;
-
-pub use block_module::BlockModule;
-pub use msg_module::MsgModule;
-pub use tx_module::TxModule;
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
benedettadavico	b402aa891a	Merge branch 'develop' into benny/gas-multiplier-fix	2023-12-19 19:53:56 +01:00
benedetta davico	1b7267ec18	Update mod.rs	2023-12-15 12:36:05 +01:00