Pass errors up the call stack

In the vpn client I've observed that 2 out of 3 times the disconnect
procedure stalls out.

Investigating in the logs these 5 are still running when we hit shutdown
timeout.

[TaskClient-nym_vpn_lib-mixnet_client_main-real_traffic_controller-ack_control-retransmission_request_listener] Polling shutdown failed: channel closed
[TaskClient-nym_vpn_lib-mixnet_client_main-real_traffic_controller-out_queue_control] Polling shutdown failed: channel closed
[TaskClient-gateway-packet-router] Polling shutdown failed: channel closed
[TaskClient-nym_vpn_lib-mixnet_client_main-gateway_transceiver] Polling shutdown failed: channel closed
[TaskClient-nym_vpn_lib-mixnet_client_main-mix_traffic_controller] Polling shutdown failed: channel closed

I _think_ what was causing the problem here is that the task client in
the packet router is not being awaited in an event loop like other
client instances.

Explictly drop it in the socket state to make sure it's not blocking
shutdown.

.github/workflows/cd-docs.yml

@@ -9,11 +9,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git python3 && sudo apt-get update --fix-missing
-      - name: Install pip3
-        run: sudo apt install -y python3-pip  
-      - name: Install Python3 modules
-        run: sudo pip3 install pandas tabulate
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
       - name: Install rsync
         run: sudo apt-get install rsync
       - uses: rlespinasse/github-slug-action@v3.x
@@ -34,24 +30,9 @@ jobs:
       - name: Remove existing Nym config directory (`~/.nym/`)
         run: cd documentation && ./remove_existing_config.sh
         continue-on-error: false
-# This is the original flow
-#      - name: Build all projects in documentation/ & move to ~/dist/docs/
-#        run: cd documentation && ./build_all_to_dist.sh
-
-# This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
-      - name: Save current branch to ~/current_branch
-        run: git rev-parse --abbrev-ref HEAD > ~/current_branch
-      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
-        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/
         run: cd documentation && ./build_all_to_dist.sh
-
-      - name: Switch to current branch
-        run: git checkout $echo "$(cat ~/current_branch)"
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ on current branch
-        run: cd documentation && ./build_all_to_dist.sh && rm ~/current_branch
-
-# End of replacemet
+        continue-on-error: false
 
       - name: Post process
         run: cd documentation && ./post_process.sh

.github/workflows/ci-contracts-upload-binaries.yml

@@ -35,7 +35,7 @@ jobs:
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.77.0
+          toolchain: stable
           target: wasm32-unknown-unknown
           override: true
 
@@ -47,17 +47,6 @@ jobs:
       - name: Build release contracts
         run: make contracts
 
-      - name: Install CosmWasm optimizer
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y docker.io
-
-      - name: Optimize WASM contracts
-        run: |
-          docker run --rm -v $(pwd)/contracts/target/wasm32-unknown-unknown/release:/code \
-          --mount type=volume,source=cosmwasm_cache,target=/code/cache \
-          cosmwasm/workspace-optimizer:0.12.9
-
       - name: Prepare build output
         shell: bash
         env:
@@ -69,7 +58,8 @@ jobs:
           cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_dkg.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
           cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_ecash.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_service_provider_directory.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_name_service.wasm $OUTPUT_DIR
 
       - name: Deploy branch to CI www
         continue-on-error: true

.github/workflows/ci-docs.yml

@@ -13,11 +13,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler git python3 && sudo apt-get update --fix-missing
-      - name: Install pip3
-        run: sudo apt install -y python3-pip  
-      - name: Install Python3 modules
-        run: sudo pip3 install pandas tabulate
+        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
       - name: Install rsync
         run: sudo apt-get install rsync
       - uses: rlespinasse/github-slug-action@v3.x
@@ -38,25 +34,9 @@ jobs:
       - name: Remove existing Nym config directory (`~/.nym/`)
         run: cd documentation && ./remove_existing_config.sh
         continue-on-error: false
-
-# This is the original flow
-#      - name: Build all projects in documentation/ & move to ~/dist/docs/
-#        run: cd documentation && ./build_all_to_dist.sh
-
-# This is a workaround replacement which builds on the last working commit b332a6b55668f60988e36961f3f62a794ba82ddb and then on current branch
-      - name: Save current branch to ~/current_branch
-        run: git rev-parse --abbrev-ref HEAD > ~/current_branch
-      - name: Git pull & switch to b332a6b55668f60988e36961f3f62a794ba82ddb
-        run: git pull && git checkout b332a6b55668f60988e36961f3f62a794ba82ddb
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ from b332a6b55668f60988e36961f3f62a794ba82ddb
+      - name: Build all projects in documentation/ & move to ~/dist/docs/
         run: cd documentation && ./build_all_to_dist.sh
-
-      - name: Switch to current branch
-        run: git checkout $echo "$(cat ~/current_branch)"
-      - name: Build all projects in documentation/ & move to ~/dist/docs/ on current branch
-        run: cd documentation && ./build_all_to_dist.sh && rm ~/current_branch
-
-# End of replacemet
+        continue-on-error: false
 
       - name: Deploy branch to CI www
         continue-on-error: true

.github/workflows/publish-nym-binaries.yml

@@ -30,7 +30,6 @@ jobs:
       mixnode_hash: ${{ steps.binary-hashes.outputs.mixnode_hash }}
       gateway_hash: ${{ steps.binary-hashes.outputs.gateway_hash }}
       nymvisor_hash: ${{ steps.binary-hashes.outputs.nymvisor_hash }}
-      nymnode_hash: ${{ steps.binary-hashes.outputs.nymnode_hash }}
       socks5_hash: ${{ steps.binary-hashes.outputs.socks5_hash }}
       netreq_hash: ${{ steps.binary-hashes.outputs.netreq_hash }}
       cli_hash: ${{ steps.binary-hashes.outputs.cli_hash }}
@@ -39,7 +38,6 @@ jobs:
       mixnode_version: ${{ steps.binary-versions.outputs.mixnode_version }}
       gateway_version: ${{ steps.binary-versions.outputs.gateway_version }}
       nymvisor_version: ${{ steps.binary-versions.outputs.nymvisor_version }}
-      nymnode_version: ${{ steps.binary-versions.outputs.nymnode_version }}
       socks5_version: ${{ steps.binary-versions.outputs.socks5_version }}
       netreq_version: ${{ steps.binary-versions.outputs.netreq_version }}
       cli_version: ${{ steps.binary-versions.outputs.cli_version }}
@@ -83,7 +81,6 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
             target/release/nymvisor
-            target/release/nym-node
           retention-days: 30
 
       - id: create-release
@@ -102,7 +99,6 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
             target/release/nymvisor
-            target/release/nym-node
 
   push-release-data-client:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}

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

