Update publish-nym-binaries.yml

remove unused binaries for publishing
Merge pull request #4671 from nymtech/feature/embedded-ignore-score
2024-06-25 09:28:11 +02:00 · 2024-06-21 10:50:15 +01:00 · 2024-06-21 10:41:33 +01:00 · 2024-06-21 10:03:24 +01:00 · 2024-06-21 10:02:29 +01:00 · 2024-06-17 11:31:41 +01:00
483 changed files with 4893 additions and 28174 deletions
@@ -1,9 +0,0 @@
-# Description
-
-Closes: #XXXX
-
-<!-- If appropriate, insert relevant description here -->
-
-# Checklist:
-
- [ ] added a changelog entry to `CHANGELOG.md`
@@ -6,7 +6,6 @@ on:
      - 'clients/**'
      - 'common/**'
      - 'explorer-api/**'
-      - 'ephemera/**'
      - 'gateway/**'
      - 'integrations/**'
      - 'mixnode/**'
@@ -24,7 +23,6 @@ on:
      - 'clients/**'
      - 'common/**'
      - 'explorer-api/**'
-      - 'ephemera/**'
      - 'gateway/**'
      - 'integrations/**'
      - 'mixnode/**'
@@ -58,8 +58,6 @@ 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_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
@@ -0,0 +1,27 @@
+name: pr-validation
+
+on:
+  pull_request:
+    branches:
+      - develop
+      - 'release/**'
+    types:
+      - labeled
+      - unlabeled
+      - opened
+      - reopened
+      - synchronize
+      - edited
+      - milestoned
+      - demilestoned
+
+env:
+  LABELS: ${{ join( github.event.pull_request.labels.*.name, ' ' ) }}
+
+jobs:
+  check-milestone:
+    name: Check Milestone
+    runs-on: ubuntu-latest
+    steps:
+      - if: github.event.pull_request.milestone == null && contains( env.LABELS, 'no-milestone' ) == false
+        run: exit 1
@@ -27,23 +27,17 @@ jobs:
      release_id: ${{ steps.create-release.outputs.id }}
      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].published_at }}
      client_hash: ${{ steps.binary-hashes.outputs.client_hash }}
-      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 }}
-      netstat_hash: ${{ steps.binary-hashes.outputs.netstat_hash }}
      client_version: ${{ steps.binary-versions.outputs.client_version }}
-      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 }}
-      netstat_version: ${{ steps.binary-versions.outputs.netstat_version }}

    steps:
      - uses: actions/checkout@v3
@@ -75,12 +69,9 @@ jobs:
          path: |
            target/release/explorer-api
            target/release/nym-client
-            target/release/nym-gateway
-            target/release/nym-mixnode
            target/release/nym-socks5-client
            target/release/nym-api
            target/release/nym-network-requester
-            target/release/nym-network-statistics
            target/release/nym-cli
            target/release/nymvisor
            target/release/nym-node
@@ -94,12 +85,9 @@ jobs:
          files: |
            target/release/explorer-api
            target/release/nym-client
-            target/release/nym-gateway
-            target/release/nym-mixnode
            target/release/nym-socks5-client
            target/release/nym-api
            target/release/nym-network-requester
-            target/release/nym-network-statistics
            target/release/nym-cli
            target/release/nymvisor
            target/release/nym-node
@@ -4,6 +4,46 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

