missing test fix

fixed tests
api support: submit ed25519 public key alongside the bte public key
2024-01-17 14:10:08 +00:00 · 2024-01-17 14:10:08 +00:00 · 2024-01-17 14:10:07 +00:00 · 2024-01-17 14:10:07 +00:00 · 2024-01-17 14:07:03 +00:00 · 2024-01-17 14:07:02 +00:00
451 changed files with 26543 additions and 6224 deletions
@@ -0,0 +1,21 @@
+name: ci-cargo-deny
+on: [workflow_dispatch]
+jobs:
+  cargo-deny:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        checks:
+          # - advisories
+          - licenses
+          - bans sources
+
+    continue-on-error: ${{ matrix.checks == 'licenses' }}
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: EmbarkStudios/cargo-deny-action@v1
+      with:
+        log-level: warn
+        command: check ${{ matrix.checks }}
+        argument: --all-features
@@ -17,6 +17,9 @@ jobs:
    steps:
      - uses: actions/checkout@v2

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

@@ -9,6 +9,7 @@
 target
 .env
 .env.dev
+envs/devnet.env
 /.vscode/settings.json
 validator/.vscode
 sample-configs/validator-config.toml
@@ -67,6 +67,7 @@ members = [
    "common/nymsphinx/params",
    "common/nymsphinx/routing",
    "common/nymsphinx/types",
+    "common/nyxd-scraper",
    "common/pemstore",
    "common/socks5-client-core",
    "common/socks5/proxy-helpers",
@@ -101,6 +102,7 @@ members = [
    "nym-node",
    "nym-node/nym-node-requests",
    "nym-outfox",
+    "nym-validator-rewarder",
    "tools/internal/ssl-inject",
    "tools/internal/sdk-version-bump",
    "tools/nym-cli",
@@ -123,6 +125,7 @@ default-members = [
    "nym-api",
    "tools/nymvisor",
    "explorer-api",
+    "nym-validator-rewarder",
 ]

 exclude = ["explorer", "contracts", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "nym-vpn/ui/src-tauri", "cpu-cycles"]
@@ -159,10 +162,12 @@ reqwest = "0.11.22"
 schemars = "0.8.1"
 serde = "1.0.152"
 serde_json = "1.0.91"
+sqlx = "0.6.3"
 tap = "1.0.1"
 time = "0.3.30"
 thiserror = "1.0.48"
-tokio = "1.24.1"
+tokio = "1.33.0"
+tokio-util = "0.7.10"
 tokio-tungstenite = "0.20.1"
 tracing = "0.1.37"
 tungstenite = { version = "0.20.1", default-features = false }
@@ -172,6 +177,14 @@ utoipa-swagger-ui = "3.1.5"
 url = "2.4"
 zeroize = "1.6.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"
+
+
 # cosmwasm-related
 cosmwasm-derive = "=1.3.0"
 cosmwasm-schema = "=1.3.0"
@@ -190,7 +203,11 @@ cw-controllers = { version = "=1.1.0" }

 # cosmrs-related
 bip32 = "0.5.1"
-cosmrs = "=0.15.0"
+
+# 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"

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

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

@@ -1667,9 +1667,9 @@
      }
    },
    "node_modules/follow-redirects": {
-      "version": "1.14.9",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz",
-      "integrity": "sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==",
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
      "dev": true,
      "funding": [
        {
@@ -5800,9 +5800,9 @@
      }
    },
    "follow-redirects": {
-      "version": "1.14.9",
-      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz",
-      "integrity": "sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w==",
+      "version": "1.15.4",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.4.tgz",
+      "integrity": "sha512-Cr4D/5wlrb0z9dgERpUL3LrmPKVDsETIJhaCMeDfuFYcqa5bldGV6wBsAN6X/vxlXQtFBMrXdXxdL8CbDTGniw==",
      "dev": true
    },
    "forwarded": {
@@ -3,6 +3,7 @@ name = "nym-client-websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
+license.workspace = true

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

@@ -5,6 +5,7 @@ authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
 rust-version = "1.56"
+license.workspace = true

 [dependencies]
 clap = { workspace = true, features = ["cargo", "derive"] }
@@ -15,4 +15,4 @@ prod:
  mixnode_identity: 3pMCJswCyA19MGYWGDWT5fBk2M8ybSZGXttyAoNY5gBB
  gateway_identity: 2BuMSfMW3zpeAjKXyKLhmY4QW1DXurrtSPEJ6CjX3SEh
  log_level: error
-  time_zone: utc
+  time_zone: utc
@@ -1,4 +1,6 @@
+import { dir } from "console";
 import { readFileSync } from "fs";
+import { dirname } from "path";
 import { TLogLevelName } from "tslog";

 import YAML from "yaml";
@@ -10,9 +12,11 @@ class ConfigHandler {

  public commonConfig: { request_headers: object };

+  private currentEnvironment: string;
+
  public environment: string;

-  public environmnetConfig: {
+  public environmentConfig: {
    log_level: TLogLevelName;
    time_zone: string;
    api_base_url: string;
@@ -35,8 +39,9 @@ class ConfigHandler {

  private setCommonConfig(): void {
    try {
+      const baseWorkingDirectory = __dirname;
      this.commonConfig = YAML.parse(
-        readFileSync("src/config/config.yaml", "utf8")
+        readFileSync(baseWorkingDirectory + "/config.yaml", "utf8"),
      ).common;
    } catch (error) {
      throw Error(`Error reading common config: (${error})`);
@@ -46,14 +51,24 @@ class ConfigHandler {
  private setEnvironmentConfig(environment: string): void {
    this.ensureEnvironmentIsValid(environment);
    try {
-      this.environmnetConfig = YAML.parse(
-        readFileSync("src/config/config.yaml", "utf8")
+      const baseWorkingDirectory = __dirname;
+      this.environmentConfig = YAML.parse(
+        readFileSync(baseWorkingDirectory + "/config.yaml", "utf8"),
      )[environment];
    } catch (error) {
+      console.log("fadsfasdfasdfsdfsa")
      throw Error(`Error reading environment config: (${error})`);
    }
  }

+  public getEnvironmentConfig(environment: string): any {
+    const baseWorkingDirectory = __dirname;
+    return (
+      this.environmentConfig ||
+      YAML.parse(readFileSync(baseWorkingDirectory + "/config.yaml", "utf8"))[environment]
+    );
+  }
+
  private ensureEnvironmentIsValid(environment: string): void {
    if (this.validEnvironments.indexOf(environment) === -1) {
      throw Error(`Config environment is not valid: "${environment}"`);
@@ -0,0 +1,4 @@
+module.exports = {
+    ConfigHandler: require('./config/configHandler.ts'),
+    RestClient: require('./restClient/RestClient.ts')
+  };
@@ -13,9 +13,9 @@ import ConfigHandler from "../config/configHandler";

 const config = ConfigHandler.getInstance();
 const log = new Logger({
-  minLevel: config.environmnetConfig.log_level,
+  minLevel: config.environmentConfig.log_level,
  dateTimeTimezone:
-    config.environmnetConfig.time_zone ||
+    config.environmentConfig.time_zone ||
    Intl.DateTimeFormat().resolvedOptions().timeZone,
 });

@@ -24,7 +24,7 @@ function isSet(property): boolean {
 }

 export class RestClient {
-  private static authToken: string;
+  public static authToken: string;

  private axiosInstance: AxiosInstance;

@@ -83,7 +83,7 @@ export class RestClient {
        data,
        additionalConfigs,
        params,
-      })
+      }),
    );

    await this.axiosInstance
@@ -214,7 +214,7 @@ export class RestClient {

    if (isSet(additionalConfigs)) {
      logRecord = `${logRecord}\nAdditional Configuration: ${stringify(
-        additionalConfigs
+        additionalConfigs,
      )}`;
    }

@@ -2,6 +2,7 @@
 name = "async-file-watcher"
 version = "0.1.0"
 edition = "2021"
+license.workspace = true

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

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

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

@@ -10,6 +11,7 @@ bip39 = { workspace = true }
 rand = "0.7.3"
 thiserror = { workspace = true }
 url = { workspace = true }
+zeroize = { workspace = true }

 nym-coconut-interface = { path = "../coconut-interface" }
 nym-credential-storage = { path = "../credential-storage" }
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::error::BandwidthControllerError;
-use nym_coconut_interface::{Base58, Parameters};
+use nym_coconut_interface::Base58;
 use nym_credential_storage::storage::Storage;
-use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
+use nym_credentials::coconut::bandwidth::BandwidthVoucher;
 use nym_credentials::coconut::utils::obtain_aggregate_signature;
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_network_defaults::VOUCHER_INFO;
@@ -12,10 +12,8 @@ use nym_validator_client::coconut::all_coconut_api_clients;
 use nym_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use nym_validator_client::nyxd::Coin;
-use nym_validator_client::nyxd::Hash;
 use rand::rngs::OsRng;
-use state::{KeyPair, State};
-use std::str::FromStr;
+use state::State;

 pub mod state;

@@ -24,30 +22,29 @@ where
    C: CoconutBandwidthSigningClient + Sync,
 {
    let mut rng = OsRng;
-    let signing_keypair = KeyPair::from(identity::KeyPair::new(&mut rng));
-    let encryption_keypair = KeyPair::from(encryption::KeyPair::new(&mut rng));
-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
+    let signing_key = identity::PrivateKey::new(&mut rng);
+    let encryption_key = encryption::PrivateKey::new(&mut rng);
+    let params = BandwidthVoucher::default_parameters();
    let voucher_value = amount.amount.to_string();

    let tx_hash = client
        .deposit(
            amount,
            String::from(VOUCHER_INFO),
-            signing_keypair.public_key.clone(),
-            encryption_keypair.public_key.clone(),
+            signing_key.public_key().to_base58_string(),
+            encryption_key.public_key().to_base58_string(),
            None,
        )
        .await?
-        .transaction_hash
-        .to_string();
+        .transaction_hash;

    let voucher = BandwidthVoucher::new(
        &params,
        voucher_value,
        VOUCHER_INFO.to_string(),
-        Hash::from_str(&tx_hash).map_err(|_| BandwidthControllerError::InvalidTxHash)?,
-        identity::PrivateKey::from_base58_string(&signing_keypair.private_key)?,
-        encryption::PrivateKey::from_base58_string(&encryption_keypair.private_key)?,
+        tx_hash,
+        signing_key,
+        encryption_key,
    );

    let state = State { voucher, params };
@@ -2,32 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use nym_coconut_interface::Parameters;
-use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
-
-use nym_crypto::asymmetric::{encryption, identity};
-
-pub(crate) struct KeyPair {
-    pub public_key: String,
-    pub private_key: String,
-}
-
-impl From<identity::KeyPair> for KeyPair {
-    fn from(kp: identity::KeyPair) -> Self {
-        Self {
-            public_key: kp.public_key().to_base58_string(),
-            private_key: kp.private_key().to_base58_string(),
-        }
-    }
-}
-
-impl From<encryption::KeyPair> for KeyPair {
-    fn from(kp: encryption::KeyPair) -> Self {
-        Self {
-            public_key: kp.public_key().to_base58_string(),
-            private_key: kp.private_key().to_base58_string(),
-        }
-    }
-}
+use nym_credentials::coconut::bandwidth::BandwidthVoucher;

 pub struct State {
    pub voucher: BandwidthVoucher,
@@ -38,7 +13,7 @@ impl State {
    pub fn new(voucher: BandwidthVoucher) -> Self {
        State {
            voucher,
-            params: Parameters::new(TOTAL_ATTRIBUTES).unwrap(),
+            params: BandwidthVoucher::default_parameters(),
        }
    }
 }
@@ -7,6 +7,7 @@ use nym_credential_storage::storage::Storage;
 use nym_validator_client::coconut::all_coconut_api_clients;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::str::FromStr;
+use zeroize::Zeroizing;
 use {
    nym_coconut_interface::Base58,
    nym_credentials::coconut::{
@@ -46,10 +47,12 @@ impl<C, St: Storage> BandwidthController<C, St> {
        let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
            .map_err(|_| StorageError::InconsistentData)?;
        let voucher_info = bandwidth_credential.voucher_info.clone();
-        let serial_number =
-            nym_coconut_interface::Attribute::try_from_bs58(bandwidth_credential.serial_number)?;
-        let binding_number =
-            nym_coconut_interface::Attribute::try_from_bs58(bandwidth_credential.binding_number)?;
+        let serial_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
+            bandwidth_credential.serial_number,
+        )?);
+        let binding_number = Zeroizing::new(nym_coconut_interface::Attribute::try_from_bs58(
+            bandwidth_credential.binding_number,
+        )?);
        let signature =
            nym_coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;
        let epoch_id = u64::from_str(&bandwidth_credential.epoch_id)
@@ -64,8 +67,8 @@ impl<C, St: Storage> BandwidthController<C, St> {
            prepare_for_spending(
                voucher_value,
                voucher_info,
-                serial_number,
-                binding_number,
+                &serial_number,
+                &binding_number,
                epoch_id,
                &signature,
                &verification_key,
@@ -35,9 +35,10 @@ opentelemetry = { version = "0.19.0", optional = true, features = ["rt-tokio"] }


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

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

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

-    // VERGEN_CARGO_PROFILE
-    /// Provides the cargo profile that was used for the build, for example `debug`.
-    pub cargo_profile: &'static str,
+    // VERGEN_CARGO_DEBUG
+    /// Provides the cargo debug mode that was used for the build.
+    pub cargo_debug: &'static str,
 }

 impl BinaryBuildInformation {
@@ -57,7 +57,7 @@ impl BinaryBuildInformation {
            commit_branch: env!("VERGEN_GIT_BRANCH"),
            rustc_version: env!("VERGEN_RUSTC_SEMVER"),
            rustc_channel: env!("VERGEN_RUSTC_CHANNEL"),
-            cargo_profile: env!("VERGEN_CARGO_PROFILE"),
+            cargo_debug: env!("VERGEN_CARGO_DEBUG"),
        }
    }

@@ -71,7 +71,7 @@ impl BinaryBuildInformation {
            commit_branch: self.commit_branch.to_owned(),
            rustc_version: self.rustc_version.to_owned(),
            rustc_channel: self.rustc_channel.to_owned(),
-            cargo_profile: self.cargo_profile.to_owned(),
+            cargo_debug: self.cargo_debug.to_owned(),
        }
    }

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

-    // VERGEN_CARGO_PROFILE
-    /// Provides the cargo profile that was used for the build, for example `debug`.
-    pub cargo_profile: String,
+    // VERGEN_CARGO_DEBUG
+    /// Provides the cargo debug mode that was used for the build.
+    pub cargo_debug: String,
 }

 impl Display for BinaryBuildInformationOwned {
@@ -151,8 +151,8 @@ impl Display for BinaryBuildInformationOwned {
            self.rustc_version,
            "rustc Channel:",
            self.rustc_channel,
-            "cargo Profile:",
-            self.cargo_profile,
+            "cargo Debug:",
+            self.cargo_debug,
        )
    }
 }
@@ -4,6 +4,7 @@ version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
+license.workspace = true

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

@@ -58,7 +59,7 @@ features = ["time"]
 version = "0.20.1"

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

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

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

 [features]
 default = []
@@ -1,6 +1,8 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

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

 pub use wasmtimer::{std::Instant, tokio::*};
@@ -127,7 +127,9 @@ impl ActionController {
                .insert(frag_id, (Arc::new(pending_ack), None))
                .is_some()
            {
-                panic!("Tried to insert duplicate pending ack")
+                // This used to be a panic, however since we've seen this actually happen in the
+                // wild, let's not take the whole client (and possibly gateway) down because of it.
+                error!("Tried to insert duplicate pending ack! This should not be possible!")
            }
        }
    }
@@ -259,6 +259,7 @@ pub(super) fn get_specified_gateway(
    gateways: &[gateway::Node],
    must_use_tls: bool,
 ) -> Result<gateway::Node, ClientCoreError> {
+    log::debug!("Requesting specified gateway: {}", gateway_identity);
    let user_gateway = identity::PublicKey::from_base58_string(gateway_identity)
        .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;

@@ -212,7 +212,7 @@ where
    D::StorageError: Send + Sync + 'static,
    T: DeserializeOwned + Serialize + Send + Sync,
 {
-    log::trace!("Setting up gateway");
+    log::debug!("Setting up gateway");
    match setup {
        GatewaySetup::MustLoad => use_loaded_gateway_details(key_store, details_store).await,
        GatewaySetup::New {
@@ -3,6 +3,7 @@ name = "nym-gateway-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
+license.workspace = true

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

@@ -792,6 +792,7 @@ pub struct InitOnly;
 impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
    // for initialisation we do not need credential storage. Though it's still a bit weird we have to set the generic...
    pub fn new_init(config: GatewayConfig, local_identity: Arc<identity::KeyPair>) -> Self {
+        log::trace!("Initialising gateway client");
        use futures::channel::mpsc;

        // note: this packet_router is completely invalid in normal circumstances, but "works"
@@ -3,14 +3,15 @@ name = "nym-mixnet-client"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"
+license.workspace = true

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

 [dependencies]
 futures = { workspace = true }
 log = { workspace = true }
-tokio = { version = "1.24.1", features = ["time", "net", "rt"] }
-tokio-util = { version = "0.7.4", features = ["codec"] }
+tokio = { workspace = true, features = ["time", "net", "rt"] }
+tokio-util = { workspace = true, features = ["codec"] }

 # internal
 nym-sphinx = { path = "../../nymsphinx" }
@@ -4,6 +4,7 @@ version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
 rust-version = "1.56"
+license.workspace = true

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

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

+impl TryFrom<NymNetworkDetails> for Config {
+    type Error = ValidatorClientError;
+
+    fn try_from(value: NymNetworkDetails) -> Result<Self, Self::Error> {
+        Config::try_from_nym_network_details(&value)
+    }
+}
+
 impl Config {
    pub fn try_from_nym_network_details(
        details: &NymNetworkDetails,
@@ -5,16 +5,24 @@ use crate::nym_api::error::NymAPIError;
 use crate::nym_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use async_trait::async_trait;
 use http_api_client::{ApiClient, NO_PARAMS};
-use nym_api_requests::coconut::{
-    BlindSignRequestBody, BlindedSignatureResponse, VerifyCredentialBody, VerifyCredentialResponse,
-};
-use nym_api_requests::models::{
-    ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
-    GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
-    MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
-    MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
-    StakeSaturationResponse, UptimeResponse,
+pub use nym_api_requests::{
+    coconut::{
+        models::{
+            EpochCredentialsResponse, IssuedCredential, IssuedCredentialBody,
+            IssuedCredentialResponse, IssuedCredentialsResponse,
+        },
+        BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody,
+        VerifyCredentialBody, VerifyCredentialResponse,
+    },
+    models::{
+        ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
+        GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
+        MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
+        MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
+        StakeSaturationResponse, UptimeResponse,
+    },
 };
+pub use nym_coconut_dkg_common::types::EpochId;
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId};
 use nym_name_service_common::response::NamesListResponse;
@@ -399,6 +407,60 @@ pub trait NymApiClientExt: ApiClient {
        .await
    }

+    async fn epoch_credentials(
+        &self,
+        dkg_epoch: EpochId,
+    ) -> Result<EpochCredentialsResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_EPOCH_CREDENTIALS,
+                &dkg_epoch.to_string(),
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    async fn issued_credential(
+        &self,
+        credential_id: i64,
+    ) -> Result<IssuedCredentialResponse, NymAPIError> {
+        self.get_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_ISSUED_CREDENTIAL,
+                &credential_id.to_string(),
+            ],
+            NO_PARAMS,
+        )
+        .await
+    }
+
+    async fn issued_credentials(
+        &self,
+        credential_ids: Vec<i64>,
+    ) -> Result<IssuedCredentialsResponse, NymAPIError> {
+        self.post_json(
+            &[
+                routes::API_VERSION,
+                routes::COCONUT_ROUTES,
+                routes::BANDWIDTH,
+                routes::COCONUT_ISSUED_CREDENTIALS,
+            ],
+            NO_PARAMS,
+            &CredentialsRequestBody {
+                credential_ids,
+                pagination: None,
+            },
+        )
+        .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)
@@ -17,6 +17,9 @@ pub const BANDWIDTH: &str = "bandwidth";

 pub const COCONUT_BLIND_SIGN: &str = "blind-sign";
 pub const COCONUT_VERIFY_BANDWIDTH_CREDENTIAL: &str = "verify-bandwidth-credential";
+pub const COCONUT_EPOCH_CREDENTIALS: &str = "epoch-credentials";
+pub const COCONUT_ISSUED_CREDENTIAL: &str = "issued-credential";
+pub const COCONUT_ISSUED_CREDENTIALS: &str = "issued-credentials";

 pub const STATUS_ROUTES: &str = "status";
 pub const MIXNODE: &str = "mixnode";
@@ -8,6 +8,8 @@ use cosmwasm_std::{Fraction, Uint128};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::Div;
+use std::str::FromStr;
+use thiserror::Error;

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

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

@@ -32,7 +32,7 @@ pub trait CoconutBandwidthSigningClient {
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NyxdError> {
        let req = CoconutBandwidthExecuteMsg::DepositFunds {
-            data: DepositData::new(info.to_string(), verification_key, encryption_key),
+            data: DepositData::new(info, verification_key, encryption_key),
        };
        self.execute_coconut_bandwidth_contract(
            fee,
@@ -7,12 +7,18 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use nym_coconut_dkg_common::dealer::{
-    ContractDealing, DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
+use nym_coconut_dkg_common::{
+    dealer::{
+        DealerDetailsResponse, DealingResponse, DealingStatusResponse, PagedDealerResponse,
+        PagedDealingsResponse,
+    },
+    msg::QueryMsg as DkgQueryMsg,
+    types::{
+        DealerDetails, DealingIndex, Epoch, EpochId, InitialReplacementData,
+        PartialContractDealing, State,
+    },
+    verification_key::{ContractVKShare, PagedVKSharesResponse},
 };
-use nym_coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
-use nym_coconut_dkg_common::types::{DealerDetails, Epoch, EpochId, InitialReplacementData};
-use nym_coconut_dkg_common::verification_key::{ContractVKShare, PagedVKSharesResponse};
 use serde::Deserialize;

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -22,10 +28,16 @@ pub trait DkgQueryClient {
    where
        for<'a> T: Deserialize<'a>;

+    async fn get_state(&self) -> Result<State, NyxdError> {
+        let request = DkgQueryMsg::GetState {};
+        self.query_dkg_contract(request).await
+    }
+
    async fn get_current_epoch(&self) -> Result<Epoch, NyxdError> {
        let request = DkgQueryMsg::GetCurrentEpochState {};
        self.query_dkg_contract(request).await
    }
+
    async fn get_current_epoch_threshold(&self) -> Result<Option<u64>, NyxdError> {
        let request = DkgQueryMsg::GetCurrentEpochThreshold {};
        self.query_dkg_contract(request).await
@@ -64,14 +76,46 @@ pub trait DkgQueryClient {
        self.query_dkg_contract(request).await
    }

-    async fn get_dealings_paged(
+    async fn get_dealing_status(
        &self,
-        idx: u64,
-        start_after: Option<String>,
+        epoch_id: EpochId,
+        dealer: String,
+        dealing_index: DealingIndex,
+    ) -> Result<DealingStatusResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealingStatus {
+            epoch_id,
+            dealer,
+            dealing_index,
+        };
+
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_dealing(
+        &self,
+        epoch_id: EpochId,
+        dealer: String,
+        dealing_index: DealingIndex,
+    ) -> Result<DealingResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealing {
+            epoch_id,
+            dealer,
+            dealing_index,
+        };
+
+        self.query_dkg_contract(request).await
+    }
+
+    async fn get_dealer_dealings_paged(
+        &self,
+        epoch_id: EpochId,
+        dealer: &str,
+        start_after: Option<DealingIndex>,
        limit: Option<u32>,
    ) -> Result<PagedDealingsResponse, NyxdError> {
-        let request = DkgQueryMsg::GetDealing {
-            idx,
+        let request = DkgQueryMsg::GetDealings {
+            epoch_id,
+            dealer: dealer.to_string(),
            limit,
            start_after,
        };
@@ -106,8 +150,12 @@ pub trait PagedDkgQueryClient: DkgQueryClient {
        collect_paged!(self, get_past_dealers_paged, dealers)
    }

-    async fn get_all_epoch_dealings(&self, idx: u64) -> Result<Vec<ContractDealing>, NyxdError> {
-        collect_paged!(self, get_dealings_paged, dealings, idx)
+    async fn get_all_dealer_dealings(
+        &self,
+        epoch_id: EpochId,
+        dealer: &str,
+    ) -> Result<Vec<PartialContractDealing>, NyxdError> {
+        collect_paged!(self, get_dealer_dealings_paged, dealings, epoch_id, dealer)
    }

    async fn get_all_verification_key_shares(
@@ -151,6 +199,7 @@ mod tests {
        msg: DkgQueryMsg,
    ) {
        match msg {
+            DkgQueryMsg::GetState {} => client.get_state().ignore(),
            DkgQueryMsg::GetCurrentEpochState {} => client.get_current_epoch().ignore(),
            DkgQueryMsg::GetCurrentEpochThreshold {} => {
                client.get_current_epoch_threshold().ignore()
@@ -165,11 +214,26 @@ mod tests {
            DkgQueryMsg::GetPastDealers { limit, start_after } => {
                client.get_past_dealers_paged(start_after, limit).ignore()
            }
+            DkgQueryMsg::GetDealingStatus {
+                epoch_id,
+                dealer,
+                dealing_index,
+            } => client
+                .get_dealing_status(epoch_id, dealer, dealing_index)
+                .ignore(),
            DkgQueryMsg::GetDealing {
-                idx,
+                epoch_id,
+                dealer,
+                dealing_index,
+            } => client.get_dealing(epoch_id, dealer, dealing_index).ignore(),
+            DkgQueryMsg::GetDealings {
+                epoch_id,
+                dealer,
                limit,
                start_after,
-            } => client.get_dealings_paged(idx, start_after, limit).ignore(),
+            } => client
+                .get_dealer_dealings_paged(epoch_id, &dealer, limit, start_after)
+                .ignore(),
            DkgQueryMsg::GetVerificationKeys {
                epoch_id,
                limit,
@@ -10,9 +10,9 @@ use async_trait::async_trait;
 use cosmrs::AccountId;
 use cosmwasm_std::Addr;
 use nym_coconut_dkg_common::msg::ExecuteMsg as DkgExecuteMsg;
-use nym_coconut_dkg_common::types::EncodedBTEPublicKeyWithProof;
+use nym_coconut_dkg_common::types::{EncodedBTEPublicKeyWithProof, PartialContractDealing};
 use nym_coconut_dkg_common::verification_key::VerificationKeyShare;
-use nym_contracts_common::dealings::ContractSafeBytes;
+use nym_contracts_common::IdentityKey;

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
@@ -42,12 +42,14 @@ pub trait DkgSigningClient {
    async fn register_dealer(
        &self,
        bte_key: EncodedBTEPublicKeyWithProof,
+        identity_key: IdentityKey,
        announce_address: String,
        resharing: bool,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NyxdError> {
        let req = DkgExecuteMsg::RegisterDealer {
            bte_key_with_proof: bte_key,
+            identity_key,
            announce_address,
            resharing,
        };
@@ -58,14 +60,11 @@ pub trait DkgSigningClient {

    async fn submit_dealing_bytes(
        &self,
-        dealing_bytes: ContractSafeBytes,
+        dealing: PartialContractDealing,
        resharing: bool,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NyxdError> {
-        let req = DkgExecuteMsg::CommitDealing {
-            dealing_bytes,
-            resharing,
-        };
+        let req = DkgExecuteMsg::CommitDealing { dealing, resharing };

        self.execute_dkg_contract(fee, req, "dealing commitment".to_string(), vec![])
            .await
@@ -148,16 +147,20 @@ mod tests {
        match msg {
            DkgExecuteMsg::RegisterDealer {
                bte_key_with_proof,
+                identity_key,
                announce_address,
                resharing,
            } => client
-                .register_dealer(bte_key_with_proof, announce_address, resharing, None)
+                .register_dealer(
+                    bte_key_with_proof,
+                    identity_key,
+                    announce_address,
+                    resharing,
+                    None,
+                )
                .ignore(),
-            DkgExecuteMsg::CommitDealing {
-                dealing_bytes,
-                resharing,
-            } => client
-                .submit_dealing_bytes(dealing_bytes, resharing, None)
+            DkgExecuteMsg::CommitDealing { dealing, resharing } => client
+                .submit_dealing_bytes(dealing, resharing, None)
                .ignore(),
            DkgExecuteMsg::CommitVerificationKeyShare { share, resharing } => client
                .submit_verification_key_share(share, resharing, None)
@@ -6,8 +6,8 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cw3::{
-    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterListResponse,
-    VoterResponse,
+    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterDetail,
+    VoterListResponse, VoterResponse,
 };
 use cw_utils::ThresholdResponse;
 use nym_multisig_contract_common::msg::QueryMsg as MultisigQueryMsg;
@@ -114,6 +114,26 @@ pub trait PagedMultisigQueryClient: MultisigQueryClient {

        Ok(proposals)
    }
+
+    async fn get_all_voters(&self) -> Result<Vec<VoterDetail>, NyxdError> {
+        let mut voters = Vec::new();
+        let mut start_after = None;
+
+        loop {
+            let mut paged_response = self.list_voters(start_after.take(), None).await?;
+
+            let last_voter = paged_response.voters.last().map(|prop| prop.addr.clone());
+            voters.append(&mut paged_response.voters);
+
+            if let Some(start_after_res) = last_voter {
+                start_after = Some(start_after_res)
+            } else {
+                break;
+            }
+        }
+
+        Ok(voters)
+    }
 }

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

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

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

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

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

-#[async_trait]
-impl<C, S> CosmWasmClient for MaybeSigningClient<C, S>
-where
-    C: TendermintRpcClient + Send + Sync,
-    S: Send + Sync,
-{
-}
-
 #[async_trait]
 impl<C, S> SigningCosmWasmClient for MaybeSigningClient<C, S>
 where
@@ -0,0 +1,8 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod slashing;
+pub mod staking;
+
+pub use staking::query::StakingQueryClient;
+// pub use slashing::query
@@ -0,0 +1,4 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod query;
@@ -0,0 +1,2 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
@@ -0,0 +1,8 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod query;
+
+pub use cosmrs::staking::{
+    QueryHistoricalInfoResponse, QueryValidatorResponse, QueryValidatorsResponse, Validator,
+};
@@ -0,0 +1,78 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use super::{QueryHistoricalInfoResponse, QueryValidatorResponse, QueryValidatorsResponse};
+use crate::nyxd::error::NyxdError;
+use crate::nyxd::{CosmWasmClient, PageRequest};
+use async_trait::async_trait;
+use cosmrs::proto::cosmos::staking::v1beta1::{
+    QueryHistoricalInfoRequest as ProtoQueryHistoricalInfoRequest,
+    QueryHistoricalInfoResponse as ProtoQueryHistoricalInfoResponse,
+    QueryValidatorRequest as ProtoQueryValidatorRequest,
+    QueryValidatorResponse as ProtoQueryValidatorResponse,
+    QueryValidatorsRequest as ProtoQueryValidatorsRequest,
+    QueryValidatorsResponse as ProtoQueryValidatorsResponse,
+};
+use cosmrs::staking::{QueryHistoricalInfoRequest, QueryValidatorRequest, QueryValidatorsRequest};
+use cosmrs::AccountId;
+
+// TODO: change trait restriction from `CosmWasmClient` to `TendermintRpcClient`
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+pub trait StakingQueryClient: CosmWasmClient {
+    async fn historical_info(&self, height: i64) -> Result<QueryHistoricalInfoResponse, NyxdError> {
+        let path = Some("/cosmos.staking.v1beta1.Query/HistoricalInfo".to_owned());
+
+        let req = QueryHistoricalInfoRequest { height };
+
+        let res = self
+            .make_abci_query::<ProtoQueryHistoricalInfoRequest, ProtoQueryHistoricalInfoResponse>(
+                path,
+                req.into(),
+            )
+            .await?;
+
+        Ok(res.try_into()?)
+    }
+
+    async fn validator(
+        &self,
+        validator_addr: AccountId,
+    ) -> Result<QueryValidatorResponse, NyxdError> {
+        let path = Some("/cosmos.staking.v1beta1.Query/Validator".to_owned());
+
+        let req = QueryValidatorRequest { validator_addr };
+
+        let res = self
+            .make_abci_query::<ProtoQueryValidatorRequest, ProtoQueryValidatorResponse>(
+                path,
+                req.into(),
+            )
+            .await?;
+
+        Ok(res.try_into()?)
+    }
+
+    async fn validators(
+        &self,
+        status: String,
+        pagination: Option<PageRequest>,
+    ) -> Result<QueryValidatorsResponse, NyxdError> {
+        let path = Some("/cosmos.staking.v1beta1.Query/Validators".to_owned());
+
+        let req = QueryValidatorsRequest { status, pagination };
+
+        let res = self
+            .make_abci_query::<ProtoQueryValidatorsRequest, ProtoQueryValidatorsResponse>(
+                path,
+                req.into(),
+            )
+            .await?;
+
+        Ok(res.try_into()?)
+    }
+}
+
+#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
+#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
+impl<T> StakingQueryClient for T where T: CosmWasmClient {}
@@ -0,0 +1,13 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::nyxd::TxResponse;
+
+pub fn find_tx_attribute(tx: &TxResponse, event_type: &str, attribute_key: &str) -> Option<String> {
+    let event = tx.tx_result.events.iter().find(|e| e.kind == event_type)?;
+    let attribute = event
+        .attributes
+        .iter()
+        .find(|attr| attr.key == attribute_key)?;
+    Some(attribute.value.clone())
+}
@@ -29,31 +29,41 @@ use tendermint_rpc::endpoint::*;
 use tendermint_rpc::{Error as TendermintRpcError, Order};
 use url::Url;

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

 #[cfg(feature = "http-client")]
 use crate::http_client;
@@ -67,6 +77,7 @@ pub mod contract_traits;
 pub mod cosmwasm_client;
 pub mod error;
 pub mod fee;
+pub mod helpers;

 #[derive(Debug, Clone)]
 pub struct Config {
@@ -92,6 +103,14 @@ impl Config {
    }
 }

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

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

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

 [dependencies]
 bs58 = "0.4.0"
@@ -21,10 +21,14 @@ pub use nym_coconut::{
 pub struct Credential {
    #[getset(get = "pub")]
    n_params: u32,
+
    #[getset(get = "pub")]
    theta: Theta,
+
    voucher_value: u64,
+
    voucher_info: String,
+
    #[getset(get = "pub")]
    epoch_id: u64,
 }
@@ -64,14 +68,12 @@ impl Credential {

    pub fn verify(&self, verification_key: &VerificationKey) -> bool {
        let params = Parameters::new(self.n_params).unwrap();
-        let public_attributes = [
-            self.voucher_value.to_string().as_bytes(),
-            self.voucher_info.as_bytes(),
-        ]
-        .iter()
-        .map(hash_to_scalar)
-        .collect::<Vec<Attribute>>();
-        nym_coconut::verify_credential(&params, verification_key, &self.theta, &public_attributes)
+
+        let hashed_value = hash_to_scalar(self.voucher_value.to_string());
+        let hashed_info = hash_to_scalar(&self.voucher_info);
+        let public_attributes = &[&hashed_value, &hashed_info];
+
+        nym_coconut::verify_credential(&params, verification_key, &self.theta, public_attributes)
    }

    pub fn as_bytes(&self) -> Vec<u8> {
@@ -180,8 +182,8 @@ mod tests {
            &params,
            &verification_key,
            &signature,
-            serial_number,
-            binding_number,
+            &serial_number,
+            &binding_number,
        )
        .unwrap();
        let credential = Credential::new(4, theta, voucher_value, voucher_info, 42);
@@ -3,6 +3,7 @@ name = "nym-cli-commands"
 version = "1.0.0"
 authors.workspace = true
 edition = "2021"
+license.workspace = true

 [dependencies]
 anyhow = { workspace = true }
@@ -26,6 +26,10 @@ pub struct Args {
 }

 pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
+    if args.amount == 0 {
+        bail!("did not specify credential amount")
+    }
+
    let loaded = CommonConfigsWrapper::try_load(args.client_config)?;

    if let Ok(id) = loaded.try_get_id() {
@@ -6,7 +6,7 @@ use log::{debug, info};
 use std::str::FromStr;

 use nym_coconut_dkg_common::msg::InstantiateMsg;
-use nym_coconut_dkg_common::types::TimeConfiguration;
+use nym_coconut_dkg_common::types::{TimeConfiguration, DEFAULT_DEALINGS};
 use nym_validator_client::nyxd::AccountId;

 #[derive(Debug, Parser)]
@@ -93,6 +93,7 @@ pub async fn generate(args: Args) {
        multisig_addr: multisig_addr.to_string(),
        time_configuration: Some(time_configuration),
        mix_denom,
+        key_size: DEFAULT_DEALINGS as u32,
    };

    debug!("instantiate_msg: {:?}", instantiate_msg);
@@ -3,6 +3,7 @@ name = "nym-config"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"
+license.workspace = true

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

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

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

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

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

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

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -4,6 +4,9 @@
 // event types
 pub const DEPOSITED_FUNDS_EVENT_TYPE: &str = "deposited-funds";

+// a 'wasm-' prefix is added to all cosmwasm events
+pub const COSMWASM_DEPOSITED_FUNDS_EVENT_TYPE: &str = "wasm-deposited-funds";
+
 // attributes that are used in multiple places
 pub const DEPOSIT_VALUE: &str = "deposit-value";
 pub const DEPOSIT_INFO: &str = "deposit-info";
@@ -2,6 +2,7 @@
 name = "nym-coconut-dkg-common"
 version = "0.1.0"
 edition = "2021"
+license.workspace = true

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

@@ -9,9 +10,10 @@ edition = "2021"
 cosmwasm-schema = { workspace = true }
 cosmwasm-std = { workspace = true }
 cw-utils = { workspace = true }
+cw4 = { workspace = true }

 contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
 nym-multisig-contract-common = { path = "../multisig-contract" }

 [features]
-schema = []
+schema = []
@@ -1,7 +1,10 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, NodeIndex};
+use crate::types::{
+    ContractDealing, DealingIndex, EncodedBTEPublicKeyWithProof, EpochId, NodeIndex,
+    PartialContractDealing,
+};
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::Addr;

@@ -9,6 +12,7 @@ use cosmwasm_std::Addr;
 pub struct DealerDetails {
    pub address: Addr,
    pub bte_public_key_with_proof: EncodedBTEPublicKeyWithProof,
+    pub ed25519_identity: String,
    pub announce_address: String,
    pub assigned_index: NodeIndex,
 }
@@ -66,35 +70,50 @@ impl PagedDealerResponse {
 }

 #[cw_serde]
-pub struct ContractDealing {
-    pub dealing: ContractSafeBytes,
+pub struct DealingResponse {
+    pub epoch_id: EpochId,
+
    pub dealer: Addr,
+
+    pub dealing_index: DealingIndex,
+
+    pub dealing: Option<ContractDealing>,
 }

-impl ContractDealing {
-    pub fn new(dealing: ContractSafeBytes, dealer: Addr) -> Self {
-        ContractDealing { dealing, dealer }
-    }
+#[cw_serde]
+pub struct DealingStatusResponse {
+    pub epoch_id: EpochId,
+
+    pub dealer: Addr,
+
+    pub dealing_index: DealingIndex,
+
+    pub dealing_submitted: bool,
 }

 #[cw_serde]
 pub struct PagedDealingsResponse {
-    pub dealings: Vec<ContractDealing>,
-    pub per_page: usize,
+    pub epoch_id: EpochId,
+
+    pub dealer: Addr,
+
+    pub dealings: Vec<PartialContractDealing>,

    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<Addr>,
+    pub start_next_after: Option<DealingIndex>,
 }

 impl PagedDealingsResponse {
    pub fn new(
-        dealings: Vec<ContractDealing>,
-        per_page: usize,
-        start_next_after: Option<Addr>,
+        epoch_id: EpochId,
+        dealer: Addr,
+        dealings: Vec<PartialContractDealing>,
+        start_next_after: Option<DealingIndex>,
    ) -> Self {
        PagedDealingsResponse {
+            epoch_id,
+            dealer,
            dealings,
-            per_page,
            start_next_after,
        }
    }
@@ -1,17 +1,23 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, EpochId, TimeConfiguration};
+use crate::types::{
+    DealingIndex, EncodedBTEPublicKeyWithProof, EpochId, PartialContractDealing, TimeConfiguration,
+};
 use crate::verification_key::VerificationKeyShare;
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::Addr;

 #[cfg(feature = "schema")]
 use crate::{
-    dealer::{DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse},
-    types::{Epoch, InitialReplacementData},
+    dealer::{
+        DealerDetailsResponse, DealingResponse, DealingStatusResponse, PagedDealerResponse,
+        PagedDealingsResponse,
+    },
+    types::{Epoch, InitialReplacementData, State},
    verification_key::PagedVKSharesResponse,
 };
+use contracts_common::IdentityKey;
 #[cfg(feature = "schema")]
 use cosmwasm_schema::QueryResponses;

@@ -21,18 +27,22 @@ pub struct InstantiateMsg {
    pub multisig_addr: String,
    pub time_configuration: Option<TimeConfiguration>,
    pub mix_denom: String,
+
+    /// Specifies the number of elements in the derived keys
+    pub key_size: u32,
 }

 #[cw_serde]
 pub enum ExecuteMsg {
    RegisterDealer {
        bte_key_with_proof: EncodedBTEPublicKeyWithProof,
+        identity_key: IdentityKey,
        announce_address: String,
        resharing: bool,
    },

    CommitDealing {
-        dealing_bytes: ContractSafeBytes,
+        dealing: PartialContractDealing,
        resharing: bool,
    },

@@ -55,6 +65,9 @@ pub enum ExecuteMsg {
 #[cw_serde]
 #[cfg_attr(feature = "schema", derive(QueryResponses))]
 pub enum QueryMsg {
+    #[cfg_attr(feature = "schema", returns(State))]
+    GetState {},
+
    #[cfg_attr(feature = "schema", returns(Epoch))]
    GetCurrentEpochState {},

@@ -79,11 +92,26 @@ pub enum QueryMsg {
        start_after: Option<String>,
    },

-    #[cfg_attr(feature = "schema", returns(PagedDealingsResponse))]
+    #[cfg_attr(feature = "schema", returns(DealingStatusResponse))]
+    GetDealingStatus {
+        epoch_id: EpochId,
+        dealer: String,
+        dealing_index: DealingIndex,
+    },
+
+    #[cfg_attr(feature = "schema", returns(DealingResponse))]
    GetDealing {
-        idx: u64,
+        epoch_id: EpochId,
+        dealer: String,
+        dealing_index: DealingIndex,
+    },
+
+    #[cfg_attr(feature = "schema", returns(PagedDealingsResponse))]
+    GetDealings {
+        epoch_id: EpochId,
+        dealer: String,
        limit: Option<u32>,
-        start_after: Option<String>,
+        start_after: Option<DealingIndex>,
    },

    #[cfg_attr(feature = "schema", returns(PagedVKSharesResponse))]
@@ -8,14 +8,38 @@ use std::str::FromStr;
 pub use crate::dealer::{DealerDetails, PagedDealerResponse};
 pub use contracts_common::dealings::ContractSafeBytes;
 pub use cosmwasm_std::{Addr, Coin, Timestamp};
+pub use cw4::Cw4Contract;

 pub type EncodedBTEPublicKeyWithProof = String;
 pub type EncodedBTEPublicKeyWithProofRef<'a> = &'a str;
 pub type NodeIndex = u64;
 pub type EpochId = u64;
+pub type DealingIndex = u32;
+pub type ContractDealing = ContractSafeBytes;

 // 2 public attributes, 2 private attributes, 1 fixed for coconut credential
-pub const TOTAL_DEALINGS: usize = 2 + 2 + 1;
+pub const DEFAULT_DEALINGS: usize = 2 + 2 + 1;
+
+#[cw_serde]
+pub struct PartialContractDealing {
+    pub index: DealingIndex,
+    pub data: ContractDealing,
+}
+
+impl PartialContractDealing {
+    pub fn new(index: DealingIndex, data: ContractDealing) -> Self {
+        PartialContractDealing { index, data }
+    }
+}
+
+impl From<(DealingIndex, ContractDealing)> for PartialContractDealing {
+    fn from(value: (DealingIndex, ContractDealing)) -> Self {
+        PartialContractDealing {
+            index: value.0,
+            data: value.1,
+        }
+    }
+}

 #[cw_serde]
 pub struct InitialReplacementData {
@@ -73,6 +97,16 @@ impl Default for TimeConfiguration {
    }
 }

+#[cw_serde]
+pub struct State {
+    pub mix_denom: String,
+    pub multisig_addr: Addr,
+    pub group_addr: Cw4Contract,
+
+    /// Specifies the number of elements in the derived keys
+    pub key_size: u32,
+}
+
 #[cw_serde]
 #[derive(Copy, Default)]
 pub struct Epoch {
@@ -174,17 +208,19 @@ impl Display for EpochState {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            EpochState::PublicKeySubmission { resharing } => {
-                write!(f, "PublicKeySubmission with resharing {resharing}")
+                write!(f, "PublicKeySubmission (resharing: {resharing})")
+            }
+            EpochState::DealingExchange { resharing } => {
+                write!(f, "DealingExchange (resharing: {resharing})")
            }
-            EpochState::DealingExchange { resharing } => write!(f, "DealingExchange {resharing}"),
            EpochState::VerificationKeySubmission { resharing } => {
-                write!(f, "VerificationKeySubmission with resharing {resharing}")
+                write!(f, "VerificationKeySubmission (resharing: {resharing})")
            }
            EpochState::VerificationKeyValidation { resharing } => {
-                write!(f, "VerificationKeyValidation with resharing {resharing}")
+                write!(f, "VerificationKeyValidation (resharing: {resharing})")
            }
            EpochState::VerificationKeyFinalization { resharing } => {
-                write!(f, "VerificationKeyFinalization with resharing {resharing}")
+                write!(f, "VerificationKeyFinalization (resharing: {resharing})")
            }
            EpochState::InProgress => write!(f, "InProgress"),
        }
@@ -2,6 +2,7 @@
 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

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

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

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

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

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

@@ -2,6 +2,7 @@
 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

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

 [features]
-schema = ["cw2"]
+schema = ["cw2"]
@@ -2,6 +2,7 @@
 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

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

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

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

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

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

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


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

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

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

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

 [dependencies]
-bls12_381 = { version = "0.5", default-features = false, features = ["pairings", "alloc", "experimental"] }
+bls12_381 = { workspace = true, default-features = false, features = ["pairings", "alloc", "experimental"] }
 cosmrs = { workspace = true }
 thiserror = { workspace = true }
 log = { workspace = true }
+zeroize = { workspace = true }

 # I guess temporarily until we get serde support in coconut up and running
 nym-coconut-interface = { path = "../coconut-interface" }
-nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "hashing"] }
+nym-crypto = { path = "../crypto", features = ["rand", "asymmetric"] }
 nym-api-requests = { path = "../../nym-api/nym-api-requests" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }

@@ -13,38 +13,60 @@ use nym_coconut_interface::{
    PrivateAttribute, PublicAttribute, Signature, VerificationKey,
 };
 use nym_crypto::asymmetric::{encryption, identity};
+use zeroize::{Zeroize, ZeroizeOnDrop};

 use super::utils::prepare_credential_for_spending;
 use crate::error::Error;

-pub const PUBLIC_ATTRIBUTES: u32 = 2;
-pub const PRIVATE_ATTRIBUTES: u32 = 2;
-pub const TOTAL_ATTRIBUTES: u32 = PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES;
-
+#[derive(Zeroize, ZeroizeOnDrop)]
 pub struct BandwidthVoucher {
-    // a random secret value generated by the client used for double-spending detection
+    // private attributes
+    /// a random secret value generated by the client used for double-spending detection
    serial_number: PrivateAttribute,
-    // a random secret value generated by the client used to bind multiple credentials together
+
+    /// a random secret value generated by the client used to bind multiple credentials together
    binding_number: PrivateAttribute,
-    // the value (e.g., bandwidth) encoded in this voucher
-    voucher_value: PublicAttribute,
-    // the plain text value (e.g., bandwidth) encoded in this voucher
+
+    // public atttributes:
+    /// the plain text value (e.g., bandwidth) encoded in this voucher
+    // TODO: in another PR change the value from `"1000"` to `"1000unym"`
    voucher_value_plain: String,
-    // a field with public information, e.g., type of voucher, interval etc.
-    voucher_info: PublicAttribute,
-    // the plain text information
+
+    /// the plain text information
    voucher_info_plain: String,
-    // the hash of the deposit transaction
+
+    /// the precomputed value (e.g., bandwidth) encoded in this voucher
+    _voucher_value_prehashed: PublicAttribute,
+
+    /// the precomputed field with public information, e.g., type of voucher, interval etc.
+    _voucher_info_prehashed: PublicAttribute,
+
+    /// the hash of the deposit transaction
+    #[zeroize(skip)]
    tx_hash: Hash,
-    // base58 encoded private key ensuring the depositer requested these attributes
+
+    /// base58 encoded private key ensuring the depositer requested these attributes
    signing_key: identity::PrivateKey,
-    // base58 encoded private key ensuring only this client receives the signature share
-    encryption_key: encryption::PrivateKey,
+
+    /// base58 encoded private key ensuring only this client receives the signature share
+    unused_ed25519: encryption::PrivateKey,
+
    pedersen_commitments_openings: Vec<Attribute>,
+
+    #[zeroize(skip)]
    blind_sign_request: BlindSignRequest,
 }

 impl BandwidthVoucher {
+    pub const PUBLIC_ATTRIBUTES: u32 = 2;
+    pub const PRIVATE_ATTRIBUTES: u32 = 2;
+    pub const ENCODED_ATTRIBUTES: u32 = 4;
+
+    pub fn default_parameters() -> Parameters {
+        // safety: the unwrap is fine here as Self::ENCODED_ATTRIBUTES is non-zero
+        Parameters::new(Self::ENCODED_ATTRIBUTES).unwrap()
+    }
+
    pub fn new(
        params: &Parameters,
        voucher_value: String,
@@ -57,24 +79,26 @@ impl BandwidthVoucher {
        let binding_number = params.random_scalar();
        let voucher_value_plain = voucher_value.clone();
        let voucher_info_plain = voucher_info.clone();
-        let voucher_value = hash_to_scalar(voucher_value.as_bytes());
-        let voucher_info = hash_to_scalar(voucher_info.as_bytes());
+
+        let _voucher_value_prehashed = hash_to_scalar(voucher_value);
+        let _voucher_info_prehashed = hash_to_scalar(voucher_info);
+
        let (pedersen_commitments_openings, blind_sign_request) = prepare_blind_sign(
            params,
-            &[serial_number, binding_number],
-            &[voucher_value, voucher_info],
+            &[&serial_number, &binding_number],
+            &[&_voucher_value_prehashed, &_voucher_info_prehashed],
        )
        .unwrap();
        BandwidthVoucher {
            serial_number,
            binding_number,
-            voucher_value,
+            _voucher_value_prehashed,
            voucher_value_plain,
-            voucher_info,
+            _voucher_info_prehashed,
            voucher_info_plain,
            tx_hash,
            signing_key,
-            encryption_key,
+            unused_ed25519: encryption_key,
            pedersen_commitments_openings,
            blind_sign_request,
        }
@@ -87,7 +111,7 @@ impl BandwidthVoucher {
        let voucher_info_plain_b = self.voucher_info_plain.as_bytes();
        let tx_hash_b = self.tx_hash.as_bytes();
        let signing_key_b = self.signing_key.to_bytes();
-        let encryption_key_b = self.encryption_key.to_bytes();
+        let encryption_key_b = self.unused_ed25519.to_bytes();
        let blind_sign_request_b = self.blind_sign_request.to_bytes();

        let mut ret = Vec::new();
@@ -171,13 +195,13 @@ impl BandwidthVoucher {
            bytes[var_length_pointer..var_length_pointer + voucher_value_plain_no].to_vec(),
        )
        .or_else(utf_err)?;
-        let voucher_value = hash_to_scalar(&voucher_value_plain);
+        let _voucher_value_prehashed = hash_to_scalar(&voucher_value_plain);
        var_length_pointer += voucher_value_plain_no;
        let voucher_info_plain = String::from_utf8(
            bytes[var_length_pointer..var_length_pointer + voucher_info_plain_no].to_vec(),
        )
        .or_else(utf_err)?;
-        let voucher_info = hash_to_scalar(&voucher_info_plain);
+        let _voucher_info_prehashed = hash_to_scalar(&voucher_info_plain);
        var_length_pointer += voucher_info_plain_no;
        let blind_sign_request = BlindSignRequest::from_bytes(
            &bytes[var_length_pointer..var_length_pointer + blind_sign_request_no],
@@ -196,36 +220,43 @@ impl BandwidthVoucher {
        Ok(Self {
            serial_number,
            binding_number,
-            voucher_value,
+            _voucher_value_prehashed,
            voucher_value_plain,
-            voucher_info,
+            _voucher_info_prehashed,
            voucher_info_plain,
            tx_hash,
            signing_key,
-            encryption_key,
+            unused_ed25519: encryption_key,
            pedersen_commitments_openings,
            blind_sign_request,
        })
    }

    /// Check if the plain values correspond to the PublicAttributes
-    pub fn verify_against_plain(values: &[PublicAttribute], plain_values: &[String]) -> bool {
+    pub fn verify_against_plain(values: &[&PublicAttribute], plain_values: &[String]) -> bool {
        values.len() == 2
            && plain_values.len() == 2
-            && values[0] == hash_to_scalar(&plain_values[0])
-            && values[1] == hash_to_scalar(&plain_values[1])
+            && values[0] == &hash_to_scalar(&plain_values[0])
+            && values[1] == &hash_to_scalar(&plain_values[1])
    }

-    pub fn tx_hash(&self) -> &Hash {
-        &self.tx_hash
+    pub fn tx_hash(&self) -> Hash {
+        self.tx_hash
    }

-    pub fn get_public_attributes(&self) -> Vec<PublicAttribute> {
-        vec![self.voucher_value, self.voucher_info]
+    pub fn get_public_attributes(&self) -> Vec<&PublicAttribute> {
+        vec![
+            &self._voucher_value_prehashed,
+            &self._voucher_info_prehashed,
+        ]
+    }
+
+    pub fn identity_key(&self) -> &identity::PrivateKey {
+        &self.signing_key
    }

    pub fn encryption_key(&self) -> &encryption::PrivateKey {
-        &self.encryption_key
+        &self.unused_ed25519
    }

    pub fn pedersen_commitments_openings(&self) -> &Vec<Attribute> {
@@ -247,27 +278,32 @@ impl BandwidthVoucher {
        ]
    }

-    pub fn get_private_attributes(&self) -> Vec<PrivateAttribute> {
-        vec![self.serial_number, self.binding_number]
+    pub fn get_private_attributes(&self) -> Vec<&PrivateAttribute> {
+        vec![&self.serial_number, &self.binding_number]
    }

-    pub fn sign(&self, request: &BlindSignRequest) -> identity::Signature {
+    pub fn signable_plaintext(request: &BlindSignRequest, tx_hash: Hash) -> Vec<u8> {
        let mut message = request.to_bytes();
-        message.extend_from_slice(self.tx_hash.to_string().as_bytes());
-        self.signing_key.sign(&message)
+        message.extend_from_slice(tx_hash.as_bytes());
+        message
+    }
+
+    pub fn sign(&self) -> identity::Signature {
+        let message = Self::signable_plaintext(&self.blind_sign_request, self.tx_hash);
+        self.signing_key.sign(message)
    }
 }

 pub fn prepare_for_spending(
    voucher_value: u64,
    voucher_info: String,
-    serial_number: PrivateAttribute,
-    binding_number: PrivateAttribute,
+    serial_number: &PrivateAttribute,
+    binding_number: &PrivateAttribute,
    epoch_id: u64,
    signature: &Signature,
    verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
-    let params = Parameters::new(TOTAL_ATTRIBUTES)?;
+    let params = Parameters::new(BandwidthVoucher::ENCODED_ATTRIBUTES)?;

    prepare_credential_for_spending(
        &params,
@@ -316,24 +352,30 @@ mod test {
        let deserialized_voucher = BandwidthVoucher::try_from_bytes(&bytes).unwrap();
        assert_eq!(voucher.serial_number, deserialized_voucher.serial_number);
        assert_eq!(voucher.binding_number, deserialized_voucher.binding_number);
-        assert_eq!(voucher.voucher_value, deserialized_voucher.voucher_value);
        assert_eq!(
            voucher.voucher_value_plain,
            deserialized_voucher.voucher_value_plain
        );
-        assert_eq!(voucher.voucher_info, deserialized_voucher.voucher_info);
        assert_eq!(
            voucher.voucher_info_plain,
            deserialized_voucher.voucher_info_plain
        );
+        assert_eq!(
+            voucher._voucher_value_prehashed,
+            deserialized_voucher._voucher_value_prehashed
+        );
+        assert_eq!(
+            voucher._voucher_info_prehashed,
+            deserialized_voucher._voucher_info_prehashed
+        );
        assert_eq!(voucher.tx_hash, deserialized_voucher.tx_hash);
        assert_eq!(
            voucher.signing_key.to_string(),
            deserialized_voucher.signing_key.to_string()
        );
        assert_eq!(
-            voucher.encryption_key.to_string(),
-            deserialized_voucher.encryption_key.to_string()
+            voucher.unused_ed25519.to_string(),
+            deserialized_voucher.unused_ed25519.to_string()
        );
        assert_eq!(
            voucher.pedersen_commitments_openings,
@@ -371,11 +413,11 @@ mod test {
            ]
        ));
        assert!(!BandwidthVoucher::verify_against_plain(
-            &[voucher.get_public_attributes()[0], Attribute::one()],
+            &[voucher.get_public_attributes()[0], &Attribute::one()],
            &voucher.get_public_attributes_plain()
        ));
        assert!(!BandwidthVoucher::verify_against_plain(
-            &[Attribute::one(), voucher.get_public_attributes()[1]],
+            &[&Attribute::one(), voucher.get_public_attributes()[1]],
            &voucher.get_public_attributes_plain()
        ));
        assert!(BandwidthVoucher::verify_against_plain(
@@ -2,5 +2,4 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod bandwidth;
-pub mod params;
 pub mod utils;
@@ -1,15 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_crypto::aes::Aes128;
-use nym_crypto::blake3;
-use nym_crypto::ctr;
-
-type Aes128Ctr = ctr::Ctr64LE<Aes128>;
-
-/// Hashing algorithm used during hkdf for ephemeral shared key generation per blinded signature
-/// response encryption.
-pub type NymApiCredentialHkdfAlgorithm = blake3::Hasher;
-
-/// Encryption algorithm used for end-to-end encryption of blinded signature response
-pub type NymApiCredentialEncryptionAlgorithm = Aes128Ctr;
@@ -1,18 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES, PUBLIC_ATTRIBUTES};
-use crate::coconut::params::{NymApiCredentialEncryptionAlgorithm, NymApiCredentialHkdfAlgorithm};
+use crate::coconut::bandwidth::BandwidthVoucher;
 use crate::error::Error;
 use log::{debug, warn};
 use nym_api_requests::coconut::BlindSignRequestBody;
 use nym_coconut_interface::{
    aggregate_signature_shares, aggregate_verification_keys, prove_bandwidth_credential, Attribute,
-    BlindedSignature, Credential, Parameters, Signature, SignatureShare, VerificationKey,
+    Credential, Parameters, Signature, SignatureShare, VerificationKey,
 };
-use nym_crypto::asymmetric::encryption::PublicKey;
-use nym_crypto::shared_key::recompute_shared_key;
-use nym_crypto::symmetric::stream_cipher;
 use nym_validator_client::client::CoconutApiClient;

 pub async fn obtain_aggregate_verification_key(
@@ -36,47 +32,34 @@ pub async fn obtain_aggregate_verification_key(

 async fn obtain_partial_credential(
    params: &Parameters,
-    attributes: &BandwidthVoucher,
+    voucher: &BandwidthVoucher,
    client: &nym_validator_client::client::NymApiClient,
    validator_vk: &VerificationKey,
 ) -> Result<Signature, Error> {
-    let public_attributes = attributes.get_public_attributes();
-    let public_attributes_plain = attributes.get_public_attributes_plain();
-    let private_attributes = attributes.get_private_attributes();
-    let blind_sign_request = attributes.blind_sign_request();
+    let public_attributes_plain = voucher.get_public_attributes_plain();
+    let blind_sign_request = voucher.blind_sign_request();
+    let request_signature = voucher.sign();

    let blind_sign_request_body = BlindSignRequestBody::new(
-        blind_sign_request,
-        attributes.tx_hash().to_string(),
-        attributes.sign(blind_sign_request).to_base58_string(),
-        &public_attributes,
+        blind_sign_request.clone(),
+        voucher.tx_hash(),
+        request_signature,
        public_attributes_plain,
-        (public_attributes.len() + private_attributes.len()) as u32,
    );
    let response = client.blind_sign(&blind_sign_request_body).await?;
-    let encrypted_signature = response.encrypted_signature;
-    let remote_key = PublicKey::from_bytes(&response.remote_key)?;

-    let encryption_key = recompute_shared_key::<
-        NymApiCredentialEncryptionAlgorithm,
-        NymApiCredentialHkdfAlgorithm,
-    >(&remote_key, attributes.encryption_key());
-    let zero_iv = stream_cipher::zero_iv::<NymApiCredentialEncryptionAlgorithm>();
-    let blinded_signature_bytes = stream_cipher::decrypt::<NymApiCredentialEncryptionAlgorithm>(
-        &encryption_key,
-        &zero_iv,
-        &encrypted_signature,
-    );
+    let blinded_signature = response.blinded_signature;

-    let blinded_signature = BlindedSignature::from_bytes(&blinded_signature_bytes)?;
+    let public_attributes = voucher.get_public_attributes();
+    let private_attributes = voucher.get_private_attributes();

-    let unblinded_signature = blinded_signature.unblind(
+    let unblinded_signature = blinded_signature.unblind_and_verify(
        params,
        validator_vk,
        &private_attributes,
        &public_attributes,
        &blind_sign_request.get_commitment_hash(),
-        attributes.pedersen_commitments_openings(),
+        voucher.pedersen_commitments_openings(),
    )?;

    Ok(unblinded_signature)
@@ -84,16 +67,13 @@ async fn obtain_partial_credential(

 pub async fn obtain_aggregate_signature(
    params: &Parameters,
-    attributes: &BandwidthVoucher,
+    voucher: &BandwidthVoucher,
    coconut_api_clients: &[CoconutApiClient],
    threshold: u64,
 ) -> Result<Signature, Error> {
    if coconut_api_clients.is_empty() {
        return Err(Error::NoValidatorsAvailable);
    }
-    let public_attributes = attributes.get_public_attributes();
-    let private_attributes = attributes.get_private_attributes();
-
    let mut shares = Vec::with_capacity(coconut_api_clients.len());
    let validators_partial_vks: Vec<_> = coconut_api_clients
        .iter()
@@ -114,7 +94,7 @@ pub async fn obtain_aggregate_signature(

        match obtain_partial_credential(
            params,
-            attributes,
+            voucher,
            &coconut_api_client.api_client,
            &coconut_api_client.verification_key,
        )
@@ -136,6 +116,9 @@ pub async fn obtain_aggregate_signature(
        return Err(Error::NotEnoughShares);
    }

+    let public_attributes = voucher.get_public_attributes();
+    let private_attributes = voucher.get_private_attributes();
+
    let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
    attributes.extend_from_slice(&private_attributes);
    attributes.extend_from_slice(&public_attributes);
@@ -150,8 +133,8 @@ pub fn prepare_credential_for_spending(
    params: &Parameters,
    voucher_value: u64,
    voucher_info: String,
-    serial_number: Attribute,
-    binding_number: Attribute,
+    serial_number: &Attribute,
+    binding_number: &Attribute,
    epoch_id: u64,
    signature: &Signature,
    verification_key: &VerificationKey,
@@ -165,7 +148,7 @@ pub fn prepare_credential_for_spending(
    )?;

    Ok(Credential::new(
-        PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES,
+        BandwidthVoucher::ENCODED_ATTRIBUTES,
        theta,
        voucher_value,
        voucher_info,
@@ -201,6 +201,17 @@ impl<'a> From<&'a PrivateKey> for PublicKey {
 }

 impl PrivateKey {
+    #[cfg(feature = "rand")]
+    pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
+        let x25519_secret = x25519_dalek::StaticSecret::new(rng);
+
+        PrivateKey(x25519_secret)
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        self.into()
+    }
+
    pub fn to_bytes(&self) -> [u8; PRIVATE_KEY_SIZE] {
        self.0.to_bytes()
    }
@@ -5,13 +5,14 @@ pub use ed25519_dalek::ed25519::signature::Signature as SignatureTrait;
 pub use ed25519_dalek::SignatureError;
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
-#[cfg(feature = "sphinx")]
-use nym_sphinx_types::{DestinationAddressBytes, DESTINATION_ADDRESS_LENGTH};
 use std::fmt::{self, Display, Formatter};
 use std::str::FromStr;
 use thiserror::Error;
 use zeroize::{Zeroize, ZeroizeOnDrop};

+#[cfg(feature = "sphinx")]
+use nym_sphinx_types::{DestinationAddressBytes, DESTINATION_ADDRESS_LENGTH};
+
 #[cfg(feature = "rand")]
 use rand::{CryptoRng, RngCore};
 #[cfg(feature = "serde")]
@@ -224,6 +225,17 @@ impl<'a> From<&'a PrivateKey> for PublicKey {
 }

 impl PrivateKey {
+    #[cfg(feature = "rand")]
+    pub fn new<R: RngCore + CryptoRng>(rng: &mut R) -> Self {
+        let ed25519_secret = ed25519_dalek::SecretKey::generate(rng);
+
+        PrivateKey(ed25519_secret)
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        self.into()
+    }
+
    pub fn to_bytes(&self) -> [u8; SECRET_KEY_LENGTH] {
        self.0.to_bytes()
    }
@@ -295,7 +307,7 @@ impl PemStorableKey for PrivateKey {
    }
 }

-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub struct Signature(ed25519_dalek::Signature);

 impl Signature {
@@ -319,6 +331,14 @@ impl Signature {
    }
 }

+impl FromStr for Signature {
+    type Err = Ed25519RecoveryError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Signature::from_base58_string(s)
+    }
+}
+
 #[cfg(feature = "serde")]
 impl Serialize for Signature {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -3,6 +3,7 @@ name = "nym-dkg"
 version = "0.1.0"
 edition = "2021"
 resolver = "2"
+license.workspace = true

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

@@ -11,7 +12,7 @@ bitvec = "1.0.0"

 # unfortunately until https://github.com/zkcrypto/bls12_381/issues/10 is resolved, we have to rely on the fork
 # as we need to be able to serialize Gt so that we could create the lookup table for baby-step-giant-step algorithm
-bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch ="gt-serialisation", default-features = false, features = ["alloc", "pairings", "experimental", "zeroize"] }
+bls12_381 = { workspace = true, default-features = false, features = ["alloc", "pairings", "experimental", "zeroize"] }
 nym-contracts-common = { path = "../cosmwasm-smart-contracts/contracts-common", optional = true }
 bs58 = "0.4"

@@ -29,11 +30,11 @@ zeroize = { workspace = true, features = ["zeroize_derive"] }
 nym-pemstore = { path = "../pemstore" }

 [dependencies.group]
-version = "0.11"
+workspace = true
 default-features = false

 [dependencies.ff]
-version = "0.11"
+workspace = true
 default-features = false

 [dev-dependencies]
@@ -14,8 +14,8 @@ use std::collections::HashMap;
 use std::ops::Neg;
 use zeroize::Zeroize;

-#[derive(Debug)]
-#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct Ciphertexts {
    pub rr: [G1Projective; NUM_CHUNKS],
    pub ss: [G1Projective; NUM_CHUNKS],
@@ -67,8 +67,8 @@ impl<'a> Instance<'a> {
    }
 }

-#[derive(Debug)]
-#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct ProofOfChunking {
    y0: G1Projective,
    bb: Vec<G1Projective>,
@@ -76,8 +76,8 @@ impl<'a> Instance<'a> {
    }
 }

-#[derive(Debug)]
-#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
+#[derive(Debug, Clone)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct ProofOfSecretSharing {
    ff: G1Projective,
    aa: G2Projective,
@@ -82,7 +82,7 @@ impl RecoveredVerificationKeys {
    }
 }

-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct Dealing {
    pub public_coefficients: PublicCoefficients,
@@ -2,6 +2,7 @@
 name = "nym-execute"
 version = "0.1.0"
 edition = "2021"
+license.workspace = true

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -20,7 +21,7 @@ tokio = { version = "1.24.1", features = [
    "net",
    "io-util",
 ] }
-tokio-util = { version = "0.7.4", features = ["codec"] }
+tokio-util = { workspace = true, features = ["codec"] }
 url = { workspace = true }
 thiserror = { workspace = true }

@@ -108,13 +108,13 @@ impl ConnectionHandler {
                    let reply_packet = match maybe_echo_packet {
                        Some(Ok(echo_packet)) => self.handle_echo_packet(echo_packet),
                        Some(Err(err)) => {
-                             error!(
+                             debug!(
                                "The socket connection got corrupted with error: {err}. Closing the socket",
                            );
                            return;
                        }
                        None => {
-                            error!("The socket connection got terminated by the remote!");
+                            debug!("The socket connection got terminated by the remote!");
                            return;
                        }
                    };
@@ -125,7 +125,7 @@ impl ConnectionHandler {
                        .write_all(reply_packet.to_bytes().as_ref())
                        .await
                    {
-                        error!(
+                        debug!(
                            "Failed to write reply packet back to the sender - {}. Closing the socket on our end",
                            err
                        );
@@ -111,6 +111,7 @@ impl NymNetworkDetails {
            .with_additional_validator_endpoint(ValidatorDetails::new(
                var(var_names::NYXD).expect("nyxd validator not set"),
                Some(var(var_names::NYM_API).expect("nym api not set")),
+                get_optional_env(var_names::NYXD_WEBSOCKET),
            ))
            .with_mixnet_contract(Some(
                var(var_names::MIXNET_CONTRACT_ADDRESS).expect("mixnet contract not set"),
@@ -340,6 +341,9 @@ impl DenomDetailsOwned {
 pub struct ValidatorDetails {
    // it is assumed those values are always valid since they're being provided in our defaults file
    pub nyxd_url: String,
+    //
+    pub websocket_url: Option<String>,
+
    // Right now api_url is optional as we are not running the api reliably on all validators
    // however, later on it should be a mandatory field
    pub api_url: Option<String>,
@@ -347,9 +351,10 @@ pub struct ValidatorDetails {
 }

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

 fn fix_deprecated_environmental_variables() {
@@ -3,6 +3,7 @@

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

 pub const NETWORK_NAME: &str = "mainnet";

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

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

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

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

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

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

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

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

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

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

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

 [dependencies]
-bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch ="gt-serialisation", default-features = false, features = ["pairings", "alloc", "experimental"] }
+bls12_381 = { workspace = true, default-features = false, features = ["pairings", "alloc", "experimental"] }
 itertools = "0.10"
 digest = "0.9"
 rand = "0.8"
@@ -16,16 +17,17 @@ serde = { workspace = true }
 serde_derive = "1.0"
 bs58 = "0.4.0"
 sha2 = "0.9"
+zeroize = { workspace = true, optional = true }

 nym-dkg = { path = "../dkg" }
 nym-pemstore = { path = "../pemstore" }

 [dependencies.ff]
-version = "0.11"
+workspace = true
 default-features = false

 [dependencies.group]
-version = "0.11"
+workspace = true
 default-features = false

 [dev-dependencies]
@@ -38,7 +40,9 @@ name = "benchmarks"
 harness = false

 [features]
+key-zeroize = ["zeroize", "bls12_381/zeroize"]
 default = []

+
 [target.'cfg(target_env = "wasm32-unknown-unknown")'.dependencies]
 getrandom = { version="0.2", features=["js"] }
@@ -7,7 +7,7 @@ use ff::Field;
 use group::{Curve, Group};
 use nym_coconut::{
    aggregate_signature_shares, aggregate_verification_keys, blind_sign, prepare_blind_sign,
-    prove_bandwidth_credential, setup, ttp_keygen, verify_credential,
+    prove_bandwidth_credential, random_scalars_refs, setup, ttp_keygen, verify_credential,
    verify_partial_blind_signature, Attribute, BlindedSignature, Parameters, Signature,
    SignatureShare, VerificationKey,
 };
@@ -66,8 +66,8 @@ fn unblind_and_aggregate(
    params: &Parameters,
    blinded_signatures: &[BlindedSignature],
    partial_verification_keys: &[VerificationKey],
-    private_attributes: &[Attribute],
-    public_attributes: &[Attribute],
+    private_attributes: &[&Attribute],
+    public_attributes: &[&Attribute],
    commitment_hash: &G1Projective,
    pedersen_commitments_openings: &[Scalar],
    verification_key: &VerificationKey,
@@ -78,7 +78,7 @@ fn unblind_and_aggregate(
        .zip(partial_verification_keys.iter())
        .map(|(signature, partial_verification_key)| {
            signature
-                .unblind(
+                .unblind_and_verify(
                    params,
                    partial_verification_key,
                    private_attributes,
@@ -171,10 +171,10 @@ fn bench_coconut(c: &mut Criterion) {

    let params = setup(case.num_public_attrs + case.num_private_attrs).unwrap();

-    let public_attributes = params.n_random_scalars(case.num_public_attrs as usize);
+    random_scalars_refs!(public_attributes, params, case.num_public_attrs as usize);
    let serial_number = params.random_scalar();
    let binding_number = params.random_scalar();
-    let private_attributes = vec![serial_number, binding_number];
+    let private_attributes = vec![&serial_number, &binding_number];

    // The prepare blind sign is performed by the user
    let (pedersen_commitments_openings, blind_sign_request) =
@@ -213,7 +213,7 @@ fn bench_coconut(c: &mut Criterion) {
            b.iter(|| {
                blind_sign(
                    &params,
-                    &keypair.secret_key(),
+                    keypair.secret_key(),
                    &blind_sign_request,
                    &public_attributes,
                )
@@ -228,7 +228,7 @@ fn bench_coconut(c: &mut Criterion) {
    for keypair in coconut_keypairs.iter() {
        let blinded_signature = blind_sign(
            &params,
-            &keypair.secret_key(),
+            keypair.secret_key(),
            &blind_sign_request,
            &public_attributes,
        )
@@ -238,7 +238,7 @@ fn bench_coconut(c: &mut Criterion) {

    let verification_keys: Vec<VerificationKey> = coconut_keypairs
        .iter()
-        .map(|keypair| keypair.verification_key())
+        .map(|keypair| keypair.verification_key().clone())
        .collect();

    // verify a random partial blind signature
@@ -255,7 +255,7 @@ fn bench_coconut(c: &mut Criterion) {
            b.iter(|| {
                verify_partial_blind_signature(
                    &params,
-                    &blind_sign_request,
+                    blind_sign_request.get_private_attributes_pedersen_commitments(),
                    &public_attributes,
                    random_blind_signature,
                    partial_verification_key,
@@ -310,8 +310,8 @@ fn bench_coconut(c: &mut Criterion) {
        &params,
        &aggr_verification_key,
        &aggregated_signature,
-        serial_number,
-        binding_number,
+        &serial_number,
+        &binding_number,
    )
    .unwrap();

@@ -329,8 +329,8 @@ fn bench_coconut(c: &mut Criterion) {
                    &params,
                    &aggr_verification_key,
                    &aggregated_signature,
-                    serial_number,
-                    binding_number,
+                    &serial_number,
+                    &binding_number,
                )
                .unwrap()
            })
@@ -34,7 +34,10 @@ impl TryFrom<&[u8]> for Ciphertext {
            )));
        }

+        // safety: we just checked for the length so the unwraps are fine
+        #[allow(clippy::unwrap_used)]
        let c1_bytes: &[u8; 48] = &bytes[..48].try_into().unwrap();
+        #[allow(clippy::unwrap_used)]
        let c2_bytes: &[u8; 48] = &bytes[48..].try_into().unwrap();

        let c1 = try_deserialize_g1_projective(
@@ -112,7 +115,16 @@ impl Bytable for PrivateKey {
    }

    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        PrivateKey::from_bytes(slice.try_into().unwrap())
+        let received = slice.len();
+        let Ok(arr) = slice.try_into() else {
+            return Err(CoconutError::UnexpectedArrayLength {
+                typ: "elgamal::PrivateKey".to_string(),
+                received,
+                expected: 32,
+            });
+        };
+
+        PrivateKey::from_bytes(arr)
    }
 }

@@ -145,21 +157,36 @@ impl PublicKey {
    }

    pub fn to_bytes(&self) -> [u8; 48] {
-        self.to_byte_vec().try_into().unwrap()
+        self.0.to_affine().to_compressed()
    }

    pub fn from_bytes(bytes: &[u8; 48]) -> Result<PublicKey> {
-        Ok(PublicKey::try_from(bytes.to_vec().as_slice()).unwrap())
+        try_deserialize_g1_projective(
+            bytes,
+            CoconutError::Deserialization(
+                "Failed to deserialize compressed ElGamal public key".to_string(),
+            ),
+        )
+        .map(PublicKey)
    }
 }

 impl Bytable for PublicKey {
    fn to_byte_vec(&self) -> Vec<u8> {
-        self.0.to_affine().to_compressed().into()
+        self.to_bytes().into()
    }

    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        Ok(PublicKey::from_bytes(slice.try_into().unwrap()).unwrap())
+        let received = slice.len();
+        let Ok(arr) = slice.try_into() else {
+            return Err(CoconutError::UnexpectedArrayLength {
+                typ: "elgamal::PublicKey".to_string(),
+                received,
+                expected: 48,
+            });
+        };
+
+        PublicKey::from_bytes(arr)
    }
 }

@@ -167,13 +194,7 @@ impl TryFrom<&[u8]> for PublicKey {
    type Error = CoconutError;

    fn try_from(slice: &[u8]) -> Result<PublicKey> {
-        try_deserialize_g1_projective(
-            slice.try_into().unwrap(),
-            CoconutError::Deserialization(
-                "Failed to deserialize compressed ElGamal public key".to_string(),
-            ),
-        )
-        .map(PublicKey)
+        PublicKey::try_from_byte_slice(slice)
    }
 }

@@ -225,7 +246,7 @@ pub fn elgamal_keygen(params: &Parameters) -> ElGamalKeyPair {

 pub fn compute_attribute_encryption(
    params: &Parameters,
-    private_attributes: &[Attribute],
+    private_attributes: &[&Attribute],
    pub_key: &PublicKey,
    commitment_hash: G1Projective,
 ) -> (Vec<Ciphertext>, Vec<EphemeralKey>) {
@@ -50,4 +50,20 @@ pub enum CoconutError {
        modulus: usize,
        object: String,
    },
+
+    #[error("received an array of unexpected size for deserialization of {typ}. got {received} but expected {expected}")]
+    UnexpectedArrayLength {
+        typ: String,
+        received: usize,
+        expected: usize,
+    },
+
+    #[error("failed to decode the base58 representation: {0}")]
+    Base58DecodingFailure(#[from] bs58::decode::Error),
+
+    #[error("failed to deserialize scalar from the received bytes - it might not have been canonically encoded")]
+    ScalarDeserializationFailure,
+
+    #[error("failed to deserialize G1Projective point from the received bytes - it might not have been canonically encoded")]
+    G1ProjectiveDeserializationFailure,
 }
@@ -1,11 +1,9 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::convert::TryInto;
+#![warn(clippy::expect_used)]
+#![warn(clippy::unwrap_used)]

-use bls12_381::Scalar;
-
-pub use crate::traits::Bytable;
 pub use elgamal::elgamal_keygen;
 pub use elgamal::ElGamalKeyPair;
 pub use elgamal::PublicKey;
@@ -30,6 +28,7 @@ pub use scheme::BlindedSignature;
 pub use scheme::Signature;
 pub use scheme::SignatureShare;
 pub use traits::Base58;
+pub use traits::Bytable;
 pub use utils::hash_to_scalar;

 pub mod elgamal;
@@ -41,18 +40,8 @@ pub mod tests;
 mod traits;
 mod utils;

-pub type Attribute = Scalar;
+pub type Attribute = bls12_381::Scalar;
 pub type PrivateAttribute = Attribute;
 pub type PublicAttribute = Attribute;

-impl Bytable for Attribute {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes().to_vec()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CoconutError> {
-        Ok(Attribute::from_bytes(slice.try_into().unwrap()).unwrap())
-    }
-}
-
-impl Base58 for Attribute {}
+pub use bls12_381::G1Projective;
@@ -91,8 +91,8 @@ impl ProofCmCs {
        commitment_opening: &Scalar,
        commitments: &[G1Projective],
        pedersen_commitments_openings: &[Scalar],
-        private_attributes: &[Attribute],
-        public_attributes: &[Attribute],
+        private_attributes: &[&Attribute],
+        public_attributes: &[&Attribute],
    ) -> Self {
        // note: this is only called from `prepare_blind_sign` that already checks
        // whether private attributes are non-empty and whether we don't have too many
@@ -162,11 +162,8 @@ impl ProofCmCs {
            &challenge,
            &pedersen_commitments_openings.iter().collect::<Vec<_>>(),
        );
-        let response_attributes = produce_responses(
-            &witness_attributes,
-            &challenge,
-            &private_attributes.iter().collect::<Vec<_>>(),
-        );
+        let response_attributes =
+            produce_responses(&witness_attributes, &challenge, private_attributes);

        ProofCmCs {
            challenge,
@@ -181,7 +178,7 @@ impl ProofCmCs {
        params: &Parameters,
        commitment: &G1Projective,
        commitments: &[G1Projective],
-        public_attributes: &[Attribute],
+        public_attributes: &[&Attribute],
    ) -> bool {
        if self.response_attributes.len() != commitments.len() {
            return false;
@@ -203,7 +200,7 @@ impl ProofCmCs {
            - public_attributes
                .iter()
                .zip(params.gen_hs().iter().skip(self.response_attributes.len()))
-                .map(|(pub_attr, hs)| hs * pub_attr)
+                .map(|(&pub_attr, hs)| hs * pub_attr)
                .sum::<G1Projective>())
            * self.challenge
            + g1 * self.response_opening
@@ -280,8 +277,12 @@ impl ProofCmCs {
        }

        let mut idx = 0;
+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let challenge_bytes = bytes[idx..idx + 32].try_into().unwrap();
        idx += 32;
+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let response_opening_bytes = bytes[idx..idx + 32].try_into().unwrap();
        idx += 32;

@@ -297,6 +298,8 @@ impl ProofCmCs {
            ),
        )?;

+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let ro_len = u64::from_le_bytes(bytes[idx..idx + 8].try_into().unwrap());
        idx += 8;
        if bytes[idx..].len() < ro_len as usize * 32 + 8 {
@@ -313,6 +316,8 @@ impl ProofCmCs {
            CoconutError::Deserialization("Failed to deserialize openings response".to_string()),
        )?;

+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let rm_len = u64::from_le_bytes(bytes[ro_end..ro_end + 8].try_into().unwrap());
        let response_attributes = try_deserialize_scalar_vec(
            rm_len,
@@ -462,7 +467,7 @@ impl ProofKappaZeta {

    pub(crate) fn from_bytes(bytes: &[u8]) -> Result<Self> {
        // at the very minimum there must be a single attribute being proven
-        if bytes.len() < 32 * 4 || (bytes.len()) % 32 != 0 {
+        if bytes.len() != 128 {
            return Err(CoconutError::DeserializationInvalidLength {
                actual: bytes.len(),
                modulus_target: bytes.len(),
@@ -472,24 +477,32 @@ impl ProofKappaZeta {
            });
        }

+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let challenge_bytes = bytes[..32].try_into().unwrap();
        let challenge = try_deserialize_scalar(
            &challenge_bytes,
            CoconutError::Deserialization("Failed to deserialize challenge".to_string()),
        )?;

+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let serial_number_bytes = &bytes[32..64].try_into().unwrap();
        let response_serial_number = try_deserialize_scalar(
            serial_number_bytes,
            CoconutError::Deserialization("failed to deserialize the serial number".to_string()),
        )?;

+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let binding_number_bytes = &bytes[64..96].try_into().unwrap();
        let response_binding_number = try_deserialize_scalar(
            binding_number_bytes,
            CoconutError::Deserialization("failed to deserialize the binding number".to_string()),
        )?;

+        // safety: bound checked + constant offset
+        #[allow(clippy::unwrap_used)]
        let blinder_bytes = bytes[96..].try_into().unwrap();
        let response_blinder = try_deserialize_scalar(
            &blinder_bytes,
@@ -512,14 +525,13 @@ impl ProofKappaZeta {

 #[cfg(test)]
 mod tests {
-    use group::Group;
-    use rand::thread_rng;
-
+    use super::*;
    use crate::scheme::keygen::keygen;
    use crate::scheme::setup::setup;
    use crate::scheme::verification::{compute_kappa, compute_zeta};
-
-    use super::*;
+    use crate::tests::helpers::random_scalars_refs;
+    use group::Group;
+    use rand::thread_rng;

    #[test]
    fn proof_cm_cs_bytes_roundtrip() {
@@ -530,7 +542,7 @@ mod tests {
        let r = params.random_scalar();
        let cms: [G1Projective; 1] = [G1Projective::random(&mut rng)];
        let rs = params.n_random_scalars(1);
-        let private_attributes = params.n_random_scalars(1);
+        random_scalars_refs!(private_attributes, params, 1);

        // 0 public 1 private
        let pi_s = ProofCmCs::construct(&params, &cm, &r, &cms, &rs, &private_attributes, &[]);
@@ -546,7 +558,7 @@ mod tests {
            G1Projective::random(&mut rng),
        ];
        let rs = params.n_random_scalars(2);
-        let private_attributes = params.n_random_scalars(2);
+        random_scalars_refs!(private_attributes, params, 2);

        // 0 public 2 privates
        let pi_s = ProofCmCs::construct(&params, &cm, &r, &cms, &rs, &private_attributes, &[]);
@@ -562,20 +574,20 @@ mod tests {
        let keypair = keygen(&params);

        // we don't care about 'correctness' of the proof. only whether we can correctly recover it from bytes
-        let serial_number = params.random_scalar();
-        let binding_number = params.random_scalar();
+        let serial_number = &params.random_scalar();
+        let binding_number = &params.random_scalar();
        let private_attributes = vec![serial_number, binding_number];

        let r = params.random_scalar();
-        let kappa = compute_kappa(&params, &keypair.verification_key(), &private_attributes, r);
+        let kappa = compute_kappa(&params, keypair.verification_key(), &private_attributes, r);
        let zeta = compute_zeta(&params, serial_number);

        // 0 public 2 private
        let pi_v = ProofKappaZeta::construct(
            &params,
-            &keypair.verification_key(),
-            &serial_number,
-            &binding_number,
+            keypair.verification_key(),
+            serial_number,
+            binding_number,
            &r,
            &kappa,
            &zeta,
@@ -592,9 +604,9 @@ mod tests {

        let pi_v = ProofKappaZeta::construct(
            &params,
-            &keypair.verification_key(),
-            &serial_number,
-            &binding_number,
+            keypair.verification_key(),
+            serial_number,
+            binding_number,
            &r,
            &kappa,
            &zeta,
@@ -83,7 +83,7 @@ pub fn aggregate_verification_keys(
 pub fn aggregate_signatures(
    params: &Parameters,
    verification_key: &VerificationKey,
-    attributes: &[Attribute],
+    attributes: &[&Attribute],
    signatures: &[PartialSignature],
    indices: Option<&[SignerIndex]>,
 ) -> Result<Signature> {
@@ -100,7 +100,7 @@ pub fn aggregate_signatures(
    let tmp = attributes
        .iter()
        .zip(verification_key.beta_g2.iter())
-        .map(|(attr, beta_i)| beta_i * attr)
+        .map(|(&attr, beta_i)| beta_i * attr)
        .sum::<G2Projective>();

    if !check_bilinear_pairing(
@@ -119,7 +119,7 @@ pub fn aggregate_signatures(
 pub fn aggregate_signature_shares(
    params: &Parameters,
    verification_key: &VerificationKey,
-    attributes: &[Attribute],
+    attributes: &[&Attribute],
    shares: &[SignatureShare],
 ) -> Result<Signature> {
    let (signatures, indices): (Vec<_>, Vec<_>) = shares
@@ -138,13 +138,13 @@ pub fn aggregate_signature_shares(

 #[cfg(test)]
 mod tests {
-    use bls12_381::G1Projective;
-    use group::Group;
-
    use crate::scheme::issuance::sign;
    use crate::scheme::keygen::ttp_keygen;
    use crate::scheme::setup::Parameters;
    use crate::scheme::verification::verify;
+    use crate::tests::helpers::random_scalars_refs;
+    use bls12_381::G1Projective;
+    use group::Group;

    use super::*;

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

        let vks = keypairs
            .into_iter()
-            .map(|keypair| keypair.verification_key())
+            .map(|keypair| keypair.verification_key().clone())
            .collect::<Vec<_>>();

        let aggr_vk1 = aggregate_verification_keys(&vks[..3], Some(&[1, 2, 3])).unwrap();
@@ -212,13 +212,18 @@ mod tests {
    #[test]
    fn signature_aggregation_works_for_any_subset_of_signatures() {
        let mut params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
+        random_scalars_refs!(attributes, params, 2);

        let keypairs = ttp_keygen(&params, 3, 5).unwrap();

        let (sks, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
+            .map(|keypair| {
+                (
+                    keypair.secret_key().clone(),
+                    keypair.verification_key().clone(),
+                )
+            })
            .unzip();

        let sigs = sks
@@ -312,12 +317,17 @@ mod tests {
    fn signature_aggregation_doesnt_work_for_empty_set_of_signatures() {
        let signatures: Vec<Signature> = vec![];
        let params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
+        random_scalars_refs!(attributes, params, 2);
        let keypairs = ttp_keygen(&params, 3, 5).unwrap();

        let (_, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
+            .map(|keypair| {
+                (
+                    keypair.secret_key().clone(),
+                    keypair.verification_key().clone(),
+                )
+            })
            .unzip();

        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
@@ -330,11 +340,16 @@ mod tests {
    fn signature_aggregation_doesnt_work_if_indices_have_invalid_length() {
        let signatures = vec![random_signature()];
        let params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
+        random_scalars_refs!(attributes, params, 2);
        let keypairs = ttp_keygen(&params, 3, 5).unwrap();
        let (_, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
+            .map(|keypair| {
+                (
+                    keypair.secret_key().clone(),
+                    keypair.verification_key().clone(),
+                )
+            })
            .unzip();
        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();

@@ -356,11 +371,16 @@ mod tests {
    fn signature_aggregation_doesnt_work_for_non_unique_indices() {
        let signatures = vec![random_signature(), random_signature()];
        let params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
+        random_scalars_refs!(attributes, params, 2);
        let keypairs = ttp_keygen(&params, 3, 5).unwrap();
        let (_, vks): (Vec<_>, Vec<_>) = keypairs
            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
+            .map(|keypair| {
+                (
+                    keypair.secret_key().clone(),
+                    keypair.verification_key().clone(),
+                )
+            })
            .unzip();
        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();

--- a/Show More
+++ b/Show More