@@ -102,18 +102,6 @@ jobs:
             nym-wallet/target/release/bundle/dmg/*.dmg
             nym-wallet/target/release/bundle/macos/*.app.tar.gz*
 
-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"            
-
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml

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

@@ -77,18 +77,6 @@ jobs:
             nym-wallet/target/release/bundle/appimage/*.AppImage
             nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz*
 
-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"               
-
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml

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

@@ -97,18 +97,6 @@ jobs:
             nym-wallet/target/release/bundle/msi/*.msi
             nym-wallet/target/release/bundle/msi/*.msi.zip*
 
-      - name: Deploy artifacts to CI www
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-avzr"
-          SOURCE: "nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
-          EXCLUDE: "/dist/, /node_modules/"            
-
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
     uses: ./.github/workflows/release-calculate-hash.yml

CHANGELOG.md

@@ -4,30 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
-## [2024.4-nutella] (2024-05-08)
-
-- [fix] apply disable_poisson_rate from internal NR/IPR cfgs ([#4579])
-- updating sign commands to include nym-node ([#4578])
-- changed nym-node redirects from 308 'Permanent Redirect' to 303: 'See Other' ([#4572])
-
-[#4579]: https://github.com/nymtech/nym/pull/4579
-[#4578]: https://github.com/nymtech/nym/pull/4578
-[#4572]: https://github.com/nymtech/nym/pull/4572
-
-## [2024.3-eclipse] (2024-04-22)
-
-- Initial release of the first iteration of the Nym Node
-- Improvements to gateway functionality
-- IPR development
-- Removal of allow list in favour of implementing an exit policy
-- Explorer delegation: enables direct delegation to nodes via the Nym Explorer
-
-
-## [2024.2-fast-and-furious] (2024-03-25)
-
-- Internal testing pre-release 
-
-
 ## [2024.1-marabou] (2024-02-15)
 
 **New Features:**

Cargo.toml

@@ -122,7 +122,6 @@ members = [
     #    "wasm/full-nym-wasm",
     "wasm/mix-fetch",
     "wasm/node-tester",
-    "wasm/zknym-lib",
 ]
 
 default-members = [
@@ -159,142 +158,44 @@ edition = "2021"
 license = "Apache-2.0"
 
 [workspace.dependencies]
-addr = "0.15.6"
-aes = "0.8.1"
-aes-gcm = "0.10.1"
 anyhow = "1.0.71"
-argon2 = "0.5.0"
 async-trait = "0.1.68"
-axum = "0.7.5"
-axum-extra = "0.9.3"
+axum = "0.6.20"
 base64 = "0.21.4"
-bincode = "1.3.3"
-bip39 = { version = "2.0.0", features = ["zeroize"] }
-bitvec = "1.0.0"
-blake3 = "1.3.1"
 bs58 = "0.5.0"
-bytecodec = "0.4.15"
-bytes = "1.5.0"
-cargo_metadata = "0.18.1"
-celes = "2.4.0"
-cfg-if = "1.0.0"
-chacha20 = "0.9.0"
-chacha20poly1305 = "0.10.1"
-chrono = "0.4.31"
-cipher = "0.4.3"
+bip39 = { version = "2.0.0", features = ["zeroize"] }
 clap = "4.4.7"
-clap_complete = "4.0"
-clap_complete_fig = "4.0"
-colored = "2.0"
-comfy-table = "6.0.0"
-console-subscriber = "0.1.1"
-console_error_panic_hook = "0.1"
-const-str = "0.5.6"
-const_format = "0.2.32"
-criterion = "0.4"
-csv = "1.3.0"
-ctr = "0.9.1"
-cupid = "0.6.1"
-curve25519-dalek = "3.2"
+cfg-if = "1.0.0"
 dashmap = "5.5.3"
-defguard_wireguard_rs = { git = "https://github.com/neacsu/wireguard-rs.git", rev = "c2cd0c1119f699f4bc43f5e6ffd6fc242caa42ed" }
-doc-comment = "0.3"
 dotenvy = "0.15.6"
-ecdsa = "0.16"
-ed25519-dalek = "1.0"
-etherparse = "0.13.0"
-eyre = "0.6.9"
-flate2 = "1.0.28"
 futures = "0.3.28"
 generic-array = "0.14.7"
 getrandom = "0.2.10"
-getset = "0.1.1"
-handlebars = "3.5.5"
-headers = "0.4.0"
-hex = "0.4.3"
-hex-literal = "0.3.3"
-hkdf = "0.12.3"
-hmac = "0.12.1"
-httpcodec = "0.2.3"
-humantime = "2.1.0"
 humantime-serde = "1.1.1"
-http = "1"
-hyper = "1.3.1"
-indexed_db_futures = "0.3.0"
-inquire = "0.6.2"
-ip_network = "0.4.1"
-isocountry = "0.3.2"
+hyper = "0.14.27"
 k256 = "0.13"
 lazy_static = "1.4.0"
-ledger-transport = "0.10.0"
-ledger-transport-hid = "0.10.0"
 log = "0.4"
-maxminddb = "0.23.0"
-mime = "0.3.17"
-nix = "0.27.1"
-notify = "5.1.0"
-okapi = "0.7.0"
 once_cell = "1.7.2"
-opentelemetry = "0.19.0"
-opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.1"
-pem = "0.8"
-pin-project = "1.0"
-pretty_env_logger = "0.4.0"
-publicsuffix = "2.2.3"
-quote = "1"
 rand = "0.8.5"
-rand-07 = "0.7.3"
-rand_chacha_02 = "0.2"
-rand_core = "0.6.3"
-rand_distr = "0.3"
-rand_pcg = "0.3.1"
-rand_seeder = "0.2.3"
-rayon = "1.5.1"
-regex = "1.8.4"
-reqwest = { version = "0.12.4", default-features = false }
-rocket = "0.5.0"
-rocket_cors = "0.6.0"
-rocket_okapi = "0.8.0"
-safer-ffi = "0.1.4"
+reqwest = { version = "0.11.22", default-features = false }
 schemars = "0.8.1"
 serde = "1.0.152"
-serde_bytes = "0.11.6"
-serde_derive = "1.0"
 serde_json = "1.0.91"
-serde_repr = "0.1"
-serde_with = "3.4.0"
-serde_yaml = "0.9.25"
-si-scale = "0.2.2"
-sphinx-packet = "0.1.0"
 sqlx = "0.6.3"
-strum = "0.25"
-subtle-encoding = "0.5"
-syn = "1"
 tap = "1.0.1"
-tar = "0.4.40"
-tempfile = "3.5.0"
-thiserror = "1.0.48"
 time = "0.3.30"
+thiserror = "1.0.48"
 tokio = "1.33.0"
-tokio-stream = "0.1.14"
-tokio-test = "0.4.2"
-tokio-tungstenite = { version = "0.20.1" }
 tokio-util = "0.7.10"
-tower = "0.4.13"
-tower-http = "0.5.2"
+tokio-tungstenite = { version = "0.20.1" }
 tracing = "0.1.37"
-tracing-opentelemetry = "0.19.0"
-tracing-subscriber = "0.3.16"
-tracing-tree = "0.2.2"
-ts-rs = "7.0.0"
 tungstenite = { version = "0.20.1", default-features = false }
+ts-rs = "7.0.0"
+utoipa = "3.5.0"
+utoipa-swagger-ui = "3.1.5"
 url = "2.4"
-utoipa = "4.2.0"
-utoipa-swagger-ui = "6.0.0"
-vergen = { version = "=8.2.6", default-features = false }
-walkdir = "2"
-wasm-bindgen-test = "0.3.36"
 zeroize = "1.6.0"
 
 prometheus = { version = "0.13.0" }
@@ -306,6 +207,7 @@ bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch = "feature/g
 group = "0.13.0"
 ff = "0.13.0"
 
+
 # cosmwasm-related
 cosmwasm-derive = "=1.4.3"
 cosmwasm-schema = "=1.4.3"
@@ -333,16 +235,14 @@ tendermint-rpc = "0.34" # same version as used by cosmrs
 prost = "0.12"
 
 # wasm-related dependencies
-gloo-utils = "0.2.0"
-gloo-net = "0.5.0"
-js-sys = "0.3.69"
-serde-wasm-bindgen = "0.6.5"
+gloo-utils = "0.1.7"
+js-sys = "0.3.63"
+serde-wasm-bindgen = "0.5.0"
 tsify = "0.4.5"
-wasm-bindgen = "0.2.92"
-wasm-bindgen-futures = "0.4.39"
+wasm-bindgen = "0.2.86"
+wasm-bindgen-futures = "0.4.37"
 wasmtimer = "0.2.0"
-web-sys = "0.3.69"
-
+web-sys = "0.3.63"
 
 # Profile settings for individual crates
 

Makefile

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

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.34"
+version = "1.1.33"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -29,7 +29,7 @@ rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits +
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
 serde_json = { workspace = true }
 thiserror = { workspace = true }
-tap = { workspace = true }
+tap = "1.0.1"
 time = { workspace = true }
 tokio = { workspace = true, features = ["rt-multi-thread", "net", "signal"] } # async runtime
 tokio-tungstenite = { workspace = true }

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.34"
+version = "1.1.33"
 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"
@@ -13,9 +13,9 @@ clap = { workspace = true, features = ["cargo", "derive"] }
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
 serde_json = { workspace = true }
-tap = { workspace = true }
+tap = "1.0.1"
 thiserror = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread", "net", "signal"] }
+tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
 rand = "0.7.3"
 time = { workspace = true }
 url = { workspace = true }

common/async-file-watcher/Cargo.toml

@@ -8,6 +8,6 @@ license.workspace = true
 
 [dependencies]
 futures = { workspace = true }
-log = { workspace = true }
-notify = { workspace = true }
+log = "0.4"
+notify = "5.1.0"
 tokio = { workspace = true, features = ["time"] }

common/bin-common/Cargo.toml

@@ -8,28 +8,40 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-const-str = { workspace = true }
+const-str = "0.5.6"
 clap = { workspace = true, features = ["derive"] }
-clap_complete = { workspace = true }
-clap_complete_fig = { workspace = true }
+clap_complete = "4.0"
+clap_complete_fig = "4.0"
 log = { workspace = true }
-pretty_env_logger = { workspace = true }
+pretty_env_logger = "0.4.0"
 semver = "0.11"
 schemars = { workspace = true, features = ["preserve_order"], optional = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
 
 ## tracing
-tracing-subscriber = { workspace = true, features = ["env-filter"], optional = true }
-tracing-tree = { workspace = true, optional = true }
-opentelemetry-jaeger = { workspace = true, features = ["rt-tokio", "collector_client", "isahc_collector_client"], optional = true }
-tracing-opentelemetry = { workspace = true, optional = true }
+tracing-subscriber = { version = "0.3.16", features = [
+    "env-filter",
+], optional = true }
+tracing-tree = { version = "0.2.2", optional = true }
+opentelemetry-jaeger = { version = "0.18.0", optional = true, features = [
+    "rt-tokio",
+    "collector_client",
+    "isahc_collector_client",
+] }
+tracing-opentelemetry = { version = "0.19.0", optional = true }
 utoipa = { workspace = true, optional = true }
-opentelemetry = { workspace = true, features = ["rt-tokio"], optional = true }
+opentelemetry = { version = "0.19.0", optional = true, features = ["rt-tokio"] }
 
 
 [build-dependencies]
-vergen = { workspace = true, features = ["build", "git", "gitcl", "rustc", "cargo"] }
+vergen = { version = "=8.2.6", default-features = false, features = [
+    "build",
+    "git",
+    "gitcl",
+    "rustc",
+    "cargo",
+] }
 
 [features]
 default = []

common/client-core/Cargo.toml

@@ -3,7 +3,7 @@ name = "nym-client-core"
 version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
-rust-version = "1.70"
+rust-version = "1.66"
 license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -12,7 +12,7 @@ license.workspace = true
 async-trait = { workspace = true }
 base64 = "0.21.2"
 bs58 = { workspace = true }
-cfg-if = { workspace = true }
+cfg-if = "1.0.0"
 clap = { workspace = true, optional = true }
 futures = { workspace = true }
 humantime-serde = { workspace = true }
@@ -21,10 +21,11 @@ rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = "0.10.6"
-si-scale = { workspace = true }
-tap = { workspace = true }
+si-scale = "0.2.2"
+tap = "1.0.1"
 thiserror = { workspace = true }
 url = { workspace = true, features = ["serde"] }
+tungstenite = { workspace = true, default-features = false }
 tokio = { workspace = true, features = ["macros"] }
 time = { workspace = true }
 zeroize = { workspace = true }
@@ -47,7 +48,7 @@ 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" }
-nym-client-core-config-types = { path = "./config-types", features = ["disk-persistence"] }
+nym-client-core-config-types = { path = "./config-types", features = ["disk-persistence"]}
 nym-client-core-surb-storage = { path = "./surb-storage" }
 nym-client-core-gateways-storage = { path = "./gateways-storage" }
 
@@ -73,17 +74,8 @@ workspace = true
 features = ["time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
-workspace = true
-features = ["rustls-tls-webpki-roots"]
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tungstenite]
-workspace = true
-default-features = true
-features = ["rustls-tls-webpki-roots"]
-
-[target."cfg(target_arch = \"wasm32\")".dependencies.tungstenite]
-workspace = true
-default-features = false
+version = "0.20.1"
+features = ["rustls-tls-native-roots"]
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
 workspace = true
@@ -108,7 +100,7 @@ version = "0.3.17"
 features = ["wasm-bindgen"]
 
 [dev-dependencies]
-tempfile = { workspace = true }
+tempfile = "3.1.0"
 
 [features]
 default = []

common/client-core/config-types/src/error.rs

@@ -8,12 +8,3 @@ use thiserror::Error;
 pub struct ConfigUpgradeFailure {
     pub current_version: String,
 }
-
-#[derive(Error, Debug)]
-pub enum InvalidTrafficModeFailure {
-    #[error("attempted to set medium toggle traffic mode with fast mode flag")]
-    MediumToggleWithFastMode,
-
-    #[error("attempted to set medium toggle traffic mode with no cover flag")]
-    MediumToggleWithNoCover,
-}

common/client-core/config-types/src/lib.rs

@@ -56,7 +56,6 @@ const DEFAULT_MAXIMUM_REPLY_SURB_AGE: Duration = Duration::from_secs(12 * 60 * 6
 // 24 hours
 const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60);
 
-use crate::error::InvalidTrafficModeFailure;
 pub use nym_country_group::CountryGroup;
 
 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
@@ -128,56 +127,6 @@ impl Config {
         self
     }
 
-    // TODO: this should be refactored properly
-    // as of 12.09.23 the below is true (not sure how this comment will rot in the future)
-    // medium_toggle:
-    // - sets secondary packet size to 16kb
-    // - disables poisson distribution of the main traffic stream
-    // - sets the cover traffic stream to 1 packet / 5s (on average)
-    // - disables per hop delay
-    //
-    // fastmode (to be renamed to `fast-poisson`):
-    // - sets average per hop delay to 10ms
-    // - sets the cover traffic stream to 1 packet / 2000s (on average); for all intents and purposes it disables the stream
-    // - sets the poisson distribution of the main traffic stream to 4ms, i.e. 250 packets / s on average
-    //
-    // no_cover:
-    // - disables poisson distribution of the main traffic stream
-    // - disables the secondary cover traffic stream
-    #[doc(hidden)]
-    pub fn try_apply_traffic_modes(
-        &mut self,
-        disable_poisson_process: bool,
-        medium_toggle: bool,
-        fast_mode: bool,
-        no_cover: bool,
-    ) -> Result<(), InvalidTrafficModeFailure> {
-        if disable_poisson_process {
-            self.set_no_poisson_process()
-        }
-
-        if medium_toggle {
-            if fast_mode {
-                return Err(InvalidTrafficModeFailure::MediumToggleWithFastMode);
-            }
-            if no_cover {
-                return Err(InvalidTrafficModeFailure::MediumToggleWithNoCover);
-            }
-
-            self.set_experimental_medium_toggle();
-        }
-
-        if fast_mode {
-            self.set_high_default_traffic_volume()
-        }
-
-        if no_cover {
-            self.set_no_cover_traffic();
-        }
-
-        Ok(())
-    }
-
     pub fn set_high_default_traffic_volume(&mut self) {
         self.debug.traffic.average_packet_delay = Duration::from_millis(10);
         // basically don't really send cover messages
@@ -187,15 +136,6 @@ impl Config {
         self.debug.traffic.message_sending_average_delay = Duration::from_millis(4);
     }
 
-    /// Enable medium mixnet traffic, for experiments only.
-    /// This includes things like disabling cover traffic, no per hop delays, etc.
-    #[doc(hidden)]
-    pub fn set_experimental_medium_toggle(&mut self) {
-        self.set_no_cover_traffic_with_keepalive();
-        self.set_no_per_hop_delays();
-        self.debug.traffic.secondary_packet_size = Some(PacketSize::ExtendedPacket16);
-    }
-
     pub fn with_disabled_poisson_process(mut self, disabled: bool) -> Self {
         if disabled {
             self.set_no_poisson_process()

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

@@ -39,7 +39,7 @@ use log::{debug, error, info, warn};
 use nym_bandwidth_controller::BandwidthController;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewaysDetailsStore};
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::{encryption, identity};
+use nym_crypto::asymmetric::encryption;
 use nym_gateway_client::{
     AcknowledgementReceiver, GatewayClient, GatewayConfig, MixnetMessageReceiver, PacketRouter,
 };
@@ -670,7 +670,6 @@ where
         let self_address = Self::mix_address(&init_res);
         let ack_key = init_res.client_keys.ack_key();
         let encryption_keys = init_res.client_keys.encryption_keypair();
-        let identity_keys = init_res.client_keys.identity_keypair();
 
         // the components are started in very specific order. Unless you know what you are doing,
         // do not change that.
@@ -793,7 +792,6 @@ where
 
         Ok(BaseClient {
             address: self_address,
-            identity_keys,
             client_input: ClientInputStatus::AwaitingProducer {
                 client_input: ClientInput {
                     connection_command_sender: client_connection_tx,
@@ -818,7 +816,6 @@ where
 
 pub struct BaseClient {
     pub address: Recipient,
-    pub identity_keys: Arc<identity::KeyPair>,
     pub client_input: ClientInputStatus,
     pub client_output: ClientOutputStatus,
     pub client_state: ClientState,

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::client::mix_traffic::transceiver::GatewayTransceiver;
+use crate::error::ClientCoreError;
 use crate::spawn_future;
 use log::*;
 use nym_sphinx::forwarding::packet::MixPacket;
@@ -60,8 +61,15 @@ impl MixTrafficController {
         )
     }
 
-    async fn on_messages(&mut self, mut mix_packets: Vec<MixPacket>) {
+    async fn on_messages(
+        &mut self,
+        mut mix_packets: Vec<MixPacket>,
+    ) -> Result<(), ClientCoreError> {
         debug_assert!(!mix_packets.is_empty());
+        info!(
+            "JON: MixTrafficController: Sending {} sphinx packets to the gateway",
+            mix_packets.len()
+        );
 
         let result = if mix_packets.len() == 1 {
             let mix_packet = mix_packets.pop().unwrap();
@@ -72,42 +80,56 @@ impl MixTrafficController {
                 .await
         };
 
-        match result {
+        let r = match result {
             Err(err) => {
                 error!("Failed to send sphinx packet(s) to the gateway: {err}");
                 self.consecutive_gateway_failure_count += 1;
                 if self.consecutive_gateway_failure_count == MAX_FAILURE_COUNT {
-                    // todo: in the future this should initiate a 'graceful' shutdown or try
-                    // to reconnect?
-                    panic!("failed to send sphinx packet to the gateway {MAX_FAILURE_COUNT} times in a row - assuming the gateway is dead. Can't do anything about it yet :(")
+                    Err(ClientCoreError::GatewayMaxRetriesExceeded)
+                } else {
+                    Err(ClientCoreError::GatewayClientSendError {
+                        gateway_client_error: err.to_string(),
+                    })
                 }
             }
             Ok(_) => {
                 trace!("We *might* have managed to forward sphinx packet(s) to the gateway!");
                 self.consecutive_gateway_failure_count = 0;
+                Ok(())
             }
-        }
+        };
+        info!("JON: MixTrafficController: done sending sphinx packets to the gateway");
+        r
     }
 
     pub fn start_with_shutdown(mut self, mut shutdown: nym_task::TaskClient) {
         spawn_future(async move {
             debug!("Started MixTrafficController with graceful shutdown support");
 
+            // let mut shutdown0 = shutdown.recv_with_delay();
+            // tokio::pin!(shutdown0);
+
             loop {
                 tokio::select! {
+                    biased;
+                    _ = shutdown.recv_with_delay() => {
+                    // _ = &mut shutdown0 => {
+                        log::trace!("MixTrafficController: Received shutdown");
+                        break;
+                    }
                     mix_packets = self.mix_rx.recv() => match mix_packets {
                         Some(mix_packets) => {
-                            self.on_messages(mix_packets).await;
+                            log::info!("JON: MixTrafficController: mix_rx recv");
+                            if let Err(err) = self.on_messages(mix_packets).await {
+                                log::error!("MixTrafficController: failed to send mix packets to the gateway: {err}");
+                            }
+                            log::info!("JON: MixTrafficController: done with mix_rx recv");
                         },
                         None => {
                             log::trace!("MixTrafficController: Stopping since channel closed");
                             break;
                         }
                     },
-                    _ = shutdown.recv_with_delay() => {
-                        log::trace!("MixTrafficController: Received shutdown");
-                        break;
-                    }
                 }
             }
             shutdown.recv_timeout().await;

common/client-core/src/client/mix_traffic/transceiver.rs

@@ -19,6 +19,12 @@ use futures::channel::{mpsc, oneshot};
 #[error(transparent)]
 pub struct ErasedGatewayError(Box<dyn std::error::Error + Send + Sync>);
 
+impl ErasedGatewayError {
+    pub fn downcast<T: std::error::Error + 'static>(&self) -> Option<&T> {
+        self.0.downcast_ref::<T>()
+    }
+}
+
 fn erase_err<E: std::error::Error + Send + Sync + 'static>(err: E) -> ErasedGatewayError {
     ErasedGatewayError(Box::new(err))
 }
@@ -40,6 +46,7 @@ pub trait GatewaySender {
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), ErasedGatewayError> {
+        log::info!("GatewaySender::batch_send_mix_packets - sending {} packets", packets.len());
         // allow for optimisation when sending multiple packets
         for packet in packets {
             self.send_mix_packet(packet).await?;
@@ -78,7 +85,10 @@ impl<G: GatewayTransceiver + ?Sized + Send> GatewayTransceiver for Box<G> {
 impl<G: GatewaySender + ?Sized + Send> GatewaySender for Box<G> {
     #[inline]
     async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
-        (**self).send_mix_packet(packet).await
+        log::info!("JON: Box<GatewaySender>::send_mix_packet - sending a packet");
+        let r = (**self).send_mix_packet(packet).await;
+        log::info!("JON: Box<GatewaySender>::send_mix_packet - sent a packet");
+        r
     }
 
     #[inline]
@@ -86,7 +96,10 @@ impl<G: GatewaySender + ?Sized + Send> GatewaySender for Box<G> {
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), ErasedGatewayError> {
-        (**self).batch_send_mix_packets(packets).await
+        log::info!("JON: Box<GatewaySender>::batch_send_mix_packets - sending {} packets", packets.len());
+        let r = (**self).batch_send_mix_packets(packets).await;
+        log::info!("JON: Box<GatewaySender>::batch_send_mix_packets - sent packets");
+        r
     }
 }
 
@@ -130,20 +143,26 @@ where
     St: Send,
 {
     async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
-        self.gateway_client
+        log::info!("JON: RemoteGateway::send_mix_packet - sending a packet");
+        let r = self.gateway_client
             .send_mix_packet(packet)
             .await
-            .map_err(erase_err)
+            .map_err(erase_err);
+        log::info!("JON: RemoteGateway::send_mix_packet - sent a packet");
+        r
     }
 
     async fn batch_send_mix_packets(
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), ErasedGatewayError> {
-        self.gateway_client
+        log::info!("JON: RemoteGateway::batch_send_mix_packets - sending {} packets", packets.len());
+        let r = self.gateway_client
             .batch_send_mix_packets(packets)
             .await
-            .map_err(erase_err)
+            .map_err(erase_err);
+        log::info!("JON: RemoteGateway::batch_send_mix_packets - sent packets");
+        r
     }
 }
 
@@ -203,10 +222,13 @@ mod nonwasm_sealed {
     #[async_trait]
     impl GatewaySender for LocalGateway {
         async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
-            self.packet_forwarder
+            log::info!("JON: LocalGateway::send_mix_packet - sending a packet");
+            let r = self.packet_forwarder
                 .unbounded_send(packet)
                 .map_err(|err| err.into_send_error())
-                .map_err(erase_err)
+                .map_err(erase_err);
+            log::info!("JON: LocalGateway::send_mix_packet - sent a packet");
+            r
         }
     }
 
@@ -261,6 +283,7 @@ impl GatewayReceiver for MockGateway {
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl GatewaySender for MockGateway {
     async fn send_mix_packet(&mut self, packet: MixPacket) -> Result<(), ErasedGatewayError> {
+        log::info!("MockGateway::send_mix_packet - sending a packet");
         self.sent.push(packet);
         Ok(())
     }

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

@@ -632,15 +632,23 @@ where
     }
 
     pub(crate) fn update_ack_delay(&self, id: FragmentIdentifier, new_delay: Delay) {
-        self.action_sender
+        if self
+            .action_sender
             .unbounded_send(Action::UpdateDelay(id, new_delay))
-            .expect("action control task has died")
+            .is_err()
+        {
+            log::debug!("action control task has died");
+        }
     }
 
     pub(crate) fn insert_pending_acks(&self, pending_acks: Vec<PendingAcknowledgement>) {
-        self.action_sender
+        if self
+            .action_sender
             .unbounded_send(Action::new_insert(pending_acks))
-            .expect("action control task has died")
+            .is_err()
+        {
+            log::debug!("action control task has died");
+        }
     }
 
     // tells real message sender (with the poisson timer) to send this to the mix network

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

@@ -198,7 +198,9 @@ where
         // queues and client load rather than the required delay. So realistically we can treat
         // whatever is about to happen as negligible additional delay.
         trace!("{} is about to get sent to the mixnet", frag_id);
-        self.sent_notifier.unbounded_send(frag_id).unwrap();
+        if self.sent_notifier.unbounded_send(frag_id).is_err() {
+            debug!("Failed to notify about sent packet");
+        }
     }
 
     fn loop_cover_message_size(&mut self) -> PacketSize {
@@ -270,7 +272,8 @@ where
         };
 
         if let Err(err) = self.mix_tx.send(vec![next_message]).await {
-            log::error!("Failed to send: {err}");
+            log::debug!("Failed to send: {err}");
+            return;
         } else {
             let event = if fragment_id.is_some() {
                 PacketStatisticsEvent::RealPacketSent(packet_size)

common/client-core/src/error.rs

@@ -78,6 +78,9 @@ pub enum ClientCoreError {
         source: tungstenite::Error,
     },
 
+    #[error("max number of retries for gateway connection has been exceeded")]
+    GatewayMaxRetriesExceeded,
+
     #[cfg(target_arch = "wasm32")]
     #[error("failed to establish gateway connection (wasm)")]
     GatewayJsConnectionFailure,
@@ -88,6 +91,11 @@ pub enum ClientCoreError {
     #[error("timed out while trying to establish gateway connection")]
     GatewayConnectionTimeout,
 
+    #[error("failed to send sphinx packet to the gateway: {gateway_client_error}")]
+    GatewayClientSendError {
+        gateway_client_error: String,
+    },
+
     #[error("no ping measurements for the gateway ({identity}) performed")]
     NoGatewayMeasurements { identity: String },
 

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

@@ -15,8 +15,8 @@ log = { workspace = true }
 thiserror = { workspace = true }
 url = { workspace = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-tokio = { workspace = true, features = ["macros"] }
-si-scale = { workspace = true }
+tokio = { version = "1.24.1", features = ["macros"] }
+si-scale = "0.2.2"
 time.workspace = true
 
 # internal
@@ -48,7 +48,10 @@ features = ["net", "sync", "time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
 workspace = true
-features = ["rustls-tls-webpki-roots"]
+# the choice of this particular tls feature was arbitrary;
+# if you reckon a different one would be more appropriate, feel free to change it
+# features = ["native-tls"]
+features = ["rustls-tls-native-roots"]
 
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]

common/client-libs/gateway-client/src/client.rs

@@ -333,6 +333,7 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         msg: Message,
     ) -> Result<ServerResponse, GatewayClientError> {
+        log::info!("JON: GatewayClient: send_websocket_message");
         let should_restart_mixnet_listener = if self.connection.is_partially_delegated() {
             self.recover_socket_connection().await?;
             true
@@ -351,6 +352,7 @@ impl<C, St> GatewayClient<C, St> {
         if should_restart_mixnet_listener {
             self.start_listening_for_mixnet_messages()?;
         }
+        log::info!("JON: GatewayClient: send_websocket_message done");
         response
     }
 
@@ -358,7 +360,8 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         messages: Vec<Message>,
     ) -> Result<(), GatewayClientError> {
-        match self.connection {
+        log::info!("JON: GatewayClient: batch_send_websocket_messages_without_response"); 
+        let r = match self.connection {
             SocketState::Available(ref mut conn) => {
                 let stream_messages: Vec<_> = messages.into_iter().map(Ok).collect();
                 let mut send_stream = futures::stream::iter(stream_messages);
@@ -381,14 +384,17 @@ impl<C, St> GatewayClient<C, St> {
             }
             SocketState::NotConnected => Err(GatewayClientError::ConnectionNotEstablished),
             _ => Err(GatewayClientError::ConnectionInInvalidState),
-        }
+        };
+        log::info!("JON: GatewayClient: batch_send_websocket_messages_without_response done");
+        r
     }
 
     async fn send_websocket_message_without_response(
         &mut self,
         msg: Message,
     ) -> Result<(), GatewayClientError> {
-        match self.connection {
+        log::info!("JON: GatewayClient: send_websocket_message_without_response");
+        let r = match self.connection {
             SocketState::Available(ref mut conn) => Ok(conn.send(msg).await?),
             SocketState::PartiallyDelegated(ref mut partially_delegated) => {
                 if let Err(err) = partially_delegated.send_without_response(msg).await {
@@ -404,7 +410,9 @@ impl<C, St> GatewayClient<C, St> {
             }
             SocketState::NotConnected => Err(GatewayClientError::ConnectionNotEstablished),
             _ => Err(GatewayClientError::ConnectionInInvalidState),
-        }
+        };
+        log::info!("JON: GatewayClient: send_websocket_message_without_response done");
+        r
     }
 
     fn check_gateway_protocol(
@@ -442,7 +450,7 @@ impl<C, St> GatewayClient<C, St> {
         }
 
         debug_assert!(self.connection.is_available());
-        log::debug!("Registering gateway");
+        log::trace!("Registering gateway");
 
         // it's fine to instantiate it here as it's only used once (during authentication or registration)
         // and putting it into the GatewayClient struct would be a hassle
@@ -494,7 +502,6 @@ impl<C, St> GatewayClient<C, St> {
         if !self.connection.is_established() {
             return Err(GatewayClientError::ConnectionNotEstablished);
         }
-        log::debug!("Authenticating with gateway");
 
         // it's fine to instantiate it here as it's only used once (during authentication or registration)
         // and putting it into the GatewayClient struct would be a hassle
@@ -530,7 +537,6 @@ impl<C, St> GatewayClient<C, St> {
                 self.authenticated = status;
                 self.bandwidth_remaining = bandwidth_remaining;
                 self.negotiated_protocol = protocol_version;
-                log::debug!("authenticated: {status}, bandwidth remaining: {bandwidth_remaining}");
                 Ok(())
             }
             ServerResponse::Error { message } => Err(GatewayClientError::GatewayError(message)),
@@ -543,11 +549,10 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
     ) -> Result<Arc<SharedKeys>, GatewayClientError> {
         if self.authenticated {
-            debug!("Already authenticated");
             return if let Some(shared_key) = &self.shared_key {
                 Ok(Arc::clone(shared_key))
             } else {
-                Err(GatewayClientError::AuthenticationFailureWithPreexistingSharedKey)
+                Err(GatewayClientError::AuthenticationFailure)
             };
         }
 
@@ -661,6 +666,7 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         packets: Vec<MixPacket>,
     ) -> Result<(), GatewayClientError> {
+        info!("JON: GatewayClient: batch_send_mix_packets");
         debug!("Sending {} mix packets", packets.len());
 
         if !self.authenticated {
@@ -687,10 +693,11 @@ impl<C, St> GatewayClient<C, St> {
             })
             .collect();
 
-        if let Err(err) = self
+        let r = if let Err(err) = self
             .batch_send_websocket_messages_without_response(messages)
             .await
         {
+            log::error!("GatewayClient: Failed to send sphinx packets to the gateway: {err}");
             if err.is_closed_connection() && self.should_reconnect_on_failure {
                 self.attempt_reconnection().await
             } else {
@@ -698,14 +705,17 @@ impl<C, St> GatewayClient<C, St> {
             }
         } else {
             Ok(())
-        }
+        };
+        log::info!("JON: GatewayClient: batch_send_mix_packets done");
+        r
     }
 
     async fn send_with_reconnection_on_failure(
         &mut self,
         msg: Message,
     ) -> Result<(), GatewayClientError> {
-        if let Err(err) = self.send_websocket_message_without_response(msg).await {
+        log::info!("JON: GatewayClient: send_with_reconnection_on_failure");
+        let r = if let Err(err) = self.send_websocket_message_without_response(msg).await {
             if err.is_closed_connection() && self.should_reconnect_on_failure {
                 debug!("Going to attempt a reconnection");
                 self.attempt_reconnection().await
@@ -715,7 +725,9 @@ impl<C, St> GatewayClient<C, St> {
             }
         } else {
             Ok(())
-        }
+        };
+        log::info!("JON: GatewayClient: send_with_reconnection_on_failure done");
+        r
     }
 
     pub async fn send_ping_message(&mut self) -> Result<(), GatewayClientError> {
@@ -734,6 +746,7 @@ impl<C, St> GatewayClient<C, St> {
         &mut self,
         mix_packet: MixPacket,
     ) -> Result<(), GatewayClientError> {
+        log::info!("JON: GatewayClient: send_mix_packet");
         if !self.authenticated {
             return Err(GatewayClientError::NotAuthenticated);
         }
@@ -753,7 +766,9 @@ impl<C, St> GatewayClient<C, St> {
                 .as_ref()
                 .expect("no shared key present even though we're authenticated!"),
         );
-        self.send_with_reconnection_on_failure(msg).await
+        let r = self.send_with_reconnection_on_failure(msg).await;
+        log::info!("JON: GatewayClient: send_mix_packet done");
+        r
     }
 
     async fn recover_socket_connection(&mut self) -> Result<(), GatewayClientError> {

common/client-libs/gateway-client/src/error.rs

@@ -71,12 +71,12 @@ pub enum GatewayClientError {
     #[error("Authentication failure")]
     AuthenticationFailure,
 
-    #[error("Authentication failure with preexisting shared key")]
-    AuthenticationFailureWithPreexistingSharedKey,
-
     #[error("Timed out")]
     Timeout,
 
+    #[error("timeout sending ws message to the gateway")]
+    TimeoutOnSendingWs,
+
     #[error("Failed to send mixnet message")]
     MixnetMsgSenderFailedToSend,
 
@@ -96,6 +96,7 @@ pub enum GatewayClientError {
 
 impl GatewayClientError {
     pub fn is_closed_connection(&self) -> bool {
+        log::info!("GatewayClientError::is_closed_connection");
         match self {
             GatewayClientError::NetworkError(ws_err) => match ws_err {
                 WsError::AlreadyClosed | WsError::ConnectionClosed => true,

common/client-libs/gateway-client/src/socket_state.rs

@@ -158,6 +158,9 @@ impl PartiallyDelegated {
                     _ = shutdown.recv() => {
                         log::trace!("GatewayClient listener: Received shutdown");
                         log::debug!("GatewayClient listener: Exiting");
+                        // The packet router a task client, and as such we need to make
+                        // sure it's dropped to not stall the shutdown process.
+                        // drop(packet_router);
                         return;
                     }
                     _ = &mut notify_receiver => {
@@ -214,16 +217,31 @@ impl PartiallyDelegated {
         &mut self,
         msg: Message,
     ) -> Result<(), GatewayClientError> {
-        Ok(self.sink_half.send(msg).await?)
+        log::info!("JON: PartiallyDelegated::send_without_response - sending a message");
+        // let r = self.sink_half.send(msg).await;
+        // Ok(r?)
+        let r = tokio::time::timeout(Duration::from_secs(3), self.sink_half.send(msg)).await;
+        let rr = match r {
+            Ok(rr) => Ok(rr?),
+            Err(_) => {
+                log::error!("JON: PartiallyDelegated::send_without_response - timeout sending a message");
+                Err(GatewayClientError::TimeoutOnSendingWs)
+            }
+        };
+        log::info!("JON: PartiallyDelegated::send_without_response - sent a message: {rr:?}");
+        rr
     }
 
     pub(crate) async fn batch_send_without_response(
         &mut self,
         messages: Vec<Message>,
     ) -> Result<(), GatewayClientError> {
+        log::info!("JON: PartiallyDelegated::batch_send_without_response - sending {} messages", messages.len());
         let stream_messages: Vec<_> = messages.into_iter().map(Ok).collect();
         let mut send_stream = futures::stream::iter(stream_messages);
-        Ok(self.sink_half.send_all(&mut send_stream).await?)
+        let r = Ok(self.sink_half.send_all(&mut send_stream).await?);
+        log::info!("JON: PartiallyDelegated::batch_send_without_response - sent messages");
+        r
     }
 
     pub(crate) async fn merge(self) -> Result<WsConn, GatewayClientError> {

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

@@ -10,7 +10,7 @@ license.workspace = true
 
 [dependencies]
 base64 = "0.13"
-colored = { workspace = true }
+colored = "2.0"
 
 nym-coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
 nym-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
@@ -24,6 +24,7 @@ nym-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contr
 nym-service-provider-directory-common = { path = "../../cosmwasm-smart-contracts/service-provider-directory" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
+reqwest = { workspace = true, features = ["json"] }
 nym-http-api-client = { path = "../../../common/http-api-client"}
 thiserror = { workspace = true }
 log = { workspace = true }
@@ -48,14 +49,14 @@ tendermint-rpc = { workspace = true }
 # of cargo's feature unification we'd get `bip32/std` meaning we'd get `std::error::Error` for the re-exported (via cosmrs) bip32::Error type
 bip32 = { workspace = true, default-features = false, features = ["std"] }
 
-eyre = { workspace = true }
+eyre = { version = "0.6" }
 cw-utils = { workspace = true }
 cw2 = { workspace = true }
 cw3 = { workspace = true }
 cw4 = { workspace = true }
 cw-controllers = { workspace = true }
 prost = { workspace = true, default-features = false }
-flate2 = { workspace = true }
+flate2 = { version = "1.0.20" }
 sha2 = { version = "0.9.5" }
 itertools = { version = "0.10" }
 zeroize = { workspace = true, features = ["zeroize_derive"] }
@@ -66,14 +67,6 @@ cosmwasm-std = { workspace = true }
 workspace = true
 features = ["tokio"]
 
-[target."cfg(target_arch = \"wasm32\")".dependencies.reqwest]
-workspace = true
-features = ["json"]
-
-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.reqwest]
-workspace = true
-features = ["json", "rustls-tls"]
-
 [dev-dependencies]
 bip39 = { workspace = true }
 cosmrs = { workspace = true, features = ["bip32"] }

common/commands/Cargo.toml

@@ -10,26 +10,26 @@ anyhow = { workspace = true }
 base64 = "0.13.0"
 bip39 = { workspace = true }
 bs58 = { workspace = true }
-comfy-table = { workspace = true }
-cfg-if = { workspace = true }
+comfy-table = "6.0.0"
+cfg-if = "1.0.0"
 clap = { workspace = true, features = ["derive"] }
-csv = { workspace = true }
+csv = "1.3.0"
 cw-utils = { workspace = true }
 futures = { workspace = true }
-handlebars = { workspace = true }
+handlebars = "3.0.1"
 humantime-serde = { workspace = true }
-inquire = { workspace = true }
+inquire = "0.6.2"
 k256 = { workspace = true, features = ["ecdsa", "sha256"] }
 log = { workspace = true }
 rand = {version = "0.6", features = ["std"] }
-serde = { workspace = true, features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 time = { workspace = true, features = ["parsing", "formatting"] }
 tokio = { workspace = true, features = ["sync"]}
 toml = "0.5.6"
 url = { workspace = true }
-tap = { workspace = true }
+tap = "1"
 zeroize = { workspace = true }
 
 cosmrs = { workspace = true }

common/commands/src/validator/mixnet/delegators/delegate_to_multiple_mixnodes.rs

@@ -157,7 +157,7 @@ async fn fetch_delegation_data(
             // If a pending undelegate tx is found, remove it from delegation map
             Undelegate { owner, mix_id, .. } => {
                 if owner == address.as_ref()
-                    && existing_delegation_map.contains_key(&mix_id.to_string())
+                    && existing_delegation_map.get(&mix_id.to_string()).is_some()
                 {
                     existing_delegation_map.remove(&mix_id.to_string());
                 }

common/config/Cargo.toml

@@ -9,7 +9,7 @@ license.workspace = true
 
 [dependencies]
 dirs = { version = "5.0.1", optional = true }
-handlebars = { workspace = true }
+handlebars = "3.5.5"
 log = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 toml = "0.7.4"

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

@@ -328,8 +328,4 @@ impl EpochState {
     pub fn is_dealing_exchange(&self) -> bool {
         matches!(self, EpochState::DealingExchange { .. })
     }
-
-    pub fn is_waiting_initialisation(&self) -> bool {
-        matches!(self, EpochState::WaitingInitialisation)
-    }
 }

common/cosmwasm-smart-contracts/contracts-common/Cargo.toml

@@ -11,7 +11,7 @@ repository = { workspace = true }
 bs58 = { workspace = true }
 cosmwasm-std = { workspace = true }
 cosmwasm-schema = { workspace = true }
-schemars = { workspace = true }
+schemars = "0.8"
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 

common/cosmwasm-smart-contracts/group-contract/Cargo.toml

@@ -10,5 +10,5 @@ license.workspace = true
 cosmwasm-schema = { workspace = true }
 cw4 = { workspace = true }
 cw-controllers = { workspace = true }
-schemars = { workspace = true }
+schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }

common/cosmwasm-smart-contracts/mixnet-contract/Cargo.toml

@@ -14,14 +14,14 @@ cosmwasm-std = { workspace = true }
 cosmwasm-schema = { workspace = true }
 cw2 = { workspace = true, optional = true }
 serde = { workspace = true, features = ["derive"] }
-serde_repr = { workspace = true }
+serde_repr = "0.1"
 
 # we still have to preserve that import for `JsonSchema` for `Layer` type (since we can't use cw_serde macro due to custom serde impl)
-schemars = { workspace = true }
+schemars = "0.8"
 thiserror = { workspace = true }
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common", version = "0.5.0" }
 serde-json-wasm = { workspace = true }
-humantime-serde = { workspace = true }
+humantime-serde = "1.1.1"
 
 # TO CHECK WHETHER STILL NEEDED:
 log = { workspace = true }

common/cosmwasm-smart-contracts/multisig-contract/Cargo.toml

@@ -13,6 +13,6 @@ cw4 = { workspace = true }
 cw-storage-plus = { workspace = true }
 cosmwasm-schema = { workspace = true }
 cosmwasm-std = { workspace = true }
-schemars = { workspace = true }
+schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
 thiserror = { workspace = true }

common/cosmwasm-smart-contracts/vesting-contract/Cargo.toml

@@ -13,7 +13,7 @@ cosmwasm-schema = { workspace = true }
 cw2 = { workspace = true, optional = true }
 mixnet-contract-common = { path = "../mixnet-contract", package = "nym-mixnet-contract-common", version = "0.6.0" }
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common", version = "0.5.0" }
-serde = { workspace = true, features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
 thiserror = { workspace = true }
 ts-rs = { workspace = true, optional = true}
 

common/credential-storage/Cargo.toml

@@ -26,4 +26,4 @@ features = [ "rt-multi-thread", "net", "signal", "fs" ]
 
 [build-dependencies]
 sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
-tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }

common/credential-storage/src/error.rs

@@ -18,7 +18,4 @@ pub enum StorageError {
 
     #[error("No unused credential in database. You need to buy at least one")]
     NoCredential,
-
-    #[error("Database unique constraint violation. Is the credential already imported?")]
-    ConstraintUnique,
 }

common/credential-storage/src/persistent_storage.rs

@@ -69,21 +69,9 @@ impl Storage for PersistentStorage {
                 bandwidth_credential.credential_data,
                 bandwidth_credential.epoch_id,
             )
-            .await
-            .map_err(|err| {
-                // There is one error we want to handle specifically.
-                // Check if database_error is `SqliteError` with code 2067 which
-                // means UNIQUE constraint violation
-                if let Some(db_error) = err.as_database_error() {
-                    if db_error.code().map_or(false, |code| code == "2067") {
-                        StorageError::ConstraintUnique
-                    } else {
-                        err.into()
-                    }
-                } else {
-                    err.into()
-                }
-            })
+            .await?;
+
+        Ok(())
     }
 
     async fn get_next_unspent_credential(

common/credential-utils/src/utils.rs

@@ -11,8 +11,11 @@ use nym_validator_client::nyxd::contract_traits::{
 };
 use nym_validator_client::nyxd::Coin;
 use std::path::PathBuf;
+use std::process::exit;
 use std::time::{Duration, SystemTime};
 
+const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute
+
 pub async fn issue_credential<C>(
     client: &C,
     amount: Coin,
@@ -89,6 +92,13 @@ where
             .as_secs();
 
         if epoch.state.is_final() {
+            if let Some(finish_timestamp) = epoch.deadline {
+                if current_timestamp_secs + SAFETY_BUFFER_SECS >= finish_timestamp.seconds() {
+                    info!("In the next {} minute(s), a transition will take place in the coconut system. Deposits should be halted in this time for safety reasons.", SAFETY_BUFFER_SECS / 60);
+                    exit(0);
+                }
+            }
+
             break;
         } else if let Some(final_timestamp) = epoch.final_timestamp_secs() {
             // Use 1 additional second to not start the next iteration immediately and spam get_current_epoch queries

common/credentials-interface/src/lib.rs

@@ -8,11 +8,11 @@ use std::str::FromStr;
 use thiserror::Error;
 
 pub use nym_coconut::{
-    aggregate_signature_shares, aggregate_signature_shares_and_verify, aggregate_verification_keys,
-    blind_sign, hash_to_scalar, keygen, prepare_blind_sign, prove_bandwidth_credential,
-    verify_credential, Attribute, Base58, BlindSignRequest, BlindedSerialNumber, BlindedSignature,
-    Bytable, CoconutError, KeyPair, Parameters, PrivateAttribute, PublicAttribute, SecretKey,
-    Signature, SignatureShare, VerificationKey, VerifyCredentialRequest,
+    aggregate_signature_shares, aggregate_verification_keys, blind_sign, hash_to_scalar, keygen,
+    prepare_blind_sign, prove_bandwidth_credential, verify_credential, Attribute, Base58,
+    BlindSignRequest, BlindedSerialNumber, BlindedSignature, Bytable, CoconutError, KeyPair,
+    Parameters, PrivateAttribute, PublicAttribute, SecretKey, Signature, SignatureShare,
+    VerificationKey, VerifyCredentialRequest,
 };
 
 pub const VOUCHER_INFO_TYPE: &str = "BandwidthVoucher";

common/credentials/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 
 [dependencies]
 bls12_381 = { workspace = true, default-features = false, features = ["pairings", "alloc", "experimental"] }
-bincode = { workspace = true }
+bincode = "1.3.3"
 cosmrs = { workspace = true }
 thiserror = { workspace = true }
 log = { workspace = true }

common/credentials/src/coconut/bandwidth/freepass.rs

@@ -12,8 +12,7 @@ use serde::{Deserialize, Serialize};
 use time::{Duration, OffsetDateTime, Time};
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
-pub const DEFAULT_FREE_PASS_VALIDITY: Duration = Duration::WEEK; // 1 week
-pub const MAX_FREE_PASS_VALIDITY: Duration = Duration::weeks(12); // 12 weeks
+pub const MAX_FREE_PASS_VALIDITY: Duration = Duration::WEEK; // 1 week
 
 #[derive(Debug, Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
 pub struct FreePassIssuedData {
@@ -78,9 +77,9 @@ impl FreePassIssuanceData {
     }
 
     pub fn default_expiry_date() -> OffsetDateTime {
-        // set it to the furthest midnight in the future such as it's no more than a week away,
+        // set it to furthest midnight in the future such as it's no more than a week away,
         // i.e. if it's currently for example 9:43 on 2nd March 2024, it will set it to 0:00 on 9th March 2024
-        (OffsetDateTime::now_utc() + DEFAULT_FREE_PASS_VALIDITY).replace_time(Time::MIDNIGHT)
+        (OffsetDateTime::now_utc() + MAX_FREE_PASS_VALIDITY).replace_time(Time::MIDNIGHT)
     }
 
     pub fn expiry_date_attribute(&self) -> &Attribute {

common/credentials/src/coconut/bandwidth/issuance.rs

@@ -10,19 +10,18 @@ use crate::coconut::bandwidth::{
 use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
 use nym_credentials_interface::{
-    aggregate_signature_shares, aggregate_signature_shares_and_verify, hash_to_scalar,
-    prepare_blind_sign, Attribute, BlindedSerialNumber, BlindedSignature, Parameters,
-    PrivateAttribute, PublicAttribute, Signature, SignatureShare, VerificationKey,
+    aggregate_signature_shares, hash_to_scalar, prepare_blind_sign, Attribute, BlindedSerialNumber,
+    BlindedSignature, Parameters, PrivateAttribute, PublicAttribute, Signature, SignatureShare,
+    VerificationKey,
 };
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_validator_client::nym_api::EpochId;
+use nym_validator_client::nyxd::{Coin, Hash};
 use nym_validator_client::signing::AccountData;
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
-pub use nym_validator_client::nyxd::{Coin, Hash};
-
 #[derive(Zeroize, ZeroizeOnDrop, Serialize, Deserialize)]
 pub enum BandwidthCredentialIssuanceDataVariant {
     Voucher(BandwidthVoucherIssuanceData),
@@ -266,13 +265,6 @@ impl IssuanceBandwidthCredential {
         self.unblind_signature(validator_vk, &signing_data, blinded_signature)
     }
 
-    pub fn unchecked_aggregate_signature_shares(
-        &self,
-        shares: &[SignatureShare],
-    ) -> Result<Signature, Error> {
-        aggregate_signature_shares(shares).map_err(Error::SignatureAggregationError)
-    }
-
     pub fn aggregate_signature_shares(
         &self,
         verification_key: &VerificationKey,
@@ -287,7 +279,7 @@ impl IssuanceBandwidthCredential {
         attributes.extend_from_slice(&private_attributes);
         attributes.extend_from_slice(&public_attributes);
 
-        aggregate_signature_shares_and_verify(params, verification_key, &attributes, shares)
+        aggregate_signature_shares(params, verification_key, &attributes, shares)
             .map_err(Error::SignatureAggregationError)
     }
 

common/credentials/src/coconut/bandwidth/issued.rs

@@ -155,6 +155,11 @@ impl IssuedBandwidthCredential {
             })
     }
 
+    pub fn randomise_signature(&mut self) {
+        let signature_prime = self.signature.randomise(bandwidth_credential_params());
+        self.signature = signature_prime.0
+    }
+
     pub fn default_parameters() -> Parameters {
         IssuanceBandwidthCredential::default_parameters()
     }

common/credentials/src/coconut/bandwidth/voucher.rs

@@ -6,7 +6,7 @@ use crate::coconut::utils::scalar_serde_helper;
 use crate::error::Error;
 use nym_api_requests::coconut::BlindSignRequestBody;
 use nym_credentials_interface::{
-    hash_to_scalar, Attribute, BlindSignRequest, BlindedSignature, CredentialType, PublicAttribute,
+    hash_to_scalar, Attribute, BlindSignRequest, BlindedSignature, PublicAttribute,
 };
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_validator_client::nyxd::{Coin, Hash};
@@ -30,10 +30,6 @@ impl<'a> From<&'a BandwidthVoucherIssuanceData> for BandwidthVoucherIssuedData {
 }
 
 impl BandwidthVoucherIssuedData {
-    pub fn new(value: Coin) -> Self {
-        BandwidthVoucherIssuedData { value }
-    }
-
     pub fn value(&self) -> &Coin {
         &self.value
     }
@@ -127,10 +123,6 @@ impl BandwidthVoucherIssuanceData {
         &self.value_prehashed
     }
 
-    pub fn typ() -> CredentialType {
-        CredentialType::Voucher
-    }
-
     pub fn tx_hash(&self) -> Hash {
         self.deposit_tx_hash
     }

common/crypto/Cargo.toml

@@ -8,21 +8,21 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-aes = { workspace = true, optional = true }
+aes = { version = "0.8.1", optional = true }
 bs58 = { workspace = true }
-blake3 = { workspace = true, features = ["traits-preview"], optional = true }
-ctr = { workspace = true, optional = true }
+blake3 = { version = "1.3.1", features = ["traits-preview"], optional = true }
+ctr = { version = "0.9.1", optional = true }
 digest = { version = "0.10.3", optional = true }
 generic-array = { workspace = true, optional = true }
-hkdf = { workspace = true, optional = true }
-hmac = { workspace = true, optional = true }
-cipher = { workspace = true, optional = true }
+hkdf = { version = "0.12.3", optional = true }
+hmac = { version = "0.12.1", optional = true }
+cipher = { version = "0.4.3", optional = true }
 x25519-dalek = { version = "1.1", optional = true }
-ed25519-dalek = { workspace = true, optional = true }
+ed25519-dalek = { version = "1.0", optional = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"], optional = true }
-serde_bytes = { workspace = true, optional = true }
+serde_bytes = { version = "0.11.6", optional = true }
 serde_crate = { version = "1.0", optional = true, default_features = false, features = ["derive"], package = "serde" }
-subtle-encoding = { workspace = true, features = ["bech32-preview"] }
+subtle-encoding = { version = "0.5", features =  ["bech32-preview"]}
 thiserror = { workspace = true }
 zeroize = { workspace = true, optional = true, features = ["zeroize_derive"] }
 

common/crypto/src/asymmetric/encryption/mod.rs

@@ -200,14 +200,6 @@ impl<'a> From<&'a PrivateKey> for PublicKey {
     }
 }
 
-impl FromStr for PrivateKey {
-    type Err = KeyRecoveryError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        PrivateKey::from_base58_string(s)
-    }
-}
-
 impl PrivateKey {
     #[cfg(feature = "rand")]
     pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {

common/crypto/src/asymmetric/identity/mod.rs

@@ -227,14 +227,6 @@ impl<'a> From<&'a PrivateKey> for PublicKey {
     }
 }
 
-impl FromStr for PrivateKey {
-    type Err = Ed25519RecoveryError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        PrivateKey::from_base58_string(s)
-    }
-}
-
 impl PrivateKey {
     #[cfg(feature = "rand")]
     pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {

common/dkg/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bitvec = { workspace = true }
+bitvec = "1.0.0"
 
 # unfortunately until https://github.com/zkcrypto/bls12_381/issues/10 is resolved, we have to rely on the fork
 # as we need to be able to serialize Gt so that we could create the lookup table for baby-step-giant-step algorithm
@@ -17,13 +17,13 @@ nym-contracts-common = { path = "../cosmwasm-smart-contracts/contracts-common",
 bs58 = { workspace = true }
 
 
-lazy_static = { workspace = true }
+lazy_static = "1.4.0"
 rand = { version = "0.8.5", default-features = false}
 rand_chacha = "0.3"
-rand_core = { workspace = true }
+rand_core = "0.6.3"
 sha2 = "0.9"
 serde = { workspace = true }
-serde_derive = { workspace = true }
+serde_derive = "1.0"
 thiserror = { workspace = true }
 zeroize = { workspace = true, features = ["zeroize_derive"] }
 
@@ -38,7 +38,7 @@ workspace = true
 default-features = false
 
 [dev-dependencies]
-criterion = { workspace = true }
+criterion = "0.4"
 
 [[bench]]
 name = "benchmarks"

common/execute/Cargo.toml

@@ -8,5 +8,5 @@ license.workspace = true
 proc-macro = true
 
 [dependencies]
-syn = { workspace = true, features = ["full"] }
-quote = { workspace = true }
+syn = { version = "1", features = ["full"] }
+quote = "1"

common/http-api-client/Cargo.toml

@@ -13,7 +13,6 @@ license.workspace = true
 [dependencies]
 async-trait = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
-http.workspace = true
 url = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

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

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use async_trait::async_trait;
-use reqwest::header::HeaderValue;
-use reqwest::{RequestBuilder, Response, StatusCode};
+use reqwest::{IntoUrl, Response, StatusCode};
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
@@ -12,8 +11,6 @@ use thiserror::Error;
 use tracing::warn;
 use url::Url;
 
-pub use reqwest::IntoUrl;
-
 pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
 
 pub type PathSegments<'a> = &'a [&'a str];
@@ -55,88 +52,6 @@ pub enum HttpClientError<E: Display = String> {
     RequestTimeout,
 }
 
-pub struct ClientBuilder {
-    url: Url,
-    timeout: Option<Duration>,
-    custom_user_agent: bool,
-    reqwest_client_builder: reqwest::ClientBuilder,
-}
-
-impl ClientBuilder {
-    pub fn new<U, E>(url: U) -> Result<Self, HttpClientError<E>>
-    where
-        U: IntoUrl,
-        E: Display,
-    {
-        // a naive check: if the provided URL does not start with http(s), add that scheme
-        let str_url = url.as_str();
-
-        if !str_url.starts_with("http") {
-            let alt = format!("http://{str_url}");
-            warn!("the provided url ('{str_url}') does not contain scheme information. Changing it to '{alt}' ...");
-            // TODO: or should we maybe default to https?
-            Self::new(alt)
-        } else {
-            Ok(ClientBuilder {
-                url: url.into_url()?,
-                timeout: None,
-                custom_user_agent: false,
-                reqwest_client_builder: reqwest::ClientBuilder::new(),
-            })
-        }
-    }
-
-    pub fn with_timeout(mut self, timeout: Duration) -> Self {
-        self.timeout = Some(timeout);
-        self
-    }
-
-    pub fn with_reqwest_builder(mut self, reqwest_builder: reqwest::ClientBuilder) -> Self {
-        self.reqwest_client_builder = reqwest_builder;
-        self
-    }
-
-    pub fn with_user_agent<V>(mut self, value: V) -> Self
-    where
-        V: TryInto<HeaderValue>,
-        V::Error: Into<http::Error>,
-    {
-        self.custom_user_agent = true;
-        self.reqwest_client_builder = self.reqwest_client_builder.user_agent(value);
-        self
-    }
-
-    pub fn build<E>(self) -> Result<Client, HttpClientError<E>>
-    where
-        E: Display,
-    {
-        #[cfg(target_arch = "wasm32")]
-        let reqwest_client = self.reqwest_client_builder.build()?;
-
-        // TODO: we should probably be propagating the error rather than panicking,
-        // but that'd break bunch of things due to type changes
-        #[cfg(not(target_arch = "wasm32"))]
-        let reqwest_client = {
-            let mut builder = self
-                .reqwest_client_builder
-                .timeout(self.timeout.unwrap_or(DEFAULT_TIMEOUT));
-            if !self.custom_user_agent {
-                builder =
-                    builder.user_agent(format!("nym-http-api-client/{}", env!("CARGO_PKG_VERSION")))
-            }
-            builder.build()?
-        };
-
-        Ok(Client {
-            base_url: self.url,
-            reqwest_client,
-
-            #[cfg(target_arch = "wasm32")]
-            request_timeout: self.timeout.unwrap_or(DEFAULT_TIMEOUT),
-        })
-    }
-}
-
 /// A simple extendable client wrapper for http request with extra url sanitization.
 #[derive(Debug, Clone)]
 pub struct Client {
@@ -150,9 +65,25 @@ pub struct Client {
 impl Client {
     // no timeout until https://github.com/seanmonstar/reqwest/issues/1135 is fixed
     pub fn new(base_url: Url, timeout: Option<Duration>) -> Self {
-        Self::new_url::<_, String>(base_url, timeout).expect(
-            "we provided valid url and we were unwrapping previous construction errors anyway",
-        )
+        #[cfg(target_arch = "wasm32")]
+        let reqwest_client = reqwest::Client::new();
+
+        // TODO: we should probably be propagating the error rather than panicking,
+        // but that'd break bunch of things due to type changes
+        #[cfg(not(target_arch = "wasm32"))]
+        let reqwest_client = reqwest::ClientBuilder::new()
+            .timeout(timeout.unwrap_or(DEFAULT_TIMEOUT))
+            .user_agent(format!("nym-http-api-client/{}", env!("CARGO_PKG_VERSION")))
+            .build()
+            .expect("Client::new()");
+
+        Client {
+            base_url,
+            reqwest_client,
+
+            #[cfg(target_arch = "wasm32")]
+            request_timeout: timeout.unwrap_or(DEFAULT_TIMEOUT),
+        }
     }
 
     pub fn new_url<U, E>(url: U, timeout: Option<Duration>) -> Result<Self, HttpClientError<E>>
@@ -160,19 +91,17 @@ impl Client {
         U: IntoUrl,
         E: Display,
     {
-        let builder = Self::builder(url)?;
-        match timeout {
-            Some(timeout) => builder.with_timeout(timeout).build(),
-            None => builder.build(),
-        }
-    }
+        // a naive check: if the provided URL does not start with http(s), add that scheme
+        let str_url = url.as_str();
 
-    pub fn builder<U, E>(url: U) -> Result<ClientBuilder, HttpClientError<E>>
-    where
-        U: IntoUrl,
-        E: Display,
-    {
-        ClientBuilder::new(url)
+        if !str_url.starts_with("http") {
+            let alt = format!("http://{str_url}");
+            warn!("the provided url ('{str_url}') does not contain scheme information. Changing it to '{alt}' ...");
+            // TODO: or should we maybe default to https?
+            Self::new_url(alt, timeout)
+        } else {
+            Ok(Self::new(url.into_url()?, timeout))
+        }
     }
 
     pub fn change_base_url(&mut self, new_url: Url) {
@@ -183,19 +112,6 @@ impl Client {
         &self.base_url
     }
 
-    pub fn create_get_request<K, V>(
-        &self,
-        path: PathSegments<'_>,
-        params: Params<'_, K, V>,
-    ) -> RequestBuilder
-    where
-        K: AsRef<str>,
-        V: AsRef<str>,
-    {
-        let url = sanitize_url(&self.base_url, path, params);
-        self.reqwest_client.get(url)
-    }
-
     async fn send_get_request<K, V, E>(
         &self,
         path: PathSegments<'_>,
@@ -226,21 +142,6 @@ impl Client {
         }
     }
 
-    pub fn create_post_request<B, K, V>(
-        &self,
-        path: PathSegments<'_>,
-        params: Params<'_, K, V>,
-        json_body: &B,
-    ) -> RequestBuilder
-    where
-        B: Serialize + ?Sized,
-        K: AsRef<str>,
-        V: AsRef<str>,
-    {
-        let url = sanitize_url(&self.base_url, path, params);
-        self.reqwest_client.post(url).json(json_body)
-    }
-
     async fn send_post_request<B, K, V, E>(
         &self,
         path: PathSegments<'_>,
@@ -506,7 +407,7 @@ pub fn sanitize_url<K: AsRef<str>, V: AsRef<str>>(
     url
 }
 
-pub async fn parse_response<T, E>(res: Response, allow_empty: bool) -> Result<T, HttpClientError<E>>
+async fn parse_response<T, E>(res: Response, allow_empty: bool) -> Result<T, HttpClientError<E>>
 where
     T: DeserializeOwned,
     E: DeserializeOwned + Display,

common/http-api-common/Cargo.toml

@@ -12,9 +12,9 @@ license.workspace = true
 
 [dependencies]
 axum.workspace = true
-bytes = { workspace = true }
-mime = { workspace = true }
+bytes = "1.5.0"
+mime = "0.3.17"
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
-serde_yaml = { workspace = true }
+serde_yaml = "0.9.25"
 utoipa = { workspace = true }

common/ip-packet-requests/Cargo.toml

@@ -9,13 +9,12 @@ edition.workspace = true
 license.workspace = true
 
 [dependencies]
-bincode = { workspace = true }
-bytes = { workspace = true }
+bincode = "1.3.3"
+bytes = "1.5.0"
 nym-bin-common = { path = "../bin-common" }
 nym-sphinx = { path = "../nymsphinx" }
 rand = "0.8.5"
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
-time = { workspace = true }
 tokio = { workspace = true, features = ["time"] }
 tokio-util = { workspace = true, features = ["codec"] }

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

@@ -12,13 +12,11 @@ pub use v6::response;
 
 pub mod codec;
 pub mod v6;
-pub mod v7;
 
 // version 3: initial version
 // version 4: IPv6 support
 // version 5: Add severity level to info response
 // version 6: Increase the available IPs
-// version 7: Add signature support (for the future)
 pub const CURRENT_VERSION: u8 = 6;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]

common/ip-packet-requests/src/v7/mod.rs

@@ -1,2 +0,0 @@
-pub mod request;
-pub mod response;

common/ip-packet-requests/src/v7/request.rs

@@ -1,395 +0,0 @@
-use nym_sphinx::addressing::clients::Recipient;
-use serde::{Deserialize, Serialize};
-use time::OffsetDateTime;
-
-use crate::{make_bincode_serializer, IpPair, CURRENT_VERSION};
-
-fn generate_random() -> u64 {
-    use rand::RngCore;
-    let mut rng = rand::rngs::OsRng;
-    rng.next_u64()
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct IpPacketRequest {
-    pub version: u8,
-    pub data: IpPacketRequestData,
-}
-
-impl IpPacketRequest {
-    pub fn new_static_connect_request(
-        ips: IpPair,
-        reply_to: Recipient,
-        reply_to_hops: Option<u8>,
-        reply_to_avg_mix_delays: Option<f64>,
-        buffer_timeout: Option<u64>,
-    ) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                version: CURRENT_VERSION,
-                data: IpPacketRequestData::StaticConnect(SignedStaticConnectRequest {
-                    request: StaticConnectRequest {
-                        request_id,
-                        ips,
-                        reply_to,
-                        reply_to_hops,
-                        reply_to_avg_mix_delays,
-                        buffer_timeout,
-                        timestamp: OffsetDateTime::now_utc(),
-                    },
-                    signature: None,
-                }),
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_dynamic_connect_request(
-        reply_to: Recipient,
-        reply_to_hops: Option<u8>,
-        reply_to_avg_mix_delays: Option<f64>,
-        buffer_timeout: Option<u64>,
-    ) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                version: CURRENT_VERSION,
-                data: IpPacketRequestData::DynamicConnect(SignedDynamicConnectRequest {
-                    request: DynamicConnectRequest {
-                        request_id,
-                        reply_to,
-                        reply_to_hops,
-                        reply_to_avg_mix_delays,
-                        buffer_timeout,
-                        timestamp: OffsetDateTime::now_utc(),
-                    },
-                    signature: None,
-                }),
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_disconnect_request(reply_to: Recipient) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                version: CURRENT_VERSION,
-                data: IpPacketRequestData::Disconnect(SignedDisconnectRequest {
-                    request: DisconnectRequest {
-                        request_id,
-                        reply_to,
-                        timestamp: OffsetDateTime::now_utc(),
-                    },
-                    signature: None,
-                }),
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_data_request(ip_packets: bytes::Bytes) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketRequestData::Data(DataRequest { ip_packets }),
-        }
-    }
-
-    pub fn new_ping(reply_to: Recipient) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                version: CURRENT_VERSION,
-                data: IpPacketRequestData::Ping(PingRequest {
-                    request_id,
-                    reply_to,
-                    timestamp: OffsetDateTime::now_utc(),
-                }),
-            },
-            request_id,
-        )
-    }
-
-    pub fn new_health_request(reply_to: Recipient) -> (Self, u64) {
-        let request_id = generate_random();
-        (
-            Self {
-                version: CURRENT_VERSION,
-                data: IpPacketRequestData::Health(HealthRequest {
-                    request_id,
-                    reply_to,
-                    timestamp: OffsetDateTime::now_utc(),
-                }),
-            },
-            request_id,
-        )
-    }
-
-    pub fn id(&self) -> Option<u64> {
-        match &self.data {
-            IpPacketRequestData::StaticConnect(request) => Some(request.request.request_id),
-            IpPacketRequestData::DynamicConnect(request) => Some(request.request.request_id),
-            IpPacketRequestData::Disconnect(request) => Some(request.request.request_id),
-            IpPacketRequestData::Data(_) => None,
-            IpPacketRequestData::Ping(request) => Some(request.request_id),
-            IpPacketRequestData::Health(request) => Some(request.request_id),
-        }
-    }
-
-    pub fn recipient(&self) -> Option<&Recipient> {
-        match &self.data {
-            IpPacketRequestData::StaticConnect(request) => Some(&request.request.reply_to),
-            IpPacketRequestData::DynamicConnect(request) => Some(&request.request.reply_to),
-            IpPacketRequestData::Disconnect(request) => Some(&request.request.reply_to),
-            IpPacketRequestData::Data(_) => None,
-            IpPacketRequestData::Ping(request) => Some(&request.reply_to),
-            IpPacketRequestData::Health(request) => Some(&request.reply_to),
-        }
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub enum IpPacketRequestData {
-    StaticConnect(SignedStaticConnectRequest),
-    DynamicConnect(SignedDynamicConnectRequest),
-    Disconnect(SignedDisconnectRequest),
-    Data(DataRequest),
-    Ping(PingRequest),
-    Health(HealthRequest),
-}
-
-impl IpPacketRequestData {
-    pub fn add_signature(&mut self, signature: Vec<u8>) -> Option<Vec<u8>> {
-        match self {
-            IpPacketRequestData::StaticConnect(request) => {
-                request.signature = Some(signature);
-                request.signature.clone()
-            }
-            IpPacketRequestData::DynamicConnect(request) => {
-                request.signature = Some(signature);
-                request.signature.clone()
-            }
-            IpPacketRequestData::Disconnect(request) => {
-                request.signature = Some(signature);
-                request.signature.clone()
-            }
-            IpPacketRequestData::Data(_)
-            | IpPacketRequestData::Ping(_)
-            | IpPacketRequestData::Health(_) => None,
-        }
-    }
-}
-
-// A static connect request is when the client provides the internal IP address it will use on the
-// ip packet router.
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct StaticConnectRequest {
-    pub request_id: u64,
-
-    pub ips: IpPair,
-
-    // The nym-address the response should be sent back to
-    pub reply_to: Recipient,
-
-    // The number of mix node hops that responses should take, in addition to the entry and exit
-    // node. Zero means only client -> entry -> exit -> client.
-    pub reply_to_hops: Option<u8>,
-
-    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
-    // ip packet router.
-    pub reply_to_avg_mix_delays: Option<f64>,
-
-    // The maximum time in milliseconds the IPR should wait when filling up a mix packet
-    // with ip packets.
-    pub buffer_timeout: Option<u64>,
-
-    // Timestamp of when the request was sent by the client.
-    pub timestamp: OffsetDateTime,
-}
-
-impl StaticConnectRequest {
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct SignedStaticConnectRequest {
-    pub request: StaticConnectRequest,
-    pub signature: Option<Vec<u8>>,
-}
-
-// A dynamic connect request is when the client does not provide the internal IP address it will use
-// on the ip packet router, and instead requests one to be assigned to it.
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct DynamicConnectRequest {
-    pub request_id: u64,
-
-    // The nym-address the response should be sent back to
-    pub reply_to: Recipient,
-
-    // The number of mix node hops that responses should take, in addition to the entry and exit
-    // node. Zero means only client -> entry -> exit -> client.
-    pub reply_to_hops: Option<u8>,
-
-    // The average delay at each mix node, in milliseconds. Currently this is not supported by the
-    // ip packet router.
-    pub reply_to_avg_mix_delays: Option<f64>,
-
-    // The maximum time in milliseconds the IPR should wait when filling up a mix packet
-    // with ip packets.
-    pub buffer_timeout: Option<u64>,
-
-    // Timestamp of when the request was sent by the client.
-    pub timestamp: OffsetDateTime,
-}
-
-impl DynamicConnectRequest {
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct SignedDynamicConnectRequest {
-    pub request: DynamicConnectRequest,
-    pub signature: Option<Vec<u8>>,
-}
-
-// A disconnect request is when the client wants to disconnect from the ip packet router and free
-// up the allocated IP address.
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct DisconnectRequest {
-    pub request_id: u64,
-
-    // The nym-address the response should be sent back to
-    pub reply_to: Recipient,
-
-    // Timestamp of when the request was sent by the client.
-    pub timestamp: OffsetDateTime,
-}
-
-impl DisconnectRequest {
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct SignedDisconnectRequest {
-    pub request: DisconnectRequest,
-    pub signature: Option<Vec<u8>>,
-}
-
-// A data request is when the client wants to send an IP packet to a destination.
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct DataRequest {
-    pub ip_packets: bytes::Bytes,
-}
-
-// A ping request is when the client wants to check if the ip packet router is still alive.
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct PingRequest {
-    pub request_id: u64,
-
-    // The nym-address the response should be sent back to
-    pub reply_to: Recipient,
-
-    // Timestamp of when the request was sent by the client.
-    pub timestamp: OffsetDateTime,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct HealthRequest {
-    pub request_id: u64,
-
-    // The nym-address the response should be sent back to
-    pub reply_to: Recipient,
-
-    // Timestamp of when the request was sent by the client.
-    pub timestamp: OffsetDateTime,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::net::{Ipv4Addr, Ipv6Addr};
-    use std::str::FromStr;
-
-    #[test]
-    fn check_size_of_request() {
-        let connect = IpPacketRequest {
-            version: 4,
-            data: IpPacketRequestData::StaticConnect(
-                SignedStaticConnectRequest {
-                    request: StaticConnectRequest {
-                        request_id: 123,
-                        ips: IpPair::new(Ipv4Addr::from_str("10.0.0.1").unwrap(), Ipv6Addr::from_str("2001:db8:a160::1").unwrap()),
-                        reply_to: Recipient::try_from_base58_string("D1rrpsysCGCYXy9saP8y3kmNpGtJZUXN9SvFoUcqAsM9.9Ssso1ea5NfkbMASdiseDSjTN1fSWda5SgEVjdSN4CvV@GJqd3ZxpXWSNxTfx7B1pPtswpetH4LnJdFeLeuY5KUuN").unwrap(),
-                        reply_to_hops: None,
-                        reply_to_avg_mix_delays: None,
-                        buffer_timeout: None,
-                        timestamp: OffsetDateTime::now_utc(),
-                    },
-                    signature: None,
-                }
-            ),
-        };
-        assert_eq!(connect.to_bytes().unwrap().len(), 139);
-    }
-
-    #[test]
-    fn check_size_of_data() {
-        let data = IpPacketRequest {
-            version: 4,
-            data: IpPacketRequestData::Data(DataRequest {
-                ip_packets: bytes::Bytes::from(vec![1u8; 32]),
-            }),
-        };
-        assert_eq!(data.to_bytes().unwrap().len(), 35);
-    }
-
-    #[test]
-    fn serialize_and_deserialize_data_request() {
-        let data = IpPacketRequest {
-            version: 4,
-            data: IpPacketRequestData::Data(DataRequest {
-                ip_packets: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
-            }),
-        };
-
-        let serialized = data.to_bytes().unwrap();
-        let deserialized = IpPacketRequest::from_reconstructed_message(
-            &nym_sphinx::receiver::ReconstructedMessage {
-                message: serialized,
-                sender_tag: None,
-            },
-        )
-        .unwrap();
-
-        assert_eq!(deserialized.version, 4);
-        assert_eq!(
-            deserialized.data,
-            IpPacketRequestData::Data(DataRequest {
-                ip_packets: bytes::Bytes::from(vec![1, 2, 4, 2, 5]),
-            })
-        );
-    }
-}

common/ip-packet-requests/src/v7/response.rs

@@ -1,410 +0,0 @@
-use nym_sphinx::addressing::clients::Recipient;
-use serde::{Deserialize, Serialize};
-
-use crate::{make_bincode_serializer, IpPair, CURRENT_VERSION};
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct IpPacketResponse {
-    pub version: u8,
-    pub data: IpPacketResponseData,
-}
-
-impl IpPacketResponse {
-    pub fn new_static_connect_success(request_id: u64, reply_to: Recipient) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
-                request_id,
-                reply_to,
-                reply: StaticConnectResponseReply::Success,
-            }),
-        }
-    }
-
-    pub fn new_static_connect_failure(
-        request_id: u64,
-        reply_to: Recipient,
-        reason: StaticConnectFailureReason,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
-                request_id,
-                reply_to,
-                reply: StaticConnectResponseReply::Failure(reason),
-            }),
-        }
-    }
-
-    pub fn new_dynamic_connect_success(request_id: u64, reply_to: Recipient, ips: IpPair) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
-                request_id,
-                reply_to,
-                reply: DynamicConnectResponseReply::Success(DynamicConnectSuccess { ips }),
-            }),
-        }
-    }
-
-    pub fn new_dynamic_connect_failure(
-        request_id: u64,
-        reply_to: Recipient,
-        reason: DynamicConnectFailureReason,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
-                request_id,
-                reply_to,
-                reply: DynamicConnectResponseReply::Failure(reason),
-            }),
-        }
-    }
-
-    pub fn new_disconnect_success(request_id: u64, reply_to: Recipient) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Disconnect(DisconnectResponse {
-                request_id,
-                reply_to,
-                reply: DisconnectResponseReply::Success,
-            }),
-        }
-    }
-
-    pub fn new_disconnect_failure(
-        request_id: u64,
-        reply_to: Recipient,
-        reason: DisconnectFailureReason,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Disconnect(DisconnectResponse {
-                request_id,
-                reply_to,
-                reply: DisconnectResponseReply::Failure(reason),
-            }),
-        }
-    }
-
-    pub fn new_unrequested_disconnect(
-        reply_to: Recipient,
-        reason: UnrequestedDisconnectReason,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::UnrequestedDisconnect(UnrequestedDisconnect {
-                reply_to,
-                reason,
-            }),
-        }
-    }
-
-    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Data(DataResponse { ip_packet }),
-        }
-    }
-
-    pub fn new_version_mismatch(
-        request_id: u64,
-        reply_to: Recipient,
-        request_version: u8,
-        our_version: u8,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Info(InfoResponse {
-                request_id,
-                reply_to,
-                reply: InfoResponseReply::VersionMismatch {
-                    request_version,
-                    response_version: our_version,
-                },
-                level: InfoLevel::Error,
-            }),
-        }
-    }
-
-    pub fn new_data_info_response(
-        reply_to: Recipient,
-        reply: InfoResponseReply,
-        level: InfoLevel,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Info(InfoResponse {
-                request_id: 0,
-                reply_to,
-                reply,
-                level,
-            }),
-        }
-    }
-
-    pub fn new_pong(request_id: u64, reply_to: Recipient) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Pong(PongResponse {
-                request_id,
-                reply_to,
-            }),
-        }
-    }
-
-    pub fn new_health_response(
-        request_id: u64,
-        reply_to: Recipient,
-        build_info: nym_bin_common::build_information::BinaryBuildInformationOwned,
-        routable: Option<bool>,
-    ) -> Self {
-        Self {
-            version: CURRENT_VERSION,
-            data: IpPacketResponseData::Health(HealthResponse {
-                request_id,
-                reply_to,
-                reply: HealthResponseReply {
-                    build_info,
-                    routable,
-                },
-            }),
-        }
-    }
-
-    pub fn id(&self) -> Option<u64> {
-        match &self.data {
-            IpPacketResponseData::StaticConnect(response) => Some(response.request_id),
-            IpPacketResponseData::DynamicConnect(response) => Some(response.request_id),
-            IpPacketResponseData::Disconnect(response) => Some(response.request_id),
-            IpPacketResponseData::UnrequestedDisconnect(_) => None,
-            IpPacketResponseData::Data(_) => None,
-            IpPacketResponseData::Pong(response) => Some(response.request_id),
-            IpPacketResponseData::Health(response) => Some(response.request_id),
-            IpPacketResponseData::Info(response) => Some(response.request_id),
-        }
-    }
-
-    pub fn recipient(&self) -> Option<&Recipient> {
-        match &self.data {
-            IpPacketResponseData::StaticConnect(response) => Some(&response.reply_to),
-            IpPacketResponseData::DynamicConnect(response) => Some(&response.reply_to),
-            IpPacketResponseData::Disconnect(response) => Some(&response.reply_to),
-            IpPacketResponseData::UnrequestedDisconnect(response) => Some(&response.reply_to),
-            IpPacketResponseData::Data(_) => None,
-            IpPacketResponseData::Pong(response) => Some(&response.reply_to),
-            IpPacketResponseData::Health(response) => Some(&response.reply_to),
-            IpPacketResponseData::Info(response) => Some(&response.reply_to),
-        }
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-
-    pub fn from_reconstructed_message(
-        message: &nym_sphinx::receiver::ReconstructedMessage,
-    ) -> Result<Self, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().deserialize(&message.message)
-    }
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum IpPacketResponseData {
-    // Response for a static connect request
-    StaticConnect(StaticConnectResponse),
-
-    // Response for a dynamic connect request
-    DynamicConnect(DynamicConnectResponse),
-
-    // Response for a disconnect initiqated by the client
-    Disconnect(DisconnectResponse),
-
-    // Message from the server that the client got disconnected without the client initiating it
-    UnrequestedDisconnect(UnrequestedDisconnect),
-
-    // Response to a data request
-    Data(DataResponse),
-
-    // Response to ping request
-    Pong(PongResponse),
-
-    // Response for a health request
-    Health(HealthResponse),
-
-    // Info response. This can be anything from informative messages to errors
-    Info(InfoResponse),
-}
-
-impl IpPacketResponseData {
-    pub fn to_bytes(&self) -> Result<Vec<u8>, bincode::Error> {
-        use bincode::Options;
-        make_bincode_serializer().serialize(self)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct StaticConnectResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: StaticConnectResponseReply,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum StaticConnectResponseReply {
-    Success,
-    Failure(StaticConnectFailureReason),
-}
-
-impl StaticConnectResponseReply {
-    pub fn is_success(&self) -> bool {
-        match self {
-            StaticConnectResponseReply::Success => true,
-            StaticConnectResponseReply::Failure(_) => false,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
-pub enum StaticConnectFailureReason {
-    #[error("requested ip address is already in use")]
-    RequestedIpAlreadyInUse,
-    #[error("requested nym-address is already in use")]
-    RequestedNymAddressAlreadyInUse,
-    #[error("{0}")]
-    Other(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct DynamicConnectResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: DynamicConnectResponseReply,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum DynamicConnectResponseReply {
-    Success(DynamicConnectSuccess),
-    Failure(DynamicConnectFailureReason),
-}
-
-impl DynamicConnectResponseReply {
-    pub fn is_success(&self) -> bool {
-        match self {
-            DynamicConnectResponseReply::Success(_) => true,
-            DynamicConnectResponseReply::Failure(_) => false,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct DynamicConnectSuccess {
-    pub ips: IpPair,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
-pub enum DynamicConnectFailureReason {
-    #[error("requested nym-address is already in use")]
-    RequestedNymAddressAlreadyInUse,
-    #[error("no available ip address")]
-    NoAvailableIp,
-    #[error("{0}")]
-    Other(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct DisconnectResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: DisconnectResponseReply,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum DisconnectResponseReply {
-    Success,
-    Failure(DisconnectFailureReason),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
-pub enum DisconnectFailureReason {
-    #[error("requested nym-address is not currently connected")]
-    RequestedNymAddressNotConnected,
-    #[error("{0}")]
-    Other(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct UnrequestedDisconnect {
-    pub reply_to: Recipient,
-    pub reason: UnrequestedDisconnectReason,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
-pub enum UnrequestedDisconnectReason {
-    #[error("client mixnet traffic timeout")]
-    ClientMixnetTrafficTimeout,
-    #[error("client tun traffic timeout")]
-    ClientTunTrafficTimeout,
-    #[error("{0}")]
-    Other(String),
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct DataResponse {
-    pub ip_packet: bytes::Bytes,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct PongResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct HealthResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: HealthResponseReply,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct HealthResponseReply {
-    // Return the binary build information of the IPR
-    pub build_info: nym_bin_common::build_information::BinaryBuildInformationOwned,
-    // Return if the IPR has performed a successful routing test.
-    pub routable: Option<bool>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct InfoResponse {
-    pub request_id: u64,
-    pub reply_to: Recipient,
-    pub reply: InfoResponseReply,
-    pub level: InfoLevel,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize, thiserror::Error)]
-pub enum InfoResponseReply {
-    #[error("{msg}")]
-    Generic { msg: String },
-    #[error(
-        "version mismatch: response is v{request_version} and response is v{response_version}"
-    )]
-    VersionMismatch {
-        request_version: u8,
-        response_version: u8,
-    },
-    #[error("destination failed exit policy filter check: {dst}")]
-    ExitPolicyFilterCheckFailed { dst: String },
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub enum InfoLevel {
-    Info,
-    Warn,
-    Error,
-}

common/ledger/Cargo.toml

@@ -7,8 +7,8 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bip32 = { workspace = true }
+bip32 = "0.5.1"
 k256 = { workspace = true }
-ledger-transport = { workspace = true }
-ledger-transport-hid = { workspace = true }
+ledger-transport = "0.10.0"
+ledger-transport-hid = "0.10.0"
 thiserror = { workspace = true }

common/mixnode-common/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bytes = { workspace = true }
+bytes = "1.0"
 futures = { workspace = true }
 humantime-serde = { workspace = true }
 log = { workspace = true }
@@ -38,4 +38,4 @@ nym-task = { path = "../task" }
 nym-validator-client = { path = "../client-libs/validator-client" }
 nym-bin-common = { path = "../bin-common" }
 nym-metrics = { path = "../nym-metrics" }
-nym-node-http-api = { path = "../../nym-node/nym-node-http-api" } 
+nym-node-http-api = { path = "../../nym-node/nym-node-http-api" } 

common/network-defaults/Cargo.toml

@@ -10,7 +10,7 @@ repository.workspace = true
 [dependencies]
 cfg-if = { workspace = true }
 dotenvy = { workspace = true }
-hex-literal = { workspace = true }
+hex-literal = "0.3.3"
 log = { workspace = true }
 once_cell = { workspace = true }
 schemars = { workspace = true, features = ["preserve_order"] }

common/network-defaults/src/mainnet.rs

@@ -18,12 +18,9 @@ pub const VESTING_CONTRACT_ADDRESS: &str =
     "n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw";
 
 pub const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str = "";
-pub const GROUP_CONTRACT_ADDRESS: &str =
-    "n1e2zq4886zzewpvpucmlw8v9p7zv692f6yck4zjzxh699dkcmlrfqk2knsr";
-pub const MULTISIG_CONTRACT_ADDRESS: &str =
-    "n1txayqfz5g9qww3rlflpg025xd26m9payz96u54x4fe3s2ktz39xqk67gzx";
-pub const COCONUT_DKG_CONTRACT_ADDRESS: &str =
-    "n19604yflqggs9mk2z26mqygq43q2kr3n932egxx630svywd5mpxjsztfpvx";
+pub const GROUP_CONTRACT_ADDRESS: &str = "";
+pub const MULTISIG_CONTRACT_ADDRESS: &str = "";
+pub const COCONUT_DKG_CONTRACT_ADDRESS: &str = "";
 pub const EPHEMERA_CONTRACT_ADDRESS: &str = "";
 
 pub const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy";

common/nonexhaustive-delayqueue/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-tokio-stream = { workspace = true } # this one seems to be a thing until `Stream` trait is stabilised in stdlib
+tokio-stream = "0.1.11" # this one seems to be a thing until `Stream` trait is stabilised in stdlib
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
 workspace = true

common/nym-metrics/Cargo.toml

@@ -14,4 +14,4 @@ license.workspace = true
 prometheus = { workspace = true }
 log = { workspace = true }
 dashmap = { workspace = true }
-lazy_static = { workspace = true }
+lazy_static = "1.4"

common/nymcoconut/Cargo.toml

@@ -14,7 +14,7 @@ digest = "0.9"
 rand = "0.8"
 thiserror = { workspace = true }
 serde = { workspace = true }
-serde_derive = { workspace = true }
+serde_derive = "1.0"
 bs58 = { workspace = true }
 sha2 = "0.9"
 zeroize = { workspace = true, optional = true }
@@ -31,8 +31,8 @@ workspace = true
 default-features = false
 
 [dev-dependencies]
-criterion = { workspace = true, features = ["html_reports"] }
-doc-comment = { workspace = true }
+criterion = { version="0.4", features=["html_reports"] }
+doc-comment = "0.3"
 rand_chacha = "0.3"
 
 [[bench]]

common/nymcoconut/benches/benchmarks.rs

@@ -6,10 +6,10 @@ use criterion::{criterion_group, criterion_main, Criterion};
 use ff::Field;
 use group::{Curve, Group};
 use nym_coconut::{
-    aggregate_signature_shares_and_verify, aggregate_verification_keys, blind_sign,
-    prepare_blind_sign, prove_bandwidth_credential, random_scalars_refs, setup, ttp_keygen,
-    verify_credential, verify_partial_blind_signature, Attribute, BlindedSignature, Parameters,
-    Signature, SignatureShare, VerificationKey,
+    aggregate_signature_shares, aggregate_verification_keys, blind_sign, prepare_blind_sign,
+    prove_bandwidth_credential, random_scalars_refs, setup, ttp_keygen, verify_credential,
+    verify_partial_blind_signature, Attribute, BlindedSignature, Parameters, Signature,
+    SignatureShare, VerificationKey,
 };
 use rand::seq::SliceRandom;
 use std::ops::Neg;
@@ -99,7 +99,7 @@ fn unblind_and_aggregate(
     let mut attributes = vec![];
     attributes.extend_from_slice(private_attributes);
     attributes.extend_from_slice(public_attributes);
-    aggregate_signature_shares_and_verify(
+    aggregate_signature_shares(
         params,
         verification_key,
         &attributes,

common/nymcoconut/src/lib.rs

@@ -4,18 +4,14 @@
 #![warn(clippy::expect_used)]
 #![warn(clippy::unwrap_used)]
 
-pub use bls12_381::Scalar;
 pub use elgamal::elgamal_keygen;
 pub use elgamal::ElGamalKeyPair;
 pub use elgamal::PublicKey;
 pub use error::CoconutError;
-pub use scheme::aggregation::aggregate_key_shares;
 pub use scheme::aggregation::aggregate_signature_shares;
-pub use scheme::aggregation::aggregate_signature_shares_and_verify;
 pub use scheme::aggregation::aggregate_verification_keys;
 pub use scheme::issuance::blind_sign;
 pub use scheme::issuance::prepare_blind_sign;
-pub use scheme::issuance::sign;
 pub use scheme::issuance::verify_partial_blind_signature;
 pub use scheme::issuance::BlindSignRequest;
 pub use scheme::keygen::keygen;
@@ -23,19 +19,16 @@ pub use scheme::keygen::ttp_keygen;
 pub use scheme::keygen::KeyPair;
 pub use scheme::keygen::SecretKey;
 pub use scheme::keygen::VerificationKey;
-pub use scheme::keygen::VerificationKeyShare;
 pub use scheme::setup::setup;
 pub use scheme::setup::Parameters;
 pub use scheme::verification::check_vk_pairing;
 pub use scheme::verification::prove_bandwidth_credential;
-pub use scheme::verification::verify;
 pub use scheme::verification::verify_credential;
 pub use scheme::verification::BlindedSerialNumber;
 pub use scheme::verification::VerifyCredentialRequest;
 pub use scheme::BlindedSignature;
 pub use scheme::Signature;
 pub use scheme::SignatureShare;
-pub use scheme::SignerIndex;
 pub use traits::Base58;
 pub use traits::Bytable;
 pub use utils::hash_to_scalar;

common/nymcoconut/src/scheme/aggregation.rs

@@ -12,7 +12,7 @@ use crate::error::{CoconutError, Result};
 use crate::scheme::verification::check_bilinear_pairing;
 use crate::scheme::{PartialSignature, Signature, SignatureShare, SignerIndex, VerificationKey};
 use crate::utils::perform_lagrangian_interpolation_at_origin;
-use crate::{Attribute, Parameters, VerificationKeyShare};
+use crate::{Attribute, Parameters};
 
 pub(crate) trait Aggregatable: Sized {
     fn aggregate(aggregatable: &[Self], indices: Option<&[SignerIndex]>) -> Result<Self>;
@@ -80,23 +80,7 @@ pub fn aggregate_verification_keys(
     Aggregatable::aggregate(keys, indices)
 }
 
-pub fn aggregate_key_shares(shares: &[VerificationKeyShare]) -> Result<VerificationKey> {
-    let (keys, indices): (Vec<_>, Vec<_>) = shares
-        .iter()
-        .map(|share| (share.key.clone(), share.index))
-        .unzip();
-
-    aggregate_verification_keys(&keys, Some(&indices))
-}
-
 pub fn aggregate_signatures(
-    signatures: &[PartialSignature],
-    indices: Option<&[SignerIndex]>,
-) -> Result<Signature> {
-    Aggregatable::aggregate(signatures, indices)
-}
-
-pub fn aggregate_signatures_and_verify(
     params: &Parameters,
     verification_key: &VerificationKey,
     attributes: &[&Attribute],
@@ -104,7 +88,11 @@ pub fn aggregate_signatures_and_verify(
     indices: Option<&[SignerIndex]>,
 ) -> Result<Signature> {
     // aggregate the signature
-    let signature = aggregate_signatures(signatures, indices)?;
+
+    let signature = match Aggregatable::aggregate(signatures, indices) {
+        Ok(res) => res,
+        Err(err) => return Err(err),
+    };
 
     // Verify the signature
     let alpha = verification_key.alpha;
@@ -128,16 +116,7 @@ pub fn aggregate_signatures_and_verify(
     Ok(signature)
 }
 
-pub fn aggregate_signature_shares(shares: &[SignatureShare]) -> Result<Signature> {
-    let (signatures, indices): (Vec<_>, Vec<_>) = shares
-        .iter()
-        .map(|share| (*share.signature(), share.index()))
-        .unzip();
-
-    aggregate_signatures(&signatures, Some(&indices))
-}
-
-pub fn aggregate_signature_shares_and_verify(
+pub fn aggregate_signature_shares(
     params: &Parameters,
     verification_key: &VerificationKey,
     attributes: &[&Attribute],
@@ -148,7 +127,7 @@ pub fn aggregate_signature_shares_and_verify(
         .map(|share| (*share.signature(), share.index()))
         .unzip();
 
-    aggregate_signatures_and_verify(
+    aggregate_signatures(
         params,
         verification_key,
         attributes,
@@ -231,7 +210,7 @@ mod tests {
 
     #[test]
     fn signature_aggregation_works_for_any_subset_of_signatures() {
-        let params = Parameters::new(2).unwrap();
+        let mut params = Parameters::new(2).unwrap();
         random_scalars_refs!(attributes, params, 2);
 
         let keypairs = ttp_keygen(&params, 3, 5).unwrap();
@@ -248,12 +227,12 @@ mod tests {
 
         let sigs = sks
             .iter()
-            .map(|sk| sign(&params, sk, &attributes).unwrap())
+            .map(|sk| sign(&mut params, sk, &attributes).unwrap())
             .collect::<Vec<_>>();
 
         // aggregating (any) threshold works
         let aggr_vk_1 = aggregate_verification_keys(&vks[..3], Some(&[1, 2, 3])).unwrap();
-        let aggr_sig1 = aggregate_signatures_and_verify(
+        let aggr_sig1 = aggregate_signatures(
             &params,
             &aggr_vk_1,
             &attributes,
@@ -263,7 +242,7 @@ mod tests {
         .unwrap();
 
         let aggr_vk_2 = aggregate_verification_keys(&vks[2..], Some(&[3, 4, 5])).unwrap();
-        let aggr_sig2 = aggregate_signatures_and_verify(
+        let aggr_sig2 = aggregate_signatures(
             &params,
             &aggr_vk_1,
             &attributes,
@@ -279,7 +258,7 @@ mod tests {
 
         // aggregating threshold+1 works
         let aggr_vk_more = aggregate_verification_keys(&vks[1..], Some(&[2, 3, 4, 5])).unwrap();
-        let aggr_more = aggregate_signatures_and_verify(
+        let aggr_more = aggregate_signatures(
             &params,
             &aggr_vk_more,
             &attributes,
@@ -291,7 +270,7 @@ mod tests {
 
         // aggregating all
         let aggr_vk_all = aggregate_verification_keys(&vks, Some(&[1, 2, 3, 4, 5])).unwrap();
-        let aggr_all = aggregate_signatures_and_verify(
+        let aggr_all = aggregate_signatures(
             &params,
             &aggr_vk_all,
             &attributes,
@@ -303,7 +282,7 @@ mod tests {
 
         // not taking enough points (threshold was 3) should fail
         let aggr_vk_not_enough = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
-        let aggr_not_enough = aggregate_signatures_and_verify(
+        let aggr_not_enough = aggregate_signatures(
             &params,
             &aggr_vk_not_enough,
             &attributes,
@@ -315,7 +294,7 @@ mod tests {
 
         // taking wrong index should fail
         let aggr_vk_bad = aggregate_verification_keys(&vks[2..], Some(&[1, 2, 3])).unwrap();
-        assert!(aggregate_signatures_and_verify(
+        assert!(aggregate_signatures(
             &params,
             &aggr_vk_bad,
             &attributes,
@@ -351,14 +330,9 @@ mod tests {
             .unzip();
 
         let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
-        assert!(aggregate_signatures_and_verify(
-            &params,
-            &aggr_vk_all,
-            &attributes,
-            &signatures,
-            None
-        )
-        .is_err());
+        assert!(
+            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, None).is_err()
+        );
     }
 
     #[test]
@@ -378,15 +352,11 @@ mod tests {
             .unzip();
         let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
 
-        assert!(aggregate_signatures_and_verify(
-            &params,
-            &aggr_vk_all,
-            &attributes,
-            &signatures,
-            Some(&[])
-        )
-        .is_err());
-        assert!(aggregate_signatures_and_verify(
+        assert!(
+            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, Some(&[]))
+                .is_err()
+        );
+        assert!(aggregate_signatures(
             &params,
             &aggr_vk_all,
             &attributes,
@@ -413,7 +383,7 @@ mod tests {
             .unzip();
         let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
 
-        assert!(aggregate_signatures_and_verify(
+        assert!(aggregate_signatures(
             &params,
             &aggr_vk_all,
             &attributes,

common/nymcoconut/src/scheme/issuance.rs

@@ -13,8 +13,9 @@ use crate::scheme::setup::Parameters;
 use crate::scheme::BlindedSignature;
 use crate::scheme::SecretKey;
 use crate::Attribute;
+/// Creates a Coconut Signature under a given secret key on a set of public attributes only.
+#[cfg(test)]
 use crate::Signature;
-
 // TODO: possibly completely remove those two functions.
 // They only exist to have a simpler and smaller code snippets to test
 // basic functionalities.
@@ -157,10 +158,6 @@ impl BlindSignRequest {
         )
     }
 
-    pub fn verify_commitment_hash(&self, public_attributes: &[&Attribute]) -> bool {
-        self.commitment_hash == compute_hash(self.commitment, public_attributes)
-    }
-
     pub fn get_commitment_hash(&self) -> G1Projective {
         self.commitment_hash
     }
@@ -429,9 +426,9 @@ pub fn verify_partial_blind_signature(
         .into()
 }
 
-/// Creates a Coconut Signature under a given secret key on a set of public attributes only.
+#[cfg(test)]
 pub fn sign(
-    params: &Parameters,
+    params: &mut Parameters,
     secret_key: &SecretKey,
     public_attributes: &[&Attribute],
 ) -> Result<Signature> {

common/nymcoconut/src/scheme/keygen.rs

@@ -151,6 +151,10 @@ impl Base58 for SecretKey {}
 // TODO: perhaps change points to affine representation
 // to make verification slightly more efficient?
 #[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(
+    feature = "key-zeroize",
+    derive(zeroize::Zeroize, zeroize::ZeroizeOnDrop)
+)]
 pub struct VerificationKey {
     // TODO add gen2 as per the paper or imply it from the fact library is using bls381?
     pub(crate) alpha: G2Projective,
@@ -407,23 +411,12 @@ impl Bytable for VerificationKey {
 
 impl Base58 for VerificationKey {}
 
-#[derive(Debug, Clone)]
-pub struct VerificationKeyShare {
-    pub key: VerificationKey,
-    pub index: SignerIndex,
-}
-
-impl From<(VerificationKey, SignerIndex)> for VerificationKeyShare {
-    fn from(value: (VerificationKey, SignerIndex)) -> Self {
-        VerificationKeyShare {
-            key: value.0,
-            index: value.1,
-        }
-    }
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 #[cfg_attr(test, derive(PartialEq, Eq, Clone))]
+#[cfg_attr(
+    feature = "key-zeroize",
+    derive(zeroize::Zeroize, zeroize::ZeroizeOnDrop)
+)]
 pub struct KeyPair {
     secret_key: SecretKey,
     verification_key: VerificationKey,
@@ -432,12 +425,6 @@ pub struct KeyPair {
     pub index: Option<SignerIndex>,
 }
 
-impl From<KeyPair> for (SecretKey, VerificationKey) {
-    fn from(value: KeyPair) -> Self {
-        (value.secret_key, value.verification_key)
-    }
-}
-
 impl PemStorableKeyPair for KeyPair {
     type PrivatePemKey = SecretKey;
     type PublicPemKey = VerificationKey;
@@ -474,13 +461,6 @@ impl KeyPair {
         &self.verification_key
     }
 
-    pub fn to_verification_key_share(&self) -> Option<VerificationKeyShare> {
-        self.index.map(|index| VerificationKeyShare {
-            key: self.verification_key.clone(),
-            index,
-        })
-    }
-
     pub fn to_bytes(&self) -> Vec<u8> {
         // Schema is coconutkeypair[14]|secret_key_len[8]|secret_key[secret_key_len]|verification_key_len[8]|verification_key[verification_key_len]|signer_index[8] - optional
         self.to_byte_vec()

common/nymcoconut/src/scheme/mod.rs

@@ -70,11 +70,6 @@ impl Signature {
         &self.1
     }
 
-    pub fn randomise_simple(&self, params: &Parameters) -> Signature {
-        let r = params.random_scalar();
-        Signature(self.0 * r, self.1 * r)
-    }
-
     pub fn randomise(&self, params: &Parameters) -> (Signature, Scalar) {
         let r = params.random_scalar();
         let r_prime = params.random_scalar();
@@ -196,7 +191,7 @@ impl BlindedSignature {
         &self,
         partial_verification_key: &VerificationKey,
         pedersen_commitments_openings: &[Scalar],
-    ) -> Signature {
+    ) -> Result<Signature> {
         // parse the signature
         let h = &self.0;
         let c = &self.1;
@@ -209,7 +204,7 @@ impl BlindedSignature {
 
         let unblinded_c = c - blinding_removers;
 
-        Signature(*h, unblinded_c)
+        Ok(Signature(*h, unblinded_c))
     }
 
     pub fn unblind_and_verify(
@@ -221,7 +216,7 @@ impl BlindedSignature {
         commitment_hash: &G1Projective,
         pedersen_commitments_openings: &[Scalar],
     ) -> Result<Signature> {
-        let unblinded = self.unblind(partial_verification_key, pedersen_commitments_openings);
+        let unblinded = self.unblind(partial_verification_key, pedersen_commitments_openings)?;
         unblinded.verify(
             params,
             partial_verification_key,
@@ -245,7 +240,6 @@ impl BlindedSignature {
 }
 
 // perhaps this should take signature by reference? we'll see how it goes
-#[derive(Clone, Copy)]
 pub struct SignatureShare {
     signature: Signature,
     index: SignerIndex,
@@ -282,9 +276,7 @@ impl SignatureShare {
 mod tests {
     use super::*;
     use crate::hash_to_scalar;
-    use crate::scheme::aggregation::{
-        aggregate_signatures_and_verify, aggregate_verification_keys,
-    };
+    use crate::scheme::aggregation::{aggregate_signatures, aggregate_verification_keys};
     use crate::scheme::issuance::{blind_sign, compute_hash, prepare_blind_sign, sign};
     use crate::scheme::keygen::{keygen, ttp_keygen};
     use crate::scheme::verification::{prove_bandwidth_credential, verify, verify_credential};
@@ -426,13 +418,13 @@ mod tests {
 
     #[test]
     fn verification_on_two_public_attributes() {
-        let params = Parameters::new(2).unwrap();
+        let mut params = Parameters::new(2).unwrap();
         random_scalars_refs!(attributes, params, 2);
 
         let keypair1 = keygen(&params);
         let keypair2 = keygen(&params);
-        let sig1 = sign(&params, keypair1.secret_key(), &attributes).unwrap();
-        let sig2 = sign(&params, keypair2.secret_key(), &attributes).unwrap();
+        let sig1 = sign(&mut params, keypair1.secret_key(), &attributes).unwrap();
+        let sig2 = sign(&mut params, keypair2.secret_key(), &attributes).unwrap();
 
         assert!(verify(
             &params,
@@ -576,14 +568,9 @@ mod tests {
         attributes.extend_from_slice(&public_attributes);
 
         let aggr_vk = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
-        let aggr_sig = aggregate_signatures_and_verify(
-            &params,
-            &aggr_vk,
-            &attributes,
-            &sigs[..2],
-            Some(&[1, 2]),
-        )
-        .unwrap();
+        let aggr_sig =
+            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[..2], Some(&[1, 2]))
+                .unwrap();
 
         let theta = prove_bandwidth_credential(
             &params,
@@ -603,14 +590,9 @@ mod tests {
 
         // taking different subset of keys and credentials
         let aggr_vk = aggregate_verification_keys(&vks[1..], Some(&[2, 3])).unwrap();
-        let aggr_sig = aggregate_signatures_and_verify(
-            &params,
-            &aggr_vk,
-            &attributes,
-            &sigs[1..],
-            Some(&[2, 3]),
-        )
-        .unwrap();
+        let aggr_sig =
+            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[1..], Some(&[2, 3]))
+                .unwrap();
 
         let theta = prove_bandwidth_credential(
             &params,

common/nymcoconut/src/scheme/setup.rs

@@ -10,7 +10,6 @@ use crate::error::{CoconutError, Result};
 use crate::utils::hash_g1;
 
 /// System-wide parameters used for the protocol
-#[derive(Clone)]
 pub struct Parameters {
     /// Generator of the G1 group
     g1: G1Affine,

common/nymcoconut/src/scheme/verification.rs

@@ -288,6 +288,7 @@ pub fn verify_credential(
 }
 
 // Used in tests only
+#[cfg(test)]
 pub fn verify(
     params: &Parameters,
     verification_key: &VerificationKey,

common/nymcoconut/src/tests/helpers.rs

@@ -75,12 +75,8 @@ pub fn theta_from_keys_and_attributes(
     attributes.extend_from_slice(public_attributes);
 
     // Randomize credentials and generate any cryptographic material to verify them
-    let signature = aggregate_signature_shares_and_verify(
-        params,
-        &verification_key,
-        &attributes,
-        &signature_shares,
-    )?;
+    let signature =
+        aggregate_signature_shares(params, &verification_key, &attributes, &signature_shares)?;
 
     // Generate cryptographic material to verify them
     let theta = prove_bandwidth_credential(

common/nymsphinx/Cargo.toml

@@ -10,7 +10,7 @@ repository = { workspace = true }
 [dependencies]
 log = { workspace = true }
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-rand_distr = { workspace = true }
+rand_distr = "0.3"
 thiserror = { workspace = true }
 
 nym-sphinx-acknowledgements = { path = "acknowledgements" }

common/nymsphinx/addressing/Cargo.toml

@@ -10,9 +10,9 @@ repository = { workspace = true }
 [dependencies]
 nym-crypto = { path = "../../crypto", features = ["asymmetric"] } # all addresses are expressed in terms on their crypto keys
 nym-sphinx-types = { path = "../types", features = ["sphinx"] } # we need to be able to refer to some types defined inside sphinx crate
-serde = { workspace = true } # implementing serialization/deserialization for some types, like `Recipient`
+serde = "1.0" # implementing serialization/deserialization for some types, like `Recipient`
 thiserror = { workspace = true }
 
 [dev-dependencies]
 rand = "0.7"
-nym-crypto = { path = "../../crypto", features = ["rand"] }
+nym-crypto = { path = "../../crypto", features = ["rand"] }

common/nymsphinx/framing/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-bytes = { workspace = true }
+bytes = "1.0"
 tokio-util = { workspace = true, features = ["codec"] }
 thiserror = { workspace = true }
 

common/nymsphinx/types/Cargo.toml

@@ -8,7 +8,7 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-sphinx-packet = { workspace = true, optional = true }
+sphinx-packet = { version = "0.1.0", optional = true }
 nym-outfox = { path = "../../../nym-outfox", optional = true }
 thiserror = { workspace = true }
 

common/nyxd-scraper/Cargo.toml

@@ -12,27 +12,25 @@ license.workspace = true
 
 [dependencies]
 async-trait.workspace = true
-const_format = { workspace = true }
+const_format = "0.2.32"
 cosmrs.workspace = true
-eyre = { workspace = true }
+eyre = "0.6.9"
 futures.workspace = true
-humantime = { workspace = true }
 sha2 = "0.10.8"
-serde = { workspace = true, features = ["derive"] }
 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
 time = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
-tokio-stream = { workspace = true }
-tokio-util = { workspace = true, features = ["rt"] }
+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"]}
+nym-bin-common = { path = "../bin-common", features = ["basic_tracing"]}
 
 
 [build-dependencies]

common/nyxd-scraper/README.md

@@ -1,23 +0,0 @@
-# Nyxd Scraper
-
-## Pruning
-
-Similarly to cosmos-sdk, we incorporate pruning into our (scraped) chain data. We attempt to follow their strategies as
-closely as possible for convenience's sake. Therefore, the following are available:
-
-### Strategies
-
-The strategies are configured in `config.toml`, with the format `pruning = "<strategy>"` where the options are:
-
-* `default`: only the last 362,880 states(approximately 3.5 weeks worth of state) are kept; pruning at 10 block
-  intervals
-* `nothing`: all historic states will be saved, nothing will be deleted (i.e. archiving node)
-* `everything`: 2 latest states will be kept; pruning at 10 block intervals.
-* `custom`: allow pruning options to be manually specified through `pruning.keep_recent`, and `pruning.interval`
-
-### Custom Pruning
-
-These are applied if and only if the pruning strategy is `custom`:
-
-* `pruning.keep_recent`: N means to keep all of the last N blocks
-* `pruning.interval`: N means to delete old block data from disk every Nth block.

common/nyxd-scraper/src/block_processor/mod.rs

@@ -8,7 +8,6 @@ use crate::error::ScraperError;
 use crate::modules::{BlockModule, MsgModule, TxModule};
 use crate::rpc_client::RpcClient;
 use crate::storage::{persist_block, ScraperStorage};
-use crate::PruningOptions;
 use futures::StreamExt;
 use std::collections::{BTreeMap, HashSet, VecDeque};
 use std::ops::{Add, Range};
@@ -19,10 +18,9 @@ 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, instrument, trace, warn};
+use tracing::{debug, error, info, warn};
 
 mod helpers;
-pub(crate) mod pruning;
 pub(crate) mod types;
 
 const MISSING_BLOCKS_CHECK_INTERVAL: Duration = Duration::from_secs(30);
@@ -42,11 +40,9 @@ impl PendingSync {
 }
 
 pub struct BlockProcessor {
-    pruning_options: PruningOptions,
     cancel: CancellationToken,
     synced: Arc<Notify>,
     last_processed_height: u32,
-    last_pruned_height: u32,
     last_processed_at: Instant,
     pending_sync: PendingSync,
     queued_blocks: BTreeMap<u32, BlockToProcess>,
@@ -66,7 +62,6 @@ pub struct BlockProcessor {
 
 impl BlockProcessor {
     pub async fn new(
-        pruning_options: PruningOptions,
         cancel: CancellationToken,
         synced: Arc<Notify>,
         incoming: UnboundedReceiver<BlockToProcess>,
@@ -75,17 +70,11 @@ impl BlockProcessor {
         rpc_client: RpcClient,
     ) -> Result<Self, ScraperError> {
         let last_processed = storage.get_last_processed_height().await?;
-        let last_processed_height = last_processed.try_into().unwrap_or_default();
-
-        let last_pruned = storage.get_pruned_height().await?;
-        let last_pruned_height = last_pruned.try_into().unwrap_or_default();
 
         Ok(BlockProcessor {
-            pruning_options,
             cancel,
             synced,
-            last_processed_height,
-            last_pruned_height,
+            last_processed_height: last_processed.try_into().unwrap_or_default(),
             last_processed_at: Instant::now(),
             pending_sync: Default::default(),
             queued_blocks: Default::default(),
@@ -142,17 +131,12 @@ impl BlockProcessor {
             }
         }
 
-        let commit_start = Instant::now();
         tx.commit()
             .await
             .map_err(|source| ScraperError::StorageTxCommitFailure { source })?;
-        crate::storage::log_db_operation_time("committing processing tx", commit_start);
 
         self.last_processed_height = full_info.block.header.height.value() as u32;
         self.last_processed_at = Instant::now();
-        if let Err(err) = self.maybe_prune_storage().await {
-            error!("failed to prune the storage: {err}");
-        }
 
         Ok(())
     }
@@ -226,61 +210,6 @@ impl BlockProcessor {
         Ok(())
     }
 
-    #[instrument(skip(self))]
-    async fn prune_storage(&mut self) -> Result<(), ScraperError> {
-        let keep_recent = self.pruning_options.strategy_keep_recent();
-        let last_to_keep = self.last_processed_height - keep_recent;
-
-        info!(
-            keep_recent,
-            oldest_to_keep = last_to_keep,
-            "pruning the storage"
-        );
-
-        let lowest: u32 = self
-            .storage
-            .lowest_block_height()
-            .await?
-            .unwrap_or_default()
-            .try_into()
-            .unwrap_or_default();
-
-        let to_prune = last_to_keep.saturating_sub(lowest);
-        match to_prune {
-            v if v > 1000 => warn!("approximately {v} blocks worth of data will be pruned"),
-            v if v > 100 => info!("approximately {v} blocks worth of data will be pruned"),
-            0 => trace!("no blocks to prune"),
-            v => debug!("approximately {v} blocks worth of data will be pruned"),
-        }
-
-        if to_prune == 0 {
-            return Ok(());
-        }
-
-        self.storage
-            .prune_storage(last_to_keep, self.last_processed_height)
-            .await?;
-
-        self.last_pruned_height = self.last_processed_height;
-        Ok(())
-    }
-
-    async fn maybe_prune_storage(&mut self) -> Result<(), ScraperError> {
-        debug!("checking for storage pruning");
-
-        if self.pruning_options.strategy.is_nothing() {
-            trace!("the current pruning strategy is 'nothing'");
-            return Ok(());
-        }
-
-        let interval = self.pruning_options.strategy_interval();
-        if self.last_pruned_height + interval <= self.last_processed_height {
-            self.prune_storage().await?;
-        }
-
-        Ok(())
-    }
-
     async fn next_incoming(&mut self, block: BlockToProcess) {
         let height = block.height;
 
@@ -350,8 +279,6 @@ impl BlockProcessor {
     async fn startup_resync(&mut self) -> Result<(), ScraperError> {
         assert!(self.pending_sync.is_empty());
 
-        self.maybe_prune_storage().await?;
-
         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;

common/nyxd-scraper/src/block_processor/pruning.rs

@@ -1,122 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::error::ScraperError;
-use serde::{Deserialize, Serialize};
-
-pub const DEFAULT_PRUNING_KEEP_RECENT: u32 = 362880;
-pub const DEFAULT_PRUNING_INTERVAL: u32 = 10;
-pub const EVERYTHING_PRUNING_KEEP_RECENT: u32 = 2;
-pub const EVERYTHING_PRUNING_INTERVAL: u32 = 10;
-
-/// We follow cosmos-sdk pruning strategies for convenience’s sake.
-#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum PruningStrategy {
-    /// 'Default' strategy defines a pruning strategy where the last 362880 heights are
-    /// kept where to-be pruned heights are pruned at every 10th height.
-    /// The last 362880 heights are kept(approximately 3.5 weeks worth of state) assuming the typical
-    /// block time is 6s. If these values do not match the applications' requirements, use the "custom" option.
-    #[default]
-    Default,
-
-    /// 'Everything' strategy defines a pruning strategy where all committed heights are
-    /// deleted, storing only the current height and last 2 states. To-be pruned heights are
-    /// pruned at every 10th height.
-    Everything,
-
-    /// 'Nothing' strategy defines a pruning strategy where all heights are kept on disk.
-    Nothing,
-
-    /// 'Custom' strategy defines a pruning strategy where the user specifies the pruning.
-    Custom,
-}
-
-impl PruningStrategy {
-    pub fn is_custom(&self) -> bool {
-        matches!(self, PruningStrategy::Custom)
-    }
-
-    pub fn is_nothing(&self) -> bool {
-        matches!(self, PruningStrategy::Nothing)
-    }
-
-    pub fn is_everything(&self) -> bool {
-        matches!(self, PruningStrategy::Everything)
-    }
-}
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct PruningOptions {
-    /// keep_recent defines how many recent heights to keep on disk.
-    pub keep_recent: u32,
-
-    /// interval defines the frequency of removing the pruned heights from the disk.
-    pub interval: u32,
-
-    /// strategy defines the currently used kind of [PruningStrategy].
-    pub strategy: PruningStrategy,
-}
-
-impl PruningOptions {
-    pub fn validate(&self) -> Result<(), ScraperError> {
-        // if strategy is not set to custom, other options are meaningless since they won't be applied
-        if !self.strategy.is_custom() {
-            return Ok(());
-        }
-
-        if self.interval == 0 {
-            return Err(ScraperError::ZeroPruningInterval);
-        }
-
-        if self.interval < EVERYTHING_PRUNING_INTERVAL {
-            return Err(ScraperError::TooSmallPruningInterval {
-                interval: self.interval,
-            });
-        }
-
-        if self.keep_recent < EVERYTHING_PRUNING_KEEP_RECENT {
-            return Err(ScraperError::TooSmallKeepRecent {
-                keep_recent: self.keep_recent,
-            });
-        }
-
-        Ok(())
-    }
-
-    pub fn nothing() -> Self {
-        PruningOptions {
-            keep_recent: 0,
-            interval: 0,
-            strategy: PruningStrategy::Nothing,
-        }
-    }
-
-    pub fn strategy_interval(&self) -> u32 {
-        match self.strategy {
-            PruningStrategy::Default => DEFAULT_PRUNING_INTERVAL,
-            PruningStrategy::Everything => EVERYTHING_PRUNING_INTERVAL,
-            PruningStrategy::Nothing => 0,
-            PruningStrategy::Custom => self.interval,
-        }
-    }
-
-    pub fn strategy_keep_recent(&self) -> u32 {
-        match self.strategy {
-            PruningStrategy::Default => DEFAULT_PRUNING_KEEP_RECENT,
-            PruningStrategy::Everything => EVERYTHING_PRUNING_KEEP_RECENT,
-            PruningStrategy::Nothing => 0,
-            PruningStrategy::Custom => self.keep_recent,
-        }
-    }
-}
-
-impl Default for PruningOptions {
-    fn default() -> Self {
-        PruningOptions {
-            keep_recent: DEFAULT_PRUNING_KEEP_RECENT,
-            interval: DEFAULT_PRUNING_INTERVAL,
-            strategy: Default::default(),
-        }
-    }
-}

common/nyxd-scraper/src/error.rs

@@ -1,9 +1,6 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::block_processor::pruning::{
-    EVERYTHING_PRUNING_INTERVAL, EVERYTHING_PRUNING_KEEP_RECENT,
-};
 use tendermint::Hash;
 use thiserror::Error;
 use tokio::sync::mpsc::error::SendError;
@@ -125,15 +122,6 @@ pub enum ScraperError {
         "could not find validator information for {address}; the validator has signed a commit"
     )]
     MissingValidatorInfoCommitted { address: String },
-
-    #[error("pruning.interval must not be set to 0. If you want to disable pruning, select pruning.strategy = \"nothing\"")]
-    ZeroPruningInterval,
-
-    #[error("pruning.interval must not be smaller than {}. got: {interval}. for most aggressive pruning, select pruning.strategy = \"everything\"", EVERYTHING_PRUNING_INTERVAL)]
-    TooSmallPruningInterval { interval: u32 },
-
-    #[error("pruning.keep_recent must not be smaller than {}. got: {keep_recent}. for most aggressive pruning, select pruning.strategy = \"everything\"", EVERYTHING_PRUNING_KEEP_RECENT)]
-    TooSmallKeepRecent { keep_recent: u32 },
 }
 
 impl<T> From<SendError<T>> for ScraperError {

common/nyxd-scraper/src/lib.rs

@@ -14,7 +14,6 @@ pub(crate) mod rpc_client;
 pub(crate) mod scraper;
 pub mod storage;
 
-pub use block_processor::pruning::{PruningOptions, PruningStrategy};
 pub use modules::{BlockModule, MsgModule, TxModule};
 pub use scraper::{Config, NyxdScraper};
 pub use storage::models;

common/nyxd-scraper/src/scraper/mod.rs

@@ -8,7 +8,6 @@ use crate::modules::{BlockModule, MsgModule, TxModule};
 use crate::rpc_client::RpcClient;
 use crate::scraper::subscriber::ChainSubscriber;
 use crate::storage::ScraperStorage;
-use crate::PruningOptions;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tokio::sync::mpsc::{channel, unbounded_channel};
@@ -28,8 +27,6 @@ pub struct Config {
     pub rpc_url: Url,
 
     pub database_path: PathBuf,
-
-    pub pruning_options: PruningOptions,
 }
 
 pub struct NyxdScraperBuilder {
@@ -57,7 +54,6 @@ impl NyxdScraperBuilder {
             processing_tx.clone(),
         );
         let mut block_processor = BlockProcessor::new(
-            scraper.config.pruning_options,
             scraper.cancel_token.clone(),
             scraper.startup_sync.clone(),
             processing_rx,
@@ -123,7 +119,6 @@ impl NyxdScraper {
     }
 
     pub async fn new(config: Config) -> Result<Self, ScraperError> {
-        config.pruning_options.validate()?;
         let storage = ScraperStorage::init(&config.database_path).await?;
 
         Ok(NyxdScraper {
@@ -165,7 +160,6 @@ impl NyxdScraper {
             processing_tx.clone(),
         );
         let block_processor = BlockProcessor::new(
-            self.config.pruning_options,
             self.cancel_token.clone(),
             self.startup_sync.clone(),
             processing_rx,

common/nyxd-scraper/src/storage/manager.rs

@@ -1,11 +1,9 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::storage::log_db_operation_time;
 use crate::storage::models::{CommitSignature, Validator};
 use sqlx::types::time::OffsetDateTime;
 use sqlx::{Executor, Sqlite};
-use tokio::time::Instant;
 use tracing::{instrument, trace};
 
 #[derive(Clone)]
@@ -27,36 +25,10 @@ impl StorageManager {
         Ok(())
     }
 
-    pub(crate) async fn get_lowest_block(&self) -> Result<Option<i64>, sqlx::Error> {
-        trace!("get_lowest_block");
-        let start = Instant::now();
-
-        let maybe_record = sqlx::query!(
-            r#"
-                SELECT height
-                FROM block
-                ORDER BY height ASC
-                LIMIT 1
-            "#,
-        )
-        .fetch_optional(&self.connection_pool)
-        .await?;
-        log_db_operation_time("get_lowest_block", start);
-
-        if let Some(row) = maybe_record {
-            Ok(row.height)
-        } else {
-            Ok(None)
-        }
-    }
-
     pub(crate) async fn get_first_block_height_after(
         &self,
         time: OffsetDateTime,
     ) -> Result<Option<i64>, sqlx::Error> {
-        trace!("get_first_block_height_after");
-        let start = Instant::now();
-
         let maybe_record = sqlx::query!(
             r#"
                 SELECT height
@@ -69,7 +41,6 @@ impl StorageManager {
         )
         .fetch_optional(&self.connection_pool)
         .await?;
-        log_db_operation_time("get_first_block_height_after", start);
 
         if let Some(row) = maybe_record {
             Ok(row.height)
@@ -82,9 +53,6 @@ impl StorageManager {
         &self,
         time: OffsetDateTime,
     ) -> Result<Option<i64>, sqlx::Error> {
-        trace!("get_last_block_height_before");
-        let start = Instant::now();
-
         let maybe_record = sqlx::query!(
             r#"
                 SELECT height
@@ -97,7 +65,6 @@ impl StorageManager {
         )
         .fetch_optional(&self.connection_pool)
         .await?;
-        log_db_operation_time("get_last_block_height_before", start);
 
         if let Some(row) = maybe_record {
             Ok(row.height)
@@ -112,9 +79,6 @@ impl StorageManager {
         start_height: i64,
         end_height: i64,
     ) -> Result<i32, sqlx::Error> {
-        trace!("get_signed_between");
-        let start = Instant::now();
-
         let count = sqlx::query!(
             r#"
                 SELECT COUNT(*) as count FROM pre_commit
@@ -130,7 +94,6 @@ impl StorageManager {
         .fetch_one(&self.connection_pool)
         .await?
         .count;
-        log_db_operation_time("get_signed_between", start);
 
         Ok(count)
     }
@@ -140,10 +103,7 @@ impl StorageManager {
         consensus_address: &str,
         height: i64,
     ) -> Result<Option<CommitSignature>, sqlx::Error> {
-        trace!("get_precommit");
-        let start = Instant::now();
-
-        let res = sqlx::query_as(
+        sqlx::query_as(
             r#"
                 SELECT * FROM pre_commit
                 WHERE validator_address = ? 
@@ -153,20 +113,14 @@ impl StorageManager {
         .bind(consensus_address)
         .bind(height)
         .fetch_optional(&self.connection_pool)
-        .await?;
-        log_db_operation_time("get_precommit", start);
-
-        Ok(res)
+        .await
     }
 
     pub(crate) async fn get_block_validators(
         &self,
         height: i64,
     ) -> Result<Vec<Validator>, sqlx::Error> {
-        trace!("get_block_validators");
-        let start = Instant::now();
-
-        let res = sqlx::query_as!(
+        sqlx::query_as!(
             Validator,
             r#"
                 SELECT * FROM validator 
@@ -179,28 +133,16 @@ impl StorageManager {
             height
         )
         .fetch_all(&self.connection_pool)
-        .await?;
-        log_db_operation_time("get_block_validators", start);
-
-        Ok(res)
+        .await
     }
 
     pub(crate) async fn get_validators(&self) -> Result<Vec<Validator>, sqlx::Error> {
-        trace!("get_validators");
-        let start = Instant::now();
-
-        let res = sqlx::query_as("SELECT * FROM validator")
+        sqlx::query_as("SELECT * FROM validator")
             .fetch_all(&self.connection_pool)
-            .await?;
-        log_db_operation_time("get_validators", start);
-
-        Ok(res)
+            .await
     }
 
     pub(crate) async fn get_last_processed_height(&self) -> Result<i64, sqlx::Error> {
-        trace!("get_last_processed_height");
-        let start = Instant::now();
-
         let maybe_record = sqlx::query!(
             r#"
                 SELECT last_processed_height FROM metadata
@@ -208,7 +150,6 @@ impl StorageManager {
         )
         .fetch_optional(&self.connection_pool)
         .await?;
-        log_db_operation_time("get_last_processed_height", start);
 
         if let Some(row) = maybe_record {
             Ok(row.last_processed_height)
@@ -216,27 +157,6 @@ impl StorageManager {
             Ok(-1)
         }
     }
-
-    pub(crate) async fn get_pruned_height(&self) -> Result<i64, sqlx::Error> {
-        trace!("get_pruned_height");
-        let start = Instant::now();
-
-        let maybe_record = sqlx::query!(
-            r#"
-                SELECT last_pruned_height FROM pruning
-            "#
-        )
-        .fetch_optional(&self.connection_pool)
-        .await?;
-
-        log_db_operation_time("get_pruned_height", start);
-
-        if let Some(row) = maybe_record {
-            Ok(row.last_pruned_height)
-        } else {
-            Ok(-1)
-        }
-    }
 }
 
 // make those generic over executor so that they could be performed over connection pool and a tx
@@ -250,8 +170,7 @@ pub(crate) async fn insert_validator<'a, E>(
 where
     E: Executor<'a, Database = Sqlite>,
 {
-    trace!("insert_validator");
-    let start = Instant::now();
+    trace!("insert validator");
 
     sqlx::query!(
         r#"
@@ -264,7 +183,6 @@ where
     )
     .execute(executor)
     .await?;
-    log_db_operation_time("insert_validator", start);
 
     Ok(())
 }
@@ -282,8 +200,7 @@ pub(crate) async fn insert_block<'a, E>(
 where
     E: Executor<'a, Database = Sqlite>,
 {
-    trace!("insert_block");
-    let start = Instant::now();
+    trace!("insert block");
 
     sqlx::query!(
         r#"
@@ -300,7 +217,6 @@ where
     )
     .execute(executor)
     .await?;
-    log_db_operation_time("insert_block", start);
 
     Ok(())
 }
@@ -317,8 +233,7 @@ pub(crate) async fn insert_precommit<'a, E>(
 where
     E: Executor<'a, Database = Sqlite>,
 {
-    trace!("insert_precommit");
-    let start = Instant::now();
+    trace!("insert precommit");
 
     sqlx::query!(
         r#"
@@ -334,7 +249,6 @@ where
     )
     .execute(executor)
     .await?;
-    log_db_operation_time("insert_precommit", start);
 
     Ok(())
 }
@@ -356,8 +270,7 @@ pub(crate) async fn insert_transaction<'a, E>(
 where
     E: Executor<'a, Database = Sqlite>,
 {
-    trace!("insert_transaction");
-    let start = Instant::now();
+    trace!("insert transaction");
 
     sqlx::query!(
         r#"
@@ -385,7 +298,6 @@ where
     )
         .execute(executor)
         .await?;
-    log_db_operation_time("insert_transaction", start);
 
     Ok(())
 }
@@ -401,8 +313,7 @@ pub(crate) async fn insert_message<'a, E>(
 where
     E: Executor<'a, Database = Sqlite>,
 {
-    trace!("insert_message");
-    let start = Instant::now();
+    trace!("insert message");
 
     sqlx::query!(
         r#"
@@ -419,7 +330,6 @@ where
     )
     .execute(executor)
     .await?;
-    log_db_operation_time("insert_message", start);
 
     Ok(())
 }
@@ -433,100 +343,10 @@ where
     E: Executor<'a, Database = Sqlite>,
 {
     trace!("update_last_processed");
-    let start = Instant::now();
 
     sqlx::query!("UPDATE metadata SET last_processed_height = ?", height)
         .execute(executor)
         .await?;
-    log_db_operation_time("update_last_processed", start);
-
-    Ok(())
-}
-
-#[instrument(skip(executor))]
-pub(crate) async fn update_last_pruned<'a, E>(height: i64, executor: E) -> Result<(), sqlx::Error>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    trace!("update_last_pruned");
-    let start = Instant::now();
-
-    sqlx::query!("UPDATE pruning SET last_pruned_height = ?", height)
-        .execute(executor)
-        .await?;
-    log_db_operation_time("update_last_pruned", start);
-
-    Ok(())
-}
-
-pub(crate) async fn prune_blocks<'a, E>(oldest_to_keep: i64, executor: E) -> Result<(), sqlx::Error>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    trace!("prune_blocks");
-    let start = Instant::now();
-
-    sqlx::query!("DELETE FROM block WHERE height < ?", oldest_to_keep)
-        .execute(executor)
-        .await?;
-    log_db_operation_time("prune_blocks", start);
-
-    Ok(())
-}
-
-pub(crate) async fn prune_pre_commits<'a, E>(
-    oldest_to_keep: i64,
-    executor: E,
-) -> Result<(), sqlx::Error>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    trace!("prune_pre_commits");
-    let start = Instant::now();
-
-    sqlx::query!("DELETE FROM pre_commit WHERE height < ?", oldest_to_keep)
-        .execute(executor)
-        .await?;
-    log_db_operation_time("prune_pre_commits", start);
-
-    Ok(())
-}
-
-pub(crate) async fn prune_transactions<'a, E>(
-    oldest_to_keep: i64,
-    executor: E,
-) -> Result<(), sqlx::Error>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    trace!("prune_transactions");
-    let start = Instant::now();
-
-    sqlx::query!(
-        "DELETE FROM \"transaction\" WHERE height < ?",
-        oldest_to_keep
-    )
-    .execute(executor)
-    .await?;
-    log_db_operation_time("prune_transactions", start);
-
-    Ok(())
-}
-
-pub(crate) async fn prune_messages<'a, E>(
-    oldest_to_keep: i64,
-    executor: E,
-) -> Result<(), sqlx::Error>
-where
-    E: Executor<'a, Database = Sqlite>,
-{
-    trace!("prune_messages");
-    let start = Instant::now();
-
-    sqlx::query!("DELETE FROM message WHERE height < ?", oldest_to_keep)
-        .execute(executor)
-        .await?;
-    log_db_operation_time("prune_messages", start);
 
     Ok(())
 }

common/nyxd-scraper/src/storage/mod.rs

@@ -5,8 +5,7 @@ use crate::block_processor::types::{FullBlockInformation, ParsedTransactionRespo
 use crate::error::ScraperError;
 use crate::storage::manager::{
     insert_block, insert_message, insert_precommit, insert_transaction, insert_validator,
-    prune_blocks, prune_messages, prune_pre_commits, prune_transactions, update_last_processed,
-    update_last_pruned, StorageManager,
+    update_last_processed, StorageManager,
 };
 use crate::storage::models::{CommitSignature, Validator};
 use sqlx::types::time::OffsetDateTime;
@@ -16,7 +15,6 @@ use std::path::Path;
 use tendermint::block::{Commit, CommitSig};
 use tendermint::Block;
 use tendermint_rpc::endpoint::validators;
-use tokio::time::Instant;
 use tracing::{debug, error, info, instrument, trace, warn};
 
 mod helpers;
@@ -30,19 +28,6 @@ pub struct ScraperStorage {
     pub(crate) manager: StorageManager,
 }
 
-pub(crate) fn log_db_operation_time(op_name: &str, start_time: Instant) {
-    let elapsed = start_time.elapsed();
-    let formatted = humantime::format_duration(elapsed);
-
-    match elapsed.as_millis() {
-        v if v > 10000 => error!("{op_name} took {formatted} to execute"),
-        v if v > 1000 => warn!("{op_name} took {formatted} to execute"),
-        v if v > 100 => info!("{op_name} took {formatted} to execute"),
-        v if v > 10 => debug!("{op_name} took {formatted} to execute"),
-        _ => trace!("{op_name} took {formatted} to execute"),
-    }
-}
-
 impl ScraperStorage {
     #[instrument]
     pub async fn init<P: AsRef<Path> + Debug>(database_path: P) -> Result<Self, ScraperError> {
@@ -80,32 +65,6 @@ impl ScraperStorage {
         Ok(storage)
     }
 
-    #[instrument(skip(self))]
-    pub async fn prune_storage(
-        &self,
-        oldest_to_keep: u32,
-        current_height: u32,
-    ) -> Result<(), ScraperError> {
-        let start = Instant::now();
-
-        let mut tx = self.begin_processing_tx().await?;
-
-        prune_messages(oldest_to_keep.into(), &mut tx).await?;
-        prune_transactions(oldest_to_keep.into(), &mut tx).await?;
-        prune_pre_commits(oldest_to_keep.into(), &mut tx).await?;
-        prune_blocks(oldest_to_keep.into(), &mut tx).await?;
-        update_last_pruned(current_height.into(), &mut tx).await?;
-
-        let commit_start = Instant::now();
-        tx.commit()
-            .await
-            .map_err(|source| ScraperError::StorageTxCommitFailure { source })?;
-        log_db_operation_time("committing pruning tx", commit_start);
-
-        log_db_operation_time("pruning storage", start);
-        Ok(())
-    }
-
     #[instrument(skip_all)]
     pub async fn begin_processing_tx(&self) -> Result<StorageTransaction, ScraperError> {
         debug!("starting storage tx");
@@ -116,10 +75,6 @@ impl ScraperStorage {
             .map_err(|source| ScraperError::StorageTxBeginFailure { source })
     }
 
-    pub async fn lowest_block_height(&self) -> Result<Option<i64>, ScraperError> {
-        Ok(self.manager.get_lowest_block().await?)
-    }
-
     pub async fn get_first_block_height_after(
         &self,
         time: OffsetDateTime,
@@ -200,10 +155,6 @@ impl ScraperStorage {
     pub async fn get_last_processed_height(&self) -> Result<i64, ScraperError> {
         Ok(self.manager.get_last_processed_height().await?)
     }
-
-    pub async fn get_pruned_height(&self) -> Result<i64, ScraperError> {
-        Ok(self.manager.get_pruned_height().await?)
-    }
 }
 
 pub async fn persist_block(

common/pemstore/Cargo.toml

@@ -8,4 +8,4 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-pem = { workspace = true }
+pem = "0.8"

common/socks5-client-core/Cargo.toml

@@ -11,14 +11,14 @@ anyhow = { workspace = true }
 dirs = "4.0"
 futures = { workspace = true }
 log = { workspace = true }
-pin-project = { workspace = true }
+pin-project = "1.0"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 reqwest = { workspace = true }
 schemars = { workspace = true, features = ["preserve_order"] }
 serde = { workspace = true, features = ["derive"] } # for config serialization/deserialization
-tap = { workspace = true }
+tap = "1.0.1"
 thiserror = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread", "net", "signal"] }
+tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal"] }
 url = { workspace = true }
 
 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }

common/socks5/proxy-helpers/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bytes = { workspace = true }
+bytes = "1.0"
 tokio = { workspace = true, features = [ "net", "io-util", "sync", "macros", "time", "rt-multi-thread" ] }
 tokio-util = { workspace = true, features = [ "io" ] } # reason for getting this guy is to to able to port to tokio 1.X more quickly by being able to use
 # their `read_buf` [from the util crate] replacement rather than having to rethink/reimplement `AvailableReader` with the new AsyncRead trait definition.
@@ -22,4 +22,4 @@ nym-socks5-requests = { path = "../requests" }
 nym-task = { path = "../../task" }
 
 [dev-dependencies]
-tokio-test = { workspace = true }
+tokio-test = "0.4.2"

common/socks5/requests/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bincode = { workspace = true }
+bincode = "1.3.3"
 log = { workspace = true }
 nym-exit-policy = { path = "../../../common/exit-policy"}
 nym-service-providers-common = { path = "../../../service-providers/common" }

common/statistics/Cargo.toml

@@ -13,8 +13,8 @@ license.workspace = true
 async-trait = { workspace = true }
 log = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
-serde = { workspace = true, features = ["derive"] }
-serde_json = { workspace = true }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1"
 sqlx = { workspace = true, features = ["runtime-tokio-rustls", "chrono"]}
 thiserror = { workspace = true }
-tokio = { workspace = true, features = ["time"] }
+tokio = { version = "1.24.1", features = [ "time" ] }

common/store-cipher/Cargo.toml

@@ -7,14 +7,14 @@ license.workspace = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-aes-gcm = { workspace = true }
-argon2 = { workspace = true }
+aes-gcm = { version = "0.10.1" }
+argon2 = { version = "0.5.0" }
 generic-array = { workspace = true, features = ["zeroize"] }
 rand = "0.8.5"
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, optional = true }
 thiserror = { workspace = true }
-zeroize = { workspace = true, features = ["zeroize_derive"] }
+zeroize = { version = "1.6.0", features = ["zeroize_derive"] }
 
 [target.'cfg(target_env = "wasm32-unknown-unknown")'.dependencies]
 getrandom = { version = "0.2", features = ["js"] }

common/tun/Cargo.toml

@@ -13,7 +13,7 @@ license.workspace = true
 [dependencies]
 thiserror.workspace = true
 tokio = { workspace = true, features = ["rt-multi-thread", "net", "io-util", "time", "sync", "macros"] }
-etherparse = { workspace = true }
+etherparse = "0.13.0"
 log.workspace = true
 nym-wireguard-types = { path = "../wireguard-types", optional = true }
 

common/tun/src/linux/tun_device.rs

@@ -159,7 +159,7 @@ impl TunDevice {
                 "add",
                 &format!("{}/{}", ipv6, netmaskv6),
                 "dev",
-                (tun.name()),
+                &tun.name(),
             ])
             .output()?;
         Ok(tun)

common/types/Cargo.toml

@@ -9,16 +9,16 @@ license.workspace = true
 
 [dependencies]
 base64 = "0.21.4"
-eyre = { workspace = true }
-hmac = { workspace = true }
+eyre = "0.6.5"
+hmac = "0.12.1"
 itertools = "0.11"
 log = { workspace = true }
 reqwest = { workspace = true }
-schemars = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
+schemars = "0.8"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = "0.10.8"
-strum = { workspace = true, features = ["derive"] }
+strum = { version = "0.25", features = ["derive"] }
 thiserror = { workspace = true }
 ts-rs = { workspace = true }
 url = { workspace = true }
@@ -34,7 +34,7 @@ nym-config = { path = "../../common/config" }
 nym-crypto = { path = "../../common/crypto", features = ["asymmetric"] }
 
 [dev-dependencies]
-tempfile = { workspace = true }
+tempfile = "3.3.0"
 
 [features]
 default = []

common/types/src/delegation.rs

@@ -50,7 +50,7 @@ pub struct DelegationWithEverything {
     pub accumulated_by_delegates: Option<DecCoin>,
     pub accumulated_by_operator: Option<DecCoin>,
     pub block_height: u64,
-    pub delegated_on_iso_datetime: Option<String>,
+    pub delegated_on_iso_datetime: String,
     pub cost_params: Option<MixNodeCostParams>,
     pub avg_uptime_percent: Option<u8>,
 
@@ -60,8 +60,6 @@ pub struct DelegationWithEverything {
     pub uses_vesting_contract_tokens: bool,
     pub unclaimed_rewards: Option<DecCoin>,
 
-    pub errors: Option<String>,
-
     // DEPRECATED, IF POSSIBLE TRY TO DISCONTINUE USE OF IT!
     pub pending_events: Vec<DelegationEvent>,
     pub mixnode_is_unbonding: Option<bool>,