+## [2024.6-chomp] (2024-06-14)
+
+- Remove additional code as part of Ephemera Purge and SP and contracts ([#4650])
+- bugfix: make sure nym-api can handle non-cw2 (or without detailed build info) compliant contracts ([#4648])
+- introduced a flag to accept toc and exposed it via self-described API ([#4647])
+- bugfix: make sure to return an error on invalid public ip ([#4646])
+- Add ci check for PR having an assigned milestone ([#4644])
+- Removed ephemera code ([#4642])
+- Remove stale peers ([#4640])
+- Add generic wg private network routing ([#4636])
+- Feature/new node endpoints ([#4635])
+- standarised ContractBuildInformation and added it to all contracts ([#4631])
+- validate nym-node public ips on startup ([#4630])
+- Bump defguard wg ([#4625])
+- Fix cargo warnings ([#4624])
+- Update kernel peers on peer modification ([#4622])
+- Handle v6 and v7 requests in the IPR, but reply with v6 ([#4620])
+- fix typo ([#4619])
+- Update crypto and rand crates ([#4607])
+- Purge name service and service provider directory contracts ([#4603])
+
+[#4650]: https://github.com/nymtech/nym/pull/4650
+[#4648]: https://github.com/nymtech/nym/pull/4648
+[#4647]: https://github.com/nymtech/nym/pull/4647
+[#4646]: https://github.com/nymtech/nym/pull/4646
+[#4644]: https://github.com/nymtech/nym/pull/4644
+[#4642]: https://github.com/nymtech/nym/pull/4642
+[#4640]: https://github.com/nymtech/nym/pull/4640
+[#4636]: https://github.com/nymtech/nym/pull/4636
+[#4635]: https://github.com/nymtech/nym/pull/4635
+[#4631]: https://github.com/nymtech/nym/pull/4631
+[#4630]: https://github.com/nymtech/nym/pull/4630
+[#4625]: https://github.com/nymtech/nym/pull/4625
+[#4624]: https://github.com/nymtech/nym/pull/4624
+[#4622]: https://github.com/nymtech/nym/pull/4622
+[#4620]: https://github.com/nymtech/nym/pull/4620
+[#4619]: https://github.com/nymtech/nym/pull/4619
+[#4607]: https://github.com/nymtech/nym/pull/4607
+[#4603]: https://github.com/nymtech/nym/pull/4603
+
 ## [2024.5-ragusa] (2024-05-22)

 - Feature/nym node api location ([#4605])
@@ -526,8 +526,6 @@ dependencies = [
 "bs58 0.5.1",
 "hmac",
 "k256",
- "once_cell",
- "pbkdf2",
 "rand_core 0.6.4",
 "ripemd",
 "sha2 0.10.8",
@@ -2095,7 +2093,7 @@ checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"

 [[package]]
 name = "explorer-api"
-version = "1.1.34"
+version = "1.1.35"
 dependencies = [
 "chrono",
 "clap 4.5.4",
@@ -2204,7 +2202,6 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
 dependencies = [
- "bitvec",
 "rand_core 0.6.4",
 "subtle 2.5.0",
 ]
@@ -3861,7 +3858,7 @@ dependencies = [

 [[package]]
 name = "nym-api"
-version = "1.1.38"
+version = "1.1.39"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -3898,11 +3895,9 @@ dependencies = [
 "nym-inclusion-probability",
 "nym-mixnet-contract-common",
 "nym-multisig-contract-common",
- "nym-name-service-common",
 "nym-node-requests",
 "nym-node-tester-utils",
 "nym-pemstore",
- "nym-service-provider-directory-common",
 "nym-sphinx",
 "nym-task",
 "nym-topology",
@@ -3945,6 +3940,7 @@ dependencies = [
 "nym-crypto",
 "nym-mixnet-contract-common",
 "nym-node-requests",
+ "rocket",
 "schemars",
 "serde",
 "serde_json",
@@ -4022,7 +4018,7 @@ dependencies = [

 [[package]]
 name = "nym-cli"
-version = "1.1.36"
+version = "1.1.37"
 dependencies = [
 "anyhow",
 "base64 0.13.1",
@@ -4081,10 +4077,8 @@ dependencies = [
 "nym-id",
 "nym-mixnet-contract-common",
 "nym-multisig-contract-common",
- "nym-name-service-common",
 "nym-network-defaults",
 "nym-pemstore",
- "nym-service-provider-directory-common",
 "nym-sphinx",
 "nym-types",
 "nym-validator-client",
@@ -4103,7 +4097,7 @@ dependencies = [

 [[package]]
 name = "nym-client"
-version = "1.1.35"
+version = "1.1.36"
 dependencies = [
 "bs58 0.5.1",
 "clap 4.5.4",
@@ -4343,10 +4337,12 @@ dependencies = [
 "bs58 0.5.1",
 "cosmwasm-schema",
 "cosmwasm-std",
+ "cw-storage-plus",
 "schemars",
 "serde",
 "serde_json",
 "thiserror",
+ "vergen",
 ]

 [[package]]
@@ -4463,16 +4459,6 @@ dependencies = [
 "zeroize",
 ]

-[[package]]
-name = "nym-ephemera-common"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-utils",
- "nym-contracts-common",
-]
-
 [[package]]
 name = "nym-execute"
 version = "0.1.0"
@@ -4520,7 +4506,7 @@ dependencies = [

 [[package]]
 name = "nym-gateway"
-version = "1.1.36"
+version = "1.1.37"
 dependencies = [
 "anyhow",
 "async-trait",
@@ -4711,6 +4697,7 @@ dependencies = [
 "bincode",
 "bytes",
 "nym-bin-common",
+ "nym-crypto",
 "nym-sphinx",
 "rand 0.8.5",
 "serde",
@@ -4755,6 +4742,7 @@ dependencies = [
 "serde_json",
 "tap",
 "thiserror",
+ "time",
 "tokio",
 "tokio-tun",
 "tokio-util",
@@ -4817,7 +4805,7 @@ dependencies = [

 [[package]]
 name = "nym-mixnode"
-version = "1.1.37"
+version = "1.1.38"
 dependencies = [
 "anyhow",
 "axum 0.7.5",
@@ -4905,20 +4893,6 @@ dependencies = [
 "thiserror",
 ]

-[[package]]
-name = "nym-name-service-common"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-controllers",
- "cw-utils",
- "cw2",
- "nym-contracts-common",
- "serde",
- "thiserror",
-]
-
 [[package]]
 name = "nym-network-defaults"
 version = "0.1.0"
@@ -4936,7 +4910,7 @@ dependencies = [

 [[package]]
 name = "nym-network-requester"
-version = "1.1.36"
+version = "1.1.37"
 dependencies = [
 "addr",
 "anyhow",
@@ -4988,7 +4962,7 @@ dependencies = [

 [[package]]
 name = "nym-network-statistics"
-version = "1.1.34"
+version = "1.1.35"
 dependencies = [
 "dirs 4.0.0",
 "log",
@@ -5005,7 +4979,7 @@ dependencies = [

 [[package]]
 name = "nym-node"
-version = "1.1.2"
+version = "1.1.3"
 dependencies = [
 "anyhow",
 "bip39",
@@ -5248,19 +5222,6 @@ dependencies = [
 "url",
 ]

-[[package]]
-name = "nym-service-provider-directory-common"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-controllers",
- "cw-utils",
- "cw2",
- "nym-contracts-common",
- "thiserror",
-]
-
 [[package]]
 name = "nym-service-providers-common"
 version = "0.1.0"
@@ -5280,7 +5241,7 @@ dependencies = [

 [[package]]
 name = "nym-socks5-client"
-version = "1.1.35"
+version = "1.1.36"
 dependencies = [
 "bs58 0.5.1",
 "clap 4.5.4",
@@ -5679,14 +5640,11 @@ dependencies = [
 "nym-coconut-dkg-common",
 "nym-config",
 "nym-contracts-common",
- "nym-ephemera-common",
 "nym-group-contract-common",
 "nym-http-api-client",
 "nym-mixnet-contract-common",
 "nym-multisig-contract-common",
- "nym-name-service-common",
 "nym-network-defaults",
- "nym-service-provider-directory-common",
 "nym-vesting-contract-common",
 "prost 0.12.4",
 "reqwest 0.12.4",
@@ -5783,6 +5741,7 @@ dependencies = [
 "nym-task",
 "nym-wireguard-types",
 "tokio",
+ "tokio-stream",
 "x25519-dalek",
 ]

@@ -5808,7 +5767,7 @@ dependencies = [

 [[package]]
 name = "nymvisor"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
 "anyhow",
 "bytes",
@@ -6120,16 +6079,6 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

-[[package]]
-name = "pbkdf2"
-version = "0.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
-dependencies = [
- "digest 0.10.7",
- "hmac",
-]
-
 [[package]]
 name = "pear"
 version = "0.2.9"
@@ -9266,11 +9215,14 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"

 [[package]]
 name = "vergen"
-version = "8.2.6"
+version = "8.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1290fd64cc4e7d3c9b07d7f333ce0ce0007253e32870e632624835cc80b83939"
+checksum = "e27d6bdd219887a9eadd19e1c34f32e47fa332301184935c6d9bca26f3cca525"
 dependencies = [
 "anyhow",
+ "cargo_metadata",
+ "cfg-if",
+ "regex",
 "rustc_version 0.4.0",
 "rustversion",
 "time",
@@ -35,12 +35,9 @@ members = [
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
-    #    "common/cosmwasm-smart-contracts/ephemera",
    "common/cosmwasm-smart-contracts/group-contract",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
-    "common/cosmwasm-smart-contracts/name-service",
-    "common/cosmwasm-smart-contracts/service-provider-directory",
    "common/cosmwasm-smart-contracts/vesting-contract",
    "common/country-group",
    "common/credential-storage",
@@ -119,7 +116,7 @@ members = [
    "tools/nymvisor",
    "tools/ts-rs-cli",
    "wasm/client",
-    #    "wasm/full-nym-wasm",
+    # "wasm/full-nym-wasm",  # If we uncomment this again, remember to also uncomment the profile settings below
    "wasm/mix-fetch",
    "wasm/node-tester",
    "wasm/zknym-lib",
@@ -292,7 +289,7 @@ tungstenite = { version = "0.20.1", default-features = false }
 url = "2.4"
 utoipa = "4.2.0"
 utoipa-swagger-ui = "6.0.0"
-vergen = { version = "=8.2.6", default-features = false }
+vergen = { version = "=8.3.1", default-features = false }
 walkdir = "2"
 wasm-bindgen-test = "0.3.36"
 zeroize = "1.6.0"
@@ -302,9 +299,9 @@ prometheus = { version = "0.13.0" }
 # coconut/DKG related
 # 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
-bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch = "feature/gt-serialization-0.8.0" }
-group = "0.13.0"
-ff = "0.13.0"
+bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", default-features = false,  branch = "feature/gt-serialization-0.8.0" }
+group = { version = "0.13.0", default-features = false }
+ff = { version = "0.13.0", default-features = false }

 # cosmwasm-related
 cosmwasm-derive = "=1.4.3"
@@ -323,14 +320,14 @@ cw4 = { version = "=1.1.2" }
 cw-controllers = { version = "=1.1.0" }

 # cosmrs-related
-bip32 = "0.5.1"
+bip32 = { version = "0.5.1", default-features = false }

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

 # wasm-related dependencies
 gloo-utils = "0.2.0"
@@ -358,9 +355,12 @@ opt-level = 'z'
 # lto = true
 opt-level = 'z'

-[profile.release.package.nym-wasm-sdk]
-# lto = true
-opt-level = 'z'
+# Commented out since the crate is also commented out from the inclusion in the
+# workspace above. We should uncomment this if we re-include it in the
+# workspace
+#[profile.release.package.nym-wasm-sdk]
+## lto = true
+#opt-level = 'z'

 [profile.release.package.mix-fetch-wasm]
 # lto = true
@@ -134,7 +134,7 @@ clippy: sdk-wasm-lint
 # Build contracts ready for deploy
 # -----------------------------------------------------------------------------

-CONTRACTS=vesting_contract mixnet_contract nym_service_provider_directory nym_name_service
+CONTRACTS=vesting_contract mixnet_contract
 CONTRACTS_WASM=$(addsuffix .wasm, $(CONTRACTS))
 CONTRACTS_OUT_DIR=contracts/target/wasm32-unknown-unknown/release

@@ -186,4 +186,4 @@ deb-gateway: build-nym-gateway
 deb-cli: build-nym-cli
 	cargo deb -p nym-cli

-deb: deb-mixnode deb-gateway deb-cli
+deb: deb-mixnode deb-gateway deb-cli
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.35"
+version = "1.1.36"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.35"
+version = "1.1.36"
 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"
@@ -24,6 +24,11 @@ const DEFAULT_MESSAGE_STREAM_AVERAGE_DELAY: Duration = Duration::from_millis(20)
 const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(50);
 const DEFAULT_TOPOLOGY_REFRESH_RATE: Duration = Duration::from_secs(5 * 60); // every 5min
 const DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT: Duration = Duration::from_millis(5_000);
+
+// the same values as our current (10.06.24) blacklist
+const DEFAULT_MIN_MIXNODE_PERFORMANCE: u8 = 50;
+const DEFAULT_MIN_GATEWAY_PERFORMANCE: u8 = 50;
+
 const DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD: Duration = Duration::from_secs(70 * 60); // 70min -> full epoch (1h) + a bit of overhead

 // Set this to a high value for now, so that we don't risk sporadic timeouts that might cause
@@ -516,6 +521,14 @@ pub struct Topology {

    /// Specifies the mixnode topology to be used for sending packets.
    pub topology_structure: TopologyStructure,
+
+    /// Specifies a minimum performance of a mixnode that is used on route construction.
+    /// This setting is only applicable when `NymApi` topology is used.
+    pub minimum_mixnode_performance: u8,
+
+    /// Specifies a minimum performance of a gateway that is used on route construction.
+    /// This setting is only applicable when `NymApi` topology is used.
+    pub minimum_gateway_performance: u8,
 }

 #[allow(clippy::large_enum_variant)]
@@ -550,6 +563,8 @@ impl Default for Topology {
            disable_refreshing: false,
            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
            topology_structure: TopologyStructure::default(),
+            minimum_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
+            minimum_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
        }
    }
 }
@@ -146,6 +146,7 @@ impl From<ConfigV5> for Config {
                        .topology
                        .max_startup_gateway_waiting_period,
                    topology_structure: value.debug.topology.topology_structure.into(),
+                    ..Default::default()
                },
                reply_surbs: ReplySurbs {
                    minimum_reply_surb_storage_threshold: value
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+CREATE TABLE remote_gateway_details_temp
+(
+    gateway_id_bs58                          TEXT NOT NULL UNIQUE PRIMARY KEY REFERENCES registered_gateway (gateway_id_bs58),
+    derived_aes128_ctr_blake3_hmac_keys_bs58 TEXT NOT NULL,
+    gateway_owner_address                    TEXT,
+    gateway_listener                         TEXT NOT NULL,
+    wg_tun_address                           TEXT
+);
+
+INSERT INTO remote_gateway_details_temp SELECT * FROM remote_gateway_details;
+
+DROP TABLE remote_gateway_details;
+ALTER TABLE remote_gateway_details_temp RENAME TO remote_gateway_details;
@@ -65,7 +65,7 @@ impl GatewayDetails {
    pub fn new_remote(
        gateway_id: identity::PublicKey,
        derived_aes128_ctr_blake3_hmac_keys: Arc<SharedKeys>,
-        gateway_owner_address: AccountId,
+        gateway_owner_address: Option<AccountId>,
        gateway_listener: Url,
        wg_tun_address: Option<Url>,
    ) -> Self {
@@ -170,7 +170,7 @@ pub struct RegisteredGateway {
 pub struct RawRemoteGatewayDetails {
    pub gateway_id_bs58: String,
    pub derived_aes128_ctr_blake3_hmac_keys_bs58: String,
-    pub gateway_owner_address: String,
+    pub gateway_owner_address: Option<String>,
    pub gateway_listener: String,
    pub wg_tun_address: Option<String>,
 }
@@ -195,14 +195,19 @@ impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {
                })?,
        );

-        let gateway_owner_address =
-            AccountId::from_str(&value.gateway_owner_address).map_err(|source| {
-                BadGateway::MalformedGatewayOwnerAccountAddress {
-                    gateway_id: value.gateway_id_bs58.clone(),
-                    raw_owner: value.gateway_owner_address.clone(),
-                    source,
-                }
-            })?;
+        let gateway_owner_address = value
+            .gateway_owner_address
+            .as_ref()
+            .map(|raw_owner| {
+                AccountId::from_str(raw_owner).map_err(|source| {
+                    BadGateway::MalformedGatewayOwnerAccountAddress {
+                        gateway_id: value.gateway_id_bs58.clone(),
+                        raw_owner: raw_owner.clone(),
+                        source,
+                    }
+                })
+            })
+            .transpose()?;

        let gateway_listener = Url::parse(&value.gateway_listener).map_err(|source| {
            BadGateway::MalformedListener {
@@ -241,7 +246,7 @@ impl<'a> From<&'a RemoteGatewayDetails> for RawRemoteGatewayDetails {
            derived_aes128_ctr_blake3_hmac_keys_bs58: value
                .derived_aes128_ctr_blake3_hmac_keys
                .to_base58_string(),
-            gateway_owner_address: value.gateway_owner_address.to_string(),
+            gateway_owner_address: value.gateway_owner_address.as_ref().map(|o| o.to_string()),
            gateway_listener: value.gateway_listener.to_string(),
            wg_tun_address: value.wg_tun_address.as_ref().map(|addr| addr.to_string()),
        }
@@ -256,7 +261,7 @@ pub struct RemoteGatewayDetails {
    // the keys will be zeroized
    pub derived_aes128_ctr_blake3_hmac_keys: Arc<SharedKeys>,

-    pub gateway_owner_address: AccountId,
+    pub gateway_owner_address: Option<AccountId>,

    pub gateway_listener: Url,

@@ -25,7 +25,7 @@ use crate::client::replies::reply_storage::{
 };
 use crate::client::topology_control::nym_api_provider::NymApiTopologyProvider;
 use crate::client::topology_control::{
-    TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
+    nym_api_provider, TopologyAccessor, TopologyRefresher, TopologyRefresherConfig,
 };
 use crate::config::{Config, DebugConfig};
 use crate::error::ClientCoreError;
@@ -388,7 +388,10 @@ where

            let cfg = GatewayConfig::new(
                details.gateway_id,
-                Some(details.gateway_owner_address.to_string()),
+                details
+                    .gateway_owner_address
+                    .as_ref()
+                    .map(|o| o.to_string()),
                gateway_listener,
            );
            GatewayClient::new(
@@ -462,12 +465,16 @@ where

    fn setup_topology_provider(
        custom_provider: Option<Box<dyn TopologyProvider + Send + Sync>>,
-        provider_from_config: config::TopologyStructure,
+        config_topology: config::Topology,
        nym_api_urls: Vec<Url>,
    ) -> Box<dyn TopologyProvider + Send + Sync> {
        // if no custom provider was ... provided ..., create one using nym-api
-        custom_provider.unwrap_or_else(|| match provider_from_config {
+        custom_provider.unwrap_or_else(|| match config_topology.topology_structure {
            config::TopologyStructure::NymApi => Box::new(NymApiTopologyProvider::new(
+                nym_api_provider::Config {
+                    min_mixnode_performance: config_topology.minimum_mixnode_performance,
+                    min_gateway_performance: config_topology.minimum_gateway_performance,
+                },
                nym_api_urls,
                env!("CARGO_PKG_VERSION").to_string(),
            )),
@@ -680,7 +687,7 @@ where

        let topology_provider = Self::setup_topology_provider(
            self.custom_topology_provider.take(),
-            self.config.debug.topology.topology_structure,
+            self.config.debug.topology,
            self.config.get_nym_api_endpoints(),
        );

@@ -92,11 +92,11 @@ pub mod v1_1_33 {
                    message: format!("the stored gateway id was malformed: {err}"),
                })?,
            derived_aes128_ctr_blake3_hmac_keys: Arc::new(gateway_shared_key),
-            gateway_owner_address: gateway_owner.parse().map_err(|err| {
+            gateway_owner_address: Some(gateway_owner.parse().map_err(|err| {
                ClientCoreError::UpgradeFailure {
                    message: format!("the stored gateway owner address was malformed: {err}"),
                }
-            })?,
+            })?),
            gateway_listener: gateway_listener.parse().map_err(|err| {
                ClientCoreError::UpgradeFailure {
                    message: format!("the stored gateway listener address was malformed: {err}"),
@@ -2,14 +2,35 @@
 // SPDX-License-Identifier: Apache-2.0

 use async_trait::async_trait;
-use log::{error, warn};
+use log::{debug, error, warn};
 use nym_topology::provider_trait::TopologyProvider;
-use nym_topology::{nym_topology_from_detailed, NymTopology, NymTopologyError};
+use nym_topology::{NymTopology, NymTopologyError};
 use rand::prelude::SliceRandom;
 use rand::thread_rng;
 use url::Url;

+// the same values as our current (10.06.24) blacklist
+pub const DEFAULT_MIN_MIXNODE_PERFORMANCE: u8 = 50;
+pub const DEFAULT_MIN_GATEWAY_PERFORMANCE: u8 = 50;
+
+pub(crate) struct Config {
+    pub(crate) min_mixnode_performance: u8,
+    pub(crate) min_gateway_performance: u8,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        // old values that decided on blacklist membership
+        Config {
+            min_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
+            min_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
+        }
+    }
+}
+
 pub(crate) struct NymApiTopologyProvider {
+    config: Config,
+
    validator_client: nym_validator_client::client::NymApiClient,
    nym_api_urls: Vec<Url>,

@@ -18,10 +39,11 @@ pub(crate) struct NymApiTopologyProvider {
 }

 impl NymApiTopologyProvider {
-    pub(crate) fn new(mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
+    pub(crate) fn new(config: Config, mut nym_api_urls: Vec<Url>, client_version: String) -> Self {
        nym_api_urls.shuffle(&mut thread_rng());

        NymApiTopologyProvider {
+            config,
            validator_client: nym_validator_client::client::NymApiClient::new(
                nym_api_urls[0].clone(),
            ),
@@ -61,7 +83,11 @@ impl NymApiTopologyProvider {
    }

    async fn get_current_compatible_topology(&mut self) -> Option<NymTopology> {
-        let mixnodes = match self.validator_client.get_cached_active_mixnodes().await {
+        let mixnodes = match self
+            .validator_client
+            .get_basic_mixnodes(Some(self.client_version.clone()))
+            .await
+        {
            Err(err) => {
                error!("failed to get network mixnodes - {err}");
                return None;
@@ -69,7 +95,11 @@ impl NymApiTopologyProvider {
            Ok(mixes) => mixes,
        };

-        let gateways = match self.validator_client.get_cached_described_gateways().await {
+        let gateways = match self
+            .validator_client
+            .get_basic_gateways(Some(self.client_version.clone()))
+            .await
+        {
            Err(err) => {
                error!("failed to get network gateways - {err}");
                return None;
@@ -77,8 +107,20 @@ impl NymApiTopologyProvider {
            Ok(gateways) => gateways,
        };

-        let topology = nym_topology_from_detailed(mixnodes, gateways)
-            .filter_system_version(&self.client_version);
+        debug!(
+            "there are {} mixnodes and {} gateways in total (before performance filtering)",
+            mixnodes.len(),
+            gateways.len()
+        );
+
+        let topology = NymTopology::from_unordered(
+            mixnodes.iter().filter(|m| {
+                m.performance.round_to_integer() >= self.config.min_mixnode_performance
+            }),
+            gateways.iter().filter(|g| {
+                g.performance.round_to_integer() >= self.config.min_gateway_performance
+            }),
+        );

        if let Err(err) = self.check_layer_distribution(&topology) {
            warn!("The current filtered active topology has extremely skewed layer distribution. It cannot be used: {err}");
@@ -29,7 +29,7 @@ pub enum SelectedGateway {
    Remote {
        gateway_id: identity::PublicKey,

-        gateway_owner_address: AccountId,
+        gateway_owner_address: Option<AccountId>,

        gateway_listener: Url,

@@ -84,13 +84,19 @@ impl SelectedGateway {

        let wg_tun_address = wg_tun_address(wg_tun_ip_address, &node)?;

-        let gateway_owner_address = AccountId::from_str(&node.owner).map_err(|source| {
-            ClientCoreError::MalformedGatewayOwnerAccountAddress {
-                gateway_id: node.identity_key.to_base58_string(),
-                raw_owner: node.owner,
-                err: source.to_string(),
-            }
-        })?;
+        let gateway_owner_address = node
+            .owner
+            .as_ref()
+            .map(|raw_owner| {
+                AccountId::from_str(raw_owner).map_err(|source| {
+                    ClientCoreError::MalformedGatewayOwnerAccountAddress {
+                        gateway_id: node.identity_key.to_base58_string(),
+                        raw_owner: raw_owner.clone(),
+                        err: source.to_string(),
+                    }
+                })
+            })
+            .transpose()?;

        let gateway_listener =
            Url::parse(&gateway_listener).map_err(|source| ClientCoreError::MalformedListener {
@@ -14,17 +14,14 @@ colored = { workspace = true }

 nym-coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
 nym-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
-nym-ephemera-common = { path = "../../cosmwasm-smart-contracts/ephemera" }
 nym-mixnet-contract-common = { path = "../../cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../../cosmwasm-smart-contracts/vesting-contract" }
 nym-coconut-bandwidth-contract-common = { path = "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 nym-multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
-nym-name-service-common = { path = "../../cosmwasm-smart-contracts/name-service" }
 nym-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contract" }
-nym-service-provider-directory-common = { path = "../../cosmwasm-smart-contracts/service-provider-directory" }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
-nym-http-api-client = { path = "../../../common/http-api-client"}
+nym-http-api-client = { path = "../../../common/http-api-client" }
 thiserror = { workspace = true }
 log = { workspace = true }
 url = { workspace = true, features = ["serde"] }
@@ -86,14 +83,6 @@ name = "offline_signing"
 # (traits would need to be moved around and refactored themselves)
 required-features = ["http-client"]

-[[example]]
-name = "query_service_provider_directory"
-required-features = ["http-client"]
-
-[[example]]
-name = "query_name_service"
-required-features = ["http-client"]
-
 [features]
 default = ["http-client"]
 http-client = ["cosmrs/rpc"]
@@ -1,37 +0,0 @@
-use std::str::FromStr;
-
-use cosmrs::AccountId;
-use nym_name_service_common::Address;
-use nym_network_defaults::{setup_env, NymNetworkDetails};
-use nym_validator_client::nyxd::contract_traits::{
-    NameServiceQueryClient, PagedNameServiceQueryClient,
-};
-
-#[tokio::main]
-async fn main() {
-    setup_env(Some("../../../envs/qa.env"));
-    let network_details = NymNetworkDetails::new_from_env();
-    let config =
-        nym_validator_client::Config::try_from_nym_network_details(&network_details).unwrap();
-    let client = nym_validator_client::Client::new_query(config).unwrap();
-
-    let config = client.nyxd.get_name_service_config().await.unwrap();
-    println!("config: {config:?}");
-
-    let names_paged = client.nyxd.get_names_paged(None, None).await.unwrap();
-    println!("names (paged): {names_paged:#?}");
-
-    let names = client.nyxd.get_all_names().await.unwrap();
-    println!("names: {names:#?}");
-
-    let owner = AccountId::from_str("n1hmf957kc7arcd39rl7xq8l0a4zyg7kxnv7su87").unwrap();
-    let names_by_owner = client.nyxd.get_names_by_owner(owner).await.unwrap();
-    println!("names (by owner): {names_by_owner:#?}");
-
-    let nym_address = Address::new("client_id.client_key@gateway_id").unwrap();
-    let names_by_address = client.nyxd.get_names_by_address(nym_address).await.unwrap();
-    println!("names (by address): {names_by_address:#?}");
-
-    let service_info = client.nyxd.get_name_entry(1).await;
-    println!("service info: {service_info:#?}");
-}
@@ -1,45 +0,0 @@
-use std::str::FromStr;
-
-use cosmrs::AccountId;
-use nym_network_defaults::{setup_env, NymNetworkDetails};
-use nym_service_provider_directory_common::NymAddress;
-use nym_validator_client::nyxd::contract_traits::{
-    PagedSpDirectoryQueryClient, SpDirectoryQueryClient,
-};
-
-#[tokio::main]
-async fn main() {
-    setup_env(Some("../../../envs/qa.env"));
-    let network_details = NymNetworkDetails::new_from_env();
-    let config =
-        nym_validator_client::Config::try_from_nym_network_details(&network_details).unwrap();
-    let client = nym_validator_client::Client::new_query(config).unwrap();
-
-    let config = client.nyxd.get_service_config().await.unwrap();
-    println!("config: {config:?}");
-
-    let services_paged = client.nyxd.get_services_paged(None, None).await.unwrap();
-    println!("services (paged): {services_paged:#?}");
-
-    let services = client.nyxd.get_all_services().await.unwrap();
-    println!("services: {services:#?}");
-
-    let announcer = AccountId::from_str("n1hmf957kc7arcd39rl7xq8l0a4zyg7kxnv7su87").unwrap();
-    let services_by_announcer = client
-        .nyxd
-        .get_services_by_announcer(announcer)
-        .await
-        .unwrap();
-    println!("services (by announcer): {services_by_announcer:#?}");
-
-    let nym_address = NymAddress::new("foo.bar@gateway");
-    let services_by_nym_address = client
-        .nyxd
-        .get_services_by_nym_address(nym_address)
-        .await
-        .unwrap();
-    assert_eq!(services_by_announcer, services_by_nym_address);
-
-    let service_info = client.nyxd.get_service_info(1).await;
-    println!("service info: {service_info:#?}");
-}
@@ -18,6 +18,7 @@ use nym_api_requests::models::{
    GatewayCoreStatusResponse, MixnodeCoreStatusResponse, MixnodeStatusResponse,
    RewardEstimationResponse, StakeSaturationResponse,
 };
+use nym_api_requests::nym_nodes::SkimmedNode;
 use nym_network_defaults::NymNetworkDetails;
 use url::Url;

@@ -265,6 +266,28 @@ impl NymApiClient {
        self.nym_api.change_base_url(new_endpoint);
    }

+    pub async fn get_basic_mixnodes(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+        Ok(self
+            .nym_api
+            .get_basic_mixnodes(semver_compatibility)
+            .await?
+            .nodes)
+    }
+
+    pub async fn get_basic_gateways(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<Vec<SkimmedNode>, ValidatorClientError> {
+        Ok(self
+            .nym_api
+            .get_basic_gateways(semver_compatibility)
+            .await?
+            .nodes)
+    }
+
    pub async fn get_cached_active_mixnodes(
        &self,
    ) -> Result<Vec<MixNodeDetails>, ValidatorClientError> {
@@ -25,14 +25,13 @@ pub use nym_coconut_dkg_common::types::EpochId;
 use nym_http_api_client::{ApiClient, NO_PARAMS};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
-use nym_name_service_common::response::NamesListResponse;
-use nym_service_provider_directory_common::response::ServicesListResponse;

 pub mod error;
 pub mod routes;

 use nym_api_requests::coconut::models::FreePassNonceResponse;
 use nym_api_requests::coconut::FreePassRequest;
+use nym_api_requests::nym_nodes::{CachedNodesResponse, SkimmedNode};
 pub use nym_http_api_client::Client;

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -97,6 +96,52 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    async fn get_basic_mixnodes(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
+        let params = if let Some(semver_compatibility) = &semver_compatibility {
+            vec![("semver_compatibility", semver_compatibility.as_str())]
+        } else {
+            vec![]
+        };
+
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                "unstable",
+                "nym-nodes",
+                "mixnodes",
+                "skimmed",
+            ],
+            &params,
+        )
+        .await
+    }
+
+    async fn get_basic_gateways(
+        &self,
+        semver_compatibility: Option<String>,
+    ) -> Result<CachedNodesResponse<SkimmedNode>, NymAPIError> {
+        let params = if let Some(semver_compatibility) = &semver_compatibility {
+            vec![("semver_compatibility", semver_compatibility.as_str())]
+        } else {
+            vec![]
+        };
+
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                "unstable",
+                "nym-nodes",
+                "gateways",
+                "skimmed",
+            ],
+            &params,
+        )
+        .await
+    }
+
    async fn get_active_mixnodes(&self) -> Result<Vec<MixNodeDetails>, NymAPIError> {
        self.get_json(
            &[routes::API_VERSION, routes::MIXNODES, routes::ACTIVE],
@@ -492,19 +537,6 @@ pub trait NymApiClientExt: ApiClient {
        )
        .await
    }
-
-    async fn get_service_providers(&self) -> Result<ServicesListResponse, NymAPIError> {
-        log::trace!("Getting service providers");
-        self.get_json(&[routes::API_VERSION, routes::SERVICE_PROVIDERS], NO_PARAMS)
-            .await
-    }
-
-    //async fn get_registered_names(&self) -> Result<Vec<NameEntry>, NymAPIError> {
-    async fn get_registered_names(&self) -> Result<NamesListResponse, NymAPIError> {
-        log::trace!("Getting registered names");
-        self.get_json(&[routes::API_VERSION, routes::REGISTERED_NAMES], NO_PARAMS)
-            .await
-    }
 }

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -40,4 +40,3 @@ pub const STAKE_SATURATION: &str = "stake-saturation";
 pub const INCLUSION_CHANCE: &str = "inclusion-probability";

 pub const SERVICE_PROVIDERS: &str = "services";
-pub const REGISTERED_NAMES: &str = "names";
@@ -1,79 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::collect_paged;
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::CosmWasmClient;
-use async_trait::async_trait;
-use nym_ephemera_common::msg::QueryMsg as EphemeraQueryMsg;
-use nym_ephemera_common::peers::PagedPeerResponse;
-use nym_ephemera_common::types::JsonPeerInfo;
-use serde::Deserialize;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait EphemeraQueryClient {
-    async fn query_ephemera_contract<T>(&self, query: EphemeraQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>;
-
-    async fn get_peers_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<PagedPeerResponse, NyxdError> {
-        let request = EphemeraQueryMsg::GetPeers { start_after, limit };
-        self.query_ephemera_contract(request).await
-    }
-}
-
-// extension trait to the query client to deal with the paged queries
-// (it didn't feel appropriate to combine it with the existing trait
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PagedEphemeraQueryClient: EphemeraQueryClient {
-    async fn get_all_ephemera_peers(&self) -> Result<Vec<JsonPeerInfo>, NyxdError> {
-        collect_paged!(self, get_peers_paged, peers)
-    }
-}
-
-#[async_trait]
-impl<T> PagedEphemeraQueryClient for T where T: EphemeraQueryClient {}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> EphemeraQueryClient for C
-where
-    C: CosmWasmClient + NymContractsProvider + Send + Sync,
-{
-    async fn query_ephemera_contract<T>(&self, query: EphemeraQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>,
-    {
-        let ephemera_contract_address = &self
-            .ephemera_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("ephemera contract"))?;
-        self.query_contract_smart(ephemera_contract_address, &query)
-            .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_query_variants_are_covered<C: EphemeraQueryClient + Send + Sync>(
-        client: C,
-        msg: EphemeraQueryMsg,
-    ) {
-        match msg {
-            EphemeraQueryMsg::GetPeers { limit, start_after } => {
-                client.get_peers_paged(start_after, limit).ignore()
-            }
-        };
-    }
-}
@@ -1,86 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::cosmwasm_client::types::ExecuteResult;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
-use crate::signing::signer::OfflineSigner;
-use async_trait::async_trait;
-use nym_ephemera_common::msg::ExecuteMsg as EphemeraExecuteMsg;
-use nym_ephemera_common::types::JsonPeerInfo;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait EphemeraSigningClient {
-    async fn execute_ephemera_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: EphemeraExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError>;
-
-    async fn register_as_peer(
-        &self,
-        peer_info: JsonPeerInfo,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = EphemeraExecuteMsg::RegisterPeer { peer_info };
-
-        self.execute_ephemera_contract(fee, req, "registering as peer".to_string(), vec![])
-            .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> EphemeraSigningClient for C
-where
-    C: SigningCosmWasmClient + NymContractsProvider + Sync,
-    NyxdError: From<<Self as OfflineSigner>::Error>,
-{
-    async fn execute_ephemera_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: EphemeraExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let ephemera_contract_address = self
-            .ephemera_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("ephemera contract"))?;
-
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let signer_address = &self.signer_addresses()?[0];
-
-        self.execute(
-            signer_address,
-            ephemera_contract_address,
-            &msg,
-            fee,
-            memo,
-            funds,
-        )
-        .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_execute_variants_are_covered<C: EphemeraSigningClient + Send + Sync>(
-        client: C,
-        msg: EphemeraExecuteMsg,
-    ) {
-        match msg {
-            EphemeraExecuteMsg::RegisterPeer { peer_info } => {
-                client.register_as_peer(peer_info, None).ignore()
-            }
-        };
-    }
-}
@@ -10,23 +10,17 @@ use std::str::FromStr;
 // query clients
 pub mod coconut_bandwidth_query_client;
 pub mod dkg_query_client;
-pub mod ephemera_query_client;
 pub mod group_query_client;
 pub mod mixnet_query_client;
 pub mod multisig_query_client;
-pub mod name_service_query_client;
-pub mod sp_directory_query_client;
 pub mod vesting_query_client;

 // signing clients
 pub mod coconut_bandwidth_signing_client;
 pub mod dkg_signing_client;
-pub mod ephemera_signing_client;
 pub mod group_signing_client;
 pub mod mixnet_signing_client;
 pub mod multisig_signing_client;
-pub mod name_service_signing_client;
-pub mod sp_directory_signing_client;
 pub mod vesting_signing_client;

 // re-export query traits
@@ -34,23 +28,17 @@ pub use coconut_bandwidth_query_client::{
    CoconutBandwidthQueryClient, PagedCoconutBandwidthQueryClient,
 };
 pub use dkg_query_client::{DkgQueryClient, PagedDkgQueryClient};
-pub use ephemera_query_client::{EphemeraQueryClient, PagedEphemeraQueryClient};
 pub use group_query_client::{GroupQueryClient, PagedGroupQueryClient};
 pub use mixnet_query_client::{MixnetQueryClient, PagedMixnetQueryClient};
 pub use multisig_query_client::{MultisigQueryClient, PagedMultisigQueryClient};
-pub use name_service_query_client::{NameServiceQueryClient, PagedNameServiceQueryClient};
-pub use sp_directory_query_client::{PagedSpDirectoryQueryClient, SpDirectoryQueryClient};
 pub use vesting_query_client::{PagedVestingQueryClient, VestingQueryClient};

 // re-export signing traits
 pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
 pub use dkg_signing_client::DkgSigningClient;
-pub use ephemera_signing_client::EphemeraSigningClient;
 pub use group_signing_client::GroupSigningClient;
 pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_signing_client::MultisigSigningClient;
-pub use name_service_signing_client::NameServiceSigningClient;
-pub use sp_directory_signing_client::SpDirectorySigningClient;
 pub use vesting_signing_client::VestingSigningClient;

 // helper for providing blanket implementation for query clients
@@ -64,13 +52,6 @@ pub trait NymContractsProvider {
    fn dkg_contract_address(&self) -> Option<&AccountId>;
    fn group_contract_address(&self) -> Option<&AccountId>;
    fn multisig_contract_address(&self) -> Option<&AccountId>;
-
-    // ephemera-related
-    fn ephemera_contract_address(&self) -> Option<&AccountId>;
-
-    // SPs
-    fn name_service_contract_address(&self) -> Option<&AccountId>;
-    fn service_provider_contract_address(&self) -> Option<&AccountId>;
 }

 #[derive(Debug, Clone)]
@@ -82,11 +63,6 @@ pub struct TypedNymContracts {
    pub group_contract_address: Option<AccountId>,
    pub multisig_contract_address: Option<AccountId>,
    pub coconut_dkg_contract_address: Option<AccountId>,
-
-    pub ephemera_contract_address: Option<AccountId>,
-
-    pub service_provider_directory_contract_address: Option<AccountId>,
-    pub name_service_contract_address: Option<AccountId>,
 }

 impl TryFrom<NymContracts> for TypedNymContracts {
@@ -118,18 +94,6 @@ impl TryFrom<NymContracts> for TypedNymContracts {
                .coconut_dkg_contract_address
                .map(|addr| addr.parse())
                .transpose()?,
-            ephemera_contract_address: value
-                .ephemera_contract_address
-                .map(|addr| addr.parse())
-                .transpose()?,
-            service_provider_directory_contract_address: value
-                .service_provider_directory_contract_address
-                .map(|addr| addr.parse())
-                .transpose()?,
-            name_service_contract_address: value
-                .name_service_contract_address
-                .map(|addr| addr.parse())
-                .transpose()?,
        })
    }
 }
@@ -1,144 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::collect_paged;
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::{error::NyxdError, CosmWasmClient};
-use async_trait::async_trait;
-use cosmrs::AccountId;
-use nym_contracts_common::{signing::Nonce, ContractBuildInformation};
-use nym_name_service_common::{
-    msg::QueryMsg as NameQueryMsg,
-    response::{ConfigResponse, NamesListResponse, PagedNamesListResponse},
-    Address, NameId, NymName, RegisteredName,
-};
-use serde::Deserialize;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait NameServiceQueryClient {
-    async fn query_name_service_contract<T>(&self, query: NameQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>;
-
-    async fn get_name_service_config(&self) -> Result<ConfigResponse, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::Config {})
-            .await
-    }
-
-    async fn get_name_entry(&self, name_id: NameId) -> Result<RegisteredName, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::NameId { name_id })
-            .await
-    }
-
-    async fn get_names_paged(
-        &self,
-        start_after: Option<NameId>,
-        limit: Option<u32>,
-    ) -> Result<PagedNamesListResponse, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::All { limit, start_after })
-            .await
-    }
-
-    async fn get_name_signing_nonce(&self, address: &AccountId) -> Result<Nonce, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::SigningNonce {
-            address: address.to_string(),
-        })
-        .await
-    }
-
-    async fn get_names_by_owner(&self, owner: AccountId) -> Result<NamesListResponse, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::ByOwner {
-            owner: owner.to_string(),
-        })
-        .await
-    }
-
-    async fn get_names_by_nym_name(&self, name: NymName) -> Result<NamesListResponse, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::ByName { name })
-            .await
-    }
-
-    async fn get_names_by_address(&self, address: Address) -> Result<NamesListResponse, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::ByAddress { address })
-            .await
-    }
-
-    async fn get_name_service_contract_version(
-        &self,
-    ) -> Result<ContractBuildInformation, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::GetContractVersion {})
-            .await
-    }
-
-    async fn get_name_service_contract_cw2_version(
-        &self,
-    ) -> Result<cw2::ContractVersion, NyxdError> {
-        self.query_name_service_contract(NameQueryMsg::GetCW2ContractVersion {})
-            .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PagedNameServiceQueryClient: NameServiceQueryClient {
-    async fn get_all_names(&self) -> Result<Vec<RegisteredName>, NyxdError> {
-        collect_paged!(self, get_names_paged, names)
-    }
-}
-
-#[async_trait]
-impl<T> PagedNameServiceQueryClient for T where T: NameServiceQueryClient {}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> NameServiceQueryClient for C
-where
-    C: CosmWasmClient + NymContractsProvider + Send + Sync,
-{
-    async fn query_name_service_contract<T>(&self, query: NameQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>,
-    {
-        let name_service_contract_address = &self
-            .name_service_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("name service contract"))?;
-        self.query_contract_smart(name_service_contract_address, &query)
-            .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_query_variants_are_covered<C: NameServiceQueryClient + Send + Sync>(
-        client: C,
-        msg: NameQueryMsg,
-    ) {
-        match msg {
-            NameQueryMsg::NameId { name_id } => client.get_name_entry(name_id).ignore(),
-            NameQueryMsg::ByOwner { owner } => {
-                client.get_names_by_owner(owner.parse().unwrap()).ignore()
-            }
-            NameQueryMsg::ByName { name } => client.get_names_by_nym_name(name).ignore(),
-            NameQueryMsg::ByAddress { address } => client.get_names_by_address(address).ignore(),
-            NameQueryMsg::All { limit, start_after } => {
-                client.get_names_paged(limit, start_after).ignore()
-            }
-            NameQueryMsg::SigningNonce { address } => client
-                .get_name_signing_nonce(&address.parse().unwrap())
-                .ignore(),
-            NameQueryMsg::Config {} => client.get_name_service_config().ignore(),
-            NameQueryMsg::GetContractVersion {} => {
-                client.get_name_service_contract_version().ignore()
-            }
-            NameQueryMsg::GetCW2ContractVersion {} => {
-                client.get_name_service_contract_cw2_version().ignore()
-            }
-        };
-    }
-}
@@ -1,138 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use async_trait::async_trait;
-use nym_contracts_common::signing::MessageSignature;
-use nym_name_service_common::{msg::ExecuteMsg as NameExecuteMsg, NameDetails, NameId, NymName};
-
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::{
-    coin::Coin, cosmwasm_client::types::ExecuteResult, error::NyxdError, Fee, SigningCosmWasmClient,
-};
-use crate::signing::signer::OfflineSigner;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait NameServiceSigningClient {
-    async fn execute_name_service_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: NameExecuteMsg,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError>;
-
-    async fn register_name(
-        &self,
-        name: NameDetails,
-        owner_signature: MessageSignature,
-        deposit: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_name_service_contract(
-            fee,
-            NameExecuteMsg::Register {
-                name,
-                owner_signature,
-            },
-            vec![deposit],
-        )
-        .await
-    }
-
-    async fn delete_name_by_id(
-        &self,
-        name_id: NameId,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_name_service_contract(fee, NameExecuteMsg::DeleteId { name_id }, vec![])
-            .await
-    }
-
-    async fn delete_service_provider_by_name(
-        &self,
-        name: NymName,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_name_service_contract(fee, NameExecuteMsg::DeleteName { name }, vec![])
-            .await
-    }
-
-    async fn update_deposit_required(
-        &self,
-        deposit_required: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_name_service_contract(
-            fee,
-            NameExecuteMsg::UpdateDepositRequired {
-                deposit_required: deposit_required.into(),
-            },
-            vec![],
-        )
-        .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> NameServiceSigningClient for C
-where
-    C: SigningCosmWasmClient + NymContractsProvider + Sync,
-    NyxdError: From<<Self as OfflineSigner>::Error>,
-{
-    async fn execute_name_service_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: NameExecuteMsg,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let name_service_contract_address = &self
-            .name_service_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("name service contract"))?;
-
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let memo = msg.default_memo();
-
-        let signer_address = &self.signer_addresses()?[0];
-        self.execute(
-            signer_address,
-            name_service_contract_address,
-            &msg,
-            fee,
-            memo,
-            funds,
-        )
-        .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue};
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_execute_variants_are_covered<C: NameServiceSigningClient + Send + Sync>(
-        client: C,
-        msg: NameExecuteMsg,
-    ) {
-        match msg {
-            NameExecuteMsg::Register {
-                name,
-                owner_signature,
-            } => client
-                .register_name(name, owner_signature, mock_coin(), None)
-                .ignore(),
-            NameExecuteMsg::DeleteId { name_id } => {
-                client.delete_name_by_id(name_id, None).ignore()
-            }
-            NameExecuteMsg::DeleteName { name } => {
-                client.delete_service_provider_by_name(name, None).ignore()
-            }
-            NameExecuteMsg::UpdateDepositRequired { deposit_required } => client
-                .update_deposit_required(deposit_required.into(), None)
-                .ignore(),
-        };
-    }
-}
@@ -1,142 +0,0 @@
-use crate::collect_paged;
-use async_trait::async_trait;
-use cosmrs::AccountId;
-use nym_contracts_common::{signing::Nonce, ContractBuildInformation};
-use nym_service_provider_directory_common::{
-    msg::QueryMsg as SpQueryMsg,
-    response::{
-        ConfigResponse, PagedServicesListResponse, ServiceInfoResponse, ServicesListResponse,
-    },
-    NymAddress, Service, ServiceId,
-};
-use serde::Deserialize;
-
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::{error::NyxdError, CosmWasmClient};
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait SpDirectoryQueryClient {
-    async fn query_service_provider_contract<T>(&self, query: SpQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>;
-
-    async fn get_service_config(&self) -> Result<ConfigResponse, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::Config {})
-            .await
-    }
-
-    async fn get_service_info(
-        &self,
-        service_id: ServiceId,
-    ) -> Result<ServiceInfoResponse, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::ServiceId { service_id })
-            .await
-    }
-
-    async fn get_services_paged(
-        &self,
-        start_after: Option<ServiceId>,
-        limit: Option<u32>,
-    ) -> Result<PagedServicesListResponse, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::All { limit, start_after })
-            .await
-    }
-
-    async fn get_services_by_announcer(
-        &self,
-        announcer: AccountId,
-    ) -> Result<ServicesListResponse, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::ByAnnouncer {
-            announcer: announcer.to_string(),
-        })
-        .await
-    }
-
-    async fn get_services_by_nym_address(
-        &self,
-        nym_address: NymAddress,
-    ) -> Result<ServicesListResponse, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::ByNymAddress { nym_address })
-            .await
-    }
-
-    async fn get_sp_contract_version(&self) -> Result<ContractBuildInformation, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::GetContractVersion {})
-            .await
-    }
-
-    async fn get_sp_contract_cw2_version(&self) -> Result<cw2::ContractVersion, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::GetCW2ContractVersion {})
-            .await
-    }
-
-    async fn get_service_signing_nonce(&self, address: &AccountId) -> Result<Nonce, NyxdError> {
-        self.query_service_provider_contract(SpQueryMsg::SigningNonce {
-            address: address.to_string(),
-        })
-        .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PagedSpDirectoryQueryClient: SpDirectoryQueryClient {
-    async fn get_all_services(&self) -> Result<Vec<Service>, NyxdError> {
-        collect_paged!(self, get_services_paged, services)
-    }
-}
-
-#[async_trait]
-impl<T> PagedSpDirectoryQueryClient for T where T: SpDirectoryQueryClient {}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> SpDirectoryQueryClient for C
-where
-    C: CosmWasmClient + NymContractsProvider + Send + Sync,
-{
-    async fn query_service_provider_contract<T>(&self, query: SpQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>,
-    {
-        let sp_directory_contract_address =
-            &self.service_provider_contract_address().ok_or_else(|| {
-                NyxdError::unavailable_contract_address("service provider directory contract")
-            })?;
-        self.query_contract_smart(sp_directory_contract_address, &query)
-            .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_query_variants_are_covered<C: SpDirectoryQueryClient + Send + Sync>(
-        client: C,
-        msg: SpQueryMsg,
-    ) {
-        match msg {
-            SpQueryMsg::ServiceId { service_id } => client.get_service_info(service_id).ignore(),
-            SpQueryMsg::ByAnnouncer { announcer } => client
-                .get_services_by_announcer(announcer.parse().unwrap())
-                .ignore(),
-            SpQueryMsg::ByNymAddress { nym_address } => {
-                client.get_services_by_nym_address(nym_address).ignore()
-            }
-            SpQueryMsg::All { limit, start_after } => {
-                client.get_services_paged(start_after, limit).ignore()
-            }
-            SpQueryMsg::SigningNonce { address } => client
-                .get_service_signing_nonce(&address.parse().unwrap())
-                .ignore(),
-            SpQueryMsg::Config {} => client.get_service_config().ignore(),
-            SpQueryMsg::GetContractVersion {} => client.get_sp_contract_version().ignore(),
-            SpQueryMsg::GetCW2ContractVersion {} => client.get_sp_contract_cw2_version().ignore(),
-        };
-    }
-}
@@ -1,148 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::{
-    coin::Coin, cosmwasm_client::types::ExecuteResult, error::NyxdError, Fee, SigningCosmWasmClient,
-};
-use crate::signing::signer::OfflineSigner;
-use async_trait::async_trait;
-use nym_contracts_common::signing::MessageSignature;
-use nym_service_provider_directory_common::{
-    msg::ExecuteMsg as SpExecuteMsg, NymAddress, ServiceDetails, ServiceId,
-};
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait SpDirectorySigningClient {
-    async fn execute_service_provider_directory_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: SpExecuteMsg,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError>;
-
-    async fn announce_service_provider(
-        &self,
-        service: ServiceDetails,
-        owner_signature: MessageSignature,
-        deposit: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_service_provider_directory_contract(
-            fee,
-            SpExecuteMsg::Announce {
-                service,
-                owner_signature,
-            },
-            vec![deposit],
-        )
-        .await
-    }
-
-    async fn delete_service_provider_by_id(
-        &self,
-        service_id: ServiceId,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_service_provider_directory_contract(
-            fee,
-            SpExecuteMsg::DeleteId { service_id },
-            vec![],
-        )
-        .await
-    }
-
-    async fn delete_service_provider_by_nym_address(
-        &self,
-        nym_address: NymAddress,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_service_provider_directory_contract(
-            fee,
-            SpExecuteMsg::DeleteNymAddress { nym_address },
-            vec![],
-        )
-        .await
-    }
-
-    async fn update_deposit_required(
-        &self,
-        deposit_required: Coin,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_service_provider_directory_contract(
-            fee,
-            SpExecuteMsg::UpdateDepositRequired {
-                deposit_required: deposit_required.into(),
-            },
-            vec![],
-        )
-        .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> SpDirectorySigningClient for C
-where
-    C: SigningCosmWasmClient + NymContractsProvider + Sync,
-    NyxdError: From<<Self as OfflineSigner>::Error>,
-{
-    async fn execute_service_provider_directory_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: SpExecuteMsg,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let sp_directory_contract_address =
-            &self.service_provider_contract_address().ok_or_else(|| {
-                NyxdError::unavailable_contract_address("service provider directory contract")
-            })?;
-
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let memo = msg.default_memo();
-
-        let signer_address = &self.signer_addresses()?[0];
-        self.execute(
-            signer_address,
-            sp_directory_contract_address,
-            &msg,
-            fee,
-            memo,
-            funds,
-        )
-        .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue};
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_execute_variants_are_covered<C: SpDirectorySigningClient + Send + Sync>(
-        client: C,
-        msg: SpExecuteMsg,
-    ) {
-        match msg {
-            SpExecuteMsg::Announce {
-                service,
-                owner_signature,
-            } => client
-                .announce_service_provider(service, owner_signature, mock_coin(), None)
-                .ignore(),
-            SpExecuteMsg::DeleteId { service_id } => client
-                .delete_service_provider_by_id(service_id, None)
-                .ignore(),
-            SpExecuteMsg::DeleteNymAddress { nym_address } => client
-                .delete_service_provider_by_nym_address(nym_address, None)
-                .ignore(),
-            SpExecuteMsg::UpdateDepositRequired { deposit_required } => client
-                .update_deposit_required(deposit_required.into(), None)
-                .ignore(),
-        };
-    }
-}
@@ -140,6 +140,6 @@ mod tests {

        let fee = &gas_price * gas_limit;
        // the failing behaviour was result value of 3937
-        assert_eq!(fee.amount, 3938u64.into());
+        assert_eq!(fee.amount, 3938u128);
    }
 }
@@ -70,6 +70,8 @@ use crate::http_client;
 use crate::{DirectSigningHttpRpcNyxdClient, QueryHttpRpcNyxdClient};
 #[cfg(feature = "http-client")]
 use cosmrs::rpc::{HttpClient, HttpClientUrl};
+use nym_contracts_common::build_information::CONTRACT_BUILD_INFO_STORAGE_KEY;
+use nym_contracts_common::ContractBuildInformation;

 pub mod coin;
 pub mod contract_traits;
@@ -246,12 +248,6 @@ impl<C, S> NyxdClient<C, S> {
        self.config.contracts.multisig_contract_address = Some(address);
    }

-    pub fn set_service_provider_contract_address(&mut self, address: AccountId) {
-        self.config
-            .contracts
-            .service_provider_directory_contract_address = Some(address);
-    }
-
    pub fn set_simulated_gas_multiplier(&mut self, multiplier: f32) {
        self.config.simulated_gas_multiplier = multiplier;
    }
@@ -284,21 +280,6 @@ impl<C, S> NymContractsProvider for NyxdClient<C, S> {
    fn multisig_contract_address(&self) -> Option<&AccountId> {
        self.config.contracts.multisig_contract_address.as_ref()
    }
-
-    fn ephemera_contract_address(&self) -> Option<&AccountId> {
-        self.config.contracts.ephemera_contract_address.as_ref()
-    }
-
-    fn name_service_contract_address(&self) -> Option<&AccountId> {
-        self.config.contracts.name_service_contract_address.as_ref()
-    }
-
-    fn service_provider_contract_address(&self) -> Option<&AccountId> {
-        self.config
-            .contracts
-            .service_provider_directory_contract_address
-            .as_ref()
-    }
 }

 // queries
@@ -349,6 +330,33 @@ where
            .await
            .map(|block| block.block_id.hash)
    }
+
+    pub async fn try_get_cw2_contract_version(
+        &self,
+        contract_address: &AccountId,
+    ) -> Option<cw2::ContractVersion> {
+        let raw_info = self
+            .query_contract_raw(contract_address, b"contract_info".to_vec())
+            .await
+            .ok()?;
+
+        serde_json::from_slice(&raw_info).ok()
+    }
+
+    pub async fn try_get_contract_build_information(
+        &self,
+        contract_address: &AccountId,
+    ) -> Option<ContractBuildInformation> {
+        let raw_info = self
+            .query_contract_raw(
+                contract_address,
+                CONTRACT_BUILD_INFO_STORAGE_KEY.as_bytes().to_vec(),
+            )
+            .await
+            .ok()?;
+
+        serde_json::from_slice(&raw_info).ok()
+    }
 }

 // signing
@@ -46,8 +46,6 @@ nym-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-cont
 nym-coconut-bandwidth-contract-common = { path = "../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 nym-coconut-dkg-common = { path = "../cosmwasm-smart-contracts/coconut-dkg" }
 nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-contract" }
-nym-service-provider-directory-common = { path = "../cosmwasm-smart-contracts/service-provider-directory" }
-nym-name-service-common = { path = "../cosmwasm-smart-contracts/name-service" }
 nym-sphinx = { path = "../../common/nymsphinx" }
 nym-client-core = { path = "../../common/client-core" }
 nym-config = { path = "../../common/config" }
@@ -6,8 +6,6 @@ use clap::{Args, Subcommand};
 pub mod gateway;
 pub mod identity_key;
 pub mod mixnode;
-pub mod name;
-pub mod service;

 #[derive(Debug, Args)]
 #[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
@@ -23,10 +21,6 @@ pub enum MixnetOperatorsCommands {
    Mixnode(mixnode::MixnetOperatorsMixnode),
    /// Manage your gateway
    Gateway(gateway::MixnetOperatorsGateway),
-    /// Manage your service
-    ServiceProvider(service::MixnetOperatorsService),
-    /// Manage your registered name
-    Name(name::MixnetOperatorsName),
    /// Sign messages using your private identity key
    IdentityKey(identity_key::MixnetOperatorsIdentityKey),
 }
@@ -1,25 +0,0 @@
-use clap::Parser;
-use log::{error, info};
-use nym_name_service_common::NameId;
-use nym_validator_client::nyxd::{contract_traits::NameServiceSigningClient, error::NyxdError};
-use tap::TapFallible;
-
-use crate::context::SigningClient;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(long)]
-    pub id: NameId,
-}
-
-pub async fn delete(args: Args, client: SigningClient) -> Result<(), NyxdError> {
-    info!("Deleting registered name alias with id {}", args.id);
-
-    let res = client
-        .delete_name_by_id(args.id, None)
-        .await
-        .tap_err(|err| error!("Failed to delete name: {err:#?}"))?;
-
-    info!("Deleted: {res:?}");
-    Ok(())
-}
@@ -1,22 +0,0 @@
-use clap::{Args, Subcommand};
-
-pub mod delete;
-pub mod register;
-pub mod register_sign_payload;
-
-#[derive(Debug, Args)]
-#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
-pub struct MixnetOperatorsName {
-    #[clap(subcommand)]
-    pub command: MixnetOperatorsNameCommands,
-}
-
-#[derive(Debug, Subcommand)]
-pub enum MixnetOperatorsNameCommands {
-    /// Register a name alias for a nym address
-    Register(register::Args),
-    /// Delete name alias for a nym address
-    Delete(delete::Args),
-    /// Create base58-encoded payload required for producing valiid register signature.
-    CreateNameRegisterPayload(register_sign_payload::Args),
-}
@@ -1,53 +0,0 @@
-use clap::Parser;
-use log::{error, info};
-use nym_contracts_common::signing::MessageSignature;
-use nym_name_service_common::{Address, Coin, NameDetails, NymName};
-use nym_sphinx::addressing::clients::Recipient;
-use nym_validator_client::nyxd::{contract_traits::NameServiceSigningClient, error::NyxdError};
-use tap::TapFallible;
-
-use crate::context::SigningClient;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    /// Name alias
-    #[clap(long)]
-    pub name: NymName,
-
-    /// Nym address that the alias is pointing to
-    #[clap(long)]
-    pub nym_address: Recipient,
-
-    #[clap(long)]
-    pub signature: MessageSignature,
-
-    /// Deposit to be made to the service provider directory, in curent DENOMINATION (e.g. 'unym')
-    #[clap(long)]
-    pub deposit: u128,
-}
-
-pub async fn register(args: Args, client: SigningClient) -> Result<(), NyxdError> {
-    info!(
-        "Registering name alias '{}' for nym address '{}'",
-        args.name, args.nym_address
-    );
-
-    let address = Address::new(&args.nym_address.to_string()).expect("invalid address");
-    let identity_key = address.client_id().to_string();
-    let name = NameDetails {
-        name: args.name,
-        address,
-        identity_key,
-    };
-
-    let denom = client.current_chain_details().mix_denom.base.as_str();
-    let deposit = Coin::new(args.deposit, denom);
-
-    let res = client
-        .register_name(name, args.signature, deposit.into(), None)
-        .await
-        .tap_err(|err| error!("Failed to register name: {err:#?}"))?;
-
-    info!("Registered name: {res:?}");
-    Ok(())
-}
@@ -1,65 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{
-    context::SigningClient,
-    utils::{account_id_to_cw_addr, DataWrapper},
-};
-
-use clap::Parser;
-use cosmwasm_std::Coin;
-
-use nym_bin_common::output_format::OutputFormat;
-use nym_name_service_common::{
-    signing_types::construct_name_register_sign_payload, Address, NymName,
-};
-use nym_sphinx::addressing::clients::Recipient;
-use nym_validator_client::nyxd::{contract_traits::NameServiceQueryClient, error::NyxdError};
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    // The name to register.
-    #[arg(long)]
-    pub name: NymName,
-
-    /// The nym address the name should point to.
-    #[arg(long)]
-    pub nym_address: Recipient,
-
-    #[arg(long)]
-    pub amount: u128,
-
-    #[arg(short, long, default_value_t = OutputFormat::default())]
-    output: OutputFormat,
-}
-
-pub async fn create_payload(args: Args, client: SigningClient) -> Result<(), NyxdError> {
-    let address = Address::new(&args.nym_address.to_string()).expect("invalid address");
-    let identity_key = address.client_id().to_string();
-    let name = nym_name_service_common::NameDetails {
-        name: args.name,
-        address,
-        identity_key,
-    };
-
-    let denom = client.current_chain_details().mix_denom.base.as_str();
-    let deposit = Coin::new(args.amount, denom);
-
-    let nonce = match client.get_name_signing_nonce(&client.address()).await {
-        Ok(nonce) => nonce,
-        Err(err) => {
-            eprint!(
-                "failed to query for the signing nonce of {}: {err}",
-                client.address()
-            );
-            return Err(err);
-        }
-    };
-
-    let address = account_id_to_cw_addr(&client.address());
-    let payload = construct_name_register_sign_payload(nonce, address, deposit, name);
-    let wrapper = DataWrapper::new(payload.to_base58_string().unwrap());
-    println!("{}", args.output.format(&wrapper));
-
-    Ok(())
-}
@@ -1,45 +0,0 @@
-use clap::Parser;
-use log::info;
-use nym_contracts_common::signing::MessageSignature;
-use nym_service_provider_directory_common::{Coin, NymAddress, ServiceDetails, ServiceType};
-use nym_validator_client::nyxd::contract_traits::SpDirectorySigningClient;
-
-use crate::context::SigningClient;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(long)]
-    pub nym_address: String,
-
-    #[clap(long)]
-    pub signature: MessageSignature,
-
-    /// Deposit to be made to the service provider directory, in curent DENOMINATION (e.g. 'unym')
-    #[clap(long)]
-    pub deposit: u128,
-
-    #[clap(long)]
-    pub identity_key: String,
-}
-
-pub async fn announce(args: Args, client: SigningClient) {
-    info!("Annoucing service provider");
-
-    let nym_address = NymAddress::Address(args.nym_address);
-    let service_type = ServiceType::NetworkRequester;
-    let service = ServiceDetails {
-        nym_address,
-        service_type,
-        identity_key: args.identity_key,
-    };
-
-    let denom = client.current_chain_details().mix_denom.base.as_str();
-    let deposit = Coin::new(args.deposit, denom);
-
-    let res = client
-        .announce_service_provider(service, args.signature, deposit.into(), None)
-        .await
-        .expect("Failed to announce service provider");
-
-    info!("Announced service provider: {res:?}");
-}
@@ -1,61 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{
-    context::SigningClient,
-    utils::{account_id_to_cw_addr, DataWrapper},
-};
-
-use clap::Parser;
-use cosmwasm_std::Coin;
-
-use nym_bin_common::output_format::OutputFormat;
-use nym_service_provider_directory_common::{
-    signing_types::construct_service_provider_announce_sign_payload, NymAddress,
-    ServiceType::NetworkRequester,
-};
-use nym_sphinx::addressing::clients::Recipient;
-use nym_validator_client::nyxd::contract_traits::SpDirectoryQueryClient;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(long)]
-    pub nym_address: Recipient,
-
-    #[clap(long)]
-    pub amount: u128,
-
-    #[clap(long)]
-    pub identity_key: String,
-
-    #[clap(short, long, default_value_t = OutputFormat::default())]
-    output: OutputFormat,
-}
-
-pub async fn create_payload(args: Args, client: SigningClient) {
-    let service = nym_service_provider_directory_common::ServiceDetails {
-        nym_address: NymAddress::new(&args.nym_address.to_string()),
-        service_type: NetworkRequester,
-        identity_key: args.identity_key,
-    };
-
-    let denom = client.current_chain_details().mix_denom.base.as_str();
-    let deposit = Coin::new(args.amount, denom);
-
-    let nonce = match client.get_service_signing_nonce(&client.address()).await {
-        Ok(nonce) => nonce,
-        Err(err) => {
-            eprint!(
-                "failed to query for the signing nonce of {}: {err}",
-                client.address()
-            );
-            return;
-        }
-    };
-
-    let address = account_id_to_cw_addr(&client.address());
-    let payload =
-        construct_service_provider_announce_sign_payload(nonce, address, deposit, service);
-    let wrapper = DataWrapper::new(payload.to_base58_string().unwrap());
-    println!("{}", args.output.format(&wrapper))
-}
@@ -1,23 +0,0 @@
-use clap::Parser;
-use log::info;
-use nym_service_provider_directory_common::ServiceId;
-use nym_validator_client::nyxd::contract_traits::SpDirectorySigningClient;
-
-use crate::context::SigningClient;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(long)]
-    pub id: ServiceId,
-}
-
-pub async fn delete(args: Args, client: SigningClient) {
-    info!("Deleting service provider with id {}", args.id);
-
-    let res = client
-        .delete_service_provider_by_id(args.id, None)
-        .await
-        .expect("Failed to delete service provider");
-
-    info!("Deleted: {res:?}");
-}
@@ -1,23 +0,0 @@
-use clap::{Args, Subcommand};
-
-pub mod announce;
-pub mod announce_sign_payload;
-pub mod delete;
-
-#[derive(Debug, Args)]
-#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
-pub struct MixnetOperatorsService {
-    #[clap(subcommand)]
-    pub command: MixnetOperatorsServiceCommands,
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Debug, Subcommand)]
-pub enum MixnetOperatorsServiceCommands {
-    /// Announce service provider to the world
-    Announce(announce::Args),
-    /// Delete entry for service provider from the directory
-    Delete(delete::Args),
-    /// Create base58-encoded payload required for producing valid announce signature.
-    CreateServiceAnnounceSignPayload(announce_sign_payload::Args),
-}
@@ -5,8 +5,6 @@ use clap::{Args, Subcommand};

 pub mod query_all_gateways;
 pub mod query_all_mixnodes;
-pub mod query_all_names;
-pub mod query_all_service_providers;

 #[derive(Debug, Args)]
 #[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
@@ -21,8 +19,4 @@ pub enum MixnetQueryCommands {
    Mixnodes(query_all_mixnodes::Args),
    /// Query gateways
    Gateways(query_all_gateways::Args),
-    /// Query announced service-providers
-    ServiceProviders(query_all_service_providers::Args),
-    /// Query registed names
-    Names(query_all_names::Args),
 }
@@ -1,53 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::QueryClientWithNyxd;
-use crate::utils::show_error;
-use clap::Parser;
-use comfy_table::Table;
-use nym_validator_client::client::NymApiClientExt;
-use nym_validator_client::nym_api::error::NymAPIError;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(value_parser)]
-    #[clap(help = "Optionally, the registered name to display")]
-    pub name: Option<String>,
-}
-
-pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    log::trace!("Querying all registered names");
-
-    match client.nym_api.get_registered_names().await {
-        Ok(res) => {
-            if let Some(name) = args.name {
-                let name = res.names.iter().find(|name_entry| {
-                    name_entry.name.name.to_string().eq_ignore_ascii_case(&name)
-                });
-                println!(
-                    "{}",
-                    ::serde_json::to_string_pretty(&name).expect("json formatting error")
-                );
-            } else {
-                let mut table = Table::new();
-
-                table.set_header(vec!["Name Id", "Owner", "Nym Address", "Name"]);
-                for name_entry in res.names {
-                    table.add_row(vec![
-                        name_entry.id.to_string(),
-                        name_entry.owner.to_string(),
-                        name_entry.name.address.to_string(),
-                        name_entry.name.name.to_string(),
-                    ]);
-                }
-
-                println!("The registered names in the directory are:");
-                println!("{table}");
-            }
-        }
-        Err(NymAPIError::NotFound) => {
-            println!("nym-api reports no name endpoint available");
-        }
-        Err(e) => show_error(e),
-    }
-}
@@ -1,55 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::QueryClientWithNyxd;
-use crate::utils::show_error;
-use clap::Parser;
-use comfy_table::Table;
-use nym_validator_client::client::NymApiClientExt;
-use nym_validator_client::nym_api::error::NymAPIError;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    #[clap(value_parser)]
-    #[clap(help = "Optionally, the service provider to display")]
-    pub nym_address: Option<String>,
-}
-
-pub async fn query(args: Args, client: &QueryClientWithNyxd) {
-    match client.nym_api.get_service_providers().await {
-        Ok(res) => {
-            if let Some(nym_address) = args.nym_address {
-                let service = res.services.iter().find(|service| {
-                    service
-                        .service
-                        .nym_address
-                        .to_string()
-                        .eq_ignore_ascii_case(&nym_address)
-                });
-                println!(
-                    "{}",
-                    ::serde_json::to_string_pretty(&service).expect("json formatting error")
-                );
-            } else {
-                let mut table = Table::new();
-
-                table.set_header(vec!["Service Id", "Announcer", "Type", "Nym Address"]);
-                for service in res.services {
-                    table.add_row(vec![
-                        service.service_id.to_string(),
-                        service.announcer.to_string(),
-                        service.service.service_type.to_string(),
-                        service.service.nym_address.to_string(),
-                    ]);
-                }
-
-                println!("The service providers in the directory are:");
-                println!("{table}");
-            }
-        }
-        Err(NymAPIError::NotFound) => {
-            println!("nym-api reports no service provider endpoint available");
-        }
-        Err(e) => show_error(e),
-    }
-}
@@ -11,9 +11,13 @@ repository = { workspace = true }
 bs58 = { workspace = true }
 cosmwasm-std = { workspace = true }
 cosmwasm-schema = { workspace = true }
+cw-storage-plus = { workspace = true }
 schemars = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }

 [dev-dependencies]
 serde_json = { workspace = true }
+
+[build-dependencies]
+vergen = { version = "=8.3.1", features = ["build", "git", "gitcl", "rustc", "cargo"] }
@@ -0,0 +1,17 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use vergen::EmitBuilder;
+
+fn main() {
+    EmitBuilder::builder()
+        .all_build()
+        .rustc_semver()
+        .git_branch()
+        .git_commit_timestamp()
+        .git_sha(false)
+        .cargo_debug()
+        .cargo_opt_level()
+        .emit()
+        .expect("failed to extract build metadata");
+}
@@ -0,0 +1,85 @@
+// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::ContractBuildInformation;
+use cosmwasm_std::{StdResult, Storage};
+use cw_storage_plus::Item;
+
+pub const CONTRACT_BUILD_INFO_STORAGE_KEY: &str = "contract_build_info";
+pub const CONTRACT_BUILD_INFO: Item<ContractBuildInformation> =
+    Item::new(CONTRACT_BUILD_INFO_STORAGE_KEY);
+
+// important note. this MUST BE called inside the contract code itself and not any intermediate crate
+// otherwise macro expansions will resolve to incorrect data
+#[macro_export]
+macro_rules! get_build_information {
+    () => {
+        $crate::types::ContractBuildInformation::new(
+            env!("CARGO_PKG_NAME"),
+            env!("CARGO_PKG_VERSION"),
+        )
+    };
+}
+
+pub fn set_state_build_information(
+    store: &mut dyn Storage,
+    build_info: ContractBuildInformation,
+) -> StdResult<()> {
+    CONTRACT_BUILD_INFO.save(store, &build_info)
+}
+
+pub fn get_contract_build_information(store: &dyn Storage) -> StdResult<ContractBuildInformation> {
+    CONTRACT_BUILD_INFO.load(store)
+}
+
+#[macro_export]
+macro_rules! set_build_information {
+    ( $store:expr ) => {
+        $crate::build_information::set_state_build_information(
+            $store,
+            $crate::get_build_information!(),
+        )
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use cosmwasm_std::testing::MockStorage;
+
+    #[test]
+    fn get_and_set_work() {
+        let mut store = MockStorage::new();
+
+        // error if not set
+        assert!(get_contract_build_information(&store).is_err());
+
+        // set and get
+        let contract_name = "nym-mixnet-contract";
+        let contract_version = "1.2.3";
+        let build_info = ContractBuildInformation::new(contract_name, contract_version);
+
+        set_state_build_information(&mut store, build_info).unwrap();
+
+        let loaded = get_contract_build_information(&store).unwrap();
+
+        let expected = ContractBuildInformation {
+            contract_name: contract_name.into(),
+            build_version: contract_version.into(),
+            build_timestamp: env!("VERGEN_BUILD_TIMESTAMP").to_string(),
+            commit_sha: option_env!("VERGEN_GIT_SHA")
+                .unwrap_or("UNKNOWN")
+                .to_string(),
+            commit_timestamp: option_env!("VERGEN_GIT_COMMIT_TIMESTAMP")
+                .unwrap_or("UNKNOWN")
+                .to_string(),
+            commit_branch: option_env!("VERGEN_GIT_BRANCH")
+                .unwrap_or("UNKNOWN")
+                .to_string(),
+            rustc_version: env!("VERGEN_RUSTC_SEMVER").to_string(),
+            cargo_debug: env!("VERGEN_CARGO_DEBUG").to_string(),
+            cargo_opt_level: env!("VERGEN_CARGO_OPT_LEVEL").to_string(),
+        };
+        assert_eq!(expected, loaded);
+    }
+}
@@ -4,6 +4,7 @@
 #![warn(clippy::expect_used)]
 #![warn(clippy::unwrap_used)]

+pub mod build_information;
 pub mod dealings;
 pub mod events;
 pub mod signing;
@@ -132,10 +132,18 @@ where
    }
 }

+fn default_unknown() -> String {
+    "unknown".to_string()
+}
+
 // TODO: there's no reason this couldn't be used for proper binaries, but in that case
 // perhaps the struct should get renamed and moved to a "more" common crate
 #[cw_serde]
 pub struct ContractBuildInformation {
+    /// Provides the name of the binary, i.e. the content of `CARGO_PKG_NAME` environmental variable.
+    #[serde(default = "default_unknown")]
+    pub contract_name: String,
+
    // VERGEN_BUILD_TIMESTAMP
    /// Provides the build timestamp, for example `2021-02-23T20:14:46.558472672+00:00`.
    pub build_timestamp: String,
@@ -159,6 +167,38 @@ pub struct ContractBuildInformation {
    // VERGEN_RUSTC_SEMVER
    /// Provides the rustc version that was used for the build, for example `1.52.0-nightly`.
    pub rustc_version: String,
+
+    // VERGEN_CARGO_DEBUG
+    /// Provides the cargo debug mode that was used for the build.
+    #[serde(default = "default_unknown")]
+    pub cargo_debug: String,
+
+    // VERGEN_CARGO_OPT_LEVEL
+    /// Provides the opt value set by cargo during the build
+    #[serde(default = "default_unknown")]
+    pub cargo_opt_level: String,
+}
+
+impl ContractBuildInformation {
+    pub fn new(name: impl Into<String>, version: impl Into<String>) -> Self {
+        ContractBuildInformation {
+            contract_name: name.into(),
+            build_version: version.into(),
+            build_timestamp: env!("VERGEN_BUILD_TIMESTAMP").to_string(),
+            commit_sha: option_env!("VERGEN_GIT_SHA")
+                .unwrap_or("UNKNOWN")
+                .to_string(),
+            commit_timestamp: option_env!("VERGEN_GIT_COMMIT_TIMESTAMP")
+                .unwrap_or("UNKNOWN")
+                .to_string(),
+            commit_branch: option_env!("VERGEN_GIT_BRANCH")
+                .unwrap_or("UNKNOWN")
+                .to_string(),
+            rustc_version: env!("VERGEN_RUSTC_SEMVER").to_string(),
+            cargo_debug: env!("VERGEN_CARGO_DEBUG").to_string(),
+            cargo_opt_level: env!("VERGEN_CARGO_OPT_LEVEL").to_string(),
+        }
+    }
 }

 #[cfg(test)]
@@ -1,17 +0,0 @@
-[package]
-name = "nym-ephemera-common"
-version = "0.1.0"
-edition = "2021"
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cosmwasm-schema = { workspace = true }
-cosmwasm-std = { workspace = true }
-cw-utils = { workspace = true }
-
-contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
-
-[features]
-schema = []
@@ -1,3 +0,0 @@
-pub mod msg;
-pub mod peers;
-pub mod types;
@@ -1,33 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#[cfg(feature = "schema")]
-use crate::peers::PagedPeerResponse;
-use crate::types::JsonPeerInfo;
-use cosmwasm_schema::cw_serde;
-#[cfg(feature = "schema")]
-use cosmwasm_schema::QueryResponses;
-
-#[cw_serde]
-pub struct InstantiateMsg {
-    pub group_addr: String,
-    pub mix_denom: String,
-}
-
-#[cw_serde]
-pub enum ExecuteMsg {
-    RegisterPeer { peer_info: JsonPeerInfo },
-}
-
-#[cw_serde]
-#[cfg_attr(feature = "schema", derive(QueryResponses))]
-pub enum QueryMsg {
-    #[cfg_attr(feature = "schema", returns(PagedPeerResponse))]
-    GetPeers {
-        limit: Option<u32>,
-        start_after: Option<String>,
-    },
-}
-
-#[cw_serde]
-pub struct MigrateMsg {}
@@ -1,25 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::types::JsonPeerInfo;
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Addr;
-
-#[cw_serde]
-pub struct PagedPeerResponse {
-    pub peers: Vec<JsonPeerInfo>,
-    pub per_page: usize,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<Addr>,
-}
-
-impl PagedPeerResponse {
-    pub fn new(peers: Vec<JsonPeerInfo>, per_page: usize, start_next_after: Option<Addr>) -> Self {
-        PagedPeerResponse {
-            peers,
-            per_page,
-            start_next_after,
-        }
-    }
-}
@@ -1,29 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Addr;
-
-#[cw_serde]
-pub struct JsonPeerInfo {
-    /// The cosmos address of the peer, used in interacting with the chain.
-    pub cosmos_address: Addr,
-    /// The TCP/IP address of the peer.
-    /// Expected formats:
-    /// 1. `<IP>:<PORT>`
-    /// 2. `/ip4/<IP>/tcp/<PORT>` - this is the format used by libp2p multiaddr
-    pub ip_address: String,
-    ///Serialized public key.
-    pub public_key: String,
-}
-
-impl JsonPeerInfo {
-    #[must_use]
-    pub fn new(cosmos_address: Addr, ip_address: String, public_key: String) -> Self {
-        Self {
-            cosmos_address,
-            ip_address,
-            public_key,
-        }
-    }
-}
@@ -234,12 +234,6 @@ pub enum MixnetContractError {
    #[error("the epoch is currently not in the 'epoch advancement' state. (the state is {current_state})")]
    EpochNotInAdvancementState { current_state: EpochState },

-    #[error("failed to parse {value} into a valid SemVer version: {error_message}")]
-    SemVerFailure {
-        value: String,
-        error_message: String,
-    },
-
    #[error("failed to verify message signature: {source}")]
    SignatureVerificationFailure {
        #[from]
@@ -1,20 +0,0 @@
-[package]
-name = "nym-name-service-common"
-version = "0.1.0"
-edition = "2021"
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cosmwasm-schema = { workspace = true }
-cosmwasm-std = { workspace = true }
-cw2 = { workspace = true, optional = true }
-cw-controllers = { workspace = true }
-cw-utils = { workspace = true }
-nym-contracts-common = { path = "../contracts-common", version = "0.5.0" }
-serde = { workspace = true, features = ["derive"] }
-thiserror = { workspace = true }
-
-[features]
-schema = ["cw2"]
@@ -1,83 +0,0 @@
-use cosmwasm_std::{Addr, StdError};
-use cw_controllers::AdminError;
-use nym_contracts_common::signing::verifier::ApiVerifierError;
-use thiserror::Error;
-
-use crate::{Address, NameId, NymName};
-
-#[derive(Error, Debug, PartialEq)]
-pub enum NameServiceError {
-    #[error("{0}")]
-    Std(#[from] StdError),
-
-    #[error("{0}")]
-    AdminError(#[from] AdminError),
-
-    #[error("name id entry not found: {name_id}")]
-    NotFound { name_id: NameId },
-
-    #[error("name entry not found: {name}")]
-    NameNotFound { name: NymName },
-
-    #[error("{sender} is not registrator of name")]
-    Unauthorized { sender: Addr },
-
-    #[error("deposit required to register a name")]
-    DepositRequired { source: cw_utils::PaymentError },
-
-    #[error("insufficiant deposit: {funds}, required: {deposit_required}")]
-    InsufficientDeposit {
-        funds: cosmwasm_std::Uint128,
-        deposit_required: cosmwasm_std::Uint128,
-    },
-
-    #[error("deposit too large: {funds}, required: {deposit_required}")]
-    TooLargeDeposit {
-        funds: cosmwasm_std::Uint128,
-        deposit_required: cosmwasm_std::Uint128,
-    },
-
-    #[error("reached the max number of names ({max_names}) for owner {owner}")]
-    ReachedMaxNamesForOwner { max_names: u32, owner: Addr },
-
-    #[error("reached the max number of names ({max_names}) for address {0}", address.to_string())]
-    ReachedMaxNamesForAddress { max_names: u32, address: Address },
-
-    #[error("failed to parse {value} into a valid SemVer version: {error_message}")]
-    SemVerFailure {
-        value: String,
-        error_message: String,
-    },
-
-    #[error("failed to recover ed25519 public key from its base58 representation: {0}")]
-    MalformedEd25519IdentityKey(String),
-
-    #[error("failed to recover ed25519 signature from its base58 representation: {0}")]
-    MalformedEd25519Signature(String),
-
-    #[error("provided ed25519 signature did not verify correctly")]
-    InvalidEd25519Signature,
-
-    #[error("failed to verify message signature: {source}")]
-    SignatureVerificationFailure {
-        #[from]
-        source: ApiVerifierError,
-    },
-
-    #[error("duplicate entries detected for name: {name}")]
-    DuplicateNames { name: NymName },
-
-    #[error("name already registered: {name}")]
-    NameAlreadyRegistered { name: NymName },
-
-    #[error("invalid nym address format: {0}")]
-    InvalidNymAddress(String),
-
-    #[error("client identity in nym address does not match the provided identity key")]
-    IdentityKeyMismatch {
-        address: Address,
-        identity_key: String,
-    },
-}
-
-pub type Result<T, E = NameServiceError> = std::result::Result<T, E>;
@@ -1,66 +0,0 @@
-use cosmwasm_std::{Coin, Event};
-
-use crate::RegisteredName;
-
-pub enum NameEventType {
-    Register,
-    DeleteId,
-    DeleteName,
-    UpdateDepositRequired,
-}
-
-impl std::fmt::Display for NameEventType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            NameEventType::Register => write!(f, "register"),
-            NameEventType::DeleteId => write!(f, "delete_id"),
-            NameEventType::DeleteName => write!(f, "delete_name"),
-            NameEventType::UpdateDepositRequired => write!(f, "update_deposit_required"),
-        }
-    }
-}
-
-impl From<NameEventType> for String {
-    fn from(event_type: NameEventType) -> Self {
-        event_type.to_string()
-    }
-}
-
-pub const ACTION: &str = "action";
-
-pub const NAME_ID: &str = "name_id";
-pub const NAME: &str = "name";
-pub const OWNER: &str = "owner";
-
-pub const DEPOSIT_REQUIRED: &str = "deposit_required";
-
-pub fn new_register_event(name: RegisteredName) -> Event {
-    Event::new(NameEventType::Register)
-        .add_attribute(ACTION, NameEventType::Register)
-        .add_attribute(NAME_ID, name.id.to_string())
-        .add_attribute(NAME, name.name.name.to_string())
-        .add_attribute(name.name.address.event_tag(), name.name.address.to_string())
-        .add_attribute(OWNER, name.owner.to_string())
-}
-
-pub fn new_delete_id_event(name: RegisteredName) -> Event {
-    Event::new(NameEventType::DeleteId)
-        .add_attribute(ACTION, NameEventType::DeleteId)
-        .add_attribute(NAME_ID, name.id.to_string())
-        .add_attribute(NAME, name.name.name.to_string())
-        .add_attribute(name.name.address.event_tag(), name.name.address.to_string())
-}
-
-pub fn new_delete_name_event(name: RegisteredName) -> Event {
-    Event::new(NameEventType::DeleteId)
-        .add_attribute(ACTION, NameEventType::DeleteName)
-        .add_attribute(NAME_ID, name.id.to_string())
-        .add_attribute(NAME, name.name.name.to_string())
-        .add_attribute(name.name.address.event_tag(), name.name.address.to_string())
-}
-
-pub fn new_update_deposit_required_event(deposit_required: Coin) -> Event {
-    Event::new(NameEventType::UpdateDepositRequired)
-        .add_attribute(ACTION, NameEventType::UpdateDepositRequired)
-        .add_attribute(DEPOSIT_REQUIRED, deposit_required.to_string())
-}
@@ -1,11 +0,0 @@
-pub mod error;
-pub mod events;
-pub mod msg;
-pub mod response;
-pub mod signing_types;
-pub mod types;
-
-// Re-export all types at the top-level
-pub use types::*;
-
-pub use cosmwasm_std::{Addr, Coin, Decimal, Fraction};
@@ -1,123 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{Address, NameDetails, NameId, NymName};
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Coin;
-use nym_contracts_common::signing::MessageSignature;
-
-#[cfg(feature = "schema")]
-use crate::{
-    response::{ConfigResponse, NamesListResponse, PagedNamesListResponse},
-    types::RegisteredName,
-};
-#[cfg(feature = "schema")]
-use cosmwasm_schema::QueryResponses;
-#[cfg(feature = "schema")]
-use nym_contracts_common::{signing::Nonce, ContractBuildInformation};
-
-#[cw_serde]
-pub struct InstantiateMsg {
-    pub deposit_required: Coin,
-}
-
-impl InstantiateMsg {
-    pub fn new(deposit_required: Coin) -> Self {
-        Self { deposit_required }
-    }
-}
-
-#[cw_serde]
-pub struct MigrateMsg {}
-
-#[cw_serde]
-pub enum ExecuteMsg {
-    /// Announcing a name pointing to a nym-address
-    Register {
-        name: NameDetails,
-        owner_signature: MessageSignature,
-    },
-
-    /// Delete a name entry by id
-    DeleteId { name_id: NameId },
-
-    /// Delete a name entry by name
-    DeleteName { name: NymName },
-
-    /// Change the deposit required for announcing a name
-    UpdateDepositRequired { deposit_required: Coin },
-}
-
-impl ExecuteMsg {
-    pub fn delete_id(name_id: NameId) -> Self {
-        ExecuteMsg::DeleteId { name_id }
-    }
-
-    pub fn default_memo(&self) -> String {
-        match self {
-            ExecuteMsg::Register {
-                name,
-                owner_signature: _,
-            } => {
-                format!("registering {} as name: {}", name.address, name.name)
-            }
-            ExecuteMsg::DeleteId { name_id } => {
-                format!("deleting name with id {name_id}")
-            }
-            ExecuteMsg::DeleteName { name } => {
-                format!("deleting name: {name}")
-            }
-            ExecuteMsg::UpdateDepositRequired { deposit_required } => {
-                format!("updating the deposit required to {deposit_required}")
-            }
-        }
-    }
-}
-
-#[cw_serde]
-#[cfg_attr(feature = "schema", derive(QueryResponses))]
-pub enum QueryMsg {
-    /// Query the name by it's assigned id
-    #[cfg_attr(feature = "schema", returns(RegisteredName))]
-    NameId { name_id: NameId },
-
-    /// Query the names by the registrator
-    #[cfg_attr(feature = "schema", returns(NamesListResponse))]
-    ByOwner { owner: String },
-
-    #[cfg_attr(feature = "schema", returns(RegisteredName))]
-    ByName { name: NymName },
-
-    #[cfg_attr(feature = "schema", returns(NamesListResponse))]
-    ByAddress { address: Address },
-
-    #[cfg_attr(feature = "schema", returns(PagedNamesListResponse))]
-    All {
-        limit: Option<u32>,
-        start_after: Option<NameId>,
-    },
-
-    #[cfg_attr(feature = "schema", returns(Nonce))]
-    SigningNonce { address: String },
-
-    #[cfg_attr(feature = "schema", returns(ConfigResponse))]
-    Config {},
-
-    /// Gets build information of this contract, such as the commit hash used for the build or rustc version.
-    #[cfg_attr(feature = "schema", returns(ContractBuildInformation))]
-    GetContractVersion {},
-
-    /// Gets the stored contract version information that's required by the CW2 spec interface for migrations.
-    #[serde(rename = "get_cw2_contract_version")]
-    #[cfg_attr(feature = "schema", returns(cw2::ContractVersion))]
-    GetCW2ContractVersion {},
-}
-
-impl QueryMsg {
-    pub fn all() -> QueryMsg {
-        QueryMsg::All {
-            limit: None,
-            start_after: None,
-        }
-    }
-}
@@ -1,53 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{NameId, RegisteredName};
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Coin;
-
-#[cw_serde]
-pub struct NamesListResponse {
-    pub names: Vec<RegisteredName>,
-}
-
-impl NamesListResponse {
-    pub fn new(names: Vec<RegisteredName>) -> NamesListResponse {
-        NamesListResponse { names }
-    }
-}
-
-impl From<&[RegisteredName]> for NamesListResponse {
-    fn from(names: &[RegisteredName]) -> Self {
-        NamesListResponse {
-            names: names.to_vec(),
-        }
-    }
-}
-
-#[cw_serde]
-pub struct PagedNamesListResponse {
-    pub names: Vec<RegisteredName>,
-    pub per_page: usize,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<NameId>,
-}
-
-impl PagedNamesListResponse {
-    pub fn new(
-        names: Vec<RegisteredName>,
-        per_page: usize,
-        start_next_after: Option<NameId>,
-    ) -> PagedNamesListResponse {
-        PagedNamesListResponse {
-            names,
-            per_page,
-            start_next_after,
-        }
-    }
-}
-
-#[cw_serde]
-pub struct ConfigResponse {
-    pub deposit_required: Coin,
-}
@@ -1,32 +0,0 @@
-use cosmwasm_std::{Addr, Coin};
-use nym_contracts_common::signing::{
-    ContractMessageContent, MessageType, Nonce, SignableMessage, SigningPurpose,
-};
-use serde::Serialize;
-
-use crate::NameDetails;
-
-pub type SignableNameRegisterMsg = SignableMessage<ContractMessageContent<NameRegister>>;
-
-#[derive(Serialize)]
-pub struct NameRegister {
-    name: NameDetails,
-}
-
-impl SigningPurpose for NameRegister {
-    fn message_type() -> MessageType {
-        MessageType::new("name-register")
-    }
-}
-
-pub fn construct_name_register_sign_payload(
-    nonce: Nonce,
-    sender: Addr,
-    deposit: Coin,
-    name: NameDetails,
-) -> SignableNameRegisterMsg {
-    let payload = NameRegister { name };
-    let proxy = None;
-    let content = ContractMessageContent::new(sender, proxy, vec![deposit], payload);
-    SignableMessage::new(nonce, content)
-}
@@ -1,252 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{Addr, Coin};
-use nym_contracts_common::IdentityKey;
-use std::{
-    fmt::{Display, Formatter},
-    str::FromStr,
-};
-use thiserror::Error;
-
-use crate::error::{NameServiceError, Result};
-
-/// The directory of names are indexed by [`NameId`].
-pub type NameId = u32;
-
-#[cw_serde]
-pub struct RegisteredName {
-    /// Unique id assigned to the registerd name.
-    pub id: NameId,
-
-    /// The registerd name details.
-    pub name: NameDetails,
-
-    /// name owner.
-    pub owner: Addr,
-
-    /// Block height at which the name was added.
-    pub block_height: u64,
-
-    /// The deposit used to announce the name.
-    pub deposit: Coin,
-}
-
-impl RegisteredName {
-    // Shortcut for getting the actual name
-    pub fn entry(&self) -> &NymName {
-        &self.name.name
-    }
-}
-
-#[cw_serde]
-pub struct NameDetails {
-    /// The name pointing to the nym address
-    pub name: NymName,
-
-    /// The address of the name alias.
-    pub address: Address,
-
-    /// The identity key of the registered name.
-    pub identity_key: IdentityKey,
-}
-
-/// String representation of a nym address, which is of the form
-/// client_id.client_enc@gateway_id.
-/// NOTE: entirely unvalidated.
-#[cw_serde]
-pub enum Address {
-    NymAddress(NymAddressInner),
-    // Possible extension:
-    //Gateway(String)
-}
-
-#[cw_serde]
-pub struct NymAddressInner {
-    client_id: String,
-    client_enc: String,
-    gateway_id: String,
-}
-
-// ADDRESS . ENCRYPTION @ GATEWAY_ID
-impl std::fmt::Display for NymAddressInner {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}.{}@{}",
-            self.client_id, self.client_enc, self.gateway_id
-        )
-    }
-}
-
-impl Address {
-    /// Create a new nym address.
-    pub fn new(address: &str) -> Result<Self> {
-        parse_nym_address(address)
-            .map(Self::NymAddress)
-            .ok_or_else(|| NameServiceError::InvalidNymAddress(address.to_string()))
-    }
-
-    pub fn client_id(&self) -> &str {
-        match self {
-            Address::NymAddress(address) => &address.client_id,
-        }
-    }
-
-    pub fn client_enc(&self) -> &str {
-        match self {
-            Address::NymAddress(address) => &address.client_enc,
-        }
-    }
-
-    pub fn gateway_id(&self) -> &str {
-        match self {
-            Address::NymAddress(address) => &address.gateway_id,
-        }
-    }
-
-    pub fn event_tag(&self) -> &str {
-        match self {
-            Address::NymAddress(_) => "nym_address",
-            //Address::Gateway(_) => "gatway_address",
-        }
-    }
-}
-
-impl Display for Address {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Address::NymAddress(address) => write!(f, "{}", address),
-        }
-    }
-}
-
-// A valid nym address is of the form client_id.client_enc@gateway_id
-fn parse_nym_address(address: &str) -> Option<NymAddressInner> {
-    let parts: Vec<&str> = address.split('@').collect();
-    if parts.len() != 2 {
-        return None;
-    }
-
-    let client_part = parts[0];
-    let gateway_part = parts[1];
-
-    // The client part consists of two parts separated by a dot
-    let client_parts: Vec<&str> = client_part.split('.').collect();
-    if client_parts.len() != 2 {
-        return None;
-    }
-
-    // Check that the gateway part does not contain any dots
-    if gateway_part.contains('.') {
-        return None;
-    }
-
-    Some(NymAddressInner {
-        client_id: client_parts[0].to_string(),
-        client_enc: client_parts[1].to_string(),
-        gateway_id: gateway_part.to_string(),
-    })
-}
-
-/// Name stored and pointing a to a nym-address
-#[cw_serde]
-pub struct NymName(String);
-
-#[derive(Debug, Error)]
-pub enum NymNameError {
-    #[error("invalid name")]
-    InvalidName,
-}
-
-/// Defines what names are allowed
-fn is_valid_name_char(c: char) -> bool {
-    // Normal lowercase letters
-    (c.is_alphabetic() && c.is_lowercase())
-        // or numbers
-        || c.is_numeric()
-        // special case hyphen or underscore
-        || c == '-' || c == '_'
-}
-
-impl NymName {
-    pub fn new(name: &str) -> Result<NymName, NymNameError> {
-        // We are a bit restrictive in which names we allow, to start out with. Consider relaxing
-        // this in the future.
-        if !name.chars().all(is_valid_name_char) {
-            return Err(NymNameError::InvalidName);
-        }
-        Ok(Self(name.to_string()))
-    }
-
-    pub fn as_str(&self) -> &str {
-        &self.0
-    }
-}
-
-impl FromStr for NymName {
-    type Err = NymNameError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Self::new(s)
-    }
-}
-
-impl Display for NymName {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::NymName;
-
-    #[test]
-    fn parse_nym_name() {
-        // Test some valid cases
-        assert!(NymName::new("foo").is_ok());
-        assert!(NymName::new("foo-bar").is_ok());
-        assert!(NymName::new("foo-bar-123").is_ok());
-        assert!(NymName::new("foo_bar").is_ok());
-        assert!(NymName::new("foo_bar_123").is_ok());
-
-        // And now test all some invalid ones
-        assert!(NymName::new("Foo").is_err());
-        assert!(NymName::new("foo bar").is_err());
-        assert!(NymName::new("foo!bar").is_err());
-        assert!(NymName::new("foo#bar").is_err());
-        assert!(NymName::new("foo$bar").is_err());
-        assert!(NymName::new("foo%bar").is_err());
-        assert!(NymName::new("foo&bar").is_err());
-        assert!(NymName::new("foo'bar").is_err());
-        assert!(NymName::new("foo(bar").is_err());
-        assert!(NymName::new("foo)bar").is_err());
-        assert!(NymName::new("foo*bar").is_err());
-        assert!(NymName::new("foo+bar").is_err());
-        assert!(NymName::new("foo,bar").is_err());
-        assert!(NymName::new("foo.bar").is_err());
-        assert!(NymName::new("foo.bar").is_err());
-        assert!(NymName::new("foo/bar").is_err());
-        assert!(NymName::new("foo/bar").is_err());
-        assert!(NymName::new("foo:bar").is_err());
-        assert!(NymName::new("foo;bar").is_err());
-        assert!(NymName::new("foo<bar").is_err());
-        assert!(NymName::new("foo=bar").is_err());
-        assert!(NymName::new("foo>bar").is_err());
-        assert!(NymName::new("foo?bar").is_err());
-        assert!(NymName::new("foo@bar").is_err());
-        assert!(NymName::new("fooBar").is_err());
-        assert!(NymName::new("foo[bar").is_err());
-        assert!(NymName::new("foo\"bar").is_err());
-        assert!(NymName::new("foo\\bar").is_err());
-        assert!(NymName::new("foo]bar").is_err());
-        assert!(NymName::new("foo^bar").is_err());
-        assert!(NymName::new("foo`bar").is_err());
-        assert!(NymName::new("foo{bar").is_err());
-        assert!(NymName::new("foo|bar").is_err());
-        assert!(NymName::new("foo}bar").is_err());
-        assert!(NymName::new("foo~bar").is_err());
-    }
-}
@@ -1,19 +0,0 @@
-[package]
-name = "nym-service-provider-directory-common"
-version = "0.1.0"
-edition = "2021"
-license.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cosmwasm-schema = { workspace = true }
-cosmwasm-std = { workspace = true }
-cw2 = { workspace = true, optional = true }
-cw-controllers = { workspace = true }
-cw-utils = { workspace = true }
-nym-contracts-common = { path = "../contracts-common", version = "0.5.0" }
-thiserror = { workspace = true }
-
-[features]
-schema = ["cw2"]
@@ -1,68 +0,0 @@
-use cosmwasm_std::{Addr, StdError};
-use cw_controllers::AdminError;
-use nym_contracts_common::signing::verifier::ApiVerifierError;
-use thiserror::Error;
-
-use crate::{NymAddress, ServiceId};
-
-#[derive(Error, Debug, PartialEq)]
-pub enum SpContractError {
-    #[error("{0}")]
-    Std(#[from] StdError),
-
-    #[error("{0}")]
-    AdminError(#[from] AdminError),
-
-    #[error("service not found: {service_id}")]
-    NotFound { service_id: ServiceId },
-
-    #[error("{sender} is not announcer of service")]
-    Unauthorized { sender: Addr },
-
-    #[error("deposit required to announce service")]
-    DepositRequired { source: cw_utils::PaymentError },
-
-    #[error("insufficiant deposit: {funds}, required: {deposit_required}")]
-    InsufficientDeposit {
-        funds: cosmwasm_std::Uint128,
-        deposit_required: cosmwasm_std::Uint128,
-    },
-
-    #[error("deposit too large: {funds}, required: {deposit_required}")]
-    TooLargeDeposit {
-        funds: cosmwasm_std::Uint128,
-        deposit_required: cosmwasm_std::Uint128,
-    },
-
-    #[error("reached the max number of providers ({max_providers}) for announcer {announcer}")]
-    ReachedMaxProvidersForAdmin { max_providers: u32, announcer: Addr },
-
-    #[error("reached the max number of aliases ({max_aliases}) for nym address {0}", nym_address.to_string())]
-    ReachedMaxAliasesForNymAddress {
-        max_aliases: u32,
-        nym_address: NymAddress,
-    },
-
-    #[error("failed to parse {value} into a valid SemVer version: {error_message}")]
-    SemVerFailure {
-        value: String,
-        error_message: String,
-    },
-
-    #[error("Failed to recover ed25519 public key from its base58 representation - {0}")]
-    MalformedEd25519IdentityKey(String),
-
-    #[error("Failed to recover ed25519 signature from its base58 representation - {0}")]
-    MalformedEd25519Signature(String),
-
-    #[error("Provided ed25519 signature did not verify correctly")]
-    InvalidEd25519Signature,
-
-    #[error("failed to verify message signature: {source}")]
-    SignatureVerificationFailure {
-        #[from]
-        source: ApiVerifierError,
-    },
-}
-
-pub type Result<T, E = SpContractError> = std::result::Result<T, E>;
@@ -1,58 +0,0 @@
-use cosmwasm_std::{Coin, Event};
-
-use crate::{Service, ServiceId};
-
-pub enum ServiceProviderEventType {
-    Announce,
-    DeleteId,
-    DeleteNymAddress,
-    UpdateDepositRequired,
-}
-
-impl std::fmt::Display for ServiceProviderEventType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ServiceProviderEventType::Announce => write!(f, "announce"),
-            ServiceProviderEventType::DeleteId => write!(f, "delete_id"),
-            ServiceProviderEventType::DeleteNymAddress => write!(f, "delete_nym_address"),
-            ServiceProviderEventType::UpdateDepositRequired => write!(f, "update_deposit_required"),
-        }
-    }
-}
-
-impl From<ServiceProviderEventType> for String {
-    fn from(event_type: ServiceProviderEventType) -> Self {
-        event_type.to_string()
-    }
-}
-
-pub const ACTION: &str = "action";
-
-pub const SERVICE_ID: &str = "service_id";
-pub const SERVICE_TYPE: &str = "service_type";
-pub const NYM_ADDRESS: &str = "nym_address";
-pub const OWNER: &str = "owner";
-
-pub const DEPOSIT_REQUIRED: &str = "deposit_required";
-
-pub fn new_announce_event(service_id: ServiceId, service: Service) -> Event {
-    Event::new(ServiceProviderEventType::Announce)
-        .add_attribute(ACTION, ServiceProviderEventType::Announce)
-        .add_attribute(SERVICE_ID, service_id.to_string())
-        .add_attribute(SERVICE_TYPE, service.service.service_type.to_string())
-        .add_attribute(NYM_ADDRESS, service.service.nym_address.to_string())
-        .add_attribute(OWNER, service.announcer.to_string())
-}
-
-pub fn new_delete_id_event(service: Service) -> Event {
-    Event::new(ServiceProviderEventType::DeleteId)
-        .add_attribute(ACTION, ServiceProviderEventType::DeleteId)
-        .add_attribute(SERVICE_ID, service.service_id.to_string())
-        .add_attribute(NYM_ADDRESS, service.service.nym_address.to_string())
-}
-
-pub fn new_update_deposit_required_event(deposit_required: Coin) -> Event {
-    Event::new(ServiceProviderEventType::UpdateDepositRequired)
-        .add_attribute(ACTION, ServiceProviderEventType::UpdateDepositRequired)
-        .add_attribute(DEPOSIT_REQUIRED, deposit_required.to_string())
-}
@@ -1,11 +0,0 @@
-pub mod error;
-pub mod events;
-pub mod msg;
-pub mod response;
-pub mod signing_types;
-pub mod types;
-
-// Re-export all types at the top-level
-pub use types::*;
-
-pub use cosmwasm_std::{Addr, Coin, Decimal, Fraction};
@@ -1,118 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{NymAddress, ServiceDetails, ServiceId};
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Coin;
-use nym_contracts_common::signing::MessageSignature;
-
-#[cfg(feature = "schema")]
-use crate::{
-    response::{ConfigResponse, PagedServicesListResponse, ServicesListResponse},
-    types::Service,
-};
-#[cfg(feature = "schema")]
-use cosmwasm_schema::QueryResponses;
-#[cfg(feature = "schema")]
-use nym_contracts_common::{signing::Nonce, ContractBuildInformation};
-
-#[cw_serde]
-pub struct InstantiateMsg {
-    pub deposit_required: Coin,
-}
-
-impl InstantiateMsg {
-    pub fn new(deposit_required: Coin) -> Self {
-        Self { deposit_required }
-    }
-}
-
-#[cw_serde]
-pub struct MigrateMsg {}
-
-#[cw_serde]
-pub enum ExecuteMsg {
-    Announce {
-        service: ServiceDetails,
-        owner_signature: MessageSignature,
-    },
-    DeleteId {
-        service_id: ServiceId,
-    },
-    DeleteNymAddress {
-        nym_address: NymAddress,
-    },
-    UpdateDepositRequired {
-        deposit_required: Coin,
-    },
-}
-
-impl ExecuteMsg {
-    pub fn delete_id(service_id: ServiceId) -> Self {
-        ExecuteMsg::DeleteId { service_id }
-    }
-
-    pub fn default_memo(&self) -> String {
-        match self {
-            ExecuteMsg::Announce {
-                service,
-                owner_signature: _,
-            } => format!(
-                "announcing {} as type {}",
-                service.nym_address, service.service_type
-            ),
-            ExecuteMsg::DeleteId { service_id } => {
-                format!("deleting service with service id {service_id}")
-            }
-            ExecuteMsg::DeleteNymAddress { nym_address } => {
-                format!("deleting service with nym address {nym_address}")
-            }
-            ExecuteMsg::UpdateDepositRequired { deposit_required } => {
-                format!("updating the deposit required to {deposit_required}")
-            }
-        }
-    }
-}
-
-#[cw_serde]
-#[cfg_attr(feature = "schema", derive(QueryResponses))]
-pub enum QueryMsg {
-    #[cfg_attr(feature = "schema", returns(Service))]
-    ServiceId { service_id: ServiceId },
-
-    #[cfg_attr(feature = "schema", returns(ServicesListResponse))]
-    ByAnnouncer { announcer: String },
-
-    #[cfg_attr(feature = "schema", returns(ServicesListResponse))]
-    ByNymAddress { nym_address: NymAddress },
-
-    #[cfg_attr(feature = "schema", returns(PagedServicesListResponse))]
-    All {
-        limit: Option<u32>,
-        start_after: Option<ServiceId>,
-    },
-
-    #[cfg_attr(feature = "schema", returns(Nonce))]
-    SigningNonce { address: String },
-
-    #[cfg_attr(feature = "schema", returns(ConfigResponse))]
-    Config {},
-
-    /// Gets build information of this contract, such as the commit hash used for the build or rustc version.
-    #[cfg_attr(feature = "schema", returns(ContractBuildInformation))]
-    GetContractVersion {},
-
-    /// Gets the stored contract version information that's required by the CW2 spec interface for migrations.
-    #[serde(rename = "get_cw2_contract_version")]
-    #[cfg_attr(feature = "schema", returns(cw2::ContractVersion))]
-    GetCW2ContractVersion {},
-}
-
-impl QueryMsg {
-    pub fn all() -> QueryMsg {
-        QueryMsg::All {
-            limit: None,
-            start_after: None,
-        }
-    }
-}
@@ -1,59 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{Service, ServiceId};
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Coin;
-
-#[cw_serde]
-pub struct ServiceInfoResponse {
-    pub service_id: ServiceId,
-    pub service: Option<Service>,
-}
-
-#[cw_serde]
-pub struct ServicesListResponse {
-    pub services: Vec<Service>,
-}
-
-impl ServicesListResponse {
-    pub fn new(services: Vec<Service>) -> ServicesListResponse {
-        ServicesListResponse { services }
-    }
-}
-
-impl From<&[Service]> for ServicesListResponse {
-    fn from(services: &[Service]) -> Self {
-        Self {
-            services: services.to_vec(),
-        }
-    }
-}
-
-#[cw_serde]
-pub struct PagedServicesListResponse {
-    pub services: Vec<Service>,
-    pub per_page: usize,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<ServiceId>,
-}
-
-impl PagedServicesListResponse {
-    pub fn new(
-        services: Vec<Service>,
-        per_page: usize,
-        start_next_after: Option<ServiceId>,
-    ) -> PagedServicesListResponse {
-        PagedServicesListResponse {
-            services,
-            per_page,
-            start_next_after,
-        }
-    }
-}
-
-#[cw_serde]
-pub struct ConfigResponse {
-    pub deposit_required: Coin,
-}
@@ -1,35 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::ServiceDetails;
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{Addr, Coin};
-use nym_contracts_common::signing::{
-    ContractMessageContent, MessageType, Nonce, SignableMessage, SigningPurpose,
-};
-
-pub type SignableServiceProviderAnnounceMsg =
-    SignableMessage<ContractMessageContent<ServiceProviderAnnounce>>;
-
-#[cw_serde]
-pub struct ServiceProviderAnnounce {
-    service: ServiceDetails,
-}
-
-impl SigningPurpose for ServiceProviderAnnounce {
-    fn message_type() -> MessageType {
-        MessageType::new("service-provider-announce")
-    }
-}
-
-pub fn construct_service_provider_announce_sign_payload(
-    nonce: Nonce,
-    sender: Addr,
-    deposit: Coin,
-    service: ServiceDetails,
-) -> SignableServiceProviderAnnounceMsg {
-    let payload = ServiceProviderAnnounce { service };
-    let proxy = None;
-    let content = ContractMessageContent::new(sender, proxy, vec![deposit], payload);
-    SignableMessage::new(nonce, content)
-}
@@ -1,79 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{Addr, Coin};
-use nym_contracts_common::IdentityKey;
-use std::fmt::{Display, Formatter};
-
-/// The directory of services are indexed by [`ServiceId`].
-pub type ServiceId = u32;
-
-#[cw_serde]
-pub struct Service {
-    /// Unique id assigned to the anounced service.
-    pub service_id: ServiceId,
-    /// The announced service.
-    pub service: ServiceDetails,
-    /// Address of the service owner.
-    pub announcer: Addr,
-    /// Block height at which the service was added.
-    pub block_height: u64,
-    /// The deposit used to announce the service.
-    pub deposit: Coin,
-}
-
-#[cw_serde]
-pub struct ServiceDetails {
-    /// The address of the service.
-    pub nym_address: NymAddress,
-    /// The service type.
-    pub service_type: ServiceType,
-    /// The identity key of the service.
-    pub identity_key: IdentityKey,
-}
-
-/// The types of addresses supported.
-#[cw_serde]
-pub enum NymAddress {
-    /// String representation of a nym address, which is of the form
-    /// client_id.client_enc@gateway_id.
-    Address(String),
-    // String name that can looked up in the nym-name-service contract (once it exists)
-    //Name(String),
-}
-
-impl NymAddress {
-    /// Create a new nym address.
-    pub fn new(address: &str) -> Self {
-        Self::Address(address.to_string())
-    }
-
-    pub fn as_str(&self) -> &str {
-        match self {
-            NymAddress::Address(address) => address,
-            //NymAddress::Name(name) => name,
-        }
-    }
-}
-
-impl Display for NymAddress {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.as_str())
-    }
-}
-
-/// The type of services provider supported
-#[cw_serde]
-pub enum ServiceType {
-    NetworkRequester,
-}
-
-impl std::fmt::Display for ServiceType {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let service_type = match self {
-            ServiceType::NetworkRequester => "network_requester",
-        };
-        write!(f, "{service_type}")
-    }
-}
@@ -12,6 +12,7 @@ license.workspace = true
 bincode = { workspace = true }
 bytes = { workspace = true }
 nym-bin-common = { path = "../bin-common" }
+nym-crypto = { path = "../crypto" }
 nym-sphinx = { path = "../nymsphinx" }
 rand = "0.8.5"
 serde = { workspace = true, features = ["derive"] }
@@ -1,2 +1,4 @@
 pub mod request;
 pub mod response;
+
+const VERSION: u8 = 6;
@@ -1,7 +1,9 @@
 use nym_sphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};

-use crate::{make_bincode_serializer, IpPair, CURRENT_VERSION};
+use crate::{make_bincode_serializer, IpPair};
+
+use super::VERSION;

 fn generate_random() -> u64 {
    use rand::RngCore;
@@ -26,7 +28,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::StaticConnect(StaticConnectRequest {
                    request_id,
                    ips,
@@ -49,7 +51,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::DynamicConnect(DynamicConnectRequest {
                    request_id,
                    reply_to,
@@ -66,7 +68,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::Disconnect(DisconnectRequest {
                    request_id,
                    reply_to,
@@ -78,7 +80,7 @@ impl IpPacketRequest {

    pub fn new_data_request(ip_packets: bytes::Bytes) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketRequestData::Data(DataRequest { ip_packets }),
        }
    }
@@ -87,7 +89,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::Ping(PingRequest {
                    request_id,
                    reply_to,
@@ -101,7 +103,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::Health(HealthRequest {
                    request_id,
                    reply_to,
@@ -1,7 +1,9 @@
 use nym_sphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};

-use crate::{make_bincode_serializer, IpPair, CURRENT_VERSION};
+use crate::{make_bincode_serializer, IpPair};
+
+use super::VERSION;

 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct IpPacketResponse {
@@ -12,7 +14,7 @@ pub struct IpPacketResponse {
 impl IpPacketResponse {
    pub fn new_static_connect_success(request_id: u64, reply_to: Recipient) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
                request_id,
                reply_to,
@@ -27,7 +29,7 @@ impl IpPacketResponse {
        reason: StaticConnectFailureReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
                request_id,
                reply_to,
@@ -38,7 +40,7 @@ impl IpPacketResponse {

    pub fn new_dynamic_connect_success(request_id: u64, reply_to: Recipient, ips: IpPair) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
                request_id,
                reply_to,
@@ -53,7 +55,7 @@ impl IpPacketResponse {
        reason: DynamicConnectFailureReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
                request_id,
                reply_to,
@@ -64,7 +66,7 @@ impl IpPacketResponse {

    pub fn new_disconnect_success(request_id: u64, reply_to: Recipient) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Disconnect(DisconnectResponse {
                request_id,
                reply_to,
@@ -79,7 +81,7 @@ impl IpPacketResponse {
        reason: DisconnectFailureReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Disconnect(DisconnectResponse {
                request_id,
                reply_to,
@@ -93,7 +95,7 @@ impl IpPacketResponse {
        reason: UnrequestedDisconnectReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::UnrequestedDisconnect(UnrequestedDisconnect {
                reply_to,
                reason,
@@ -103,7 +105,7 @@ impl IpPacketResponse {

    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Data(DataResponse { ip_packet }),
        }
    }
@@ -115,7 +117,7 @@ impl IpPacketResponse {
        our_version: u8,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Info(InfoResponse {
                request_id,
                reply_to,
@@ -134,7 +136,7 @@ impl IpPacketResponse {
        level: InfoLevel,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Info(InfoResponse {
                request_id: 0,
                reply_to,
@@ -146,7 +148,7 @@ impl IpPacketResponse {

    pub fn new_pong(request_id: u64, reply_to: Recipient) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Pong(PongResponse {
                request_id,
                reply_to,
@@ -161,7 +163,7 @@ impl IpPacketResponse {
        routable: Option<bool>,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Health(HealthResponse {
                request_id,
                reply_to,
@@ -0,0 +1,124 @@
+use time::OffsetDateTime;
+
+use crate::{v6, v7};
+
+impl From<v6::request::IpPacketRequest> for v7::request::IpPacketRequest {
+    fn from(ip_packet_request: v6::request::IpPacketRequest) -> Self {
+        Self {
+            version: 7,
+            data: ip_packet_request.data.into(),
+        }
+    }
+}
+
+impl From<v6::request::IpPacketRequestData> for v7::request::IpPacketRequestData {
+    fn from(ip_packet_request_data: v6::request::IpPacketRequestData) -> Self {
+        match ip_packet_request_data {
+            v6::request::IpPacketRequestData::StaticConnect(r) => {
+                v7::request::IpPacketRequestData::StaticConnect(
+                    v7::request::SignedStaticConnectRequest {
+                        request: r.into(),
+                        signature: None,
+                    },
+                )
+            }
+            v6::request::IpPacketRequestData::DynamicConnect(r) => {
+                v7::request::IpPacketRequestData::DynamicConnect(
+                    v7::request::SignedDynamicConnectRequest {
+                        request: r.into(),
+                        signature: None,
+                    },
+                )
+            }
+            v6::request::IpPacketRequestData::Disconnect(r) => {
+                v7::request::IpPacketRequestData::Disconnect(v7::request::SignedDisconnectRequest {
+                    request: r.into(),
+                    signature: None,
+                })
+            }
+            v6::request::IpPacketRequestData::Data(r) => {
+                v7::request::IpPacketRequestData::Data(r.into())
+            }
+            v6::request::IpPacketRequestData::Ping(r) => {
+                v7::request::IpPacketRequestData::Ping(r.into())
+            }
+            v6::request::IpPacketRequestData::Health(r) => {
+                v7::request::IpPacketRequestData::Health(r.into())
+            }
+        }
+    }
+}
+
+impl From<v6::request::StaticConnectRequest> for v7::request::StaticConnectRequest {
+    fn from(static_connect_request: v6::request::StaticConnectRequest) -> Self {
+        Self {
+            request_id: static_connect_request.request_id,
+            ips: static_connect_request.ips,
+            reply_to: static_connect_request.reply_to,
+            reply_to_hops: static_connect_request.reply_to_hops,
+            reply_to_avg_mix_delays: static_connect_request.reply_to_avg_mix_delays,
+            buffer_timeout: static_connect_request.buffer_timeout,
+            timestamp: OffsetDateTime::now_utc(),
+        }
+    }
+}
+
+impl From<v6::request::DynamicConnectRequest> for v7::request::DynamicConnectRequest {
+    fn from(dynamic_connect_request: v6::request::DynamicConnectRequest) -> Self {
+        Self {
+            request_id: dynamic_connect_request.request_id,
+            reply_to: dynamic_connect_request.reply_to,
+            reply_to_hops: dynamic_connect_request.reply_to_hops,
+            reply_to_avg_mix_delays: dynamic_connect_request.reply_to_avg_mix_delays,
+            buffer_timeout: dynamic_connect_request.buffer_timeout,
+            timestamp: OffsetDateTime::now_utc(),
+        }
+    }
+}
+
+impl From<v6::request::DisconnectRequest> for v7::request::SignedDisconnectRequest {
+    fn from(disconnect_request: v6::request::DisconnectRequest) -> Self {
+        Self {
+            request: disconnect_request.into(),
+            signature: None,
+        }
+    }
+}
+
+impl From<v6::request::DisconnectRequest> for v7::request::DisconnectRequest {
+    fn from(disconnect_request: v6::request::DisconnectRequest) -> Self {
+        Self {
+            request_id: disconnect_request.request_id,
+            reply_to: disconnect_request.reply_to,
+            timestamp: OffsetDateTime::now_utc(),
+        }
+    }
+}
+
+impl From<v6::request::DataRequest> for v7::request::DataRequest {
+    fn from(data_request: v6::request::DataRequest) -> Self {
+        Self {
+            ip_packets: data_request.ip_packets,
+        }
+    }
+}
+
+impl From<v6::request::PingRequest> for v7::request::PingRequest {
+    fn from(ping_request: v6::request::PingRequest) -> Self {
+        Self {
+            request_id: ping_request.request_id,
+            reply_to: ping_request.reply_to,
+            timestamp: OffsetDateTime::now_utc(),
+        }
+    }
+}
+
+impl From<v6::request::HealthRequest> for v7::request::HealthRequest {
+    fn from(health_request: v6::request::HealthRequest) -> Self {
+        Self {
+            request_id: health_request.request_id,
+            reply_to: health_request.reply_to,
+            timestamp: OffsetDateTime::now_utc(),
+        }
+    }
+}
@@ -1,2 +1,6 @@
+pub mod conversion;
 pub mod request;
 pub mod response;
+pub mod signature;
+
+const VERSION: u8 = 7;
@@ -1,8 +1,14 @@
+use nym_crypto::asymmetric::identity;
 use nym_sphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};
 use time::OffsetDateTime;

-use crate::{make_bincode_serializer, IpPair, CURRENT_VERSION};
+use crate::{make_bincode_serializer, IpPair};
+
+use super::{
+    signature::{SignatureError, SignedRequest},
+    VERSION,
+};

 fn generate_random() -> u64 {
    use rand::RngCore;
@@ -27,7 +33,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::StaticConnect(SignedStaticConnectRequest {
                    request: StaticConnectRequest {
                        request_id,
@@ -54,7 +60,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::DynamicConnect(SignedDynamicConnectRequest {
                    request: DynamicConnectRequest {
                        request_id,
@@ -75,7 +81,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::Disconnect(SignedDisconnectRequest {
                    request: DisconnectRequest {
                        request_id,
@@ -91,7 +97,7 @@ impl IpPacketRequest {

    pub fn new_data_request(ip_packets: bytes::Bytes) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketRequestData::Data(DataRequest { ip_packets }),
        }
    }
@@ -100,7 +106,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::Ping(PingRequest {
                    request_id,
                    reply_to,
@@ -115,7 +121,7 @@ impl IpPacketRequest {
        let request_id = generate_random();
        (
            Self {
-                version: CURRENT_VERSION,
+                version: VERSION,
                data: IpPacketRequestData::Health(HealthRequest {
                    request_id,
                    reply_to,
@@ -173,19 +179,19 @@ pub enum IpPacketRequestData {
 }

 impl IpPacketRequestData {
-    pub fn add_signature(&mut self, signature: Vec<u8>) -> Option<Vec<u8>> {
+    pub fn add_signature(&mut self, signature: identity::Signature) -> Option<identity::Signature> {
        match self {
            IpPacketRequestData::StaticConnect(request) => {
                request.signature = Some(signature);
-                request.signature.clone()
+                request.signature
            }
            IpPacketRequestData::DynamicConnect(request) => {
                request.signature = Some(signature);
-                request.signature.clone()
+                request.signature
            }
            IpPacketRequestData::Disconnect(request) => {
                request.signature = Some(signature);
-                request.signature.clone()
+                request.signature
            }
            IpPacketRequestData::Data(_)
            | IpPacketRequestData::Ping(_)
@@ -231,7 +237,30 @@ impl StaticConnectRequest {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct SignedStaticConnectRequest {
    pub request: StaticConnectRequest,
-    pub signature: Option<Vec<u8>>,
+    pub signature: Option<identity::Signature>,
+}
+
+impl SignedRequest for SignedStaticConnectRequest {
+    fn identity(&self) -> &identity::PublicKey {
+        self.request.reply_to.identity()
+    }
+
+    fn request(&self) -> Result<Vec<u8>, SignatureError> {
+        self.request
+            .to_bytes()
+            .map_err(|error| SignatureError::RequestSerializationError {
+                message: "failed to serialize request to binary".to_string(),
+                error,
+            })
+    }
+
+    fn signature(&self) -> Option<&identity::Signature> {
+        self.signature.as_ref()
+    }
+
+    fn timestamp(&self) -> OffsetDateTime {
+        self.request.timestamp
+    }
 }

 // A dynamic connect request is when the client does not provide the internal IP address it will use
@@ -269,7 +298,30 @@ impl DynamicConnectRequest {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct SignedDynamicConnectRequest {
    pub request: DynamicConnectRequest,
-    pub signature: Option<Vec<u8>>,
+    pub signature: Option<identity::Signature>,
+}
+
+impl SignedRequest for SignedDynamicConnectRequest {
+    fn identity(&self) -> &identity::PublicKey {
+        self.request.reply_to.identity()
+    }
+
+    fn request(&self) -> Result<Vec<u8>, SignatureError> {
+        self.request
+            .to_bytes()
+            .map_err(|error| SignatureError::RequestSerializationError {
+                message: "failed to serialize request to binary".to_string(),
+                error,
+            })
+    }
+
+    fn signature(&self) -> Option<&identity::Signature> {
+        self.signature.as_ref()
+    }
+
+    fn timestamp(&self) -> OffsetDateTime {
+        self.request.timestamp
+    }
 }

 // A disconnect request is when the client wants to disconnect from the ip packet router and free
@@ -295,7 +347,30 @@ impl DisconnectRequest {
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct SignedDisconnectRequest {
    pub request: DisconnectRequest,
-    pub signature: Option<Vec<u8>>,
+    pub signature: Option<identity::Signature>,
+}
+
+impl SignedRequest for SignedDisconnectRequest {
+    fn identity(&self) -> &identity::PublicKey {
+        self.request.reply_to.identity()
+    }
+
+    fn request(&self) -> Result<Vec<u8>, SignatureError> {
+        self.request
+            .to_bytes()
+            .map_err(|error| SignatureError::RequestSerializationError {
+                message: "failed to serialize request to binary".to_string(),
+                error,
+            })
+    }
+
+    fn signature(&self) -> Option<&identity::Signature> {
+        self.signature.as_ref()
+    }
+
+    fn timestamp(&self) -> OffsetDateTime {
+        self.request.timestamp
+    }
 }

 // A data request is when the client wants to send an IP packet to a destination.
@@ -1,7 +1,9 @@
 use nym_sphinx::addressing::clients::Recipient;
 use serde::{Deserialize, Serialize};

-use crate::{make_bincode_serializer, IpPair, CURRENT_VERSION};
+use crate::{make_bincode_serializer, IpPair};
+
+use super::VERSION;

 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct IpPacketResponse {
@@ -12,7 +14,7 @@ pub struct IpPacketResponse {
 impl IpPacketResponse {
    pub fn new_static_connect_success(request_id: u64, reply_to: Recipient) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
                request_id,
                reply_to,
@@ -27,7 +29,7 @@ impl IpPacketResponse {
        reason: StaticConnectFailureReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::StaticConnect(StaticConnectResponse {
                request_id,
                reply_to,
@@ -38,7 +40,7 @@ impl IpPacketResponse {

    pub fn new_dynamic_connect_success(request_id: u64, reply_to: Recipient, ips: IpPair) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
                request_id,
                reply_to,
@@ -53,7 +55,7 @@ impl IpPacketResponse {
        reason: DynamicConnectFailureReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::DynamicConnect(DynamicConnectResponse {
                request_id,
                reply_to,
@@ -64,7 +66,7 @@ impl IpPacketResponse {

    pub fn new_disconnect_success(request_id: u64, reply_to: Recipient) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Disconnect(DisconnectResponse {
                request_id,
                reply_to,
@@ -79,7 +81,7 @@ impl IpPacketResponse {
        reason: DisconnectFailureReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Disconnect(DisconnectResponse {
                request_id,
                reply_to,
@@ -93,7 +95,7 @@ impl IpPacketResponse {
        reason: UnrequestedDisconnectReason,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::UnrequestedDisconnect(UnrequestedDisconnect {
                reply_to,
                reason,
@@ -103,7 +105,7 @@ impl IpPacketResponse {

    pub fn new_ip_packet(ip_packet: bytes::Bytes) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Data(DataResponse { ip_packet }),
        }
    }
@@ -115,7 +117,7 @@ impl IpPacketResponse {
        our_version: u8,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Info(InfoResponse {
                request_id,
                reply_to,
@@ -134,7 +136,7 @@ impl IpPacketResponse {
        level: InfoLevel,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Info(InfoResponse {
                request_id: 0,
                reply_to,
@@ -146,7 +148,7 @@ impl IpPacketResponse {

    pub fn new_pong(request_id: u64, reply_to: Recipient) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Pong(PongResponse {
                request_id,
                reply_to,
@@ -161,7 +163,7 @@ impl IpPacketResponse {
        routable: Option<bool>,
    ) -> Self {
        Self {
-            version: CURRENT_VERSION,
+            version: VERSION,
            data: IpPacketResponseData::Health(HealthResponse {
                request_id,
                reply_to,
@@ -275,6 +277,8 @@ pub enum StaticConnectFailureReason {
    RequestedIpAlreadyInUse,
    #[error("requested nym-address is already in use")]
    RequestedNymAddressAlreadyInUse,
+    #[error("request timestamp is out of date")]
+    OutOfDateTimestamp,
    #[error("{0}")]
    Other(String),
 }
@@ -0,0 +1,57 @@
+use std::time::Duration;
+
+use nym_crypto::asymmetric::identity;
+
+// For reply protection, if a request is older than this, it will be rejected
+const MAX_REQUEST_AGE: Duration = Duration::from_secs(10);
+
+#[derive(thiserror::Error, Debug)]
+pub enum SignatureError {
+    #[error("signature is missing")]
+    MissingSignature,
+
+    #[error("failed to serialize request to binary: {message}")]
+    RequestSerializationError {
+        message: String,
+        error: Box<bincode::ErrorKind>,
+    },
+
+    #[error("signature verification failed: request out of date")]
+    RequestOutOfDate,
+
+    #[error("signature verification failed")]
+    VerificationFailed {
+        message: String,
+        error: identity::SignatureError,
+    },
+}
+
+pub trait SignedRequest {
+    fn identity(&self) -> &identity::PublicKey;
+
+    fn request(&self) -> Result<Vec<u8>, SignatureError>;
+
+    fn signature(&self) -> Option<&identity::Signature>;
+
+    fn timestamp(&self) -> time::OffsetDateTime;
+
+    fn verify(&self) -> Result<(), SignatureError> {
+        if let Some(signature) = self.signature() {
+            // First check that the request is recent enough
+            if time::OffsetDateTime::now_utc() - self.timestamp() > MAX_REQUEST_AGE {
+                return Err(SignatureError::RequestOutOfDate);
+            }
+
+            let request_as_bytes = self.request()?;
+
+            self.identity()
+                .verify(request_as_bytes, signature)
+                .map_err(|error| SignatureError::VerificationFailed {
+                    message: "signature verification failed".to_string(),
+                    error,
+                })
+        } else {
+            Err(SignatureError::MissingSignature)
+        }
+    }
+}
@@ -31,9 +31,6 @@ pub struct NymContracts {
    pub group_contract_address: Option<String>,
    pub multisig_contract_address: Option<String>,
    pub coconut_dkg_contract_address: Option<String>,
-    pub ephemera_contract_address: Option<String>,
-    pub service_provider_directory_contract_address: Option<String>,
-    pub name_service_contract_address: Option<String>,
 }

 // I wanted to use the simpler `NetworkDetails` name, but there's a clash
@@ -128,11 +125,6 @@ impl NymNetworkDetails {
            .with_group_contract(get_optional_env(var_names::GROUP_CONTRACT_ADDRESS))
            .with_multisig_contract(get_optional_env(var_names::MULTISIG_CONTRACT_ADDRESS))
            .with_coconut_dkg_contract(get_optional_env(var_names::COCONUT_DKG_CONTRACT_ADDRESS))
-            .with_ephemera_contract(get_optional_env(var_names::EPHEMERA_CONTRACT_ADDRESS))
-            .with_service_provider_directory_contract(get_optional_env(
-                var_names::SERVICE_PROVIDER_DIRECTORY_CONTRACT_ADDRESS,
-            ))
-            .with_name_service_contract(get_optional_env(var_names::NAME_SERVICE_CONTRACT_ADDRESS))
            .with_explorer_api(get_optional_env(var_names::EXPLORER_API))
    }

@@ -161,9 +153,6 @@ impl NymNetworkDetails {
                coconut_dkg_contract_address: parse_optional_str(
                    mainnet::COCONUT_DKG_CONTRACT_ADDRESS,
                ),
-                ephemera_contract_address: parse_optional_str(mainnet::EPHEMERA_CONTRACT_ADDRESS),
-                service_provider_directory_contract_address: None,
-                name_service_contract_address: None,
            },
            explorer_api: parse_optional_str(mainnet::EXPLORER_API),
        }
@@ -269,27 +258,6 @@ impl NymNetworkDetails {
        self
    }

-    #[must_use]
-    pub fn with_ephemera_contract<S: Into<String>>(mut self, contract: Option<S>) -> Self {
-        self.contracts.ephemera_contract_address = contract.map(Into::into);
-        self
-    }
-
-    #[must_use]
-    pub fn with_service_provider_directory_contract<S: Into<String>>(
-        mut self,
-        contract: Option<S>,
-    ) -> Self {
-        self.contracts.service_provider_directory_contract_address = contract.map(Into::into);
-        self
-    }
-
-    #[must_use]
-    pub fn with_name_service_contract<S: Into<String>>(mut self, contract: Option<S>) -> Self {
-        self.contracts.name_service_contract_address = contract.map(Into::into);
-        self
-    }
-
    #[must_use]
    pub fn with_explorer_api<S: Into<String>>(mut self, endpoint: Option<S>) -> Self {
        self.explorer_api = endpoint.map(Into::into);
@@ -453,22 +421,13 @@ pub fn setup_env<P: AsRef<Path>>(config_env_file: Option<P>) {
    }
 }

-// Name of the event triggered by the eth contract. If the event name is changed,
-// this would also need to be changed; It is currently tested against the json abi
-pub const ETH_EVENT_NAME: &str = "BBCredentialPurchased";
-pub const ETH_BURN_FUNCTION_NAME: &str = "generateBasicBandwidthCredential";
-pub const ETH_ERC20_APPROVE_FUNCTION_NAME: &str = "approve";
-
-// Ethereum constants used for token bridge
 /// How much bandwidth (in bytes) one token can buy
 pub const BYTES_PER_UTOKEN: u64 = 1024;
-
 /// How much bandwidth (in bytes) one freepass provides
 pub const BYTES_PER_FREEPASS: u64 = 1024 * 1024 * 1024; // 1GB
-
 /// Threshold for claiming more bandwidth: 1 MB
 pub const REMAINING_BANDWIDTH_THRESHOLD: i64 = 1024 * 1024;
-/// How many ERC20 tokens should be burned to buy bandwidth
+/// How many tokens should be burned to buy bandwidth
 pub const TOKENS_TO_BURN: u64 = 1;
 /// How many ERC20 utokens should be burned to buy bandwidth
 pub const UTOKENS_TO_BURN: u64 = TOKENS_TO_BURN * 1000000;
@@ -24,7 +24,6 @@ pub const MULTISIG_CONTRACT_ADDRESS: &str =
    "n1txayqfz5g9qww3rlflpg025xd26m9payz96u54x4fe3s2ktz39xqk67gzx";
 pub const COCONUT_DKG_CONTRACT_ADDRESS: &str =
    "n19604yflqggs9mk2z26mqygq43q2kr3n932egxx630svywd5mpxjsztfpvx";
-pub const EPHEMERA_CONTRACT_ADDRESS: &str = "";

 pub const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy";

@@ -107,10 +106,6 @@ pub fn export_to_env() {
        var_names::COCONUT_DKG_CONTRACT_ADDRESS,
        COCONUT_DKG_CONTRACT_ADDRESS,
    );
-    set_var_to_default(
-        var_names::EPHEMERA_CONTRACT_ADDRESS,
-        EPHEMERA_CONTRACT_ADDRESS,
-    );
    set_var_to_default(
        var_names::REWARDING_VALIDATOR_ADDRESS,
        REWARDING_VALIDATOR_ADDRESS,
@@ -156,10 +151,6 @@ pub fn export_to_env_if_not_set() {
        var_names::COCONUT_DKG_CONTRACT_ADDRESS,
        COCONUT_DKG_CONTRACT_ADDRESS,
    );
-    set_var_conditionally_to_default(
-        var_names::EPHEMERA_CONTRACT_ADDRESS,
-        EPHEMERA_CONTRACT_ADDRESS,
-    );
    set_var_conditionally_to_default(
        var_names::REWARDING_VALIDATOR_ADDRESS,
        REWARDING_VALIDATOR_ADDRESS,
@@ -18,12 +18,8 @@ pub const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str = "COCONUT_BANDWIDTH_CONTRACT
 pub const GROUP_CONTRACT_ADDRESS: &str = "GROUP_CONTRACT_ADDRESS";
 pub const MULTISIG_CONTRACT_ADDRESS: &str = "MULTISIG_CONTRACT_ADDRESS";
 pub const COCONUT_DKG_CONTRACT_ADDRESS: &str = "COCONUT_DKG_CONTRACT_ADDRESS";
-pub const EPHEMERA_CONTRACT_ADDRESS: &str = "EPHEMERA_CONTRACT_ADDRESS";
 pub const REWARDING_VALIDATOR_ADDRESS: &str = "REWARDING_VALIDATOR_ADDRESS";
 pub const STATISTICS_SERVICE_DOMAIN_ADDRESS: &str = "STATISTICS_SERVICE_DOMAIN_ADDRESS";
-pub const SERVICE_PROVIDER_DIRECTORY_CONTRACT_ADDRESS: &str =
-    "SERVICE_PROVIDER_DIRECTORY_CONTRACT_ADDRESS";
-pub const NAME_SERVICE_CONTRACT_ADDRESS: &str = "NAME_SERVICE_CONTRACT_ADDRESS";
 pub const NYXD: &str = "NYXD";
 pub const NYM_API: &str = "NYM_API";
 pub const NYXD_WEBSOCKET: &str = "NYXD_WS";
@@ -41,7 +41,7 @@ impl<'a> From<&'a mix::Node> for TestableNode {
    fn from(value: &'a mix::Node) -> Self {
        TestableNode {
            encoded_identity: value.identity_key.to_base58_string(),
-            owner: value.owner.clone(),
+            owner: value.owner.as_ref().cloned().unwrap_or_default(),
            typ: NodeType::Mixnode {
                mix_id: value.mix_id,
            },
@@ -53,7 +53,7 @@ impl<'a> From<&'a gateway::Node> for TestableNode {
    fn from(value: &'a gateway::Node) -> Self {
        TestableNode {
            encoded_identity: value.identity_key.to_base58_string(),
-            owner: value.owner.clone(),
+            owner: value.owner.as_ref().cloned().unwrap_or_default(),
            typ: NodeType::Gateway,
        }
    }
@@ -300,8 +300,8 @@ impl Fragment {
 #[derive(PartialEq, Clone, Debug)]
 pub(crate) struct FragmentHeader {
    /// ID associated with `FragmentSet` to which this particular `Fragment` belongs.
-    /// Its value is restricted to (0, i32::max_value()].
-    /// Note that it *excludes* 0, but *includes* i32::max_value().
+    /// Its value is restricted to (0, i32::MAX].
+    /// Note that it *excludes* 0, but *includes* i32::MAX.
    /// This allows the field to be represented using 31 bits.
    id: i32,

@@ -319,7 +319,7 @@ pub(crate) struct FragmentHeader {
    previous_fragments_set_id: Option<i32>,

    /// Optional ID of next `FragmentSet` into which the original message was split.
-    /// Note, this option is only valid of `current_fragment == total_fragments == u8::max_value()`
+    /// Note, this option is only valid of `current_fragment == total_fragments == u8::MAX`
    next_fragments_set_id: Option<i32>,
 }

@@ -414,7 +414,7 @@ impl FragmentHeader {

            if current_fragment == 1 {
                previous_fragments_set_id = Some(linked_id);
-            } else if total_fragments == current_fragment && current_fragment == u8::max_value() {
+            } else if total_fragments == current_fragment && current_fragment == u8::MAX {
                next_fragments_set_id = Some(linked_id);
            } else {
                return Err(ChunkingError::MalformedHeaderError);
@@ -585,14 +585,7 @@ mod fragment_tests {
        rng.fill_bytes(&mut msg);

        let fragment = Fragment {
-            header: FragmentHeader::try_new(
-                12345,
-                u8::max_value(),
-                u8::max_value(),
-                None,
-                Some(1234),
-            )
-            .unwrap(),
+            header: FragmentHeader::try_new(12345, u8::MAX, u8::MAX, None, Some(1234)).unwrap(),
            payload: msg,
        };
        let packet_bytes = fragment.clone().into_bytes();
@@ -602,14 +595,7 @@ mod fragment_tests {
        rng.fill_bytes(&mut msg);

        let fragment = Fragment {
-            header: FragmentHeader::try_new(
-                12345,
-                u8::max_value(),
-                u8::max_value(),
-                None,
-                Some(1234),
-            )
-            .unwrap(),
+            header: FragmentHeader::try_new(12345, u8::MAX, u8::MAX, None, Some(1234)).unwrap(),
            payload: msg,
        };
        let packet_bytes = fragment.clone().into_bytes();
@@ -822,8 +808,8 @@ mod fragment_tests {
        assert!(Fragment::try_new(
            &full_payload,
            id,
-            u8::max_value(),
-            u8::max_value(),
+            u8::MAX,
+            u8::MAX,
            None,
            Some(link_id),
            max_plaintext_size(),
@@ -884,8 +870,8 @@ mod fragment_tests {
        assert!(Fragment::try_new(
            &non_full_payload,
            id,
-            u8::max_value(),
-            u8::max_value(),
+            u8::MAX,
+            u8::MAX,
            None,
            Some(link_id),
            max_plaintext_size(),
@@ -894,8 +880,8 @@ mod fragment_tests {
        assert!(Fragment::try_new(
            &non_full_payload2,
            id,
-            u8::max_value(),
-            u8::max_value(),
+            u8::MAX,
+            u8::MAX,
            None,
            Some(link_id),
            max_plaintext_size(),
@@ -905,8 +891,8 @@ mod fragment_tests {
        assert!(Fragment::try_new(
            &too_much_payload,
            id,
-            u8::max_value(),
-            u8::max_value(),
+            u8::MAX,
+            u8::MAX,
            None,
            Some(link_id),
            max_plaintext_size(),
@@ -1008,14 +994,7 @@ mod fragment_header {
        fn fragmented_header_cannot_be_created_with_zero_id() {
            assert!(FragmentHeader::try_new(0, 10, 5, None, None).is_err());
            assert!(FragmentHeader::try_new(12345, 10, 5, Some(0), None).is_err());
-            assert!(FragmentHeader::try_new(
-                12345,
-                u8::max_value(),
-                u8::max_value(),
-                None,
-                Some(0),
-            )
-            .is_err());
+            assert!(FragmentHeader::try_new(12345, u8::MAX, u8::MAX, None, Some(0),).is_err());
        }

        #[test]
@@ -1066,14 +1045,7 @@ mod fragment_header {
        #[test]
        fn can_only_be_post_linked_for_last_fragment() {
            assert!(FragmentHeader::try_new(12345, 10, 10, None, Some(1234)).is_ok());
-            assert!(FragmentHeader::try_new(
-                12345,
-                u8::max_value(),
-                u8::max_value(),
-                None,
-                Some(1234),
-            )
-            .is_ok());
+            assert!(FragmentHeader::try_new(12345, u8::MAX, u8::MAX, None, Some(1234),).is_ok());
            assert!(FragmentHeader::try_new(12345, 10, 2, Some(1234), None).is_err());
        }

@@ -1117,8 +1089,7 @@ mod fragment_header {
        #[test]
        fn post_linked_can_be_converted_to_and_from_bytes_for_exact_number_of_bytes_provided() {
            let fragmented_header =
-                FragmentHeader::try_new(12345, u8::max_value(), u8::max_value(), None, Some(1234))
-                    .unwrap();
+                FragmentHeader::try_new(12345, u8::MAX, u8::MAX, None, Some(1234)).unwrap();

            let header_bytes = fragmented_header.to_bytes();
            let (recovered_header, bytes_used) =
@@ -1130,8 +1101,7 @@ mod fragment_header {
        #[test]
        fn post_linked_can_be_converted_to_and_from_bytes_for_more_than_required_number_of_bytes() {
            let fragmented_header =
-                FragmentHeader::try_new(12345, u8::max_value(), u8::max_value(), None, Some(1234))
-                    .unwrap();
+                FragmentHeader::try_new(12345, u8::MAX, u8::MAX, None, Some(1234)).unwrap();

            let mut header_bytes = fragmented_header.to_bytes();
            header_bytes.append(vec![1, 2, 3, 4, 5].as_mut());
@@ -41,7 +41,7 @@ pub mod set;
 /// (or implicitly the only one), it has no lower bound on the number of `Fragment`s.
 /// (Apart from the restriction of containing at least a single one). If the set is located
 /// somewhere in the middle, *it must be* full. Finally, regardless of its position, it must also be
-/// true that it contains no more than `u8::max_value()`, i.e. 255 `Fragment`s.
+/// true that it contains no more than `u8::MAX`, i.e. 255 `Fragment`s.
 /// Again, the reasoning for this is further explained in `set.rs` file. However, you might
 /// also want to look at `fragment.rs` to understand the full context behind that design choice.
 ///
@@ -151,7 +151,7 @@ mod tests {
            - MAX_NODE_ADDRESS_UNPADDED_LEN;

        let plaintext_lens = vec![17, used_plaintext_len, 20, 42, 10000];
-        const SET_LEN: usize = u8::max_value() as usize;
+        const SET_LEN: usize = u8::MAX as usize;

        for plaintext_len in plaintext_lens {
            let unlinked_len = unlinked_fragment_payload_max_len(plaintext_len);
@@ -24,7 +24,7 @@ struct ReconstructionBuffer {
    previous_fragments_set_id: Option<i32>,
    /// Once all fragments are received, the value of `next_fragments_set_id` is copied
    /// from the last `Fragment` in the set (assuming the set is full, i.e. it contains
-    /// `u8::max_value()` elements).
+    /// `u8::MAX` elements).
    next_fragments_set_id: Option<i32>,

    /// The actual `Fragment` data held by the `ReconstructionBuffer`. When created it is already
@@ -40,7 +40,7 @@ pub type ReconstructedMessage = (Vec<u8>, Vec<i32>);
 impl ReconstructionBuffer {
    /// Initialises new instance of a `ReconstructionBuffer` with given size, i.e.
    /// number of expected `Fragment`s in the set.
-    /// The `u8` input type of `size` argument ensures it has the `u8::max_value()` upper bound.
+    /// The `u8` input type of `size` argument ensures it has the `u8::MAX` upper bound.
    fn new(size: u8) -> Self {
        // Note: `new` should have never been called with size 0 in the first place
        // as `size` value is based on the first recovered `Fragment` in the set.
@@ -122,8 +122,8 @@ impl ReconstructionBuffer {
                .as_ref()
                .unwrap()
                .previous_fragments_set_id();
-            self.next_fragments_set_id = if self.fragments.len() == u8::max_value() as usize {
-                self.fragments[u8::max_value() as usize - 1]
+            self.next_fragments_set_id = if self.fragments.len() == u8::MAX as usize {
+                self.fragments[u8::MAX as usize - 1]
                    .as_ref()
                    .unwrap()
                    .next_fragments_set_id()
@@ -313,8 +313,8 @@ mod reconstruction_buffer {
            assert_eq!(None, frag);
        }

-        let buf = ReconstructionBuffer::new(u8::max_value());
-        assert_eq!(u8::max_value() as usize, buf.fragments.len());
+        let buf = ReconstructionBuffer::new(u8::MAX);
+        assert_eq!(u8::MAX as usize, buf.fragments.len());
        for frag in buf.fragments {
            assert_eq!(None, frag);
        }
@@ -358,11 +358,11 @@ mod reconstruction_buffer {
        buf.insert_fragment(Fragment::try_from_bytes(&raw_fragments[2]).unwrap());
        assert_eq!(message.to_vec(), buf.reconstruct_set_data());

-        let mut buf = ReconstructionBuffer::new(u8::max_value());
+        let mut buf = ReconstructionBuffer::new(u8::MAX);
        let message = vec![
            42u8;
            unlinked_fragment_payload_max_len(AVAILABLE_PLAINTEXT_SIZE)
-                * u8::max_value() as usize
+                * u8::MAX as usize
        ];
        let raw_fragments: Vec<_> =
            crate::split_into_sets(&mut rand::rngs::OsRng, &message, AVAILABLE_PLAINTEXT_SIZE)
@@ -445,7 +445,7 @@ mod reconstruction_buffer {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize - 1) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize - 1) {
            buf.insert_fragment(Fragment::try_from_bytes(raw_fragment).unwrap());
        }

@@ -563,7 +563,7 @@ mod message_reconstructor {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -611,7 +611,7 @@ mod message_reconstructor {
                .collect();

        // note that first set is not fully inserted
-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize - 1) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize - 1) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -657,7 +657,7 @@ mod message_reconstructor {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -699,7 +699,7 @@ mod message_reconstructor {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -738,7 +738,7 @@ mod message_reconstructor {
                .collect();

        // note that first set is not fully inserted
-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize - 1) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize - 1) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -779,7 +779,7 @@ mod message_reconstructor {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize * 2) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize * 2) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -793,7 +793,7 @@ mod message_reconstructor {
        assert!(reconstructor
            .insert_new_fragment(
                reconstructor
-                    .recover_fragment(raw_fragments[(u8::max_value() as usize) * 2].clone())
+                    .recover_fragment(raw_fragments[(u8::MAX as usize) * 2].clone())
                    .unwrap()
            )
            .is_none());
@@ -822,11 +822,7 @@ mod message_reconstructor {
                .collect();

        // note that first set is not fully inserted
-        for raw_fragment in raw_fragments
-            .iter()
-            .skip(1)
-            .take(u8::max_value() as usize * 2 - 1)
-        {
+        for raw_fragment in raw_fragments.iter().skip(1).take(u8::MAX as usize * 2 - 1) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -839,7 +835,7 @@ mod message_reconstructor {
        assert!(reconstructor
            .insert_new_fragment(
                reconstructor
-                    .recover_fragment(raw_fragments[(u8::max_value() as usize) * 2].clone())
+                    .recover_fragment(raw_fragments[(u8::MAX as usize) * 2].clone())
                    .unwrap()
            )
            .is_none());
@@ -896,7 +892,7 @@ mod message_reconstructor {
                .collect();

        // note that first set is not fully inserted
-        for raw_fragment in raw_fragments1.iter().take(u8::max_value() as usize - 1) {
+        for raw_fragment in raw_fragments1.iter().take(u8::MAX as usize - 1) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -930,7 +926,7 @@ mod message_reconstructor {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments2.iter().take(u8::max_value() as usize) {
+        for raw_fragment in raw_fragments2.iter().take(u8::MAX as usize) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -970,7 +966,7 @@ mod message_reconstructor {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize) {
            assert!(reconstructor
                .insert_new_fragment(
                    reconstructor
@@ -1252,7 +1248,7 @@ mod message_reconstructor {
        //
        // we're inserting this via the buffer approach as not to trigger immediate re-assembly
        let mut reconstructor = MessageReconstructor::default();
-        let mut set_buf1 = ReconstructionBuffer::new(u8::max_value());
+        let mut set_buf1 = ReconstructionBuffer::new(u8::MAX);
        let mut set_buf2 = ReconstructionBuffer::new(1);

        let mut rng = thread_rng();
@@ -1267,7 +1263,7 @@ mod message_reconstructor {
                .map(|x| x.into_bytes())
                .collect();

-        for raw_fragment in raw_fragments.iter().take(u8::max_value() as usize) {
+        for raw_fragment in raw_fragments.iter().take(u8::MAX as usize) {
            set_buf1.insert_fragment(Fragment::try_from_bytes(raw_fragment).unwrap());
        }

@@ -1630,19 +1626,19 @@ mod message_reconstruction {
                    .into_iter()
                    .flat_map(|fragment_set| fragment_set.into_iter())
                    .collect();
-            assert_eq!(fragments1.len(), u8::max_value() as usize);
+            assert_eq!(fragments1.len(), u8::MAX as usize);
            let mut fragments2: Vec<_> =
                crate::split_into_sets(&mut rand::rngs::OsRng, &message2, AVAILABLE_PLAINTEXT_SIZE)
                    .into_iter()
                    .flat_map(|fragment_set| fragment_set.into_iter())
                    .collect();
-            assert_eq!(fragments2.len(), u8::max_value() as usize);
+            assert_eq!(fragments2.len(), u8::MAX as usize);

            // combine and shuffle fragments
            fragments1.append(fragments2.as_mut());
            fragments1.shuffle(&mut rng);
            let fragments = fragments1;
-            assert_eq!(fragments.len(), (u8::max_value() as usize) * 2);
+            assert_eq!(fragments.len(), (u8::MAX as usize) * 2);

            let mut message_reconstructor = MessageReconstructor::default();
            for fragment in fragments.into_iter() {
@@ -1762,7 +1758,7 @@ mod message_reconstruction {
                    .flat_map(|fragment_set| fragment_set.into_iter())
                    .map(|x| x.into_bytes())
                    .collect();
-            assert_eq!(fragments.len(), 4 * (u8::max_value() as usize));
+            assert_eq!(fragments.len(), 4 * (u8::MAX as usize));
            // shuffle the fragments
            fragments.shuffle(&mut rng);

@@ -1811,19 +1807,19 @@ mod message_reconstruction {
                    .into_iter()
                    .flat_map(|fragment_set| fragment_set.into_iter())
                    .collect();
-            assert_eq!(fragments1.len(), 4 * (u8::max_value() as usize));
+            assert_eq!(fragments1.len(), 4 * (u8::MAX as usize));
            let mut fragments2: Vec<_> =
                crate::split_into_sets(&mut rand::rngs::OsRng, &message2, AVAILABLE_PLAINTEXT_SIZE)
                    .into_iter()
                    .flat_map(|fragment_set| fragment_set.into_iter())
                    .collect();
-            assert_eq!(fragments2.len(), 4 * (u8::max_value() as usize));
+            assert_eq!(fragments2.len(), 4 * (u8::MAX as usize));

            // combine and shuffle fragments
            fragments1.append(fragments2.as_mut());
            fragments1.shuffle(&mut rng);
            let fragments = fragments1;
-            assert_eq!(fragments.len(), (u8::max_value() as usize) * 8);
+            assert_eq!(fragments.len(), (u8::MAX as usize) * 8);

            let mut message_reconstructor = MessageReconstructor::default();
            for fragment in fragments.into_iter() {
@@ -11,7 +11,7 @@ use rand::Rng;
 /// on its payload length of the maximum number of `Fragment`s multiplied by their maximum,
 /// fragmented, length.
 pub const fn max_unlinked_set_payload_length(max_plaintext_size: usize) -> usize {
-    u8::max_value() as usize * unlinked_fragment_payload_max_len(max_plaintext_size)
+    u8::MAX as usize * unlinked_fragment_payload_max_len(max_plaintext_size)
 }

 /// If the set is being linked to another one, by either being the very first set, or the very last,
@@ -52,8 +52,8 @@ pub const fn two_way_linked_set_payload_length(max_plaintext_size: usize) -> usi
 pub(crate) type FragmentSet = Vec<Fragment>;

 /// Generate a pseudo-random id for a `FragmentSet`.
-/// Its value is restricted to (0, i32::max_value()].
-/// Note that it *excludes* 0, but *includes* i32::max_value().
+/// Its value is restricted to (0, i32::MAX].
+/// Note that it *excludes* 0, but *includes* i32::MAX.
 /// This particular range allows for the id to be represented using 31bits, rather than
 /// the full length of 32 while still providing more than enough variability to
 /// distinguish different `FragmentSet`s.
@@ -89,13 +89,13 @@ fn prepare_unlinked_fragmented_set(
        / unlinked_fragment_payload_max_len(max_plaintext_size) as f64)
        .ceil() as usize;

-    debug_assert!(pre_casted_frags <= u8::max_value() as usize);
+    debug_assert!(pre_casted_frags <= u8::MAX as usize);
    let num_fragments = pre_casted_frags as u8;

    let mut fragments = Vec::with_capacity(num_fragments as usize);

    for i in 1..(pre_casted_frags + 1) {
-        // we can't use u8 directly here as upper (NON-INCLUSIVE, so it would always fit) bound could be u8::max_value() + 1
+        // we can't use u8 directly here as upper (NON-INCLUSIVE, so it would always fit) bound could be u8::MAX + 1
        let lb = (i - 1) * unlinked_fragment_payload_max_len(max_plaintext_size);
        let ub = usize::min(
            message.len(),
@@ -131,7 +131,7 @@ fn prepare_linked_fragment_set(
 ) -> FragmentSet {
    // determine number of fragments in the set:
    let num_frags_usize = if next_link_id.is_some() {
-        u8::max_value() as usize
+        u8::MAX as usize
    } else {
        // we know this set is linked, if it's not post-linked then it MUST BE pre-linked
        let tail_len = if message.len() >= linked_fragment_payload_max_len(max_plaintext_size) {
@@ -142,7 +142,7 @@ fn prepare_linked_fragment_set(
        let pre_casted_frags = 1
            + (tail_len as f64 / unlinked_fragment_payload_max_len(max_plaintext_size) as f64)
                .ceil() as usize;
-        if pre_casted_frags > u8::max_value() as usize {
+        if pre_casted_frags > u8::MAX as usize {
            panic!("message would produce too many fragments!")
        };
        pre_casted_frags
@@ -162,7 +162,7 @@ fn prepare_linked_fragment_set(

    let mut fragments = Vec::with_capacity(num_frags_usize);
    for i in 1..(num_frags_usize + 1) {
-        // we can't use u8 directly here as upper (NON-INCLUSIVE, so i would always fit) bound could be u8::max_value() + 1
+        // we can't use u8 directly here as upper (NON-INCLUSIVE, so i would always fit) bound could be u8::MAX + 1
        let fragment = Fragment::try_new(
            &message[lb..ub],
            id,
@@ -343,7 +343,7 @@ mod tests {
    fn verify_post_linked_set_payload(mut set: FragmentSet, payload: &[u8]) {
        for i in (0..set.len()).rev() {
            let lb = i * unlinked_fragment_payload_max_len(max_plaintext_size());
-            let ub = if i == (u8::max_value() as usize - 1) {
+            let ub = if i == (u8::MAX as usize - 1) {
                i * unlinked_fragment_payload_max_len(max_plaintext_size())
                    + linked_fragment_payload_max_len(max_plaintext_size())
            } else {
@@ -365,7 +365,7 @@ mod tests {
                (i - 1) * unlinked_fragment_payload_max_len(max_plaintext_size())
                    + linked_fragment_payload_max_len(max_plaintext_size())
            };
-            let ub = if i == (u8::max_value() as usize - 1) {
+            let ub = if i == (u8::MAX as usize - 1) {
                (i - 1) * unlinked_fragment_payload_max_len(max_plaintext_size())
                    + 2 * linked_fragment_payload_max_len(max_plaintext_size())
            } else {
@@ -434,7 +434,7 @@ mod tests {
                id,
                max_plaintext_size(),
            );
-            assert_eq!(u8::max_value() as usize, max_fragment_set.len());
+            assert_eq!(u8::MAX as usize, max_fragment_set.len());
            verify_unlinked_set_payload(max_fragment_set, &max_fragments_set_payload);

            let mut full_set_payload =
@@ -442,7 +442,7 @@ mod tests {
            rng.fill_bytes(&mut full_set_payload);
            let full_fragment_set =
                prepare_unlinked_fragmented_set(&full_set_payload, id, max_plaintext_size());
-            assert_eq!(u8::max_value() as usize, full_fragment_set.len());
+            assert_eq!(u8::MAX as usize, full_fragment_set.len());
            verify_unlinked_set_payload(full_fragment_set, &full_set_payload);
        }

@@ -515,7 +515,7 @@ mod tests {
                None,
                max_plaintext_size(),
            );
-            assert_eq!(u8::max_value() as usize, max_fragment_set.len());
+            assert_eq!(u8::MAX as usize, max_fragment_set.len());
            verify_pre_linked_set_payload(max_fragment_set, &max_fragments_set_payload);

            let mut full_set_payload =
@@ -528,7 +528,7 @@ mod tests {
                None,
                max_plaintext_size(),
            );
-            assert_eq!(u8::max_value() as usize, full_fragment_set.len());
+            assert_eq!(u8::MAX as usize, full_fragment_set.len());
            verify_pre_linked_set_payload(full_fragment_set, &full_set_payload);
        }

@@ -561,7 +561,7 @@ mod tests {
                Some(link_id),
                max_plaintext_size(),
            );
-            assert_eq!(u8::max_value() as usize, full_fragment_set.len());
+            assert_eq!(u8::MAX as usize, full_fragment_set.len());
            verify_post_linked_set_payload(full_fragment_set, &full_set_payload);
        }

@@ -608,7 +608,7 @@ mod tests {
                Some(post_link_id),
                max_plaintext_size(),
            );
-            assert_eq!(u8::max_value() as usize, full_fragment_set.len());
+            assert_eq!(u8::MAX as usize, full_fragment_set.len());
            verify_two_way_linked_set_payload(full_fragment_set, &full_set_payload);
        }

@@ -700,8 +700,8 @@ mod tests {

            let mut sets = split_into_sets(&mut rng, &message, max_plaintext_size());
            assert_eq!(2, sets.len());
-            assert_eq!(sets[0].len(), u8::max_value() as usize);
-            assert_eq!(sets[1].len(), u8::max_value() as usize);
+            assert_eq!(sets[0].len(), u8::MAX as usize);
+            assert_eq!(sets[1].len(), u8::MAX as usize);
            verify_correct_link(&sets[0], &sets[1]);
            verify_pre_linked_set_payload(
                sets.pop().unwrap(),
@@ -726,9 +726,9 @@ mod tests {
            rng.fill_bytes(&mut message);
            let mut sets = split_into_sets(&mut rng, &message, max_plaintext_size());
            assert_eq!(4, sets.len());
-            assert_eq!(sets[0].len(), u8::max_value() as usize);
-            assert_eq!(sets[1].len(), u8::max_value() as usize);
-            assert_eq!(sets[2].len(), u8::max_value() as usize);
+            assert_eq!(sets[0].len(), u8::MAX as usize);
+            assert_eq!(sets[1].len(), u8::MAX as usize);
+            assert_eq!(sets[2].len(), u8::MAX as usize);

            verify_correct_link(&sets[0], &sets[1]);
            verify_correct_link(&sets[1], &sets[2]);
@@ -766,10 +766,10 @@ mod tests {

            let mut sets = split_into_sets(&mut rng, &message, max_plaintext_size());
            assert_eq!(4, sets.len());
-            assert_eq!(sets[0].len(), u8::max_value() as usize);
-            assert_eq!(sets[1].len(), u8::max_value() as usize);
-            assert_eq!(sets[2].len(), u8::max_value() as usize);
-            assert_eq!(sets[3].len(), u8::max_value() as usize);
+            assert_eq!(sets[0].len(), u8::MAX as usize);
+            assert_eq!(sets[1].len(), u8::MAX as usize);
+            assert_eq!(sets[2].len(), u8::MAX as usize);
+            assert_eq!(sets[3].len(), u8::MAX as usize);

            verify_correct_link(&sets[0], &sets[1]);
            verify_correct_link(&sets[1], &sets[2]);
@@ -235,7 +235,7 @@ mod message_receiver {
            1,
            vec![mix::Node {
                mix_id: 123,
-                owner: "foomp1".to_string(),
+                owner: None,
                host: "10.20.30.40".parse().unwrap(),
                mix_host: "10.20.30.40:1789".parse().unwrap(),
                identity_key: identity::PublicKey::from_base58_string(
@@ -255,7 +255,7 @@ mod message_receiver {
            2,
            vec![mix::Node {
                mix_id: 234,
-                owner: "foomp2".to_string(),
+                owner: None,
                host: "11.21.31.41".parse().unwrap(),
                mix_host: "11.21.31.41:1789".parse().unwrap(),
                identity_key: identity::PublicKey::from_base58_string(
@@ -275,7 +275,7 @@ mod message_receiver {
            3,
            vec![mix::Node {
                mix_id: 456,
-                owner: "foomp3".to_string(),
+                owner: None,
                host: "12.22.32.42".parse().unwrap(),
                mix_host: "12.22.32.42:1789".parse().unwrap(),
                identity_key: identity::PublicKey::from_base58_string(
@@ -295,7 +295,7 @@ mod message_receiver {
            // currently coco_nodes don't really exist so this is still to be determined
            mixes,
            vec![gateway::Node {
-                owner: "foomp4".to_string(),
+                owner: None,
                host: "1.2.3.4".parse().unwrap(),
                mix_host: "1.2.3.4:1789".parse().unwrap(),
                clients_ws_port: 9000,
@@ -8,6 +8,9 @@ use nym_mixnet_contract_common::GatewayBond;
 use nym_sphinx_addressing::nodes::{NodeIdentity, NymNodeRoutingAddress};
 use nym_sphinx_types::Node as SphinxNode;

+use nym_api_requests::nym_nodes::SkimmedNode;
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use std::fmt;
 use std::fmt::Formatter;
 use std::io;
@@ -40,11 +43,13 @@ pub enum GatewayConversionError {
        #[source]
        err: AddrParseError,
    },
+
+    #[error("provided node is not an entry gateway in this epoch!")]
+    NotGateway,
 }

 #[derive(Clone)]
 pub struct Node {
-    pub owner: String,
    pub host: NetworkAddress,
    // we're keeping this as separate resolved field since we do not want to be resolving the potential
    // hostname every time we want to construct a path via this node
@@ -58,6 +63,9 @@ pub struct Node {

    pub identity_key: identity::PublicKey,
    pub sphinx_key: encryption::PublicKey, // TODO: or nymsphinx::PublicKey? both are x25519
+
+    // to be removed:
+    pub owner: Option<String>,
    pub version: NodeVersion,
 }

@@ -78,11 +86,9 @@ impl std::fmt::Debug for Node {

 impl Node {
    pub fn parse_host(raw: &str) -> Result<NetworkAddress, GatewayConversionError> {
-        raw.parse()
-            .map_err(|err| GatewayConversionError::InvalidAddress {
-                value: raw.to_owned(),
-                source: err,
-            })
+        // safety: this conversion is infallible
+        // (but we retain result return type for legacy reasons)
+        Ok(raw.parse().unwrap())
    }

    pub fn extract_mix_host(
@@ -120,7 +126,7 @@ impl fmt::Display for Node {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
-            "Node(id: {}, owner: {}, host: {})",
+            "Node(id: {}, owner: {:?}, host: {})",
            self.identity_key, self.owner, self.host,
        )
    }
@@ -154,7 +160,7 @@ impl<'a> TryFrom<&'a GatewayBond> for Node {
        let mix_host = Self::extract_mix_host(&host, bond.gateway.mix_port)?;

        Ok(Node {
-            owner: bond.owner.as_str().to_owned(),
+            owner: Some(bond.owner.as_str().to_owned()),
            host,
            mix_host,
            clients_ws_port: bond.gateway.clients_port,
@@ -199,7 +205,7 @@ impl<'a> TryFrom<&'a DescribedGateway> for Node {
        let mix_host = SocketAddr::new(ips[0], value.bond.gateway.mix_port);

        Ok(Node {
-            owner: value.bond.owner.as_str().to_owned(),
+            owner: Some(value.bond.owner.as_str().to_owned()),
            host,
            mix_host,
            clients_ws_port: self_described.mixnet_websockets.ws_port,
@@ -219,6 +225,43 @@ impl<'a> TryFrom<&'a DescribedGateway> for Node {
    }
 }

+impl<'a> TryFrom<&'a SkimmedNode> for Node {
+    type Error = GatewayConversionError;
+
+    fn try_from(value: &'a SkimmedNode) -> Result<Self, Self::Error> {
+        let Some(entry_details) = &value.entry else {
+            return Err(GatewayConversionError::NotGateway);
+        };
+
+        if value.ip_addresses.is_empty() {
+            return Err(GatewayConversionError::NoIpAddressesProvided {
+                gateway: value.ed25519_identity_pubkey.clone(),
+            });
+        }
+
+        // safety: we just checked the slice is not empty
+        #[allow(clippy::unwrap_used)]
+        let ip = value.ip_addresses.choose(&mut thread_rng()).unwrap();
+
+        let host = if let Some(hostname) = &entry_details.hostname {
+            NetworkAddress::Hostname(hostname.to_string())
+        } else {
+            NetworkAddress::IpAddr(*ip)
+        };
+
+        Ok(Node {
+            host,
+            mix_host: SocketAddr::new(*ip, value.mix_port),
+            clients_ws_port: entry_details.ws_port,
+            clients_wss_port: entry_details.wss_port,
+            identity_key: value.ed25519_identity_pubkey.parse()?,
+            sphinx_key: value.x25519_sphinx_pubkey.parse()?,
+            owner: None,
+            version: NodeVersion::Unknown,
+        })
+    }
+}
+
 impl TryFrom<DescribedGateway> for Node {
    type Error = GatewayConversionError;

@@ -6,7 +6,7 @@

 use crate::filter::VersionFilterable;
 pub use error::NymTopologyError;
-use log::warn;
+use log::{debug, warn};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use nym_sphinx_addressing::nodes::NodeIdentity;
@@ -14,6 +14,7 @@ use nym_sphinx_types::Node as SphinxNode;
 use rand::prelude::SliceRandom;
 use rand::{CryptoRng, Rng};
 use std::collections::BTreeMap;
+use std::convert::Infallible;

 use std::fmt::{self, Display, Formatter};
 use std::io;
@@ -93,7 +94,7 @@ impl NetworkAddress {
 }

 impl FromStr for NetworkAddress {
-    type Err = std::io::Error;
+    type Err = Infallible;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if let Ok(ip_addr) = s.parse() {
@@ -137,6 +138,38 @@ impl NymTopology {
        NymTopology { mixes, gateways }
    }

+    pub fn from_unordered<MI, GI, M, G>(unordered_mixes: MI, unordered_gateways: GI) -> Self
+    where
+        MI: Iterator<Item = M>,
+        GI: Iterator<Item = G>,
+        G: TryInto<gateway::Node>,
+        M: TryInto<mix::Node>,
+        <G as TryInto<gateway::Node>>::Error: Display,
+        <M as TryInto<mix::Node>>::Error: Display,
+    {
+        let mut mixes = BTreeMap::new();
+        let mut gateways = Vec::new();
+
+        for node in unordered_mixes.into_iter() {
+            match node.try_into() {
+                Ok(mixnode) => mixes
+                    .entry(mixnode.layer as MixLayer)
+                    .or_insert_with(Vec::new)
+                    .push(mixnode),
+                Err(err) => debug!("malformed mixnode: {err}"),
+            }
+        }
+
+        for node in unordered_gateways.into_iter() {
+            match node.try_into() {
+                Ok(gateway) => gateways.push(gateway),
+                Err(err) => debug!("malformed gateway: {err}"),
+            }
+        }
+
+        NymTopology::new(mixes, gateways)
+    }
+
    #[cfg(feature = "serializable")]
    pub fn new_from_file<P: AsRef<std::path::Path>>(path: P) -> std::io::Result<Self> {
        let file = std::fs::File::open(path)?;
@@ -491,7 +524,7 @@ mod converting_mixes_to_vec {
        fn returns_a_vec_with_hashmap_values() {
            let node1 = mix::Node {
                mix_id: 42,
-                owner: "N/A".to_string(),
+                owner: Some("N/A".to_string()),
                host: "3.3.3.3".parse().unwrap(),
                mix_host: "3.3.3.3:1789".parse().unwrap(),
                identity_key: identity::PublicKey::from_base58_string(
@@ -507,12 +540,12 @@ mod converting_mixes_to_vec {
            };

            let node2 = mix::Node {
-                owner: "Alice".to_string(),
+                owner: Some("Alice".to_string()),
                ..node1.clone()
            };

            let node3 = mix::Node {
-                owner: "Bob".to_string(),
+                owner: Some("Bob".to_string()),
                ..node1.clone()
            };

@@ -522,7 +555,9 @@ mod converting_mixes_to_vec {

            let topology = NymTopology::new(mixes, vec![]);
            let mixvec = topology.mixes_as_vec();
-            assert!(mixvec.iter().any(|node| node.owner == "N/A"));
+            assert!(mixvec
+                .iter()
+                .any(|node| node.owner.as_ref() == Some(&"N/A".to_string())));
        }
    }

@@ -8,6 +8,9 @@ use nym_mixnet_contract_common::{MixId, MixNodeBond};
 use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
 use nym_sphinx_types::Node as SphinxNode;

+use nym_api_requests::nym_nodes::{NodeRole, SkimmedNode};
+use rand::seq::SliceRandom;
+use rand::thread_rng;
 use std::fmt::Formatter;
 use std::io;
 use std::net::SocketAddr;
@@ -27,12 +30,20 @@ pub enum MixnodeConversionError {
        #[source]
        source: io::Error,
    },
+
+    #[error("invalid mix layer")]
+    InvalidLayer,
+
+    #[error("'{mixnode}' has not provided any valid ip addresses")]
+    NoIpAddressesProvided { mixnode: String },
+
+    #[error("provided node is not a mixnode in this epoch!")]
+    NotMixnode,
 }

 #[derive(Clone)]
 pub struct Node {
    pub mix_id: MixId,
-    pub owner: String,
    pub host: NetworkAddress,
    // we're keeping this as separate resolved field since we do not want to be resolving the potential
    // hostname every time we want to construct a path via this node
@@ -40,7 +51,10 @@ pub struct Node {
    pub identity_key: identity::PublicKey,
    pub sphinx_key: encryption::PublicKey, // TODO: or nymsphinx::PublicKey? both are x25519
    pub layer: Layer,
+
+    // to be removed:
    pub version: NodeVersion,
+    pub owner: Option<String>,
 }

 impl std::fmt::Debug for Node {
@@ -60,11 +74,9 @@ impl std::fmt::Debug for Node {

 impl Node {
    pub fn parse_host(raw: &str) -> Result<NetworkAddress, MixnodeConversionError> {
-        raw.parse()
-            .map_err(|err| MixnodeConversionError::InvalidAddress {
-                value: raw.to_owned(),
-                source: err,
-            })
+        // safety: this conversion is infallible
+        // (but we retain result return type for legacy reasons)
+        Ok(raw.parse().unwrap())
    }

    pub fn extract_mix_host(
@@ -109,7 +121,7 @@ impl<'a> TryFrom<&'a MixNodeBond> for Node {

        Ok(Node {
            mix_id: bond.mix_id,
-            owner: bond.owner.as_str().to_owned(),
+            owner: Some(bond.owner.as_str().to_owned()),
            host,
            mix_host,
            identity_key: identity::PublicKey::from_base58_string(&bond.mix_node.identity_key)?,
@@ -120,6 +132,42 @@ impl<'a> TryFrom<&'a MixNodeBond> for Node {
    }
 }

+impl<'a> TryFrom<&'a SkimmedNode> for Node {
+    type Error = MixnodeConversionError;
+
+    fn try_from(value: &'a SkimmedNode) -> Result<Self, Self::Error> {
+        if value.ip_addresses.is_empty() {
+            return Err(MixnodeConversionError::NoIpAddressesProvided {
+                mixnode: value.ed25519_identity_pubkey.clone(),
+            });
+        }
+
+        let layer = match value.role {
+            NodeRole::Mixnode { layer } => layer
+                .try_into()
+                .map_err(|_| MixnodeConversionError::InvalidLayer)?,
+            _ => return Err(MixnodeConversionError::NotMixnode),
+        };
+
+        // safety: we just checked the slice is not empty
+        #[allow(clippy::unwrap_used)]
+        let ip = value.ip_addresses.choose(&mut thread_rng()).unwrap();
+
+        let host = NetworkAddress::IpAddr(*ip);
+
+        Ok(Node {
+            mix_id: value.node_id,
+            host,
+            mix_host: SocketAddr::new(*ip, value.mix_port),
+            identity_key: value.ed25519_identity_pubkey.parse()?,
+            sphinx_key: value.x25519_sphinx_pubkey.parse()?,
+            layer,
+            owner: None,
+            version: NodeVersion::Unknown,
+        })
+    }
+}
+
 impl TryFrom<MixNodeBond> for Node {
    type Error = MixnodeConversionError;

@@ -109,7 +109,8 @@ pub struct SerializableMixNode {
    #[serde(alias = "mix_id")]
    pub mix_id: u32,

-    pub owner: String,
+    #[cfg_attr(feature = "wasm-serde-types", tsify(optional))]
+    pub owner: Option<String>,

    pub host: String,

@@ -180,7 +181,8 @@ impl<'a> From<&'a mix::Node> for SerializableMixNode {
 #[serde(rename_all = "camelCase")]
 #[serde(deny_unknown_fields)]
 pub struct SerializableGateway {
-    pub owner: String,
+    #[cfg_attr(feature = "wasm-serde-types", tsify(optional))]
+    pub owner: Option<String>,

    pub host: String,

@@ -362,6 +362,14 @@ pub struct TopologyWasm {
    /// the first valid instance.
    /// Supersedes `topology_refresh_rate_ms`.
    pub disable_refreshing: bool,
+
+    /// Specifies a minimum performance of a mixnode that is used on route construction.
+    /// This setting is only applicable when `NymApi` topology is used.
+    pub minimum_mixnode_performance: u8,
+
+    /// Specifies a minimum performance of a gateway that is used on route construction.
+    /// This setting is only applicable when `NymApi` topology is used.
+    pub minimum_gateway_performance: u8,
 }

 impl Default for TopologyWasm {
@@ -382,6 +390,8 @@ impl From<TopologyWasm> for ConfigTopology {
                topology.max_startup_gateway_waiting_period_ms as u64,
            ),
            topology_structure: Default::default(),
+            minimum_mixnode_performance: topology.minimum_mixnode_performance,
+            minimum_gateway_performance: topology.minimum_gateway_performance,
        }
    }
 }
@@ -395,6 +405,8 @@ impl From<ConfigTopology> for TopologyWasm {
                .max_startup_gateway_waiting_period
                .as_millis() as u32,
            disable_refreshing: topology.disable_refreshing,
+            minimum_mixnode_performance: topology.minimum_mixnode_performance,
+            minimum_gateway_performance: topology.minimum_gateway_performance,
        }
    }
 }
@@ -244,6 +244,16 @@ pub struct TopologyWasmOverride {
    /// Supersedes `topology_refresh_rate_ms`.
    #[tsify(optional)]
    pub disable_refreshing: Option<bool>,
+
+    /// Specifies a minimum performance of a mixnode that is used on route construction.
+    /// This setting is only applicable when `NymApi` topology is used.
+    #[tsify(optional)]
+    pub minimum_mixnode_performance: Option<u8>,
+
+    /// Specifies a minimum performance of a gateway that is used on route construction.
+    /// This setting is only applicable when `NymApi` topology is used.
+    #[tsify(optional)]
+    pub minimum_gateway_performance: Option<u8>,
 }

 impl From<TopologyWasmOverride> for TopologyWasm {
@@ -261,6 +271,12 @@ impl From<TopologyWasmOverride> for TopologyWasm {
                .max_startup_gateway_waiting_period_ms
                .unwrap_or(def.max_startup_gateway_waiting_period_ms),
            disable_refreshing: value.disable_refreshing.unwrap_or(def.disable_refreshing),
+            minimum_mixnode_performance: value
+                .minimum_mixnode_performance
+                .unwrap_or(def.minimum_mixnode_performance),
+            minimum_gateway_performance: value
+                .minimum_gateway_performance
+                .unwrap_or(def.minimum_gateway_performance),
        }
    }
 }
@@ -16,7 +16,7 @@ pub struct WasmRawRegisteredGateway {

    pub derived_aes128_ctr_blake3_hmac_keys_bs58: String,

-    pub gateway_owner_address: String,
+    pub gateway_owner_address: Option<String>,

    pub gateway_listener: String,
 }
@@ -55,7 +55,10 @@ impl<'a> From<&'a GatewayRegistration> for WasmRawRegisteredGateway {
            derived_aes128_ctr_blake3_hmac_keys_bs58: remote_details
                .derived_aes128_ctr_blake3_hmac_keys
                .to_base58_string(),
-            gateway_owner_address: remote_details.gateway_owner_address.to_string(),
+            gateway_owner_address: remote_details
+                .gateway_owner_address
+                .as_ref()
+                .map(|a| a.to_string()),
            gateway_listener: remote_details.gateway_listener.to_string(),
        }
    }
@@ -25,3 +25,4 @@ nym-network-defaults = { path = "../network-defaults" }
 nym-task = { path = "../task" }
 nym-wireguard-types = { path = "../wireguard-types" }
 tokio = { workspace = true, features = ["rt-multi-thread", "net", "io-util"] }
+tokio-stream = { workspace = true }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tommy Verrall	a5bcbcc1f5	Update publish-nym-binaries.yml remove unused binaries for publishing	2024-06-25 09:28:11 +02:00
Jędrzej Stuczyński	2ca63a6fd5	Merge pull request #4671 from nymtech/feature/embedded-ignore-score make embedded NR/IPR ignore performance of the gateway	2024-06-21 10:50:15 +01:00
Jędrzej Stuczyński	d33baec79b	clippy	2024-06-21 10:41:33 +01:00
Jędrzej Stuczyński	0626e54b6a	make embedded NR/IPR ignore performance of the gateway	2024-06-21 10:03:24 +01:00
Drazen Urch	2a260d46f8	New clippy lints (#4660 ) * New clippy lints * I guess this got removed	2024-06-21 10:02:29 +01:00
Jędrzej Stuczyński	06ebe56914	Merge pull request #4654 from nymtech/chore/rename-accept-toc-flag renamed 'accept-toc' flag and fields into explicit 'accept-operator-terms-and-conditions'	2024-06-17 11:31:41 +01:00
Jędrzej Stuczyński	1c3140898f	fixed warning message	2024-06-17 10:09:05 +01:00
Jędrzej Stuczyński	9ebe8310a1	renamed 'accept-toc' flag and fields into explicit 'accept-operator-terms-and-conditions'	2024-06-14 17:22:42 +01:00
benedettadavico	cf5c5f1df4	update changelog and bump binaries	2024-06-14 16:21:26 +02:00
Tommy Verrall	f30cfc0be7	Merge pull request #4650 from nymtech/bugfix/remove-ephemera_migrations Remove additional code as part of Ephemera Purge and SP and contracts	2024-06-12 17:05:09 +02:00
Tommy Verrall	9460a9941c	remove additional code :)	2024-06-12 16:40:11 +02:00
Tommy Verrall	eeffc0db51	fmt	2024-06-12 16:29:00 +02:00
Tommy Verrall	b7d6e0e1e3	remove left over bbc code	2024-06-12 16:27:00 +02:00
Tommy Verrall	45e0b406ac	remove additional ephemera code and related service provider info	2024-06-12 16:15:52 +02:00
Jędrzej Stuczyński	579527b480	Merge pull request #4648 from nymtech/bugfix/contracts-compat bugfix: make sure nym-api can handle non-cw2 (or without detailed build info) compliant contracts	2024-06-11 19:04:32 +02:00
Jędrzej Stuczyński	70360196f0	bugfix: make sure nym-api can handle non-cw2 (or without detailed build info) compliant contracts	2024-06-11 17:38:24 +01:00
Tommy Verrall	b777adeda6	Merge pull request #4639 from nymtech/jon/remove-pr-template Remove old PR template	2024-06-11 16:25:23 +02:00
Jędrzej Stuczyński	6a6505c9d7	Merge pull request #4647 from nymtech/feature/toc-flag introduced a flag to accept toc and exposed it via self-described API	2024-06-11 15:20:42 +02:00
Jędrzej Stuczyński	b10119d339	Merge pull request #4646 from nymtech/jstuczyn-patch-1 bugfix: make sure to return an error on invalid public ip	2024-06-11 15:09:25 +02:00
Jędrzej Stuczyński	3a4bd4ffd6	introduced a flag to accept toc and exposed it via self-described API	2024-06-11 14:08:09 +01:00
Jędrzej Stuczyński	9769387730	bugfix: make sure to return an error on invalid public ip	2024-06-11 13:58:25 +01:00
Jędrzej Stuczyński	71747e3c82	Merge pull request #4630 from nymtech/feature/forbid-empty-ips validate nym-node public ips on startup	2024-06-11 14:43:42 +02:00
Jędrzej Stuczyński	5cbbeee0d5	Merge pull request #4631 from nymtech/feature/standarise-contract-info standarised ContractBuildInformation and added it to all contracts	2024-06-11 14:43:25 +02:00
Jędrzej Stuczyński	f1486fb989	updated schema files	2024-06-11 12:22:38 +01:00
Jędrzej Stuczyński	c50c30ae76	standarised ContractBuildInformation and added it to all contracts	2024-06-11 12:22:15 +01:00
Jędrzej Stuczyński	5745cb4d7a	Merge pull request #4642 from nymtech/chore/purge-ephemera Removed ephemera code	2024-06-11 13:15:04 +02:00
Jon Häggblad	00c978c864	Add ci check for PR having an assigned milestone (#4644 ) * Add ci check for PR having an assigned milestone * fix trigger	2024-06-11 12:58:25 +02:00
Tommy Verrall	9e4c58efdf	Merge pull request #4640 from nymtech/feature/periodic_remove Remove stale peers	2024-06-11 12:26:55 +02:00
Tommy Verrall	13e6fcaa85	Merge pull request #4635 from nymtech/feature/new-node-endpoints Feature/new node endpoints	2024-06-11 12:26:30 +02:00
Tommy Verrall	9bd095ec18	Merge pull request #4638 from nymtech/dependabot/npm_and_yarn/testnet-faucet/braces-3.0.3 Bump braces from 3.0.2 to 3.0.3 in /testnet-faucet	2024-06-11 12:25:13 +02:00
Jędrzej Stuczyński	60d50ff17a	fixed visibility of '--local' flag	2024-06-11 11:22:31 +01:00
Tommy Verrall	03f3f0285a	Merge pull request #4624 from nymtech/jon/fix-cargo-warnings Fix cargo warnings	2024-06-11 12:22:12 +02:00
Jędrzej Stuczyński	3e87063ab4	Removed ephemera code	2024-06-11 11:17:26 +01:00
Bogdan-Ștefan Neacşu	a32cbd44b0	Remove stale peers	2024-06-11 10:05:38 +00:00
Jon Häggblad	962070a33c	Remove old PR template	2024-06-11 12:04:24 +02:00
Jon Häggblad	55f11a5433	Disable profile settings for crate not included Cargo is warning about warning: profile package spec `nym-wasm-sdk` in profile `release` did not match any packages Fix this by commenting out the profile settings for that crate as it's currently not included in the main workspace	2024-06-11 11:52:04 +02:00
Jon Häggblad	48332a1069	Fix cargo warnings about default-features for the main workspace On every cargo command we have the set warnings: warning: /home/jon/src/nym/nym/common/dkg/Cargo.toml: `default-features` is ignored for bls12_381, since `default-features` was not specified for `workspace.dependencies.bls12_381`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/dkg/Cargo.toml: `default-features` is ignored for ff, since `default-features` was not specified for `workspace.dependencies.ff`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/dkg/Cargo.toml: `default-features` is ignored for group, since `default-features` was not specified for `workspace.dependencies.group`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/client-libs/validator-client/Cargo.toml: `default-features` is ignored for bip32, since `default-features` was not specified for `workspace.dependencies.bip32`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/client-libs/validator-client/Cargo.toml: `default-features` is ignored for prost, since `default-features` was not specified for `workspace.dependencies.prost`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/credentials-interface/Cargo.toml: `default-features` is ignored for bls12_381, since `default-features` was not specified for `workspace.dependencies.bls12_381`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/credentials/Cargo.toml: `default-features` is ignored for bls12_381, since `default-features` was not specified for `workspace.dependencies.bls12_381`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/nymcoconut/Cargo.toml: `default-features` is ignored for bls12_381, since `default-features` was not specified for `workspace.dependencies.bls12_381`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/nymcoconut/Cargo.toml: `default-features` is ignored for ff, since `default-features` was not specified for `workspace.dependencies.ff`, this could become a hard error in the future warning: /home/jon/src/nym/nym/common/nymcoconut/Cargo.toml: `default-features` is ignored for group, since `default-features` was not specified for `workspace.dependencies.group`, this could become a hard error in the future This commit adds default-features = false to the workspace dependencies to fix these. An alternative way would be to remove `default-features = false` in the crates, but I assume these were put there for a good reason. Also we might have other crates outside of the main workspace that depends on these crates having default features disabled.	2024-06-11 11:52:01 +02:00
Jon Häggblad	f43a2a1e42	Merge pull request #4603 from nymtech/jon/purge-name-service-and-sp-dir-contracts Purge name service and service provider directory contracts	2024-06-11 11:50:13 +02:00
dependabot[bot]	205c887686	Bump braces from 3.0.2 to 3.0.3 in /testnet-faucet Bumps [braces](https://github.com/micromatch/braces) from 3.0.2 to 3.0.3. - [Changelog](https://github.com/micromatch/braces/blob/master/CHANGELOG.md) - [Commits](https://github.com/micromatch/braces/compare/3.0.2...3.0.3) --- updated-dependencies: - dependency-name: braces dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com>	2024-06-11 09:48:46 +00:00
Jon Häggblad	4666e91820	Merge pull request #4620 from nymtech/jon/ipr-read-both-v6-and-v7 Handle v6 and v7 requests in the IPR, but reply with v6	2024-06-11 11:48:00 +02:00
Tommy Verrall	7d0a25d570	Merge pull request #4619 from stefanopier/develop fix typo	2024-06-11 11:06:27 +02:00
Jędrzej Stuczyński	464041f9e1	ibid for nym-connect	2024-06-10 14:48:35 +01:00
Jędrzej Stuczyński	433748521c	wasm fixes	2024-06-10 13:00:24 +01:00
Jędrzej Stuczyński	3cbcd001f4	clippy + test build issues	2024-06-10 11:36:57 +01:00
Jędrzej Stuczyński	282b27646f	review comments	2024-06-10 11:19:27 +01:00
Jędrzej Stuczyński	5cc3ee32e9	fix test	2024-06-10 11:17:44 +01:00
Jędrzej Stuczyński	f412f45b50	proper type conversions and client compat	2024-06-10 11:03:26 +01:00
Jędrzej Stuczyński	9c19452758	scaffolding of using new endpoints in the client	2024-06-10 10:11:07 +01:00
Jędrzej Stuczyński	bf34d00478	new endpoints on nym-api side	2024-06-07 17:02:53 +01:00
Jon Häggblad	065d416305	Update lock files after merging in develop	2024-06-07 12:46:46 +02:00
Jon Häggblad	3e93d2a250	Merge remote-tracking branch 'origin/develop' into jon/purge-name-service-and-sp-dir-contracts	2024-06-07 12:41:46 +02:00
Jon Häggblad	8bc85191d5	Replace Vec<u8> signature with strong type	2024-06-07 12:33:07 +02:00
Jędrzej Stuczyński	7d714a22f0	validate nym-node public ips on startup	2024-06-06 11:23:16 +01:00
Jon Häggblad	7019dcc11f	Clean up parsing request	2024-05-28 22:26:13 +02:00
Jon Häggblad	bab842d277	Move comment	2024-05-28 19:35:23 +02:00
Jon Häggblad	a374bca601	Check timestamp	2024-05-28 15:10:45 +02:00
Jon Häggblad	d4d3041816	Verify signature if present	2024-05-28 12:22:39 +02:00
Jon Häggblad	70766b6d3e	Handle v6 and v7 requests in the IPR, but reply with v6	2024-05-28 09:00:08 +02:00
Stefano Piermatteo	437c66ad0b	fix typo	2024-05-24 20:18:06 +02:00
Jon Häggblad	b617729873	Remove from contract Makefile	2024-05-20 15:08:18 +02:00
Jon Häggblad	c5e1ea289c	nym-connect and nym-wallet lock files	2024-05-20 09:50:32 +02:00
Jon Häggblad	266c98a80e	Don't upload in ci workflow	2024-05-20 09:48:48 +02:00
Jon Häggblad	4540b3b41a	lock file for contracts	2024-05-20 09:43:07 +02:00
Jon Häggblad	a9beb13189	Remove references in Makefile	2024-05-20 09:42:23 +02:00
Jon Häggblad	ebc30ec248	Remove everywhere sp contract is used	2024-05-20 09:38:22 +02:00
Jon Häggblad	3cd9c6ad13	Remove nym-service-provider-directory-common	2024-05-20 09:27:40 +02:00
Jon Häggblad	b83d4e964b	Remove nym-service-provider-directory from workspace	2024-05-20 09:27:09 +02:00
Jon Häggblad	bceb59a832	Remove nym-service-provider-directory	2024-05-20 09:26:14 +02:00
Jon Häggblad	50a48603e3	Remove everywhere name-service contract is used	2024-05-20 09:25:10 +02:00
Jon Häggblad	1ae718c345	Purge nym-name-service-common	2024-05-20 09:13:17 +02:00
Jon Häggblad	12c4450527	Remove nym-name-service from workspace	2024-05-20 09:12:06 +02:00
Jon Häggblad	5bf34950ab	Delete nym-name-service contract	2024-05-20 09:11:25 +02:00