add cargo install mdbook-cmdrun

.github/actions/nym-hash-releases/create-hashes.mjs

@@ -3,27 +3,8 @@ import fetch from "node-fetch";
 import { Octokit } from "@octokit/rest";
 import fs from "fs";
 import path from "path";
-import { execSync } from "child_process";
-
-function getBinInfo(path) {
-    // let's be super naive about it. add a+x bits on the file and try to run the command
-    try {
-        let mode = fs.statSync(path).mode
-        fs.chmodSync(path, mode | 0o111)
-
-        const raw = execSync(`${path} build-info --output=json`, { stdio: 'pipe', encoding: "utf8" });
-        const parsed = JSON.parse(raw)
-        return parsed
-    } catch (_) {
-        return undefined
-    }
-}
 
 async function run(assets, algorithm, filename, cache) {
-    if (!cache) {
-        console.warn("cache is set to 'false', but we we no longer support it")
-    }
-
     try {
         fs.mkdirSync('.tmp');
     } catch(e) {
@@ -38,25 +19,26 @@ async function run(assets, algorithm, filename, cache) {
 
             let buffer = null;
             let sig = null;
+            if(cache) {
+                // cache in `${WORKING_DIR}/.tmp/`
+                const cacheFilename = path.resolve(`.tmp/${asset.name}`);
+                if(!fs.existsSync(cacheFilename)) {
+                    console.log(`Downloading ${asset.browser_download_url}... to ${cacheFilename}`);
+                    buffer = Buffer.from(await fetch(asset.browser_download_url).then(res => res.arrayBuffer()));
+                    fs.writeFileSync(cacheFilename, buffer);
+                } else {
+                    console.log(`Loading from ${cacheFilename}`);
+                    buffer = Buffer.from(fs.readFileSync(cacheFilename));
 
-            // cache in `${WORKING_DIR}/.tmp/`
-            const cacheFilename = path.resolve(`.tmp/${asset.name}`);
-            if(!fs.existsSync(cacheFilename)) {
-                console.log(`Downloading ${asset.browser_download_url}... to ${cacheFilename}`);
-                buffer = Buffer.from(await fetch(asset.browser_download_url).then(res => res.arrayBuffer()));
-                fs.writeFileSync(cacheFilename, buffer);
+                    // console.log('Reading signature from content');
+                    // if(asset.name.endsWith('.sig')) {
+                    //     sig = fs.readFileSync(cacheFilename).toString();
+                    // }
+                }
             } else {
-                console.log(`Loading from ${cacheFilename}`);
-                buffer = Buffer.from(fs.readFileSync(cacheFilename));
-
-                // console.log('Reading signature from content');
-                // if(asset.name.endsWith('.sig')) {
-                //     sig = fs.readFileSync(cacheFilename).toString();
-                // }
+                // fetch always
+                buffer = Buffer.from(await fetch(asset.browser_download_url).then(res => res.arrayBuffer()));
             }
-
-            const binInfo = getBinInfo(cacheFilename)
-
             if(!hashes[asset.name]) {
                 hashes[asset.name] = {};
             }
@@ -117,9 +99,6 @@ async function run(assets, algorithm, filename, cache) {
             if(kind) {
                 hashes[asset.name].kind = kind;
             }
-            if(binInfo) {
-                hashes[asset.name].details = binInfo;
-            }
 
             // process Tauri signature files
             if(asset.name.endsWith('.sig')) {
@@ -246,8 +225,6 @@ export async function createHashesFromReleaseTagOrNameOrId({ releaseTagOrNameOrI
             assets: hashes,
         };
 
-        console.log(output)
-
         if(upload) {
             console.log(`🚚 Uploading ${filename} to release name="${release.name}" id=${release.id} (${release.upload_url})...`);
 

.github/workflows/ci-cargo-deny.yml

@@ -1,21 +0,0 @@
-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

.github/workflows/ci-nym-api-tests.yml

@@ -17,9 +17,6 @@ jobs:
     steps:
       - uses: actions/checkout@v2
 
-      - name: install yarn in root
-        run: cd ../.. yarn install
-
       - name: Install npm
         run: npm install
 

.gitignore

@@ -9,7 +9,6 @@
 target
 .env
 .env.dev
-envs/devnet.env
 /.vscode/settings.json
 validator/.vscode
 sample-configs/validator-config.toml

Cargo.toml

@@ -67,7 +67,6 @@ members = [
     "common/nymsphinx/params",
     "common/nymsphinx/routing",
     "common/nymsphinx/types",
-    "common/nyxd-scraper",
     "common/pemstore",
     "common/socks5-client-core",
     "common/socks5/proxy-helpers",
@@ -102,12 +101,10 @@ 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",
     "tools/nym-nr-query",
-    "tools/nymvisor",
     "tools/ts-rs-cli",
     "wasm/client",
 #    "wasm/full-nym-wasm",
@@ -123,9 +120,7 @@ default-members = [
     "service-providers/network-statistics",
     "mixnode",
     "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"]
@@ -162,12 +157,9 @@ 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.33.0"
-tokio-util = "0.7.10"
+tokio = "1.24.1"
 tokio-tungstenite = "0.20.1"
 tracing = "0.1.37"
 tungstenite = { version = "0.20.1", default-features = false }
@@ -177,14 +169,6 @@ 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"
@@ -203,11 +187,7 @@ cw-controllers = { version = "=1.1.0" }
 
 # cosmrs-related
 bip32 = "0.5.1"
-
-# temporarily using a fork again (yay.) because we need staking and slashing support
-cosmrs = { git = "https://github.com/jstuczyn/cosmos-rust", branch ="nym-temp/all-validator-features" }
-#cosmrs = {  git = "https://github.com/jstuczyn/cosmos-rust", branch = "nym-temp/all-validator-features" } # unfortuntely we need a fork by yours truly to get the staking support
-tendermint = "0.34" # same version as used by cosmrs
+cosmrs = "=0.15.0"
 tendermint-rpc = "0.34" # same version as used by cosmrs
 prost = "0.12"
 

LICENSES/gpl-3.0

@@ -1,675 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means tocopy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
- 

about.hbs

@@ -1,70 +0,0 @@
-<html>
-
-<head>
-    <style>
-        @media (prefers-color-scheme: dark) {
-            body {
-                background: #333;
-                color: white;
-            }
-            a {
-                color: skyblue;
-            }
-        }
-        .container {
-            font-family: sans-serif;
-            max-width: 800px;
-            margin: 0 auto;
-        }
-        .intro {
-            text-align: center;
-        }
-        .licenses-list {
-            list-style-type: none;
-            margin: 0;
-            padding: 0;
-        }
-        .license-used-by {
-            margin-top: -10px;
-        }
-        .license-text {
-            max-height: 200px;
-            overflow-y: scroll;
-            white-space: pre-wrap;
-        }
-    </style>
-</head>
-
-<body>
-    <main class="container">
-        <div class="intro">
-            <h1>Third Party Licenses</h1>
-            <p>This page lists the licenses of the projects used in cargo-about.</p>
-        </div>
-    
-        <h2>Overview of licenses:</h2>
-        <ul class="licenses-overview">
-            {{#each overview}}
-            <li><a href="#{{id}}">{{name}}</a> ({{count}})</li>
-            {{/each}}
-        </ul>
-
-        <h2>All license text:</h2>
-        <ul class="licenses-list">
-            {{#each licenses}}
-            <li class="license">
-                <h3 id="{{id}}">{{name}}</h3>
-                <h4>Used by:</h4>
-                <ul class="license-used-by">
-                    {{#each used_by}}
-                    <li><a href="{{#if crate.repository}} {{crate.repository}} {{else}} https://crates.io/crates/{{crate.name}} {{/if}}">{{crate.name}} {{crate.version}}</a></li>
-                    {{/each}}
-                </ul>
-                <pre class="license-text">{{text}}</pre>
-            </li>
-            {{/each}}
-        </ul>
-    </main>
-</body>
-
-</html>

about.toml

@@ -1,19 +0,0 @@
-private = { ignore = true }
-
-accepted = [
-    "0BSD",
-    "Apache-2.0",
-    "BSD-2-Clause",
-    "BSD-3-Clause",
-    "CC0-1.0",
-    "ISC",
-    "MIT",
-    "MPL-2.0",
-    "Unicode-DFS-2016",
-    "OpenSSL",
-]
-
-workarounds = [
-    "ring",
-    "rustls",
-]

clients/native/Cargo.toml

@@ -5,7 +5,6 @@ authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej St
 description = "Implementation of the Nym Client"
 edition = "2021"
 rust-version = "1.65"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

clients/native/examples/js-examples/websocket/package-lock.json

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

clients/native/websocket-requests/Cargo.toml

@@ -3,7 +3,6 @@ name = "nym-client-websocket-requests"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

clients/socks5/Cargo.toml

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

common/api-test-utils/index.ts

@@ -1,4 +0,0 @@
-module.exports = {
-    ConfigHandler: require('./config/configHandler.ts'),
-    RestClient: require('./restClient/RestClient.ts')
-  };

common/async-file-watcher/Cargo.toml

@@ -2,7 +2,6 @@
 name = "async-file-watcher"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

common/async-file-watcher/src/lib.rs

@@ -10,8 +10,6 @@ use std::path::{Path, PathBuf};
 use std::time::Duration;
 use tokio::time::Instant;
 
-pub use notify::{Error as NotifyError, Result as NotifyResult};
-
 pub type FileWatcherEventSender = mpsc::UnboundedSender<Event>;
 pub type FileWatcherEventReceiver = mpsc::UnboundedReceiver<Event>;
 
@@ -24,7 +22,7 @@ pub struct AsyncFileWatcher {
     last_received: HashMap<EventKind, Instant>,
     tick_duration: Duration,
 
-    inner_rx: mpsc::UnboundedReceiver<NotifyResult<Event>>,
+    inner_rx: mpsc::UnboundedReceiver<notify::Result<Event>>,
     event_sender: FileWatcherEventSender,
 }
 
@@ -32,7 +30,7 @@ impl AsyncFileWatcher {
     pub fn new_file_changes_watcher<P: AsRef<Path>>(
         path: P,
         event_sender: FileWatcherEventSender,
-    ) -> NotifyResult<Self> {
+    ) -> notify::Result<Self> {
         Self::new(
             path,
             event_sender,
@@ -50,7 +48,7 @@ impl AsyncFileWatcher {
         event_sender: FileWatcherEventSender,
         filters: Option<Vec<EventKind>>,
         tick_duration: Option<Duration>,
-    ) -> NotifyResult<Self> {
+    ) -> notify::Result<Self> {
         let watcher_config = Config::default();
         let (inner_tx, inner_rx) = mpsc::unbounded();
         let watcher = RecommendedWatcher::new(
@@ -114,17 +112,17 @@ impl AsyncFileWatcher {
         false
     }
 
-    fn start_watching(&mut self) -> NotifyResult<()> {
+    fn start_watching(&mut self) -> notify::Result<()> {
         self.is_watching = true;
         self.watcher.watch(&self.path, RecursiveMode::NonRecursive)
     }
 
-    fn stop_watching(&mut self) -> NotifyResult<()> {
+    fn stop_watching(&mut self) -> notify::Result<()> {
         self.is_watching = false;
         self.watcher.unwatch(&self.path)
     }
 
-    pub async fn watch(&mut self) -> NotifyResult<()> {
+    pub async fn watch(&mut self) -> notify::Result<()> {
         self.start_watching()?;
 
         while let Some(event) = self.inner_rx.next().await {

common/bandwidth-controller/Cargo.toml

@@ -2,7 +2,6 @@
 name = "nym-bandwidth-controller"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -11,7 +10,6 @@ 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" }

common/bandwidth-controller/src/acquire/mod.rs

@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::error::BandwidthControllerError;
-use nym_coconut_interface::Base58;
+use nym_coconut_interface::{Base58, Parameters};
 use nym_credential_storage::storage::Storage;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use nym_credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 use nym_credentials::coconut::utils::obtain_aggregate_signature;
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_network_defaults::VOUCHER_INFO;
@@ -12,8 +12,10 @@ 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::State;
+use state::{KeyPair, State};
+use std::str::FromStr;
 
 pub mod state;
 
@@ -22,29 +24,30 @@ where
     C: CoconutBandwidthSigningClient + Sync,
 {
     let mut rng = OsRng;
-    let signing_key = identity::PrivateKey::new(&mut rng);
-    let encryption_key = encryption::PrivateKey::new(&mut rng);
-    let params = BandwidthVoucher::default_parameters();
+    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 voucher_value = amount.amount.to_string();
 
     let tx_hash = client
         .deposit(
             amount,
             String::from(VOUCHER_INFO),
-            signing_key.public_key().to_base58_string(),
-            encryption_key.public_key().to_base58_string(),
+            signing_keypair.public_key.clone(),
+            encryption_keypair.public_key.clone(),
             None,
         )
         .await?
-        .transaction_hash;
+        .transaction_hash
+        .to_string();
 
     let voucher = BandwidthVoucher::new(
         &params,
         voucher_value,
         VOUCHER_INFO.to_string(),
-        tx_hash,
-        signing_key,
-        encryption_key,
+        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)?,
     );
 
     let state = State { voucher, params };

common/bandwidth-controller/src/acquire/state.rs

@@ -2,7 +2,32 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use nym_coconut_interface::Parameters;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+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(),
+        }
+    }
+}
 
 pub struct State {
     pub voucher: BandwidthVoucher,
@@ -13,7 +38,7 @@ impl State {
     pub fn new(voucher: BandwidthVoucher) -> Self {
         State {
             voucher,
-            params: BandwidthVoucher::default_parameters(),
+            params: Parameters::new(TOTAL_ATTRIBUTES).unwrap(),
         }
     }
 }

common/bandwidth-controller/src/lib.rs

@@ -7,7 +7,6 @@ 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::{
@@ -47,12 +46,10 @@ 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 = 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 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 signature =
             nym_coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;
         let epoch_id = u64::from_str(&bandwidth_credential.epoch_id)
@@ -67,8 +64,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,

common/bin-common/Cargo.toml

@@ -35,10 +35,9 @@ opentelemetry = { version = "0.19.0", optional = true, features = ["rt-tokio"] }
 
 
 [build-dependencies]
-vergen = { version = "=8.2.6", default-features = false, features = [
+vergen = { version = "=7.4.3", default-features = false, features = [
     "build",
     "git",
-    "gitcl",
     "rustc",
     "cargo",
 ] }
@@ -48,9 +47,8 @@ default = []
 openapi = ["utoipa"]
 output_format = ["serde_json"]
 bin_info_schema = ["schemars"]
-basic_tracing = ["tracing-subscriber"]
 tracing = [
-    "basic_tracing",
+    "tracing-subscriber",
     "tracing-tree",
     "opentelemetry-jaeger",
     "tracing-opentelemetry",

common/bin-common/build.rs

@@ -1,14 +1,13 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use vergen::EmitBuilder;
+use vergen::{vergen, Config};
 
 fn main() {
-    EmitBuilder::builder()
-        .all_build()
-        .all_git()
-        .all_rustc()
-        .all_cargo()
-        .emit()
-        .expect("failed to extract build metadata");
+    let mut config = Config::default();
+    if std::env::var("DOCS_RS").is_ok() {
+        // If we don't have access to git information, such as in a docs.rs build, don't error
+        *config.git_mut().skip_if_error_mut() = true;
+    }
+    vergen(config).expect("failed to extract build metadata");
 }

common/bin-common/src/build_information/mod.rs

@@ -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_DEBUG
-    /// Provides the cargo debug mode that was used for the build.
-    pub cargo_debug: &'static str,
+    // VERGEN_CARGO_PROFILE
+    /// Provides the cargo profile that was used for the build, for example `debug`.
+    pub cargo_profile: &'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_debug: env!("VERGEN_CARGO_DEBUG"),
+            cargo_profile: env!("VERGEN_CARGO_PROFILE"),
         }
     }
 
@@ -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_debug: self.cargo_debug.to_owned(),
+            cargo_profile: self.cargo_profile.to_owned(),
         }
     }
 
@@ -80,7 +80,7 @@ impl BinaryBuildInformation {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[cfg_attr(feature = "bin_info_schema", derive(schemars::JsonSchema))]
 pub struct BinaryBuildInformationOwned {
@@ -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_DEBUG
-    /// Provides the cargo debug mode that was used for the build.
-    pub cargo_debug: String,
+    // VERGEN_CARGO_PROFILE
+    /// Provides the cargo profile that was used for the build, for example `debug`.
+    pub cargo_profile: String,
 }
 
 impl Display for BinaryBuildInformationOwned {
@@ -151,8 +151,8 @@ impl Display for BinaryBuildInformationOwned {
             self.rustc_version,
             "rustc Channel:",
             self.rustc_channel,
-            "cargo Debug:",
-            self.cargo_debug,
+            "cargo Profile:",
+            self.cargo_profile,
         )
     }
 }

common/bin-common/src/logging/mod.rs

@@ -43,30 +43,6 @@ pub fn setup_logging() {
         .init();
 }
 
-#[cfg(feature = "basic_tracing")]
-pub fn setup_tracing_logger() {
-    let log_builder = tracing_subscriber::fmt()
-        // Use a more compact, abbreviated log format
-        .compact()
-        // Display source code file paths
-        .with_file(true)
-        // Display source code line numbers
-        .with_line_number(true)
-        // Don't display the event's target (module path)
-        .with_target(false);
-
-    if ::std::env::var("RUST_LOG").is_ok() {
-        log_builder
-            .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
-            .init()
-    } else {
-        // default to 'Info
-        log_builder
-            .with_max_level(tracing_subscriber::filter::LevelFilter::INFO)
-            .init()
-    }
-}
-
 // TODO: This has to be a macro, running it as a function does not work for the file_appender for some reason
 #[cfg(feature = "tracing")]
 #[macro_export]

common/client-core/Cargo.toml

@@ -4,7 +4,6 @@ version = "1.1.15"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -59,7 +58,7 @@ features = ["time"]
 version = "0.20.1"
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
-workspace = true
+version = "0.6.2"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
 optional = true
 
@@ -90,7 +89,7 @@ tempfile = "3.1.0"
 
 [build-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
+sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
 
 [features]
 default = []

common/client-core/src/client/helpers/wasm.rs

@@ -1,8 +1,6 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-#![allow(unused_imports)]
-
 use std::time::Duration;
 
 pub use wasmtimer::{std::Instant, tokio::*};

common/client-core/src/client/inbound_messages.rs

@@ -28,7 +28,6 @@ pub enum InputMessage {
         recipient: Recipient,
         data: Vec<u8>,
         lane: TransmissionLane,
-        mix_hops: Option<u8>,
     },
 
     /// Creates a message used for a duplex anonymous communication where the recipient
@@ -44,7 +43,6 @@ pub enum InputMessage {
         data: Vec<u8>,
         reply_surbs: u32,
         lane: TransmissionLane,
-        mix_hops: Option<u8>,
     },
 
     /// Attempt to use our internally received and stored `ReplySurb` to send the message back
@@ -94,29 +92,6 @@ impl InputMessage {
             recipient,
             data,
             lane,
-            mix_hops: None,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
-        }
-    }
-
-    // IMHO `new_regular` should take `mix_hops: Option<u8>` as an argument instead of creating
-    // this function, but that would potentially break backwards compatibility with the current API
-    pub fn new_regular_with_custom_hops(
-        recipient: Recipient,
-        data: Vec<u8>,
-        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
-        mix_hops: Option<u8>,
-    ) -> Self {
-        let message = InputMessage::Regular {
-            recipient,
-            data,
-            lane,
-            mix_hops,
         };
         if let Some(packet_type) = packet_type {
             InputMessage::new_wrapper(message, packet_type)
@@ -137,31 +112,6 @@ impl InputMessage {
             data,
             reply_surbs,
             lane,
-            mix_hops: None,
-        };
-        if let Some(packet_type) = packet_type {
-            InputMessage::new_wrapper(message, packet_type)
-        } else {
-            message
-        }
-    }
-
-    // IMHO `new_anonymous` should take `mix_hops: Option<u8>` as an argument instead of creating
-    // this function, but that would potentially break backwards compatibility with the current API
-    pub fn new_anonymous_with_custom_hops(
-        recipient: Recipient,
-        data: Vec<u8>,
-        reply_surbs: u32,
-        lane: TransmissionLane,
-        packet_type: Option<PacketType>,
-        mix_hops: Option<u8>,
-    ) -> Self {
-        let message = InputMessage::Anonymous {
-            recipient,
-            data,
-            reply_surbs,
-            lane,
-            mix_hops,
         };
         if let Some(packet_type) = packet_type {
             InputMessage::new_wrapper(message, packet_type)

common/client-core/src/client/real_messages_control/acknowledgement_control/action_controller.rs

@@ -127,9 +127,7 @@ impl ActionController {
                 .insert(frag_id, (Arc::new(pending_ack), None))
                 .is_some()
             {
-                // 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!")
+                panic!("Tried to insert duplicate pending ack")
             }
         }
     }

common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs

@@ -73,11 +73,10 @@ where
         content: Vec<u8>,
         lane: TransmissionLane,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) {
         if let Err(err) = self
             .message_handler
-            .try_send_plain_message(recipient, content, lane, packet_type, mix_hops)
+            .try_send_plain_message(recipient, content, lane, packet_type)
             .await
         {
             warn!("failed to send a plain message - {err}")
@@ -91,18 +90,10 @@ where
         reply_surbs: u32,
         lane: TransmissionLane,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) {
         if let Err(err) = self
             .message_handler
-            .try_send_message_with_reply_surbs(
-                recipient,
-                content,
-                reply_surbs,
-                lane,
-                packet_type,
-                mix_hops,
-            )
+            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type)
             .await
         {
             warn!("failed to send a repliable message - {err}")
@@ -115,9 +106,8 @@ where
                 recipient,
                 data,
                 lane,
-                mix_hops,
             } => {
-                self.handle_plain_message(recipient, data, lane, PacketType::Mix, mix_hops)
+                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
                     .await
             }
             InputMessage::Anonymous {
@@ -125,17 +115,9 @@ where
                 data,
                 reply_surbs,
                 lane,
-                mix_hops,
             } => {
-                self.handle_repliable_message(
-                    recipient,
-                    data,
-                    reply_surbs,
-                    lane,
-                    PacketType::Mix,
-                    mix_hops,
-                )
-                .await
+                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
+                    .await
             }
             InputMessage::Reply {
                 recipient_tag,
@@ -153,9 +135,8 @@ where
                     recipient,
                     data,
                     lane,
-                    mix_hops,
                 } => {
-                    self.handle_plain_message(recipient, data, lane, packet_type, mix_hops)
+                    self.handle_plain_message(recipient, data, lane, packet_type)
                         .await
                 }
                 InputMessage::Anonymous {
@@ -163,17 +144,9 @@ where
                     data,
                     reply_surbs,
                     lane,
-                    mix_hops,
                 } => {
-                    self.handle_repliable_message(
-                        recipient,
-                        data,
-                        reply_surbs,
-                        lane,
-                        packet_type,
-                        mix_hops,
-                    )
-                    .await
+                    self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type)
+                        .await
                 }
                 InputMessage::Reply {
                     recipient_tag,

common/client-core/src/client/real_messages_control/acknowledgement_control/mod.rs

@@ -69,7 +69,6 @@ pub(crate) struct PendingAcknowledgement {
     message_chunk: Fragment,
     delay: SphinxDelay,
     destination: PacketDestination,
-    mix_hops: Option<u8>,
 }
 
 impl PendingAcknowledgement {
@@ -78,13 +77,11 @@ impl PendingAcknowledgement {
         message_chunk: Fragment,
         delay: SphinxDelay,
         recipient: Recipient,
-        mix_hops: Option<u8>,
     ) -> Self {
         PendingAcknowledgement {
             message_chunk,
             delay,
             destination: PacketDestination::KnownRecipient(recipient.into()),
-            mix_hops,
         }
     }
 
@@ -101,9 +98,6 @@ impl PendingAcknowledgement {
                 recipient_tag,
                 extra_surb_request,
             },
-            // Messages sent using SURBs are using the number of mix hops set by the recipient when
-            // they provided the SURBs, so it doesn't make sense to include it here.
-            mix_hops: None,
         }
     }
 

common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs

@@ -49,18 +49,12 @@ where
         packet_recipient: Recipient,
         chunk_data: Fragment,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) -> Result<PreparedFragment, PreparationError> {
         debug!("retransmitting normal packet...");
 
         // TODO: Figure out retransmission packet type signaling
         self.message_handler
-            .try_prepare_single_chunk_for_sending(
-                packet_recipient,
-                chunk_data,
-                packet_type,
-                mix_hops,
-            )
+            .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, packet_type)
             .await
     }
 
@@ -95,7 +89,6 @@ where
                     **recipient,
                     timed_out_ack.message_chunk.clone(),
                     packet_type,
-                    timed_out_ack.mix_hops,
                 )
                 .await
             }

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

@@ -418,10 +418,9 @@ where
         message: Vec<u8>,
         lane: TransmissionLane,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) -> Result<(), PreparationError> {
         let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type, mix_hops)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
             .await
     }
 
@@ -431,7 +430,6 @@ where
         recipient: Recipient,
         lane: TransmissionLane,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) -> Result<(), PreparationError> {
         debug!("Sending non-reply message with packet type {packet_type}");
         // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
@@ -463,7 +461,6 @@ where
                 &self.config.ack_key,
                 &recipient,
                 packet_type,
-                mix_hops,
             )?;
 
             let real_message = RealMessage::new(
@@ -471,8 +468,7 @@ where
                 Some(fragment.fragment_identifier()),
             );
             let delay = prepared_fragment.total_delay;
-            let pending_ack =
-                PendingAcknowledgement::new_known(fragment, delay, recipient, mix_hops);
+            let pending_ack = PendingAcknowledgement::new_known(fragment, delay, recipient);
 
             real_messages.push(real_message);
             pending_acks.push(pending_ack);
@@ -489,7 +485,6 @@ where
         recipient: Recipient,
         amount: u32,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) -> Result<(), PreparationError> {
         debug!("Sending additional reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -506,7 +501,6 @@ where
             recipient,
             TransmissionLane::AdditionalReplySurbs,
             packet_type,
-            mix_hops,
         )
         .await?;
 
@@ -523,7 +517,6 @@ where
         num_reply_surbs: u32,
         lane: TransmissionLane,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) -> Result<(), SurbWrappedPreparationError> {
         debug!("Sending message with reply SURBs with packet type {packet_type}");
         let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -534,7 +527,7 @@ where
         let message =
             NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));
 
-        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type, mix_hops)
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
             .await?;
 
         log::trace!("storing {} reply keys", reply_keys.len());
@@ -548,7 +541,6 @@ where
         recipient: Recipient,
         chunk: Fragment,
         packet_type: PacketType,
-        mix_hops: Option<u8>,
     ) -> Result<PreparedFragment, PreparationError> {
         debug!("Sending single chunk with packet type {packet_type}");
         let topology_permit = self.topology_access.get_read_permit().await;
@@ -562,7 +554,6 @@ where
                 &self.config.ack_key,
                 &recipient,
                 packet_type,
-                mix_hops,
             )
             .unwrap();
 

common/client-core/src/client/replies/reply_controller/mod.rs

@@ -516,7 +516,6 @@ where
                     recipient,
                     to_send,
                     nym_sphinx::params::PacketType::Mix,
-                    self.config.reply_surbs.surb_mix_hops,
                 )
                 .await
             {

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

@@ -607,10 +607,6 @@ pub struct ReplySurbs {
     /// This is going to be superseded by key rotation once implemented.
     #[serde(with = "humantime_serde")]
     pub maximum_reply_key_age: Duration,
-
-    /// Specifies the number of mixnet hops the packet should go through. If not specified, then
-    /// the default value is used.
-    pub surb_mix_hops: Option<u8>,
 }
 
 impl Default for ReplySurbs {
@@ -626,7 +622,6 @@ impl Default for ReplySurbs {
             maximum_reply_surb_drop_waiting_period: DEFAULT_MAXIMUM_REPLY_SURB_DROP_WAITING_PERIOD,
             maximum_reply_surb_age: DEFAULT_MAXIMUM_REPLY_SURB_AGE,
             maximum_reply_key_age: DEFAULT_MAXIMUM_REPLY_KEY_AGE,
-            surb_mix_hops: None,
         }
     }
 }

common/client-core/src/config/old_config_v1_1_30.rs

@@ -155,7 +155,6 @@ impl From<ConfigV1_1_30> for Config {
                         .maximum_reply_surb_drop_waiting_period,
                     maximum_reply_surb_age: value.debug.reply_surbs.maximum_reply_surb_age,
                     maximum_reply_key_age: value.debug.reply_surbs.maximum_reply_key_age,
-                    surb_mix_hops: None,
                 },
             },
         }

common/client-core/src/init/helpers.rs

@@ -259,7 +259,6 @@ 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)?;
 

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

@@ -212,7 +212,7 @@ where
     D::StorageError: Send + Sync + 'static,
     T: DeserializeOwned + Serialize + Send + Sync,
 {
-    log::debug!("Setting up gateway");
+    log::trace!("Setting up gateway");
     match setup {
         GatewaySetup::MustLoad => use_loaded_gateway_details(key_store, details_store).await,
         GatewaySetup::New {

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

@@ -3,7 +3,6 @@ name = "nym-gateway-client"
 version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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

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

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

@@ -3,15 +3,14 @@ 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 = { workspace = true, features = ["time", "net", "rt"] }
-tokio-util = { workspace = true, features = ["codec"] }
+tokio = { version = "1.24.1", features = ["time", "net", "rt"] }
+tokio-util = { version = "0.7.4", features = ["codec"] }
 
 # internal
 nym-sphinx = { path = "../../nymsphinx" }

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

@@ -4,7 +4,6 @@ version = "0.1.0"
 authors = ["Jędrzej Stuczyński <andrew@nymtech.net>"]
 edition = "2021"
 rust-version = "1.56"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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

@@ -42,14 +42,6 @@ pub struct Config {
     nyxd_config: nyxd::Config,
 }
 
-impl TryFrom<NymNetworkDetails> for Config {
-    type Error = ValidatorClientError;
-
-    fn try_from(value: NymNetworkDetails) -> Result<Self, Self::Error> {
-        Config::try_from_nym_network_details(&value)
-    }
-}
-
 impl Config {
     pub fn try_from_nym_network_details(
         details: &NymNetworkDetails,

common/client-libs/validator-client/src/nym_api/mod.rs

@@ -5,24 +5,16 @@ use crate::nym_api::error::NymAPIError;
 use crate::nym_api::routes::{CORE_STATUS_COUNT, SINCE_ARG};
 use async_trait::async_trait;
 use http_api_client::{ApiClient, NO_PARAMS};
-pub use nym_api_requests::{
-    coconut::{
-        models::{
-            EpochCredentialsResponse, IssuedCredential, IssuedCredentialBody,
-            IssuedCredentialResponse, IssuedCredentialsResponse,
-        },
-        BlindSignRequestBody, BlindedSignatureResponse, CredentialsRequestBody,
-        VerifyCredentialBody, VerifyCredentialResponse,
-    },
-    models::{
-        ComputeRewardEstParam, DescribedGateway, GatewayBondAnnotated, GatewayCoreStatusResponse,
-        GatewayStatusReportResponse, GatewayUptimeHistoryResponse, InclusionProbabilityResponse,
-        MixNodeBondAnnotated, MixnodeCoreStatusResponse, MixnodeStatusReportResponse,
-        MixnodeStatusResponse, MixnodeUptimeHistoryResponse, RewardEstimationResponse,
-        StakeSaturationResponse, UptimeResponse,
-    },
+use nym_api_requests::coconut::{
+    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_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;
@@ -407,60 +399,6 @@ 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)

common/client-libs/validator-client/src/nym_api/routes.rs

@@ -17,9 +17,6 @@ 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";

common/client-libs/validator-client/src/nyxd/coin.rs

@@ -8,8 +8,6 @@ use cosmwasm_std::{Fraction, Uint128};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::Div;
-use std::str::FromStr;
-use thiserror::Error;
 
 #[derive(Serialize, Deserialize, Clone, Copy, Default, Debug, PartialEq, Eq)]
 pub struct MismatchedDenoms;
@@ -128,37 +126,6 @@ impl From<CosmWasmCoin> for Coin {
     }
 }
 
-// unfortunately cosmwasm didn't re-export this correct so we just redefine its
-#[derive(Error, Debug, PartialEq, Eq)]
-pub enum CoinFromStrError {
-    #[error("Missing denominator")]
-    MissingDenom,
-    #[error("Missing amount or non-digit characters in amount")]
-    MissingAmount,
-    #[error("Invalid amount: {0}")]
-    InvalidAmount(#[from] std::num::ParseIntError),
-}
-
-impl FromStr for Coin {
-    type Err = CoinFromStrError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let pos = s
-            .find(|c: char| !c.is_ascii_digit())
-            .ok_or(CoinFromStrError::MissingDenom)?;
-        let (amount, denom) = s.split_at(pos);
-
-        if amount.is_empty() {
-            return Err(CoinFromStrError::MissingAmount);
-        }
-
-        Ok(Coin {
-            amount: amount.parse::<u128>()?,
-            denom: denom.to_string(),
-        })
-    }
-}
-
 pub trait CoinConverter {
     type Target;
 

common/client-libs/validator-client/src/nyxd/contract_traits/coconut_bandwidth_signing_client.rs

@@ -32,7 +32,7 @@ pub trait CoconutBandwidthSigningClient {
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NyxdError> {
         let req = CoconutBandwidthExecuteMsg::DepositFunds {
-            data: DepositData::new(info, verification_key, encryption_key),
+            data: DepositData::new(info.to_string(), verification_key, encryption_key),
         };
         self.execute_coconut_bandwidth_contract(
             fee,

common/client-libs/validator-client/src/nyxd/contract_traits/dkg_query_client.rs

@@ -1,4 +1,4 @@
-// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::collect_paged;
@@ -7,21 +7,13 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use nym_coconut_dkg_common::types::ChunkIndex;
-use serde::Deserialize;
-
-pub use nym_coconut_dkg_common::{
-    dealer::{DealerDetailsResponse, PagedDealerResponse},
-    dealing::{
-        DealerDealingsStatusResponse, DealingChunkResponse, DealingChunkStatusResponse,
-        DealingMetadataResponse, DealingStatusResponse,
-    },
-    msg::QueryMsg as DkgQueryMsg,
-    types::{
-        DealerDetails, DealingIndex, Epoch, EpochId, EpochState, InitialReplacementData, State,
-    },
-    verification_key::{ContractVKShare, PagedVKSharesResponse, VkShareResponse},
+use nym_coconut_dkg_common::dealer::{
+    ContractDealing, DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
 };
+use nym_coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
+use nym_coconut_dkg_common::types::{DealerDetails, Epoch, EpochId, InitialReplacementData};
+use nym_coconut_dkg_common::verification_key::{ContractVKShare, PagedVKSharesResponse};
+use serde::Deserialize;
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
@@ -30,16 +22,10 @@ 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
@@ -78,86 +64,17 @@ pub trait DkgQueryClient {
         self.query_dkg_contract(request).await
     }
 
-    async fn get_dealings_metadata(
+    async fn get_dealings_paged(
         &self,
-        epoch_id: EpochId,
-        dealer: String,
-        dealing_index: DealingIndex,
-    ) -> Result<DealingMetadataResponse, NyxdError> {
-        let request = DkgQueryMsg::GetDealingsMetadata {
-            epoch_id,
-            dealer,
-            dealing_index,
+        idx: u64,
+        start_after: Option<String>,
+        limit: Option<u32>,
+    ) -> Result<PagedDealingsResponse, NyxdError> {
+        let request = DkgQueryMsg::GetDealing {
+            idx,
+            limit,
+            start_after,
         };
-
-        self.query_dkg_contract(request).await
-    }
-
-    async fn get_dealer_dealings_status(
-        &self,
-        epoch_id: EpochId,
-        dealer: String,
-    ) -> Result<DealerDealingsStatusResponse, NyxdError> {
-        let request = DkgQueryMsg::GetDealerDealingsStatus { epoch_id, dealer };
-
-        self.query_dkg_contract(request).await
-    }
-
-    async fn get_dealing_status(
-        &self,
-        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_chunk_status(
-        &self,
-        epoch_id: EpochId,
-        dealer: String,
-        dealing_index: DealingIndex,
-        chunk_index: ChunkIndex,
-    ) -> Result<DealingChunkStatusResponse, NyxdError> {
-        let request = DkgQueryMsg::GetDealingChunkStatus {
-            epoch_id,
-            dealer,
-            dealing_index,
-            chunk_index,
-        };
-
-        self.query_dkg_contract(request).await
-    }
-
-    async fn get_dealing_chunk(
-        &self,
-        epoch_id: EpochId,
-        dealer: String,
-        dealing_index: DealingIndex,
-        chunk_index: ChunkIndex,
-    ) -> Result<DealingChunkResponse, NyxdError> {
-        let request = DkgQueryMsg::GetDealingChunk {
-            epoch_id,
-            dealer,
-            dealing_index,
-            chunk_index,
-        };
-
-        self.query_dkg_contract(request).await
-    }
-
-    async fn get_vk_share(
-        &self,
-        epoch_id: EpochId,
-        owner: String,
-    ) -> Result<VkShareResponse, NyxdError> {
-        let request = DkgQueryMsg::GetVerificationKey { epoch_id, owner };
         self.query_dkg_contract(request).await
     }
 
@@ -174,11 +91,6 @@ pub trait DkgQueryClient {
         };
         self.query_dkg_contract(request).await
     }
-
-    async fn get_contract_cw2_version(&self) -> Result<cw2::ContractVersion, NyxdError> {
-        self.query_dkg_contract(DkgQueryMsg::GetCW2ContractVersion {})
-            .await
-    }
 }
 
 // extension trait to the query client to deal with the paged queries
@@ -194,6 +106,10 @@ 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_verification_key_shares(
         &self,
         epoch_id: EpochId,
@@ -227,7 +143,6 @@ where
 mod tests {
     use super::*;
     use crate::nyxd::contract_traits::tests::IgnoreValue;
-    use nym_coconut_dkg_common::msg::QueryMsg;
 
     // it's enough that this compiles and clippy is happy about it
     #[allow(dead_code)]
@@ -236,7 +151,6 @@ 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()
@@ -251,42 +165,11 @@ 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::GetDealingsMetadata {
-                epoch_id,
-                dealer,
-                dealing_index,
-            } => client
-                .get_dealings_metadata(epoch_id, dealer, dealing_index)
-                .ignore(),
-            QueryMsg::GetDealerDealingsStatus { epoch_id, dealer } => {
-                client.get_dealer_dealings_status(epoch_id, dealer).ignore()
-            }
-            DkgQueryMsg::GetDealingChunkStatus {
-                epoch_id,
-                dealer,
-                dealing_index,
-                chunk_index,
-            } => client
-                .get_dealing_chunk_status(epoch_id, dealer, dealing_index, chunk_index)
-                .ignore(),
-            DkgQueryMsg::GetDealingChunk {
-                epoch_id,
-                dealer,
-                dealing_index,
-                chunk_index,
-            } => client
-                .get_dealing_chunk(epoch_id, dealer, dealing_index, chunk_index)
-                .ignore(),
-            DkgQueryMsg::GetVerificationKey { epoch_id, owner } => {
-                client.get_vk_share(epoch_id, owner).ignore()
-            }
+            DkgQueryMsg::GetDealing {
+                idx,
+                limit,
+                start_after,
+            } => client.get_dealings_paged(idx, start_after, limit).ignore(),
             DkgQueryMsg::GetVerificationKeys {
                 epoch_id,
                 limit,
@@ -294,7 +177,6 @@ mod tests {
             } => client
                 .get_vk_shares_paged(epoch_id, start_after, limit)
                 .ignore(),
-            DkgQueryMsg::GetCW2ContractVersion {} => client.get_contract_cw2_version().ignore(),
         };
     }
 }

common/client-libs/validator-client/src/nyxd/contract_traits/dkg_signing_client.rs

@@ -8,11 +8,11 @@ use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
 use crate::signing::signer::OfflineSigner;
 use async_trait::async_trait;
 use cosmrs::AccountId;
-use nym_coconut_dkg_common::dealing::{DealingChunkInfo, PartialContractDealing};
+use cosmwasm_std::Addr;
 use nym_coconut_dkg_common::msg::ExecuteMsg as DkgExecuteMsg;
-use nym_coconut_dkg_common::types::{DealingIndex, EncodedBTEPublicKeyWithProof};
+use nym_coconut_dkg_common::types::EncodedBTEPublicKeyWithProof;
 use nym_coconut_dkg_common::verification_key::VerificationKeyShare;
-use nym_contracts_common::IdentityKey;
+use nym_contracts_common::dealings::ContractSafeBytes;
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
@@ -25,13 +25,6 @@ pub trait DkgSigningClient {
         funds: Vec<Coin>,
     ) -> Result<ExecuteResult, NyxdError>;
 
-    async fn initiate_dkg(&self, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
-        let req = DkgExecuteMsg::InitiateDkg {};
-
-        self.execute_dkg_contract(fee, req, "initiating the DKG".to_string(), vec![])
-            .await
-    }
-
     async fn advance_dkg_epoch_state(&self, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
         let req = DkgExecuteMsg::AdvanceEpochState {};
 
@@ -49,14 +42,12 @@ 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,
         };
@@ -65,32 +56,18 @@ pub trait DkgSigningClient {
             .await
     }
 
-    async fn submit_dealing_metadata(
+    async fn submit_dealing_bytes(
         &self,
-        dealing_index: DealingIndex,
-        chunks: Vec<DealingChunkInfo>,
+        dealing_bytes: ContractSafeBytes,
         resharing: bool,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NyxdError> {
-        let req = DkgExecuteMsg::CommitDealingsMetadata {
-            dealing_index,
-            chunks,
+        let req = DkgExecuteMsg::CommitDealing {
+            dealing_bytes,
             resharing,
         };
 
-        self.execute_dkg_contract(fee, req, "dealing metadata commitment".to_string(), vec![])
-            .await
-    }
-
-    async fn submit_dealing_chunk(
-        &self,
-        chunk: PartialContractDealing,
-        resharing: bool,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = DkgExecuteMsg::CommitDealingsChunk { chunk, resharing };
-
-        self.execute_dkg_contract(fee, req, "dealing chunk commitment".to_string(), vec![])
+        self.execute_dkg_contract(fee, req, "dealing commitment".to_string(), vec![])
             .await
     }
 
@@ -117,10 +94,9 @@ pub trait DkgSigningClient {
         resharing: bool,
         fee: Option<Fee>,
     ) -> Result<ExecuteResult, NyxdError> {
-        let req = DkgExecuteMsg::VerifyVerificationKeyShare {
-            owner: owner.to_string(),
-            resharing,
-        };
+        // the call to unchecked is fine as we're converting from pre-validated `AccountId`
+        let owner = Addr::unchecked(owner.to_string());
+        let req = DkgExecuteMsg::VerifyVerificationKeyShare { owner, resharing };
 
         self.execute_dkg_contract(
             fee,
@@ -170,36 +146,28 @@ mod tests {
         msg: DkgExecuteMsg,
     ) {
         match msg {
-            DkgExecuteMsg::InitiateDkg {} => client.initiate_dkg(None).ignore(),
             DkgExecuteMsg::RegisterDealer {
                 bte_key_with_proof,
-                identity_key,
                 announce_address,
                 resharing,
             } => client
-                .register_dealer(
-                    bte_key_with_proof,
-                    identity_key,
-                    announce_address,
-                    resharing,
-                    None,
-                )
+                .register_dealer(bte_key_with_proof, announce_address, resharing, None)
                 .ignore(),
-            DkgExecuteMsg::CommitDealingsMetadata {
-                dealing_index,
-                chunks,
+            DkgExecuteMsg::CommitDealing {
+                dealing_bytes,
                 resharing,
             } => client
-                .submit_dealing_metadata(dealing_index, chunks, resharing, None)
+                .submit_dealing_bytes(dealing_bytes, resharing, None)
                 .ignore(),
-            DkgExecuteMsg::CommitDealingsChunk { chunk, resharing } => {
-                client.submit_dealing_chunk(chunk, resharing, None).ignore()
-            }
             DkgExecuteMsg::CommitVerificationKeyShare { share, resharing } => client
                 .submit_verification_key_share(share, resharing, None)
                 .ignore(),
             DkgExecuteMsg::VerifyVerificationKeyShare { owner, resharing } => client
-                .verify_verification_key_share(&owner.parse().unwrap(), resharing, None)
+                .verify_verification_key_share(
+                    &owner.into_string().parse().unwrap(),
+                    resharing,
+                    None,
+                )
                 .ignore(),
             DkgExecuteMsg::SurpassedThreshold {} => client.surpass_threshold(None).ignore(),
             DkgExecuteMsg::AdvanceEpochState {} => client.advance_dkg_epoch_state(None).ignore(),

common/client-libs/validator-client/src/nyxd/contract_traits/mod.rs

@@ -8,26 +8,26 @@ use std::str::FromStr;
 // TODO: all of those could/should be derived via a macro
 
 // query clients
-pub mod coconut_bandwidth_query_client;
-pub mod dkg_query_client;
-pub mod ephemera_query_client;
-pub mod group_query_client;
-pub mod mixnet_query_client;
-pub mod multisig_query_client;
-pub mod name_service_query_client;
-pub mod sp_directory_query_client;
-pub mod vesting_query_client;
+mod coconut_bandwidth_query_client;
+mod dkg_query_client;
+mod ephemera_query_client;
+mod group_query_client;
+mod mixnet_query_client;
+mod multisig_query_client;
+mod name_service_query_client;
+mod sp_directory_query_client;
+mod vesting_query_client;
 
 // signing clients
-pub mod coconut_bandwidth_signing_client;
-pub mod dkg_signing_client;
-pub mod ephemera_signing_client;
-pub mod group_signing_client;
-pub mod mixnet_signing_client;
-pub mod multisig_signing_client;
-pub mod name_service_signing_client;
-pub mod sp_directory_signing_client;
-pub mod vesting_signing_client;
+mod coconut_bandwidth_signing_client;
+mod dkg_signing_client;
+mod ephemera_signing_client;
+mod group_signing_client;
+mod mixnet_signing_client;
+mod multisig_signing_client;
+mod name_service_signing_client;
+mod sp_directory_signing_client;
+mod vesting_signing_client;
 
 // re-export query traits
 pub use coconut_bandwidth_query_client::{

common/client-libs/validator-client/src/nyxd/contract_traits/multisig_query_client.rs

@@ -6,8 +6,8 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::CosmWasmClient;
 use async_trait::async_trait;
 use cw3::{
-    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterDetail,
-    VoterListResponse, VoterResponse,
+    ProposalListResponse, ProposalResponse, VoteListResponse, VoteResponse, VoterListResponse,
+    VoterResponse,
 };
 use cw_utils::ThresholdResponse;
 use nym_multisig_contract_common::msg::QueryMsg as MultisigQueryMsg;
@@ -114,26 +114,6 @@ 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]

common/client-libs/validator-client/src/nyxd/cosmwasm_client/client_traits/query_client.rs

@@ -52,6 +52,10 @@ use wasmtimer::tokio::sleep;
 pub const DEFAULT_BROADCAST_POLLING_RATE: Duration = Duration::from_secs(4);
 pub const DEFAULT_BROADCAST_TIMEOUT: Duration = Duration::from_secs(60);
 
+#[cfg(feature = "http-client")]
+#[async_trait]
+impl CosmWasmClient for cosmrs::rpc::HttpClient {}
+
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 pub trait CosmWasmClient: TendermintRpcClient {
@@ -518,7 +522,3 @@ pub trait CosmWasmClient: TendermintRpcClient {
         res.try_into()
     }
 }
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<T> CosmWasmClient for T where T: TendermintRpcClient {}

common/client-libs/validator-client/src/nyxd/cosmwasm_client/client_traits/signing_client.rs

@@ -425,7 +425,7 @@ where
                     amount: amount.into_iter().map(Into::into).collect(),
                 }
                 .to_any()
-                .map_err(|_| NyxdError::SerializationError("MsgSend".to_owned()))
+                .map_err(|_| NyxdError::SerializationError("MsgExecuteContract".to_owned()))
             })
             .collect::<Result<_, _>>()?;
 

common/client-libs/validator-client/src/nyxd/cosmwasm_client/mod.rs

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::nyxd::cosmwasm_client::client_traits::SigningCosmWasmClient;
+use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
 use crate::nyxd::error::NyxdError;
 use crate::nyxd::{Config, GasPrice, Hash, Height};
 use crate::rpc::TendermintRpcClient;
@@ -26,7 +26,6 @@ use cosmrs::rpc::{HttpClient, HttpClientUrl};
 pub mod client_traits;
 mod helpers;
 pub mod logs;
-pub mod module_traits;
 pub mod types;
 
 #[derive(Debug)]
@@ -330,6 +329,14 @@ where
     }
 }
 
+#[async_trait]
+impl<C, S> CosmWasmClient for MaybeSigningClient<C, S>
+where
+    C: TendermintRpcClient + Send + Sync,
+    S: Send + Sync,
+{
+}
+
 #[async_trait]
 impl<C, S> SigningCosmWasmClient for MaybeSigningClient<C, S>
 where

common/client-libs/validator-client/src/nyxd/cosmwasm_client/module_traits/mod.rs

@@ -1,8 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod slashing;
-pub mod staking;
-
-pub use staking::query::StakingQueryClient;
-// pub use slashing::query

common/client-libs/validator-client/src/nyxd/cosmwasm_client/module_traits/slashing/mod.rs

@@ -1,4 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod query;

common/client-libs/validator-client/src/nyxd/cosmwasm_client/module_traits/staking/mod.rs

@@ -1,8 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod query;
-
-pub use cosmrs::staking::{
-    QueryHistoricalInfoResponse, QueryValidatorResponse, QueryValidatorsResponse, Validator,
-};

common/client-libs/validator-client/src/nyxd/cosmwasm_client/module_traits/staking/query.rs

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

common/client-libs/validator-client/src/nyxd/helpers.rs

@@ -1,13 +0,0 @@
-// 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())
-}

common/client-libs/validator-client/src/nyxd/mod.rs

@@ -29,41 +29,31 @@ use tendermint_rpc::endpoint::*;
 use tendermint_rpc::{Error as TendermintRpcError, Order};
 use url::Url;
 
-pub use crate::nyxd::{
-    cosmwasm_client::{
-        client_traits::{CosmWasmClient, SigningCosmWasmClient},
-        module_traits::{self, StakingQueryClient},
-    },
-    fee::Fee,
-};
+pub use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
+pub use crate::nyxd::fee::Fee;
 pub use crate::rpc::TendermintRpcClient;
 pub use coin::Coin;
-pub use cosmrs::{
-    bank::MsgSend,
-    bip32,
-    crypto::PublicKey,
-    query::{PageRequest, PageResponse},
-    tendermint::{
-        abci::{response::DeliverTx, types::ExecTxResult, Event, EventAttribute},
-        block::Height,
-        hash::{self, Algorithm, Hash},
-        validator::Info as TendermintValidatorInfo,
-        Time as TendermintTime,
-    },
-    tx::{self, Msg},
-    AccountId, Any, Coin as CosmosCoin, Denom, Gas,
+pub use cosmrs::bank::MsgSend;
+pub use cosmrs::tendermint::abci::{
+    response::DeliverTx, types::ExecTxResult, Event, EventAttribute,
 };
+pub use cosmrs::tendermint::block::Height;
+pub use cosmrs::tendermint::hash::{self, Algorithm, Hash};
+pub use cosmrs::tendermint::validator::Info as TendermintValidatorInfo;
+pub use cosmrs::tendermint::Time as TendermintTime;
+pub use cosmrs::tx::Msg;
+pub use cosmrs::tx::{self};
+pub use cosmrs::Coin as CosmosCoin;
+pub use cosmrs::Gas;
+pub use cosmrs::{bip32, AccountId, Denom};
 pub use cosmwasm_std::Coin as CosmWasmCoin;
-pub use cw2;
-pub use cw3;
-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, Request, Response, SimpleRequest,
+    Paging,
 };
+pub use tendermint_rpc::{Request, Response, SimpleRequest};
 
 #[cfg(feature = "http-client")]
 use crate::http_client;
@@ -77,7 +67,6 @@ pub mod contract_traits;
 pub mod cosmwasm_client;
 pub mod error;
 pub mod fee;
-pub mod helpers;
 
 #[derive(Debug, Clone)]
 pub struct Config {
@@ -103,14 +92,6 @@ impl Config {
     }
 }
 
-impl TryFrom<NymNetworkDetails> for Config {
-    type Error = NyxdError;
-
-    fn try_from(value: NymNetworkDetails) -> Result<Self, Self::Error> {
-        Config::try_from_nym_network_details(&value)
-    }
-}
-
 #[derive(Debug)]
 pub struct NyxdClient<C, S = NoSigner> {
     client: MaybeSigningClient<C, S>,
@@ -395,11 +376,7 @@ where
         })
     }
 
-    pub async fn simulate<I, M>(
-        &self,
-        messages: I,
-        memo: impl Into<String> + Send + 'static,
-    ) -> Result<SimulateResponse, NyxdError>
+    pub async fn simulate<I, M>(&self, messages: I) -> Result<SimulateResponse, NyxdError>
     where
         I: IntoIterator<Item = M> + Send,
         M: Msg,
@@ -414,7 +391,7 @@ where
                     .map_err(|_| {
                         NyxdError::SerializationError("custom simulate messages".to_owned())
                     })?,
-                memo,
+                "simulating execution of transactions",
             )
             .await
     }
@@ -742,7 +719,7 @@ where
     where
         H: Into<Height> + Send,
     {
-        TendermintRpcClient::validators(&self.client, height, paging).await
+        self.client.validators(height, paging).await
     }
 
     async fn latest_consensus_params(
@@ -817,6 +794,14 @@ where
     }
 }
 
+#[async_trait]
+impl<C, S> CosmWasmClient for NyxdClient<C, S>
+where
+    C: TendermintRpcClient + Send + Sync,
+    S: Send + Sync,
+{
+}
+
 impl<C, S> OfflineSigner for NyxdClient<C, S>
 where
     S: OfflineSigner,

common/coconut-interface/Cargo.toml

@@ -3,7 +3,6 @@ name = "nym-coconut-interface"
 version = "0.1.0"
 edition = "2021"
 description = "Crutch library until there is proper SerDe support for coconut structs"
-license.workspace = true
 
 [dependencies]
 bs58 = "0.4.0"

common/coconut-interface/src/lib.rs

@@ -14,21 +14,17 @@ pub use nym_coconut::{
     aggregate_signature_shares, aggregate_verification_keys, blind_sign, hash_to_scalar,
     prepare_blind_sign, prove_bandwidth_credential, Attribute, Base58, BlindSignRequest,
     BlindedSignature, Bytable, CoconutError, KeyPair, Parameters, PrivateAttribute,
-    PublicAttribute, SecretKey, Signature, SignatureShare, Theta, VerificationKey,
+    PublicAttribute, Signature, SignatureShare, Theta, VerificationKey,
 };
 
 #[derive(Debug, Serialize, Deserialize, Getters, CopyGetters, Clone, PartialEq, Eq)]
 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,
 }
@@ -68,12 +64,14 @@ impl Credential {
 
     pub fn verify(&self, verification_key: &VerificationKey) -> bool {
         let params = Parameters::new(self.n_params).unwrap();
-
-        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)
+        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)
     }
 
     pub fn as_bytes(&self) -> Vec<u8> {
@@ -182,8 +180,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);

common/commands/Cargo.toml

@@ -3,7 +3,6 @@ name = "nym-cli-commands"
 version = "1.0.0"
 authors.workspace = true
 edition = "2021"
-license.workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
@@ -22,7 +21,7 @@ rand = {version = "0.6", features = ["std"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
-time = { workspace = true, features = ["parsing", "formatting"] }
+time = { version = "0.3.6", features = ["parsing", "formatting"] }
 toml = "0.5.6"
 url = { workspace = true }
 tap = "1"

common/commands/src/coconut/issue_credentials.rs

@@ -26,10 +26,6 @@ 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() {

common/commands/src/validator/cosmwasm/generators/coconut_dkg.rs

@@ -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, DEFAULT_DEALINGS};
+use nym_coconut_dkg_common::types::TimeConfiguration;
 use nym_validator_client::nyxd::AccountId;
 
 #[derive(Debug, Parser)]
@@ -93,7 +93,6 @@ 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);

common/config/Cargo.toml

@@ -3,7 +3,6 @@ name = "nym-config"
 version = "0.1.0"
 authors = ["Jedrzej Stuczynski <andrew@nymtech.net>"]
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -18,4 +17,4 @@ url = { workspace = true }
 nym-network-defaults = { path = "../network-defaults" }
 
 [features]
-default = ["dirs"]
+default = ["dirs"]

common/config/src/lib.rs

@@ -4,7 +4,7 @@
 use handlebars::{Handlebars, TemplateRenderError};
 use serde::de::DeserializeOwned;
 use serde::Serialize;
-use std::fs::{create_dir_all, File};
+use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::{fs, io};
@@ -72,22 +72,16 @@ where
     C: NymConfigTemplate,
     P: AsRef<Path>,
 {
-    let path = path.as_ref();
-    log::info!("saving config file to {}", path.display());
+    log::debug!("trying to save config file to {}", path.as_ref().display());
+    let file = File::create(path.as_ref())?;
 
-    if let Some(parent) = path.parent() {
-        create_dir_all(parent)?;
-    }
-
-    let file = File::create(path)?;
-
-    // TODO: check for whether any of our configs store anything sensitive
+    // TODO: check for whether any of our configs stores anything sensitive
     // and change that to 0o644 instead
     #[cfg(target_family = "unix")]
     {
         use std::os::unix::fs::PermissionsExt;
 
-        let mut perms = fs::metadata(path)?.permissions();
+        let mut perms = fs::metadata(path.as_ref())?.permissions();
         perms.set_mode(0o600);
         fs::set_permissions(path, perms)?;
     }

common/cosmwasm-smart-contracts/coconut-bandwidth-contract/Cargo.toml

@@ -2,7 +2,6 @@
 name = "nym-coconut-bandwidth-contract-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -13,4 +12,4 @@ cw2 = { workspace = true, optional = true }
 nym-multisig-contract-common = { path = "../multisig-contract" }
 
 [features]
-schema = ["cw2"]
+schema = ["cw2"]

common/cosmwasm-smart-contracts/coconut-bandwidth-contract/src/events.rs

@@ -4,9 +4,6 @@
 // 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";

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

@@ -2,7 +2,6 @@
 name = "nym-coconut-dkg-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -10,11 +9,9 @@ license.workspace = true
 cosmwasm-schema = { workspace = true }
 cosmwasm-std = { workspace = true }
 cw-utils = { workspace = true }
-cw2 = { workspace = true }
-cw4 = { workspace = true }
 
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
 nym-multisig-contract-common = { path = "../multisig-contract" }
 
 [features]
-schema = []
+schema = []

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

@@ -1,7 +1,7 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::types::{EncodedBTEPublicKeyWithProof, NodeIndex};
+use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, NodeIndex};
 use cosmwasm_schema::cw_serde;
 use cosmwasm_std::Addr;
 
@@ -9,7 +9,6 @@ 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,
 }
@@ -65,3 +64,38 @@ impl PagedDealerResponse {
         }
     }
 }
+
+#[cw_serde]
+pub struct ContractDealing {
+    pub dealing: ContractSafeBytes,
+    pub dealer: Addr,
+}
+
+impl ContractDealing {
+    pub fn new(dealing: ContractSafeBytes, dealer: Addr) -> Self {
+        ContractDealing { dealing, dealer }
+    }
+}
+
+#[cw_serde]
+pub struct PagedDealingsResponse {
+    pub dealings: Vec<ContractDealing>,
+    pub per_page: usize,
+
+    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
+    pub start_next_after: Option<Addr>,
+}
+
+impl PagedDealingsResponse {
+    pub fn new(
+        dealings: Vec<ContractDealing>,
+        per_page: usize,
+        start_next_after: Option<Addr>,
+    ) -> Self {
+        PagedDealingsResponse {
+            dealings,
+            per_page,
+            start_next_after,
+        }
+    }
+}

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

@@ -1,284 +0,0 @@
-// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::types::{ChunkIndex, DealingIndex, EpochId, PartialContractDealingData};
-use contracts_common::dealings::ContractSafeBytes;
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Addr;
-use std::collections::{BTreeMap, HashMap};
-
-/// Defines the maximum size of a dealing chunk. Currently set to 2kB
-pub const MAX_DEALING_CHUNK_SIZE: usize = 2048;
-
-/// Defines the maximum size of a full dealing.
-/// Currently set to 100kB (which is enough for a dealing created for 100 parties)
-pub const MAX_DEALING_SIZE: usize = 102400;
-
-pub const MAX_DEALING_CHUNKS: usize = MAX_DEALING_SIZE / MAX_DEALING_CHUNK_SIZE;
-
-// 2 public attributes, 2 private attributes, 1 fixed for coconut credential
-pub const DEFAULT_DEALINGS: usize = 2 + 2 + 1;
-
-pub fn chunk_dealing(
-    dealing_index: DealingIndex,
-    dealing_bytes: Vec<u8>,
-    chunk_size: usize,
-) -> HashMap<ChunkIndex, PartialContractDealing> {
-    let mut chunks = HashMap::new();
-    for (chunk_index, chunk) in dealing_bytes.chunks(chunk_size).enumerate() {
-        let chunk = PartialContractDealing {
-            dealing_index,
-            chunk_index: chunk_index as ChunkIndex,
-            data: ContractSafeBytes(chunk.to_vec()),
-        };
-        chunks.insert(chunk_index as ChunkIndex, chunk);
-    }
-
-    chunks
-}
-
-#[cw_serde]
-#[derive(Copy)]
-pub struct DealingChunkInfo {
-    pub size: usize,
-}
-
-impl DealingChunkInfo {
-    pub fn new(size: usize) -> Self {
-        DealingChunkInfo { size }
-    }
-
-    pub fn construct(dealing_len: usize, chunk_size: usize) -> Vec<Self> {
-        let (full_chunks, overflow) = (dealing_len / chunk_size, dealing_len % chunk_size);
-
-        let mut chunks = Vec::new();
-        for _ in 0..full_chunks {
-            chunks.push(DealingChunkInfo::new(chunk_size));
-        }
-
-        if overflow != 0 {
-            chunks.push(DealingChunkInfo::new(overflow));
-        }
-
-        chunks
-    }
-}
-
-#[cw_serde]
-#[derive(Copy)]
-pub struct SubmittedChunk {
-    pub info: DealingChunkInfo,
-
-    pub status: ChunkSubmissionStatus,
-}
-
-#[cw_serde]
-#[derive(Default, Copy)]
-pub struct ChunkSubmissionStatus {
-    // this field is updated by the contract itself to indicate when this particular chunk has been received
-    pub submission_height: Option<u64>,
-}
-
-impl ChunkSubmissionStatus {
-    pub fn submitted(&self) -> bool {
-        self.submission_height.is_some()
-    }
-}
-
-impl From<DealingChunkInfo> for SubmittedChunk {
-    fn from(value: DealingChunkInfo) -> Self {
-        SubmittedChunk::new(value)
-    }
-}
-
-impl SubmittedChunk {
-    pub fn new(info: DealingChunkInfo) -> Self {
-        SubmittedChunk {
-            info,
-            status: Default::default(),
-        }
-    }
-
-    pub fn submitted(&self) -> bool {
-        self.status.submitted()
-    }
-}
-
-#[cw_serde]
-pub struct DealingMetadata {
-    pub dealing_index: DealingIndex,
-
-    pub submitted_chunks: BTreeMap<ChunkIndex, SubmittedChunk>,
-}
-
-impl DealingMetadata {
-    pub fn new(dealing_index: DealingIndex, chunks: Vec<DealingChunkInfo>) -> Self {
-        DealingMetadata {
-            dealing_index,
-            submitted_chunks: chunks
-                .into_iter()
-                .enumerate()
-                .map(|(id, chunk)| (id as ChunkIndex, chunk.into()))
-                .collect(),
-        }
-    }
-
-    pub fn is_complete(&self) -> bool {
-        self.submitted_chunks.values().all(|c| c.submitted())
-    }
-
-    pub fn total_size(&self) -> usize {
-        self.submitted_chunks.values().map(|c| c.info.size).sum()
-    }
-
-    pub fn submission_statuses(&self) -> BTreeMap<ChunkIndex, ChunkSubmissionStatus> {
-        self.submitted_chunks
-            .iter()
-            .map(|(id, c)| (*id, c.status))
-            .collect()
-    }
-}
-
-#[cw_serde]
-pub struct PartialContractDealing {
-    pub dealing_index: DealingIndex,
-    pub chunk_index: ChunkIndex,
-    pub data: PartialContractDealingData,
-}
-
-impl PartialContractDealing {
-    pub fn new(
-        dealing_index: DealingIndex,
-        chunk_index: ChunkIndex,
-        data: PartialContractDealingData,
-    ) -> Self {
-        PartialContractDealing {
-            dealing_index,
-            chunk_index,
-            data,
-        }
-    }
-}
-
-#[cw_serde]
-pub struct DealingMetadataResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub dealing_index: DealingIndex,
-
-    pub metadata: Option<DealingMetadata>,
-}
-
-#[cw_serde]
-pub struct DealingChunkResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub dealing_index: DealingIndex,
-
-    pub chunk_index: ChunkIndex,
-
-    pub chunk: Option<PartialContractDealingData>,
-}
-
-#[cw_serde]
-pub struct DealingChunkStatusResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub dealing_index: DealingIndex,
-
-    pub chunk_index: ChunkIndex,
-
-    pub status: ChunkSubmissionStatus,
-}
-
-#[cw_serde]
-pub struct DealingStatusResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub dealing_index: DealingIndex,
-
-    pub status: DealingStatus,
-}
-
-#[cw_serde]
-pub struct DealingStatus {
-    pub has_metadata: bool,
-
-    pub fully_submitted: bool,
-
-    pub chunk_submission_status: BTreeMap<ChunkIndex, ChunkSubmissionStatus>,
-}
-
-impl From<Option<DealingMetadata>> for DealingStatus {
-    fn from(metadata: Option<DealingMetadata>) -> Self {
-        DealingStatus {
-            has_metadata: metadata.is_some(),
-            fully_submitted: metadata
-                .as_ref()
-                .map(|m| m.is_complete())
-                .unwrap_or_default(),
-            chunk_submission_status: metadata
-                .map(|m| m.submission_statuses())
-                .unwrap_or_default(),
-        }
-    }
-}
-
-#[cw_serde]
-pub struct DealerDealingsStatusResponse {
-    pub epoch_id: EpochId,
-
-    pub dealer: Addr,
-
-    pub all_dealings_fully_submitted: bool,
-
-    pub dealing_submission_status: BTreeMap<DealingIndex, DealingStatus>,
-}
-
-impl DealerDealingsStatusResponse {
-    pub fn full_dealings(&self) -> usize {
-        self.dealing_submission_status
-            .values()
-            .filter(|s| s.fully_submitted)
-            .count()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn chunking_dealings() {
-        const CHUNK_SIZE: usize = 512;
-
-        let test_cases = [
-            (CHUNK_SIZE - 10, CHUNK_SIZE, 1),
-            (CHUNK_SIZE, CHUNK_SIZE, 1),
-            (CHUNK_SIZE + 10, CHUNK_SIZE, 2),
-            (CHUNK_SIZE * 2, CHUNK_SIZE, 2),
-            (CHUNK_SIZE * 2 + 1, CHUNK_SIZE, 3),
-            (CHUNK_SIZE * 10 + 42, CHUNK_SIZE, 11),
-        ];
-
-        for (dealing_len, chunk_size, expected_chunks) in test_cases {
-            let chunks = DealingChunkInfo::construct(dealing_len, chunk_size);
-            assert_eq!(expected_chunks, chunks.len());
-            assert_eq!(dealing_len, chunks.iter().map(|c| c.size).sum::<usize>());
-
-            let mut expected_last = dealing_len % chunk_size;
-            if expected_last == 0 {
-                expected_last = chunk_size;
-            }
-            assert_eq!(chunks.last().unwrap().size, expected_last);
-        }
-    }
-}

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

@@ -1,8 +1,4 @@
-// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
 pub mod dealer;
-pub mod dealing;
 pub mod event_attributes;
 pub mod msg;
 pub mod types;

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

@@ -1,23 +1,16 @@
-// Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::dealing::{DealingChunkInfo, PartialContractDealing};
-use crate::types::{
-    ChunkIndex, DealingIndex, EncodedBTEPublicKeyWithProof, EpochId, TimeConfiguration,
-};
+use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, EpochId, TimeConfiguration};
 use crate::verification_key::VerificationKeyShare;
-use contracts_common::IdentityKey;
 use cosmwasm_schema::cw_serde;
+use cosmwasm_std::Addr;
 
 #[cfg(feature = "schema")]
 use crate::{
-    dealer::{DealerDetailsResponse, PagedDealerResponse},
-    dealing::{
-        DealerDealingsStatusResponse, DealingChunkResponse, DealingChunkStatusResponse,
-        DealingMetadataResponse, DealingStatusResponse,
-    },
-    types::{Epoch, InitialReplacementData, State},
-    verification_key::{PagedVKSharesResponse, VkShareResponse},
+    dealer::{DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse},
+    types::{Epoch, InitialReplacementData},
+    verification_key::PagedVKSharesResponse,
 };
 #[cfg(feature = "schema")]
 use cosmwasm_schema::QueryResponses;
@@ -28,31 +21,18 @@ 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 {
-    // we could have just re-used AdvanceEpochState, but imo an explicit message is better
-    InitiateDkg {},
-
     RegisterDealer {
         bte_key_with_proof: EncodedBTEPublicKeyWithProof,
-        identity_key: IdentityKey,
         announce_address: String,
         resharing: bool,
     },
 
-    CommitDealingsMetadata {
-        dealing_index: DealingIndex,
-        chunks: Vec<DealingChunkInfo>,
-        resharing: bool,
-    },
-
-    CommitDealingsChunk {
-        chunk: PartialContractDealing,
+    CommitDealing {
+        dealing_bytes: ContractSafeBytes,
         resharing: bool,
     },
 
@@ -62,7 +42,8 @@ pub enum ExecuteMsg {
     },
 
     VerifyVerificationKeyShare {
-        owner: String,
+        // TODO: this should be using a String...
+        owner: Addr,
         resharing: bool,
     },
 
@@ -74,9 +55,6 @@ 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 {},
 
@@ -101,53 +79,19 @@ pub enum QueryMsg {
         start_after: Option<String>,
     },
 
-    #[cfg_attr(feature = "schema", returns(DealingMetadataResponse))]
-    GetDealingsMetadata {
-        epoch_id: EpochId,
-        dealer: String,
-        dealing_index: DealingIndex,
+    #[cfg_attr(feature = "schema", returns(PagedDealingsResponse))]
+    GetDealing {
+        idx: u64,
+        limit: Option<u32>,
+        start_after: Option<String>,
     },
 
-    #[cfg_attr(feature = "schema", returns(DealerDealingsStatusResponse))]
-    GetDealerDealingsStatus { epoch_id: EpochId, dealer: String },
-
-    #[cfg_attr(feature = "schema", returns(DealingStatusResponse))]
-    GetDealingStatus {
-        epoch_id: EpochId,
-        dealer: String,
-        dealing_index: DealingIndex,
-    },
-
-    #[cfg_attr(feature = "schema", returns(DealingChunkStatusResponse))]
-    GetDealingChunkStatus {
-        epoch_id: EpochId,
-        dealer: String,
-        dealing_index: DealingIndex,
-        chunk_index: ChunkIndex,
-    },
-
-    #[cfg_attr(feature = "schema", returns(DealingChunkResponse))]
-    GetDealingChunk {
-        epoch_id: EpochId,
-        dealer: String,
-        dealing_index: DealingIndex,
-        chunk_index: ChunkIndex,
-    },
-
-    #[cfg_attr(feature = "schema", returns(VkShareResponse))]
-    GetVerificationKey { epoch_id: EpochId, owner: String },
-
     #[cfg_attr(feature = "schema", returns(PagedVKSharesResponse))]
     GetVerificationKeys {
         epoch_id: EpochId,
         limit: Option<u32>,
         start_after: Option<String>,
     },
-
-    /// Gets the stored contract version information that's required by the CW2 spec interface for migrations.
-    #[serde(rename = "get_cw2_contract_version")]
-    #[cfg_attr(feature = "schema", returns(cw2::ContractVersion))]
-    GetCW2ContractVersion {},
 }
 
 #[cw_serde]

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

@@ -8,18 +8,14 @@ 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;
-// we really don't need to hold more data than that (even u8 would have been enough),
-// but explicitly make it different type than `DealingIndex` so type system would detect any
-// accidental misuses
-pub type ChunkIndex = u16;
-pub type PartialContractDealingData = ContractSafeBytes;
+
+// 2 public attributes, 2 private attributes, 1 fixed for coconut credential
+pub const TOTAL_DEALINGS: usize = 2 + 2 + 1;
 
 #[cw_serde]
 pub struct InitialReplacementData {
@@ -77,23 +73,13 @@ 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 {
     pub state: EpochState,
     pub epoch_id: EpochId,
     pub time_configuration: TimeConfiguration,
-    pub finish_timestamp: Option<Timestamp>,
+    pub finish_timestamp: Timestamp,
 }
 
 impl Epoch {
@@ -104,40 +90,36 @@ impl Epoch {
         current_timestamp: Timestamp,
     ) -> Self {
         let duration = match state {
-            EpochState::WaitingInitialisation => None,
             EpochState::PublicKeySubmission { .. } => {
-                Some(time_configuration.public_key_submission_time_secs)
-            }
-            EpochState::DealingExchange { .. } => {
-                Some(time_configuration.dealing_exchange_time_secs)
+                time_configuration.public_key_submission_time_secs
             }
+            EpochState::DealingExchange { .. } => time_configuration.dealing_exchange_time_secs,
             EpochState::VerificationKeySubmission { .. } => {
-                Some(time_configuration.verification_key_submission_time_secs)
+                time_configuration.verification_key_submission_time_secs
             }
             EpochState::VerificationKeyValidation { .. } => {
-                Some(time_configuration.verification_key_validation_time_secs)
+                time_configuration.verification_key_validation_time_secs
             }
             EpochState::VerificationKeyFinalization { .. } => {
-                Some(time_configuration.verification_key_finalization_time_secs)
+                time_configuration.verification_key_finalization_time_secs
             }
-            EpochState::InProgress => Some(time_configuration.in_progress_time_secs),
+            EpochState::InProgress => time_configuration.in_progress_time_secs,
         };
         Epoch {
             state,
             epoch_id,
             time_configuration,
-            finish_timestamp: duration.map(|d| current_timestamp.plus_seconds(d)),
+            finish_timestamp: current_timestamp.plus_seconds(duration),
         }
     }
 
-    pub fn final_timestamp_secs(&self) -> Option<u64> {
-        let mut finish = self.finish_timestamp?.seconds();
+    pub fn final_timestamp_secs(&self) -> u64 {
+        let mut finish = self.finish_timestamp.seconds();
         let time_configuration = self.time_configuration;
         let mut curr_epoch_state = self.state;
         while let Some(state) = curr_epoch_state.next() {
             curr_epoch_state = state;
             let adding = match curr_epoch_state {
-                EpochState::WaitingInitialisation => return None,
                 EpochState::PublicKeySubmission { .. } => {
                     time_configuration.public_key_submission_time_secs
                 }
@@ -155,13 +137,12 @@ impl Epoch {
             };
             finish += adding;
         }
-        Some(finish)
+        finish
     }
 }
 
 // currently (it is still extremely likely to change, we might be able to get rid of verification key-related complaints),
 // the epoch can be in the following states (in order):
-// 0. WaitingInitialisation -> the contract has been instantiated, but awaits for the admin to kick off the process (group members might still be getting added)
 // 1. PublicKeySubmission -> potential dealers are submitting their BTE and ed25519 public keys to participate in dealing exchange
 // 2. DealingExchange -> the actual (off-chain) dealing exchange is happening
 // 3. ComplaintSubmission -> receivers submitting evidence of other dealers sending malformed data
@@ -175,7 +156,6 @@ impl Epoch {
 #[cw_serde]
 #[derive(Copy)]
 pub enum EpochState {
-    WaitingInitialisation,
     PublicKeySubmission { resharing: bool },
     DealingExchange { resharing: bool },
     VerificationKeySubmission { resharing: bool },
@@ -186,28 +166,25 @@ pub enum EpochState {
 
 impl Default for EpochState {
     fn default() -> Self {
-        Self::WaitingInitialisation
+        Self::PublicKeySubmission { resharing: false }
     }
 }
 
 impl Display for EpochState {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            EpochState::WaitingInitialisation => write!(f, "Waiting for initialisation"),
             EpochState::PublicKeySubmission { resharing } => {
-                write!(f, "PublicKeySubmission (resharing: {resharing})")
-            }
-            EpochState::DealingExchange { resharing } => {
-                write!(f, "DealingExchange (resharing: {resharing})")
+                write!(f, "PublicKeySubmission with resharing {resharing}")
             }
+            EpochState::DealingExchange { resharing } => write!(f, "DealingExchange {resharing}"),
             EpochState::VerificationKeySubmission { resharing } => {
-                write!(f, "VerificationKeySubmission (resharing: {resharing})")
+                write!(f, "VerificationKeySubmission with resharing {resharing}")
             }
             EpochState::VerificationKeyValidation { resharing } => {
-                write!(f, "VerificationKeyValidation (resharing: {resharing})")
+                write!(f, "VerificationKeyValidation with resharing {resharing}")
             }
             EpochState::VerificationKeyFinalization { resharing } => {
-                write!(f, "VerificationKeyFinalization (resharing: {resharing})")
+                write!(f, "VerificationKeyFinalization with resharing {resharing}")
             }
             EpochState::InProgress => write!(f, "InProgress"),
         }
@@ -215,13 +192,8 @@ impl Display for EpochState {
 }
 
 impl EpochState {
-    pub fn first() -> Self {
-        EpochState::PublicKeySubmission { resharing: false }
-    }
-
     pub fn next(self) -> Option<Self> {
         match self {
-            EpochState::WaitingInitialisation => None,
             EpochState::PublicKeySubmission { resharing } => {
                 Some(EpochState::DealingExchange { resharing })
             }

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

@@ -20,13 +20,6 @@ pub struct ContractVKShare {
     pub verified: bool,
 }
 
-#[cw_serde]
-pub struct VkShareResponse {
-    pub owner: Addr,
-    pub epoch_id: EpochId,
-    pub share: Option<ContractVKShare>,
-}
-
 #[cw_serde]
 pub struct PagedVKSharesResponse {
     pub shares: Vec<ContractVKShare>,
@@ -43,10 +36,7 @@ pub fn to_cosmos_msg(
     multisig_addr: String,
     expiration_time: Timestamp,
 ) -> StdResult<CosmosMsg> {
-    let verify_vk_share_req = ExecuteMsg::VerifyVerificationKeyShare {
-        owner: owner.to_string(),
-        resharing,
-    };
+    let verify_vk_share_req = ExecuteMsg::VerifyVerificationKeyShare { owner, resharing };
     let verify_vk_share_msg = CosmosMsg::Wasm(WasmMsg::Execute {
         contract_addr: coconut_dkg_addr,
         msg: to_binary(&verify_vk_share_req)?,
@@ -67,14 +57,7 @@ pub fn to_cosmos_msg(
     Ok(msg)
 }
 
-// DKG SAFETY:
-// each legit verification proposal will only contain a single execute msg,
-// if they have more than one, we can safely ignore it
-pub fn owner_from_cosmos_msgs(msgs: &[CosmosMsg]) -> Option<String> {
-    if msgs.len() != 1 {
-        return None;
-    }
-
+pub fn owner_from_cosmos_msgs(msgs: &[CosmosMsg]) -> Option<Addr> {
     if let Some(CosmosMsg::Wasm(WasmMsg::Execute {
         contract_addr: _,
         msg,

common/cosmwasm-smart-contracts/contracts-common/src/dealings.rs

@@ -4,14 +4,14 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::fmt::{Display, Formatter};
-use std::ops::{Deref, DerefMut};
+use std::ops::Deref;
 
 // some sane upper-bound size on byte sizes
 // currently set to 128 bytes
 pub const MAX_DISPLAY_SIZE: usize = 128;
 
-// helps to transfer bytes between contract boundary to decrease amount of data sent accross
-// after it's put to `Binary`
+// TODO: if we are to use this for different types, it might make sense to introduce something like
+// CommitmentTypeId field on the below for distinguishing different ones. it would somehow become part of the trait
 #[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq, Hash, JsonSchema)]
 pub struct ContractSafeBytes(pub Vec<u8>);
 
@@ -23,18 +23,6 @@ impl Deref for ContractSafeBytes {
     }
 }
 
-impl DerefMut for ContractSafeBytes {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl From<Vec<u8>> for ContractSafeBytes {
-    fn from(value: Vec<u8>) -> Self {
-        ContractSafeBytes(value)
-    }
-}
-
 impl Display for ContractSafeBytes {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         if !self.0.is_empty() {

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

@@ -2,7 +2,6 @@
 name = "nym-ephemera-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -14,4 +13,4 @@ cw-utils = { workspace = true }
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
 
 [features]
-schema = []
+schema = []

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

@@ -2,7 +2,6 @@
 name = "nym-group-contract-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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

@@ -25,12 +25,12 @@ humantime-serde = "1.1.1"
 
 # TO CHECK WHETHER STILL NEEDED:
 log = { workspace = true }
-time = { workspace = true, features = ["parsing", "formatting"] }
+time = { version = "0.3.6", features = ["parsing", "formatting"] }
 ts-rs = { workspace = true, optional = true }
 
 [dev-dependencies]
 rand_chacha = "0.3"
-time = { workspace = true, features = ["serde", "macros"] }
+time = { version = "0.3.5", features = ["serde", "macros"] }
 
 [features]
 default = []

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

@@ -2,7 +2,6 @@
 name = "nym-multisig-contract-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

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

@@ -2,7 +2,6 @@
 name = "nym-name-service-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -17,4 +16,4 @@ serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }
 
 [features]
-schema = ["cw2"]
+schema = ["cw2"]

common/cosmwasm-smart-contracts/service-provider-directory/Cargo.toml

@@ -2,7 +2,6 @@
 name = "nym-service-provider-directory-common"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -16,4 +15,4 @@ nym-contracts-common = { path = "../contracts-common", version = "0.5.0" }
 thiserror = { workspace = true }
 
 [features]
-schema = ["cw2"]
+schema = ["cw2"]

common/credential-storage/Cargo.toml

@@ -2,7 +2,6 @@
 name = "nym-credential-storage"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -14,14 +13,14 @@ thiserror = { workspace = true }
 tokio = { version = "1.24.1", features = ["sync"]}
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
-workspace = true
+version = "0.5"
 features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-workspace = true
+version = "1.24.1"
 features = [ "rt-multi-thread", "net", "signal", "fs" ]
 
 
 [build-dependencies]
-sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
+sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
 tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }

common/credential-utils/Cargo.toml

@@ -2,7 +2,6 @@
 name = "nym-credential-utils"
 version = "0.1.0"
 edition = "2021"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

common/credential-utils/src/utils.rs

@@ -5,9 +5,7 @@ use nym_bandwidth_controller::acquire::state::State;
 use nym_client_core::config::disk_persistence::CommonClientPaths;
 use nym_config::DEFAULT_DATA_DIR;
 use nym_credential_storage::persistent_storage::PersistentStorage;
-use nym_validator_client::nyxd::contract_traits::{
-    dkg_query_client::EpochState, CoconutBandwidthSigningClient, DkgQueryClient,
-};
+use nym_validator_client::nyxd::contract_traits::{CoconutBandwidthSigningClient, DkgQueryClient};
 use nym_validator_client::nyxd::Coin;
 use std::path::PathBuf;
 use std::process::exit;
@@ -89,29 +87,21 @@ where
             .duration_since(SystemTime::UNIX_EPOCH)
             .expect("the system clock is set to 01/01/1970 (or earlier)")
             .as_secs();
-
         if epoch.state.is_final() {
-            if let Some(finish_timestamp) = epoch.finish_timestamp {
-                if current_timestamp_secs + SAFETY_BUFFER_SECS >= finish_timestamp.seconds() {
-                    info!("In the next {} minute(s), a transition will take place in the coconut system. Deposits should be halted in this time for safety reasons.", SAFETY_BUFFER_SECS / 60);
-                    exit(0);
-                }
+            if current_timestamp_secs + SAFETY_BUFFER_SECS >= epoch.finish_timestamp.seconds() {
+                info!("In the next {} minute(s), a transition will take place in the coconut system. Deposits should be halted in this time for safety reasons.", SAFETY_BUFFER_SECS / 60);
+                exit(0);
             }
 
             break;
-        } else if let Some(final_timestamp) = epoch.final_timestamp_secs() {
+        } else {
             // Use 1 additional second to not start the next iteration immediately and spam get_current_epoch queries
-            let secs_until_final = final_timestamp.saturating_sub(current_timestamp_secs) + 1;
+            let secs_until_final = epoch
+                .final_timestamp_secs()
+                .saturating_sub(current_timestamp_secs)
+                + 1;
             info!("Approximately {} seconds until coconut is available. Sleeping until then. You can safely kill the process at any moment.", secs_until_final);
             tokio::time::sleep(Duration::from_secs(secs_until_final)).await;
-        } else if matches!(epoch.state, EpochState::WaitingInitialisation) {
-            info!("dkg hasn't been initialised yet and it is not known when it will be. Going to check again later");
-            tokio::time::sleep(Duration::from_secs(60 * 5)).await;
-        } else {
-            // this should never be the case since the only case where final timestamp is unknown is when it's waiting for initialisation,
-            // but let's guard ourselves against future changes
-            info!("it is unknown when coconut will be come available. Going to check again later");
-            tokio::time::sleep(Duration::from_secs(60 * 5)).await;
         }
     }
 

common/credentials/Cargo.toml

@@ -2,20 +2,18 @@
 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 = { workspace = true, default-features = false, features = ["pairings", "alloc", "experimental"] }
+bls12_381 = { version = "0.5", 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"] }
+nym-crypto = { path = "../crypto", features = ["rand", "asymmetric", "symmetric", "hashing"] }
 nym-api-requests = { path = "../../nym-api/nym-api-requests" }
 nym-validator-client = { path = "../client-libs/validator-client", default-features = false }
 

common/credentials/src/coconut/bandwidth.rs

@@ -13,60 +13,38 @@ 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;
 
-#[derive(Zeroize, ZeroizeOnDrop)]
+pub const PUBLIC_ATTRIBUTES: u32 = 2;
+pub const PRIVATE_ATTRIBUTES: u32 = 2;
+pub const TOTAL_ATTRIBUTES: u32 = PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES;
+
 pub struct BandwidthVoucher {
-    // private attributes
-    /// a random secret value generated by the client used for double-spending detection
+    // 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,
-
-    // public atttributes:
-    /// the plain text value (e.g., bandwidth) encoded in this voucher
-    // TODO: in another PR change the value from `"1000"` to `"1000unym"`
+    // the value (e.g., bandwidth) encoded in this voucher
+    voucher_value: PublicAttribute,
+    // the plain text value (e.g., bandwidth) encoded in this voucher
     voucher_value_plain: String,
-
-    /// the plain text information
+    // a field with public information, e.g., type of voucher, interval etc.
+    voucher_info: PublicAttribute,
+    // the plain text information
     voucher_info_plain: String,
-
-    /// 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)]
+    // the hash of the deposit transaction
     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
-    unused_ed25519: encryption::PrivateKey,
-
+    // base58 encoded private key ensuring only this client receives the signature share
+    encryption_key: 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,
@@ -79,26 +57,24 @@ 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_prehashed = hash_to_scalar(voucher_value);
-        let _voucher_info_prehashed = hash_to_scalar(voucher_info);
-
+        let voucher_value = hash_to_scalar(voucher_value.as_bytes());
+        let voucher_info = hash_to_scalar(voucher_info.as_bytes());
         let (pedersen_commitments_openings, blind_sign_request) = prepare_blind_sign(
             params,
-            &[&serial_number, &binding_number],
-            &[&_voucher_value_prehashed, &_voucher_info_prehashed],
+            &[serial_number, binding_number],
+            &[voucher_value, voucher_info],
         )
         .unwrap();
         BandwidthVoucher {
             serial_number,
             binding_number,
-            _voucher_value_prehashed,
+            voucher_value,
             voucher_value_plain,
-            _voucher_info_prehashed,
+            voucher_info,
             voucher_info_plain,
             tx_hash,
             signing_key,
-            unused_ed25519: encryption_key,
+            encryption_key,
             pedersen_commitments_openings,
             blind_sign_request,
         }
@@ -111,7 +87,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.unused_ed25519.to_bytes();
+        let encryption_key_b = self.encryption_key.to_bytes();
         let blind_sign_request_b = self.blind_sign_request.to_bytes();
 
         let mut ret = Vec::new();
@@ -195,13 +171,13 @@ impl BandwidthVoucher {
             bytes[var_length_pointer..var_length_pointer + voucher_value_plain_no].to_vec(),
         )
         .or_else(utf_err)?;
-        let _voucher_value_prehashed = hash_to_scalar(&voucher_value_plain);
+        let voucher_value = 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_prehashed = hash_to_scalar(&voucher_info_plain);
+        let voucher_info = 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],
@@ -220,43 +196,36 @@ impl BandwidthVoucher {
         Ok(Self {
             serial_number,
             binding_number,
-            _voucher_value_prehashed,
+            voucher_value,
             voucher_value_plain,
-            _voucher_info_prehashed,
+            voucher_info,
             voucher_info_plain,
             tx_hash,
             signing_key,
-            unused_ed25519: encryption_key,
+            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_prehashed,
-            &self._voucher_info_prehashed,
-        ]
-    }
-
-    pub fn identity_key(&self) -> &identity::PrivateKey {
-        &self.signing_key
+    pub fn get_public_attributes(&self) -> Vec<PublicAttribute> {
+        vec![self.voucher_value, self.voucher_info]
     }
 
     pub fn encryption_key(&self) -> &encryption::PrivateKey {
-        &self.unused_ed25519
+        &self.encryption_key
     }
 
     pub fn pedersen_commitments_openings(&self) -> &Vec<Attribute> {
@@ -278,32 +247,27 @@ 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 signable_plaintext(request: &BlindSignRequest, tx_hash: Hash) -> Vec<u8> {
+    pub fn sign(&self, request: &BlindSignRequest) -> identity::Signature {
         let mut message = request.to_bytes();
-        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)
+        message.extend_from_slice(self.tx_hash.to_string().as_bytes());
+        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(BandwidthVoucher::ENCODED_ATTRIBUTES)?;
+    let params = Parameters::new(TOTAL_ATTRIBUTES)?;
 
     prepare_credential_for_spending(
         &params,
@@ -352,30 +316,24 @@ 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.unused_ed25519.to_string(),
-            deserialized_voucher.unused_ed25519.to_string()
+            voucher.encryption_key.to_string(),
+            deserialized_voucher.encryption_key.to_string()
         );
         assert_eq!(
             voucher.pedersen_commitments_openings,
@@ -413,11 +371,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(

common/credentials/src/coconut/mod.rs

@@ -2,4 +2,5 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod bandwidth;
+pub mod params;
 pub mod utils;

common/credentials/src/coconut/params.rs

@@ -0,0 +1,15 @@
+// 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;

common/credentials/src/coconut/utils.rs

@@ -1,14 +1,18 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::coconut::bandwidth::BandwidthVoucher;
+use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES, PUBLIC_ATTRIBUTES};
+use crate::coconut::params::{NymApiCredentialEncryptionAlgorithm, NymApiCredentialHkdfAlgorithm};
 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,
-    Credential, Parameters, Signature, SignatureShare, VerificationKey,
+    BlindedSignature, 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(
@@ -32,34 +36,47 @@ pub async fn obtain_aggregate_verification_key(
 
 async fn obtain_partial_credential(
     params: &Parameters,
-    voucher: &BandwidthVoucher,
+    attributes: &BandwidthVoucher,
     client: &nym_validator_client::client::NymApiClient,
     validator_vk: &VerificationKey,
 ) -> Result<Signature, Error> {
-    let public_attributes_plain = voucher.get_public_attributes_plain();
-    let blind_sign_request = voucher.blind_sign_request();
-    let request_signature = voucher.sign();
+    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 blind_sign_request_body = BlindSignRequestBody::new(
-        blind_sign_request.clone(),
-        voucher.tx_hash(),
-        request_signature,
+        blind_sign_request,
+        attributes.tx_hash().to_string(),
+        attributes.sign(blind_sign_request).to_base58_string(),
+        &public_attributes,
         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 blinded_signature = response.blinded_signature;
+    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 public_attributes = voucher.get_public_attributes();
-    let private_attributes = voucher.get_private_attributes();
+    let blinded_signature = BlindedSignature::from_bytes(&blinded_signature_bytes)?;
 
-    let unblinded_signature = blinded_signature.unblind_and_verify(
+    let unblinded_signature = blinded_signature.unblind(
         params,
         validator_vk,
         &private_attributes,
         &public_attributes,
         &blind_sign_request.get_commitment_hash(),
-        voucher.pedersen_commitments_openings(),
+        attributes.pedersen_commitments_openings(),
     )?;
 
     Ok(unblinded_signature)
@@ -67,13 +84,16 @@ async fn obtain_partial_credential(
 
 pub async fn obtain_aggregate_signature(
     params: &Parameters,
-    voucher: &BandwidthVoucher,
+    attributes: &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()
@@ -94,7 +114,7 @@ pub async fn obtain_aggregate_signature(
 
         match obtain_partial_credential(
             params,
-            voucher,
+            attributes,
             &coconut_api_client.api_client,
             &coconut_api_client.verification_key,
         )
@@ -116,9 +136,6 @@ 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);
@@ -133,8 +150,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,
@@ -148,7 +165,7 @@ pub fn prepare_credential_for_spending(
     )?;
 
     Ok(Credential::new(
-        BandwidthVoucher::ENCODED_ATTRIBUTES,
+        PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES,
         theta,
         voucher_value,
         voucher_info,

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

@@ -201,17 +201,6 @@ 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()
     }

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

@@ -5,14 +5,13 @@ 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")]
@@ -225,17 +224,6 @@ 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()
     }
@@ -307,7 +295,7 @@ impl PemStorableKey for PrivateKey {
     }
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug)]
 pub struct Signature(ed25519_dalek::Signature);
 
 impl Signature {
@@ -331,14 +319,6 @@ 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>

common/dkg/Cargo.toml

@@ -3,7 +3,6 @@ name = "nym-dkg"
 version = "0.1.0"
 edition = "2021"
 resolver = "2"
-license.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -12,7 +11,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 = { workspace = true, default-features = false, features = ["alloc", "pairings", "experimental", "zeroize"] }
+bls12_381 = { git = "https://github.com/jstuczyn/bls12_381", branch ="gt-serialisation", default-features = false, features = ["alloc", "pairings", "experimental", "zeroize"] }
 nym-contracts-common = { path = "../cosmwasm-smart-contracts/contracts-common", optional = true }
 bs58 = "0.4"
 
@@ -30,11 +29,11 @@ zeroize = { workspace = true, features = ["zeroize_derive"] }
 nym-pemstore = { path = "../pemstore" }
 
 [dependencies.group]
-workspace = true
+version = "0.11"
 default-features = false
 
 [dependencies.ff]
-workspace = true
+version = "0.11"
 default-features = false
 
 [dev-dependencies]

common/dkg/src/bte/encryption.rs

@@ -14,7 +14,8 @@ use std::collections::HashMap;
 use std::ops::Neg;
 use zeroize::Zeroize;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
+#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
 pub struct Ciphertexts {
     pub rr: [G1Projective; NUM_CHUNKS],
     pub ss: [G1Projective; NUM_CHUNKS],

common/dkg/src/bte/keys.rs

@@ -53,7 +53,8 @@ impl PublicKey {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct PublicKeyWithProof {
     pub(crate) key: PublicKey,
     pub(crate) proof: ProofOfDiscreteLog,

common/dkg/src/bte/proof_chunking.rs

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

common/dkg/src/bte/proof_discrete_log.rs

@@ -13,7 +13,8 @@ use zeroize::Zeroize;
 const DISCRETE_LOG_DOMAIN: &[u8] =
     b"NYM_COCONUT_NIDKG_V01_CS01_WITH_BLS12381_XMD:SHA-256_SSWU_RO_PROOF_DISCRETE_LOG";
 
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct ProofOfDiscreteLog {
     pub(crate) rand_commitment: G1Projective,
     pub(crate) response: Scalar,

common/dkg/src/bte/proof_sharing.rs

@@ -76,7 +76,8 @@ impl<'a> Instance<'a> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
+#[cfg_attr(test, derive(Clone, PartialEq, Eq))]
 pub struct ProofOfSecretSharing {
     ff: G1Projective,
     aa: G2Projective,

common/dkg/src/dealing.rs

@@ -82,7 +82,8 @@ impl RecoveredVerificationKeys {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug)]
+#[cfg_attr(test, derive(PartialEq, Eq))]
 pub struct Dealing {
     pub public_coefficients: PublicCoefficients,
     pub ciphertexts: Ciphertexts,
@@ -320,17 +321,9 @@ impl<'a> TryFrom<&'a nym_contracts_common::dealings::ContractSafeBytes> for Deal
     }
 }
 
-/// Attempt to run the `VkCombine` algorithm to obtain the public master verification key, `VK`
-/// alongside shares of the verification key, `shvk_{1}`, `shvk_{2}`, ... `svhk_{n}`, where n is the number of receivers.
-///
-/// # Arguments
-///
-/// * `dealings`: map of dealer indices to dealings they generated
-/// * `threshold`: explicit threshold value of the associated dealings
-/// * `receivers`:map of receiver indices to their public keys
-// note: this function assumes all dealings have already been verified
+// this assumes all dealings have been verified
 pub fn try_recover_verification_keys(
-    dealings: &BTreeMap<NodeIndex, Dealing>,
+    dealings: &[Dealing],
     threshold: Threshold,
     receivers: &BTreeMap<NodeIndex, PublicKey>,
 ) -> Result<RecoveredVerificationKeys, DkgError> {
@@ -338,31 +331,24 @@ pub fn try_recover_verification_keys(
         return Err(DkgError::NoDealingsAvailable);
     }
 
-    let threshold = threshold as usize;
-
-    if dealings.len() < threshold {
-        return Err(DkgError::NotEnoughDealingsAvailable {
-            available: dealings.len(),
-            required: threshold,
-        });
-    }
+    let threshold_usize = threshold as usize;
 
     if !dealings
-        .values()
-        .all(|dealing| dealing.public_coefficients.size() == threshold)
+        .iter()
+        .all(|dealing| dealing.public_coefficients.size() == threshold_usize)
     {
         return Err(DkgError::MismatchedDealings);
     }
 
-    let dealer_indices = dealings.keys().collect::<Vec<_>>();
+    let indices = receivers.keys().collect::<Vec<_>>();
 
     // Compute A0, ..., A_{t-1}
-    let mut interpolated_coefficients = Vec::with_capacity(threshold);
-    for k in 0..threshold {
-        let mut samples = Vec::with_capacity(dealer_indices.len());
-        for (dealer_index, dealing) in dealings.iter() {
+    let mut interpolated_coefficients = Vec::with_capacity(threshold_usize);
+    for k in 0..threshold_usize {
+        let mut samples = Vec::with_capacity(indices.len());
+        for (j, dealing) in dealings.iter().enumerate() {
             samples.push((
-                Scalar::from(*dealer_index),
+                Scalar::from(*indices[j]),
                 *dealing.public_coefficients.nth(k),
             ))
         }
@@ -379,7 +365,7 @@ pub fn try_recover_verification_keys(
     // shvk_j = A0^{j^0} * A1^{j^1} * ... * A_{t-1}^{j^{t-1}}
     let verification_key_shares = receivers
         .keys()
-        .map(|receiver_index| interpolated_coefficients.evaluate_at(&Scalar::from(*receiver_index)))
+        .map(|index| interpolated_coefficients.evaluate_at(&Scalar::from(*index)))
         .collect();
 
     Ok(RecoveredVerificationKeys {
@@ -471,17 +457,14 @@ mod tests {
         let dealings = node_indices
             .iter()
             .map(|&dealer_index| {
-                (
-                    dealer_index,
-                    Dealing::create(&mut rng, &params, dealer_index, threshold, &receivers, None).0,
-                )
+                Dealing::create(&mut rng, &params, dealer_index, threshold, &receivers, None).0
             })
-            .collect::<BTreeMap<_, _>>();
+            .collect::<Vec<_>>();
 
         let mut derived_secrets = Vec::new();
-        for (i, (ref dk, _)) in full_keys.iter().enumerate() {
+        for (i, (ref mut dk, _)) in full_keys.iter_mut().enumerate() {
             let shares = dealings
-                .values()
+                .iter()
                 .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
                 .collect();
             derived_secrets.push(
@@ -530,12 +513,9 @@ mod tests {
         let dealings = node_indices
             .iter()
             .map(|&dealer_index| {
-                (
-                    dealer_index,
-                    Dealing::create(&mut rng, &params, dealer_index, threshold, &receivers, None).0,
-                )
+                Dealing::create(&mut rng, &params, dealer_index, threshold, &receivers, None).0
             })
-            .collect::<BTreeMap<_, _>>();
+            .collect::<Vec<_>>();
 
         let RecoveredVerificationKeys {
             recovered_master,
@@ -551,66 +531,6 @@ mod tests {
         .is_ok())
     }
 
-    #[test]
-    #[ignore] // expensive test
-    fn verifying_partial_verification_keys_with_different_dealers_and_receivers() {
-        let dummy_seed = [42u8; 32];
-        let mut rng = rand_chacha::ChaCha20Rng::from_seed(dummy_seed);
-        let params = setup();
-
-        let dealer_indices = [1, 2, 3, 8];
-        let receiver_indices = [3, 4, 5, 6, 7];
-        let threshold = 3;
-
-        let mut receivers = BTreeMap::new();
-        let mut full_keys = Vec::new();
-        for index in &receiver_indices {
-            let (dk, pk) = keygen(&params, &mut rng);
-            receivers.insert(*index, *pk.public_key());
-            full_keys.push((dk, pk))
-        }
-
-        let dealings = dealer_indices
-            .iter()
-            .map(|&dealer_index| {
-                (
-                    dealer_index,
-                    Dealing::create(&mut rng, &params, dealer_index, threshold, &receivers, None).0,
-                )
-            })
-            .collect::<BTreeMap<_, _>>();
-
-        let RecoveredVerificationKeys {
-            recovered_master,
-            recovered_partials,
-        } = try_recover_verification_keys(&dealings, threshold, &receivers).unwrap();
-
-        let g2 = G2Projective::generator();
-
-        let mut derived_secrets = Vec::new();
-        for (i, (dk, _)) in full_keys.iter().enumerate() {
-            let shares = dealings
-                .values()
-                .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
-                .collect();
-
-            let recovered_secret = combine_shares(shares, &dealer_indices).unwrap();
-
-            // make sure it matches the associated vk
-            assert_eq!(recovered_partials[i], g2 * recovered_secret);
-
-            derived_secrets.push(recovered_secret)
-        }
-
-        assert!(verify_verification_keys(
-            &recovered_master,
-            &recovered_partials,
-            &receivers,
-            threshold
-        )
-        .is_ok())
-    }
-
     #[test]
     #[ignore] // expensive test
     fn dealing_roundtrip() {

common/dkg/src/error.rs

@@ -3,7 +3,7 @@
 
 use thiserror::Error;
 
-#[derive(Debug, Error, Clone)]
+#[derive(Debug, Error)]
 pub enum DkgError {
     #[error("Provided set of values contained duplicate coordinate")]
     DuplicateCoordinate,