Add rollup config to output CommonJS bundle

The WASM bundle is embedded as a base64 encoded resource and loaded synchronously, because this is the only mechanism widely supported to load WASM inside a web worker currently. Hopefully in the future this can be changed to pure modules.

.github/workflows/audit.yml

@@ -35,10 +35,6 @@ jobs:
         with:
           name: report
           path: .github/workflows/support-files/notifications
-      - name: install npm
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16
       - name: Keybase - Node Install
         run: npm install
         working-directory: .github/workflows/support-files

.github/workflows/audit_on_dispatch.yml

@@ -0,0 +1,58 @@
+name: Daily security audit
+
+on: workflow_dispatch
+jobs:
+  cargo-deny:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout repository code
+        uses: actions/checkout@v2
+      - name: Install rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install cargo deny
+        run: cargo install --locked cargo-deny
+      - name: Run cargo deny
+        run: |
+          find . -name Cargo.toml -exec cargo deny --manifest-path {} check \
+            advisories -A advisory-not-detected  --hide-inclusion-graph \; &> \
+            >(uniq  &> .github/workflows/support-files/notifications/deny.message )
+      - uses: actions/upload-artifact@v3
+        with:
+          name: report
+          path: .github/workflows/support-files/notifications/deny.message
+  notification:
+    needs: cargo-deny
+    runs-on: custom-runner-linux
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v2
+      - name: Download report from previous job
+        uses: actions/download-artifact@v3
+        with:
+          name: report
+          path: .github/workflows/support-files/notifications
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - name: Keybase - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Keybase - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: security
+          NYM_PROJECT_NAME: "Daily security report"
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+          KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
+          KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
+          KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
+          KEYBASE_NYM_CHANNEL: "security"
+          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
+          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/build-ts-packages.yml

@@ -12,7 +12,6 @@ jobs:
     - uses: actions/checkout@v2
     - name: Install rsync
       run: sudo apt-get install rsync
-      continue-on-error: true
     - uses: rlespinasse/github-slug-action@v3.x
     - uses: actions/setup-node@v3
       with:

.github/workflows/build.yml

@@ -17,7 +17,6 @@ jobs:
     steps:
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
 
       - name: Check out repository code
         uses: actions/checkout@v2
@@ -42,12 +41,6 @@ jobs:
           command: build
           args: --workspace
 
-      - name: Build all examples
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --examples
-
       - name: Run all tests
         uses: actions-rs/cargo@v1
         with:
@@ -72,7 +65,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: clippy
-          args: --workspace --all-targets --all-features -- -D warnings
+          args: --workspace -- -D warnings
 
       # COCONUT stuff
 

.github/workflows/connect.yml

@@ -13,7 +13,6 @@ jobs:
     steps:
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools libayatana-appindicator3-dev
-        continue-on-error: true
 
       - name: Check out repository code
         uses: actions/checkout@v2

.github/workflows/network-explorer-api.yml

@@ -21,7 +21,6 @@ jobs:
 
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
 
       - name: Check the release tag starts with `nym-explorer-api-`
         if: startsWith(github.ref, 'refs/tags/nym-explorer-api-') == false && github.event_name != 'workflow_dispatch'

.github/workflows/network-explorer.yml

@@ -17,7 +17,6 @@ jobs:
     - uses: actions/checkout@v2
     - name: Install rsync
       run: sudo apt-get install rsync
-      continue-on-error: true
     - uses: rlespinasse/github-slug-action@v3.x
     - uses: actions/setup-node@v3
       with:

.github/workflows/nightly_build.yml

@@ -25,7 +25,6 @@ jobs:
     steps:
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
         if: matrix.os == 'ubuntu-20.04'
 
       - name: Check out repository code
@@ -39,12 +38,6 @@ jobs:
           override: true
           components: rustfmt, clippy
 
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
       - name: Build all binaries
         uses: actions-rs/cargo@v1
         with:
@@ -57,18 +50,6 @@ jobs:
         with:
           command: clean
 
-      - name: Build all examples
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --workspace --examples
-
-      - name: Reclaim some disk space (because Windows is being annoying)
-        uses: actions-rs/cargo@v1
-        if: ${{ matrix.os == 'windows-latest' }}
-        with:
-          command: clean
-
       - name: Run all tests
         uses: actions-rs/cargo@v1
         with:
@@ -88,6 +69,12 @@ jobs:
           command: test
           args: --workspace --all-features -- --ignored
 
+      - name: Check formatting
+        uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
       - name: Reclaim some disk space (because Windows is being annoying)
         uses: actions-rs/cargo@v1
         if: ${{ matrix.os == 'windows-latest' }}
@@ -106,7 +93,7 @@ jobs:
         if: ${{ matrix.rust != 'nightly' }}
         with:
           command: clippy
-          args: --workspace --all-targets --all-features -- -D warnings
+          args: --workspace --all-targets -- -D warnings
 
       - name: Reclaim some disk space
         uses: actions-rs/cargo@v1
@@ -180,11 +167,6 @@ jobs:
         uses: technote-space/workflow-conclusion-action@v2
       - name: Check out repository code
         uses: actions/checkout@v2
-      - name: install npm
-        uses: actions/setup-node@v3
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        with:
-          node-version: 16
       - name: Keybase - Node Install
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install

.github/workflows/nightly_build_release.yml

@@ -38,7 +38,6 @@ jobs:
     steps:
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
         if: matrix.os == 'ubuntu-20.04'
 
       - name: Check out latest release branch
@@ -183,11 +182,6 @@ jobs:
         uses: technote-space/workflow-conclusion-action@v2
       - name: Check out repository code
         uses: actions/checkout@v3
-      - name: install npm
-        uses: actions/setup-node@v3
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        with:
-          node-version: 16
       - name: Keybase - Node Install
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install

.github/workflows/nightly_build_release2.yml

@@ -38,7 +38,6 @@ jobs:
     steps:
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
         if: matrix.os == 'ubuntu-20.04'
 
       - name: Check out latest release branch
@@ -183,11 +182,6 @@ jobs:
         uses: technote-space/workflow-conclusion-action@v2
       - name: Check out repository code
         uses: actions/checkout@v3
-      - name: install npm
-        uses: actions/setup-node@v3
-        if: env.WORKFLOW_CONCLUSION == 'failure'
-        with:
-          node-version: 16
       - name: Keybase - Node Install
         if: env.WORKFLOW_CONCLUSION == 'failure'
         run: npm install

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

@@ -23,7 +23,6 @@ jobs:
         run: >
           sudo apt-get update &&
           sudo apt-get install -y webkit2gtk-4.0 libayatana-appindicator3-dev
-        continue-on-error: true
       - name: Check the release tag starts with `nym-connect-`
         if: startsWith(github.ref, 'refs/tags/nym-connect-') == false && github.event_name != 'workflow_dispatch'
         uses: actions/github-script@v3

.github/workflows/nym-connect.yml

@@ -16,7 +16,6 @@ jobs:
     - uses: actions/checkout@v2
     - name: Install rsync
       run: sudo apt-get install rsync
-      continue-on-error: true
     - uses: rlespinasse/github-slug-action@v3.x
     - uses: actions/setup-node@v3
       with:

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

@@ -27,7 +27,6 @@ jobs:
 
       - name: Install Dependencies (Linux)
         run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
-        continue-on-error: true
 
       - name: Check the release tag starts with `nym-binaries-`
         if: startsWith(github.ref, 'refs/tags/nym-binaries-') == false && github.event_name != 'workflow_dispatch'
@@ -61,7 +60,7 @@ jobs:
             target/release/nym-gateway
             target/release/nym-mixnode
             target/release/nym-socks5-client
-            target/release/nym-api
+            target/release/nym-validator-api
             target/release/nym-network-requester
             target/release/nym-network-statistics
             target/release/nym-cli
@@ -76,7 +75,7 @@ jobs:
             target/release/nym-gateway
             target/release/nym-mixnode
             target/release/nym-socks5-client
-            target/release/nym-api
+            target/release/nym-validator-api
             target/release/nym-network-requester
             target/release/nym-network-statistics
             target/release/nym-cli

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

@@ -22,7 +22,6 @@ jobs:
         run: >
           sudo apt-get update &&
           sudo apt-get install -y webkit2gtk-4.0
-        continue-on-error: true
       - name: Check the release tag starts with `nym-wallet-`
         if: startsWith(github.ref, 'refs/tags/nym-wallet-') == false
         uses: actions/github-script@v3

.github/workflows/nym-wallet-storybook.yml

@@ -12,7 +12,6 @@ jobs:
     - uses: actions/checkout@v2
     - name: Install rsync
       run: sudo apt-get install rsync
-      continue-on-error: true
     - uses: rlespinasse/github-slug-action@v3.x
     - uses: actions/setup-node@v3
       with:

.github/workflows/nym_wallet.yml

@@ -26,7 +26,6 @@ jobs:
           libappindicator3-dev
           webkit2gtk-driver
           xvfb
-        continue-on-error: true
 
       - name: Install minimal stable
         uses: actions-rs/toolchain@v1

.github/workflows/typescript-lint.yml

@@ -1,50 +0,0 @@
-name: CI for linting Typescript
-
-on:
-  push:
-    paths:
-      - 'ts-packages/**'
-      - 'sdk/typescript/**'
-      - nym-connect
-      - nym-wallet
-
-jobs:
-  build:
-    runs-on: custom-runner-linux
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install rsync
-      run: sudo apt-get install rsync
-      continue-on-error: true
-    - uses: rlespinasse/github-slug-action@v3.x
-    - uses: actions/setup-node@v3
-      with:
-        node-version: 16
-    - name: Setup yarn
-      run: npm install -g yarn
-    - name: Lint
-      run: yarn && yarn lint && yarn tsc
-    - name: Keybase - Node Install
-      run: npm install
-      working-directory: .github/workflows/support-files
-    - name: Keybase - Send Notification
-      env:
-        NYM_NOTIFICATION_KIND: ts-packages
-        NYM_PROJECT_NAME: "ts-packages"
-        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-        NYM_CI_WWW_LOCATION: "ts-${{ env.GITHUB_REF_SLUG }}"
-        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-        GIT_BRANCH: "${GITHUB_REF##*/}"
-        KEYBASE_NYMBOT_USERNAME: "${{ secrets.KEYBASE_NYMBOT_USERNAME }}"
-        KEYBASE_NYMBOT_PAPERKEY: "${{ secrets.KEYBASE_NYMBOT_PAPERKEY }}"
-        KEYBASE_NYMBOT_TEAM: "${{ secrets.KEYBASE_NYMBOT_TEAM }}"
-        KEYBASE_NYM_CHANNEL: "ci-ts-packages"
-        IS_SUCCESS: "${{ job.status == 'success' }}"
-        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
-        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-      uses: docker://keybaseio/client:stable-node
-      with:
-        args: .github/workflows/support-files/notifications/entry_point.sh

.github/workflows/wasm_client_build.yml

@@ -29,6 +29,11 @@ jobs:
           command: build
           args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown --features=coconut
 
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path clients/webassembly/Cargo.toml
+
       - uses: actions-rs/cargo@v1
         with:
           command: fmt

CHANGELOG.md

@@ -2,77 +2,28 @@
 
 Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-# [Unreleased]
-
-### Added
-
-- dkg rerun from scratch and dkg-specific epochs ([#2839])
-- nym-sdk: add support for surb storage ([#2870])
-- nym-sdk: enable reply-SURBs by default ([#2874])
-
-[#2839]: https://github.com/nymtech/nym/pull/2839
-[#2870]: https://github.com/nymtech/nym/pull/2870
-[#2874]: https://github.com/nymtech/nym/pull/2874
-
-# [v1.1.7] (2023-01-24)
-
-### Added
-
-- Gateways now shut down gracefully ([#2019]).
-- Rust SDK - Initial version for nym-client ([#2669]).
-- Introduce vesting contract query for addresses of all vesting accounts (required for the circulating supply calculation) ([#2778]).
-- Add threshold value to the contract storage ([#1893])
-
-### Changed
-
-- Refactor vesting account storage (and in particular, ACCOUNTS saving) ([#2795]).
-- Move from manual advancing DKG state to an automatic process ([#2670]).
-
-### Fixed
-
-- Gateways now shut down gracefully ([#2019]).
-
-[#2019]: https://github.com/nymtech/nym/issues/2019
-[#2669]: https://github.com/nymtech/nym/issues/2669
-[#2795]: https://github.com/nymtech/nym/issues/2795
-[#2778]: https://github.com/nymtech/nym/issues/2778
-[#2670]: https://github.com/nymtech/nym/issues/2670
-[#1893]: https://github.com/nymtech/nym/issues/1893
-
-## [v1.1.6] (2023-01-17)
+## [Unreleased]
 
 ### Added
 
 - nym-sdk: added initial version of a Rust client sdk
 - nym-api: added `/circulating-supply` endpoint ([#2814])
-- nym-api: add endpoint listing detailed gateway info by @octol in https://github.com/nymtech/nym/pull/2833
 
 ### Changed
 
-- streamline override_config functions -> there's a lot of duplicate if statements everywhere ([#2774])
-- clean-up nym-api startup arguments/flags to use clap 3 and its macro-derived arguments ([#2772])
 - renamed all references to validator_api to nym_api
-- renamed all references to nymd to nyxd ([#2696])
+- renamed all references to nymd to nyxd
 - all-binaries: standarised argument names (note: old names should still be accepted) ([#2762]
 
 ### Fixed
 
 - nym-api: should now correctly use `rewarding.enabled` config flag ([#2753])
 
-[#2696]: https://github.com/nymtech/nym/pull/2696
 [#2753]: https://github.com/nymtech/nym/pull/2753
 [#2762]: https://github.com/nymtech/nym/pull/2762
 [#2814]: https://github.com/nymtech/nym/pull/2814
-[#2772]: https://github.com/nymtech/nym/pull/2772
-[#2774]: https://github.com/nymtech/nym/pull/2774
 
-## [v1.1.5] (2023-01-10)
-
-### Added
-
-### Changed
-
-## [v1.1.5] (2023-01-10)
+## [v1.1.5] (2022-01-10)
 
 ### Added
 

Cargo.toml

@@ -34,7 +34,6 @@ members = [
     "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
     "common/cosmwasm-smart-contracts/coconut-dkg",
     "common/cosmwasm-smart-contracts/contracts-common",
-    "common/cosmwasm-smart-contracts/group-contract",
     "common/cosmwasm-smart-contracts/mixnet-contract",
     "common/cosmwasm-smart-contracts/multisig-contract",
     "common/cosmwasm-smart-contracts/vesting-contract",
@@ -96,12 +95,3 @@ default-members = [
 ]
 
 exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect"]
-
-[workspace.package]
-authors = ["Nym Technologies SA"]
-repository = "https://github.com/nymtech/nym"
-homepage = "https://nymtech.net"
-edition = "2021"
-
-[workspace.dependencies]
-log = "0.4"

Makefile

@@ -4,7 +4,7 @@ no-clippy: build cargo-test wasm fmt
 happy: fmt clippy-happy test
 clippy-all: clippy-main clippy-coconut clippy-all-contracts clippy-all-wallet clippy-all-connect clippy-all-wasm-client
 clippy-happy: clippy-happy-main clippy-happy-contracts clippy-happy-wallet clippy-happy-connect
-cargo-test: test-main test-contracts test-wallet test-connect test-coconut
+cargo-test: test-main test-contracts test-wallet test-connect test-coconut test-wasm-client
 cargo-test-expensive: test-main-expensive test-contracts-expensive test-wallet-expensive test-connect-expensive test-coconut-expensive
 build: build-contracts build-wallet build-main build-connect build-wasm-client
 fmt: fmt-main fmt-contracts fmt-wallet fmt-connect fmt-wasm-client
@@ -68,6 +68,9 @@ test-wallet:
 test-wallet-expensive:
 	cargo test --manifest-path nym-wallet/Cargo.toml --all-features -- --ignored
 
+test-wasm-client:
+	cargo test --workspace --manifest-path clients/webassembly/Cargo.toml --all-features
+
 test-connect:
 	cargo test --manifest-path nym-connect/Cargo.toml --all-features
 

clients/client-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "client-core"
-version = "1.1.7"
+version = "1.1.5"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 edition = "2021"
 rust-version = "1.66"
@@ -13,7 +13,7 @@ dirs = "4.0"
 dashmap = "5.4.0"
 futures = "0.3"
 humantime-serde = "1.0"
-log = { workspace = true }
+log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.89"

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

@@ -25,8 +25,6 @@ use client_connections::{ConnectionCommandReceiver, ConnectionCommandSender, Lan
 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
 use gateway_client::bandwidth::BandwidthController;
-#[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::CosmWasmClient;
 use gateway_client::{
     AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
     MixnetMessageSender,
@@ -41,8 +39,6 @@ use std::time::Duration;
 use tap::TapFallible;
 use task::{TaskClient, TaskManager};
 use url::Url;
-#[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::CosmWasmClient;
 
 use super::received_buffer::ReceivedBufferMessage;
 
@@ -133,7 +129,7 @@ impl From<bool> for CredentialsToggle {
     }
 }
 
-pub struct BaseClientBuilder<'a, B, C: Clone> {
+pub struct BaseClientBuilder<'a, B> {
     // due to wasm limitations I had to split it like this : (
     gateway_config: &'a GatewayEndpointConfig,
     debug_config: &'a DebugConfig,
@@ -141,21 +137,20 @@ pub struct BaseClientBuilder<'a, B, C: Clone> {
     nym_api_endpoints: Vec<Url>,
     reply_storage_backend: B,
 
-    bandwidth_controller: Option<BandwidthController<C>>,
+    bandwidth_controller: Option<BandwidthController>,
     key_manager: KeyManager,
 }
 
-impl<'a, B, C> BaseClientBuilder<'a, B, C>
+impl<'a, B> BaseClientBuilder<'a, B>
 where
     B: ReplyStorageBackend + Send + Sync + 'static,
-    C: CosmWasmClient + Sync + Send + Clone + 'static,
 {
     pub fn new_from_base_config<T>(
         base_config: &'a Config<T>,
         key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C>>,
+        bandwidth_controller: Option<BandwidthController>,
         reply_storage_backend: B,
-    ) -> BaseClientBuilder<'a, B, C> {
+    ) -> BaseClientBuilder<'a, B> {
         BaseClientBuilder {
             gateway_config: base_config.get_gateway_endpoint_config(),
             debug_config: base_config.get_debug_config(),
@@ -171,11 +166,11 @@ where
         gateway_config: &'a GatewayEndpointConfig,
         debug_config: &'a DebugConfig,
         key_manager: KeyManager,
-        bandwidth_controller: Option<BandwidthController<C>>,
+        bandwidth_controller: Option<BandwidthController>,
         reply_storage_backend: B,
         credentials_toggle: CredentialsToggle,
         nym_api_endpoints: Vec<Url>,
-    ) -> BaseClientBuilder<'a, B, C> {
+    ) -> BaseClientBuilder<'a, B> {
         BaseClientBuilder {
             gateway_config,
             debug_config,
@@ -284,7 +279,7 @@ where
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         shutdown: TaskClient,
-    ) -> Result<GatewayClient<C>, ClientCoreError> {
+    ) -> Result<GatewayClient, ClientCoreError> {
         let gateway_id = self.gateway_config.gateway_id.clone();
         if gateway_id.is_empty() {
             return Err(ClientCoreError::GatewayIdUnknown);
@@ -370,7 +365,7 @@ where
     // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for
     // requests?
     fn start_mix_traffic_controller(
-        gateway_client: GatewayClient<C>,
+        gateway_client: GatewayClient,
         shutdown: TaskClient,
     ) -> BatchMixMessageSender {
         info!("Starting mix traffic controller...");
@@ -386,32 +381,22 @@ where
     where
         <B as ReplyStorageBackend>::StorageError: Sync + Send,
     {
-        if backend.is_active() {
-            log::trace!("Setup persistent reply storage");
-            let persistent_storage = PersistentReplyStorage::new(backend);
-            let mem_store = persistent_storage
-                .load_state_from_backend()
+        let persistent_storage = PersistentReplyStorage::new(backend);
+        let mem_store = persistent_storage
+            .load_state_from_backend()
+            .await
+            .map_err(|err| ClientCoreError::SurbStorageError {
+                source: Box::new(err),
+            })?;
+
+        let store_clone = mem_store.clone();
+        spawn_future(async move {
+            persistent_storage
+                .flush_on_shutdown(store_clone, shutdown)
                 .await
-                .map_err(|err| ClientCoreError::SurbStorageError {
-                    source: Box::new(err),
-                })?;
+        });
 
-            let store_clone = mem_store.clone();
-            spawn_future(async move {
-                persistent_storage
-                    .flush_on_shutdown(store_clone, shutdown)
-                    .await
-            });
-
-            Ok(mem_store)
-        } else {
-            log::trace!("Setup inactive reply storage");
-            Ok(backend
-                .get_inactive_storage()
-                .map_err(|err| ClientCoreError::SurbStorageError {
-                    source: Box::new(err),
-                })?)
-        }
+        Ok(mem_store)
     }
 
     pub async fn start_base(mut self) -> Result<BaseClient, ClientCoreError>

clients/client-core/src/client/base_client/non_wasm_helpers.rs

@@ -43,14 +43,6 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
     Ok(storage_backend)
 }
 
-fn setup_inactive_backend(debug_config: &DebugConfig) -> fs_backend::Backend {
-    info!("creating inactive surb database");
-    fs_backend::Backend::new_inactive(
-        debug_config.minimum_reply_surb_storage_threshold,
-        debug_config.maximum_reply_surb_storage_threshold,
-    )
-}
-
 fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {
     let db_path = db_path.as_ref();
     debug_assert!(db_path.exists());
@@ -73,29 +65,24 @@ fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {
 }
 
 pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
-    db_path: Option<P>,
+    db_path: P,
     debug_config: &DebugConfig,
 ) -> Result<fs_backend::Backend, ClientCoreError> {
-    if let Some(db_path) = db_path {
-        // if the database file doesnt exist, initialise fresh storage, otherwise attempt to load
-        // the existing one
-        let db_path = db_path.as_ref();
-        if db_path.exists() {
-            info!("loading existing surb database");
-            match fs_backend::Backend::try_load(db_path).await {
-                Ok(backend) => Ok(backend),
-                Err(err) => {
-                    error!("failed to setup persistent storage backend for our reply needs: {err}. We're going to create a fresh database instead. This behaviour might change in the future");
+    // if the database file doesnt exist, initialise fresh storage, otherwise attempt to load the existing one
+    let db_path = db_path.as_ref();
+    if db_path.exists() {
+        info!("loading existing surb database");
+        match fs_backend::Backend::try_load(db_path).await {
+            Ok(backend) => Ok(backend),
+            Err(err) => {
+                error!("failed to setup persistent storage backend for our reply needs: {err}. We're going to create a fresh database instead. This behaviour might change in the future");
 
-                    archive_corrupted_database(db_path)?;
-                    setup_fresh_backend(db_path, debug_config).await
-                }
+                archive_corrupted_database(db_path)?;
+                setup_fresh_backend(db_path, debug_config).await
             }
-        } else {
-            setup_fresh_backend(db_path, debug_config).await
         }
     } else {
-        Ok(setup_inactive_backend(debug_config))
+        setup_fresh_backend(db_path, debug_config).await
     }
 }
 

clients/client-core/src/client/mix_traffic.rs

@@ -2,13 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::spawn_future;
-#[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::CosmWasmClient;
 use gateway_client::GatewayClient;
 use log::*;
 use nymsphinx::forwarding::packet::MixPacket;
-#[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::CosmWasmClient;
 
 pub type BatchMixMessageSender = tokio::sync::mpsc::Sender<Vec<MixPacket>>;
 pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
@@ -17,10 +13,10 @@ pub type BatchMixMessageReceiver = tokio::sync::mpsc::Receiver<Vec<MixPacket>>;
 pub const MIX_MESSAGE_RECEIVER_BUFFER_SIZE: usize = 32;
 const MAX_FAILURE_COUNT: usize = 100;
 
-pub struct MixTrafficController<C: Clone> {
+pub struct MixTrafficController {
     // TODO: most likely to be replaced by some higher level construct as
     // later on gateway_client will need to be accessible by other entities
-    gateway_client: GatewayClient<C>,
+    gateway_client: GatewayClient,
     mix_rx: BatchMixMessageReceiver,
 
     // TODO: this is temporary work-around.
@@ -28,13 +24,8 @@ pub struct MixTrafficController<C: Clone> {
     consecutive_gateway_failure_count: usize,
 }
 
-impl<C> MixTrafficController<C>
-where
-    C: CosmWasmClient + Sync + Send + Clone + 'static,
-{
-    pub fn new(
-        gateway_client: GatewayClient<C>,
-    ) -> (MixTrafficController<C>, BatchMixMessageSender) {
+impl MixTrafficController {
+    pub fn new(gateway_client: GatewayClient) -> (MixTrafficController, BatchMixMessageSender) {
         let (sphinx_message_sender, sphinx_message_receiver) =
             tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
         (

clients/client-core/src/client/replies/reply_storage/backend/browser_backend.rs

@@ -41,8 +41,4 @@ impl ReplyStorageBackend for Backend {
     async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
         self.empty.load_surb_storage().await
     }
-
-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        self.empty.get_inactive_storage()
-    }
 }

clients/client-core/src/client/replies/reply_storage/backend/fs_backend/error.rs

@@ -10,12 +10,6 @@ pub enum StorageError {
     #[error("the provided database path doesn't have a filename defined")]
     DatabasePathWithoutFilename { provided_path: PathBuf },
 
-    #[error("unable to create the directory for the database")]
-    DatabasePathUnableToCreateParentDirectory {
-        provided_path: PathBuf,
-        source: io::Error,
-    },
-
     #[error("failed to rename our databse file - {source}")]
     DatabaseRenameError {
         #[source]

clients/client-core/src/client/replies/reply_storage/backend/fs_backend/manager.rs

@@ -20,16 +20,6 @@ impl StorageManager {
         database_path: P,
         fresh: bool,
     ) -> Result<Self, StorageError> {
-        // ensure the whole directory structure exists
-        if let Some(parent_dir) = database_path.as_ref().parent() {
-            std::fs::create_dir_all(parent_dir).map_err(|source| {
-                StorageError::DatabasePathUnableToCreateParentDirectory {
-                    provided_path: database_path.as_ref().to_path_buf(),
-                    source,
-                }
-            })?;
-        }
-
         let mut opts = sqlx::sqlite::SqliteConnectOptions::new()
             .filename(database_path)
             .create_if_missing(fresh);

clients/client-core/src/client/replies/reply_storage/backend/fs_backend/mod.rs

@@ -22,49 +22,11 @@ mod error;
 mod manager;
 mod models;
 
-#[derive(Debug)]
-enum StorageManagerState {
-    Storage(StorageManager),
-    Inactive(InactiveMetadata),
-}
-
-// When the storage backaed is initialized as inactive, it will still contain metadata parameters
-// that will be needed when the in-mem storage is fetched for use.
-#[derive(Debug)]
-struct InactiveMetadata {
-    pub minimum_reply_surb_storage_threshold: usize,
-    pub maximum_reply_surb_storage_threshold: usize,
-}
-
-impl StorageManagerState {
-    fn get(&self) -> &StorageManager {
-        match self {
-            StorageManagerState::Storage(manager) => manager,
-            StorageManagerState::Inactive(_) => {
-                panic!("tried to get storage of an inactive backend")
-            }
-        }
-    }
-
-    fn get_mut(&mut self) -> &mut StorageManager {
-        match self {
-            StorageManagerState::Storage(manager) => manager,
-            StorageManagerState::Inactive(_) => {
-                panic!("tried to get storage of an inactive backend")
-            }
-        }
-    }
-
-    fn is_active(&self) -> bool {
-        matches!(self, StorageManagerState::Storage(_))
-    }
-}
-
 #[derive(Debug)]
 pub struct Backend {
     temporary_old_path: Option<PathBuf>,
     database_path: PathBuf,
-    manager: StorageManagerState,
+    manager: StorageManager,
 }
 
 impl Backend {
@@ -78,30 +40,15 @@ impl Backend {
             });
         }
 
-        let manager = StorageManager::init(database_path, true).await?;
-        manager.create_status_table().await?;
-
         let backend = Backend {
             temporary_old_path: None,
             database_path: owned_path,
-            manager: StorageManagerState::Storage(manager),
+            manager: StorageManager::init(database_path, true).await?,
         };
 
-        Ok(backend)
-    }
+        backend.manager.create_status_table().await?;
 
-    pub fn new_inactive(
-        minimum_reply_surb_storage_threshold: usize,
-        maximum_reply_surb_storage_threshold: usize,
-    ) -> Self {
-        Backend {
-            temporary_old_path: None,
-            database_path: PathBuf::new(),
-            manager: StorageManagerState::Inactive(InactiveMetadata {
-                minimum_reply_surb_storage_threshold,
-                maximum_reply_surb_storage_threshold,
-            }),
-        }
+        Ok(backend)
     }
 
     pub async fn try_load<P: AsRef<Path>>(database_path: P) -> Result<Self, StorageError> {
@@ -172,12 +119,12 @@ impl Backend {
         Ok(Backend {
             temporary_old_path: None,
             database_path: owned_path,
-            manager: StorageManagerState::Storage(manager),
+            manager,
         })
     }
 
     async fn close_pool(&mut self) {
-        self.manager.get_mut().connection_pool.close().await;
+        self.manager.connection_pool.close().await;
     }
 
     async fn rotate(&mut self) -> Result<(), StorageError> {
@@ -196,9 +143,8 @@ impl Backend {
 
         fs::rename(&self.database_path, &temp_old)
             .map_err(|err| StorageError::DatabaseRenameError { source: err })?;
-        self.manager =
-            StorageManagerState::Storage(StorageManager::init(&self.database_path, true).await?);
-        self.manager.get_mut().create_status_table().await?;
+        self.manager = StorageManager::init(&self.database_path, true).await?;
+        self.manager.create_status_table().await?;
 
         self.temporary_old_path = Some(temp_old);
         Ok(())
@@ -215,27 +161,26 @@ impl Backend {
     }
 
     async fn start_storage_flush(&self) -> Result<(), StorageError> {
-        Ok(self.manager.get().set_flush_status(true).await?)
+        Ok(self.manager.set_flush_status(true).await?)
     }
 
     async fn end_storage_flush(&self) -> Result<(), StorageError> {
         self.manager
-            .get()
             .set_previous_flush_timestamp(OffsetDateTime::now_utc().unix_timestamp())
             .await?;
-        Ok(self.manager.get().set_flush_status(false).await?)
+        Ok(self.manager.set_flush_status(false).await?)
     }
 
     async fn start_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.get().set_client_in_use_status(true).await?)
+        Ok(self.manager.set_client_in_use_status(true).await?)
     }
 
     async fn stop_client_use(&self) -> Result<(), StorageError> {
-        Ok(self.manager.get().set_client_in_use_status(false).await?)
+        Ok(self.manager.set_client_in_use_status(false).await?)
     }
 
     async fn get_stored_tags(&self) -> Result<UsedSenderTags, StorageError> {
-        let stored = self.manager.get().get_tags().await?;
+        let stored = self.manager.get_tags().await?;
 
         // stop at the first instance of corruption. if even a single entry is malformed,
         // something weird has happened and we can't trust the rest of the data
@@ -251,7 +196,6 @@ impl Backend {
         for map_ref in tags.as_raw_iter() {
             let (recipient, tag) = map_ref.pair();
             self.manager
-                .get()
                 .insert_tag(StoredSenderTag::new(*recipient, *tag))
                 .await?;
         }
@@ -259,7 +203,7 @@ impl Backend {
     }
 
     async fn get_stored_reply_keys(&self) -> Result<SentReplyKeys, StorageError> {
-        let stored = self.manager.get().get_reply_keys().await?;
+        let stored = self.manager.get_reply_keys().await?;
 
         // stop at the first instance of corruption. if even a single entry is malformed,
         // something weird has happened and we can't trust the rest of the data
@@ -275,7 +219,6 @@ impl Backend {
         for map_ref in reply_keys.as_raw_iter() {
             let (digest, key) = map_ref.pair();
             self.manager
-                .get()
                 .insert_reply_key(StoredReplyKey::new(*digest, *key))
                 .await?;
         }
@@ -283,7 +226,7 @@ impl Backend {
     }
 
     async fn get_stored_reply_surbs(&self) -> Result<ReceivedReplySurbsMap, StorageError> {
-        let surb_senders = self.manager.get().get_surb_senders().await?;
+        let surb_senders = self.manager.get_surb_senders().await?;
 
         let metadata = self.get_reply_surb_storage_metadata().await?;
         let mut received_surbs = Vec::with_capacity(surb_senders.len());
@@ -293,7 +236,6 @@ impl Backend {
                 sender.try_into()?;
             let stored_surbs = self
                 .manager
-                .get()
                 .get_reply_surbs(sender_id)
                 .await?
                 .into_iter()
@@ -321,7 +263,6 @@ impl Backend {
             let (tag, received_surbs) = map_ref.pair();
             let sender_id = self
                 .manager
-                .get()
                 .insert_surb_sender(StoredSurbSender::new(
                     *tag,
                     received_surbs.surbs_last_received_at(),
@@ -330,7 +271,6 @@ impl Backend {
 
             for reply_surb in received_surbs.surbs_ref() {
                 self.manager
-                    .get()
                     .insert_reply_surb(StoredReplySurb::new(sender_id, reply_surb))
                     .await?
             }
@@ -342,7 +282,6 @@ impl Backend {
         &self,
     ) -> Result<ReplySurbStorageMetadata, StorageError> {
         self.manager
-            .get()
             .get_reply_surb_storage_metadata()
             .await
             .map_err(Into::into)
@@ -353,7 +292,6 @@ impl Backend {
         reply_surbs: &ReceivedReplySurbsMap,
     ) -> Result<(), StorageError> {
         self.manager
-            .get()
             .insert_reply_surb_storage_metadata(ReplySurbStorageMetadata::new(
                 reply_surbs.min_surb_threshold(),
                 reply_surbs.max_surb_threshold(),
@@ -367,10 +305,6 @@ impl Backend {
 impl ReplyStorageBackend for Backend {
     type StorageError = error::StorageError;
 
-    fn is_active(&self) -> bool {
-        self.manager.is_active()
-    }
-
     async fn start_storage_session(&self) -> Result<(), Self::StorageError> {
         self.start_client_use().await
     }
@@ -408,18 +342,6 @@ impl ReplyStorageBackend for Backend {
         Ok(CombinedReplyStorage::load(reply_keys, reply_surbs, tags))
     }
 
-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        match self.manager {
-            StorageManagerState::Storage(_) => {
-                panic!("tried to get inactive storage from an active storage backend")
-            }
-            StorageManagerState::Inactive(ref state) => Ok(CombinedReplyStorage::new(
-                state.minimum_reply_surb_storage_threshold,
-                state.maximum_reply_surb_storage_threshold,
-            )),
-        }
-    }
-
     async fn stop_storage_session(self) -> Result<(), Self::StorageError> {
         self.stop_client_use().await
     }

clients/client-core/src/client/replies/reply_storage/backend/mod.rs

@@ -50,23 +50,12 @@ impl ReplyStorageBackend for Empty {
             self.max_surb_threshold,
         ))
     }
-
-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError> {
-        Ok(CombinedReplyStorage::new(
-            self.min_surb_threshold,
-            self.max_surb_threshold,
-        ))
-    }
 }
 
 #[async_trait]
 pub trait ReplyStorageBackend: Sized {
     type StorageError: Error + 'static;
 
-    fn is_active(&self) -> bool {
-        true
-    }
-
     async fn start_storage_session(&self) -> Result<(), Self::StorageError> {
         Ok(())
     }
@@ -84,11 +73,6 @@ pub trait ReplyStorageBackend: Sized {
 
     async fn load_surb_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError>;
 
-    /// In the case the storage backend is initialized in an inactive state (persisting data is
-    /// disabled), we might still need to fetch the (in-mem) storage and the parameters it was
-    /// created with.
-    fn get_inactive_storage(&self) -> Result<CombinedReplyStorage, Self::StorageError>;
-
     async fn stop_storage_session(self) -> Result<(), Self::StorageError> {
         Ok(())
     }

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

@@ -8,8 +8,6 @@ use crate::{
 };
 use config::NymConfig;
 use crypto::asymmetric::identity;
-#[cfg(target_arch = "wasm32")]
-use gateway_client::wasm_mockups::SigningNyxdClient;
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
 use rand::{seq::SliceRandom, thread_rng};
@@ -17,8 +15,6 @@ use std::{sync::Arc, time::Duration};
 use tap::TapFallible;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;
-#[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::SigningNyxdClient;
 
 pub(super) async fn query_gateway_details(
     validator_servers: Vec<Url>,
@@ -60,7 +56,7 @@ pub(super) async fn register_with_gateway(
     our_identity: Arc<identity::KeyPair>,
 ) -> Result<Arc<SharedKeys>, ClientCoreError> {
     let timeout = Duration::from_millis(1500);
-    let mut gateway_client: GatewayClient<SigningNyxdClient> = GatewayClient::new_init(
+    let mut gateway_client = GatewayClient::new_init(
         gateway.clients_address(),
         gateway.identity_key,
         gateway.owner.clone(),

clients/credential/src/commands.rs

@@ -13,7 +13,6 @@ use credentials::coconut::bandwidth::{BandwidthVoucher, TOTAL_ATTRIBUTES};
 use credentials::coconut::utils::obtain_aggregate_signature;
 use crypto::asymmetric::{encryption, identity};
 use network_defaults::{NymNetworkDetails, VOUCHER_INFO};
-use validator_client::nyxd::traits::DkgQueryClient;
 use validator_client::nyxd::tx::Hash;
 use validator_client::{CoconutApiClient, Config};
 
@@ -81,8 +80,7 @@ pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStor
     let network_details = NymNetworkDetails::new_from_env();
     let config = Config::try_from_nym_network_details(&network_details)?;
     let client = validator_client::Client::new_query(config)?;
-    let epoch_id = client.nyxd.get_current_epoch().await?.epoch_id;
-    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client, epoch_id).await?;
+    let coconut_api_clients = CoconutApiClient::all_coconut_api_clients(&client).await?;
 
     let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
     let bandwidth_credential_attributes = BandwidthVoucher::new(
@@ -108,7 +106,6 @@ pub(crate) async fn get_credential(state: &State, shared_storage: PersistentStor
             bandwidth_credential_attributes.get_private_attributes()[0].to_bs58(),
             bandwidth_credential_attributes.get_private_attributes()[1].to_bs58(),
             signature.to_bs58(),
-            epoch_id.to_string(),
         )
         .await?;
 

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.7"
+version = "1.1.5"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -23,7 +23,7 @@ url = "2.2"
 clap = { version = "4.0", features = ["cargo", "derive"] }
 dirs = "4.0"
 lazy_static = "1.4.0"
-log = { workspace = true } # self explanatory
+log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
 rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization

clients/native/src/client/mod.rs

@@ -21,7 +21,6 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nymsphinx::receiver::ReconstructedMessage;
 use task::TaskManager;
-use validator_client::nyxd::QueryNyxdClient;
 
 pub(crate) mod config;
 
@@ -45,28 +44,42 @@ impl SocketClient {
         }
     }
 
-    async fn create_bandwidth_controller(config: &Config) -> BandwidthController<QueryNyxdClient> {
-        let details = network_defaults::NymNetworkDetails::new_from_env();
-        let mut client_config = validator_client::Config::try_from_nym_network_details(&details)
-            .expect("failed to construct validator client config");
-        let nyxd_url = config
-            .get_base()
-            .get_validator_endpoints()
-            .pop()
-            .expect("No nyxd validator endpoint provided");
-        let api_url = config
-            .get_base()
-            .get_nym_api_endpoints()
-            .pop()
-            .expect("No validator api endpoint provided");
-        // overwrite env configuration with config URLs
-        client_config = client_config.with_urls(nyxd_url, api_url);
-        let client = validator_client::Client::new_query(client_config)
-            .expect("Could not construct query client");
-        BandwidthController::new(
+    async fn create_bandwidth_controller(config: &Config) -> BandwidthController {
+        #[cfg(feature = "coconut")]
+        let bandwidth_controller = {
+            let details = network_defaults::NymNetworkDetails::new_from_env();
+            let mut client_config =
+                validator_client::Config::try_from_nym_network_details(&details)
+                    .expect("failed to construct validator client config");
+            let nyxd_url = config
+                .get_base()
+                .get_validator_endpoints()
+                .pop()
+                .expect("No nyxd validator endpoint provided");
+            let api_url = config
+                .get_base()
+                .get_nym_api_endpoints()
+                .pop()
+                .expect("No validator api endpoint provided");
+            // overwrite env configuration with config URLs
+            client_config = client_config.with_urls(nyxd_url, api_url);
+            let client = validator_client::Client::new_query(client_config)
+                .expect("Could not construct query client");
+            let coconut_api_clients =
+                validator_client::CoconutApiClient::all_coconut_api_clients(&client)
+                    .await
+                    .expect("Could not query api clients");
+            BandwidthController::new(
+                credential_storage::initialise_storage(config.get_base().get_database_path()).await,
+                coconut_api_clients,
+            )
+        };
+        #[cfg(not(feature = "coconut"))]
+        let bandwidth_controller = BandwidthController::new(
             credential_storage::initialise_storage(config.get_base().get_database_path()).await,
-            client,
         )
+        .expect("Could not create bandwidth controller");
+        bandwidth_controller
     }
 
     fn start_websocket_listener(
@@ -124,7 +137,7 @@ impl SocketClient {
             self.key_manager,
             Some(Self::create_bandwidth_controller(&self.config).await),
             non_wasm_helpers::setup_fs_reply_surb_backend(
-                Some(self.config.get_base().get_reply_surb_database_path()),
+                self.config.get_base().get_reply_surb_database_path(),
                 self.config.get_debug_settings(),
             )
             .await?,
@@ -161,7 +174,7 @@ impl SocketClient {
             self.key_manager,
             Some(Self::create_bandwidth_controller(&self.config).await),
             non_wasm_helpers::setup_fs_reply_surb_backend(
-                Some(self.config.get_base().get_reply_surb_database_path()),
+                self.config.get_base().get_reply_surb_database_path(),
                 self.config.get_debug_settings(),
             )
             .await?,

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.7"
+version = "1.1.5"
 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"
@@ -15,7 +15,7 @@ clap = { version = "4.0", features = ["cargo", "derive"] }
 dirs = "4.0"
 futures = "0.3"
 lazy_static = "1.4.0"
-log = { workspace = true }
+log = "0.4"
 pin-project = "1.0"
 pretty_env_logger = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }

clients/socks5/src/client/mod.rs

@@ -20,7 +20,6 @@ use log::*;
 use nymsphinx::addressing::clients::Recipient;
 use std::error::Error;
 use task::{TaskClient, TaskManager};
-use validator_client::nyxd::QueryNyxdClient;
 
 pub mod config;
 
@@ -54,28 +53,42 @@ impl NymClient {
         }
     }
 
-    async fn create_bandwidth_controller(config: &Config) -> BandwidthController<QueryNyxdClient> {
-        let details = network_defaults::NymNetworkDetails::new_from_env();
-        let mut client_config = validator_client::Config::try_from_nym_network_details(&details)
-            .expect("failed to construct validator client config");
-        let nyxd_url = config
-            .get_base()
-            .get_validator_endpoints()
-            .pop()
-            .expect("No nyxd validator endpoint provided");
-        let api_url = config
-            .get_base()
-            .get_nym_api_endpoints()
-            .pop()
-            .expect("No validator api endpoint provided");
-        // overwrite env configuration with config URLs
-        client_config = client_config.with_urls(nyxd_url, api_url);
-        let client = validator_client::Client::new_query(client_config)
-            .expect("Could not construct query client");
-        BandwidthController::new(
+    async fn create_bandwidth_controller(config: &Config) -> BandwidthController {
+        #[cfg(feature = "coconut")]
+        let bandwidth_controller = {
+            let details = network_defaults::NymNetworkDetails::new_from_env();
+            let mut client_config =
+                validator_client::Config::try_from_nym_network_details(&details)
+                    .expect("failed to construct validator client config");
+            let nyxd_url = config
+                .get_base()
+                .get_validator_endpoints()
+                .pop()
+                .expect("No nyxd validator endpoint provided");
+            let api_url = config
+                .get_base()
+                .get_nym_api_endpoints()
+                .pop()
+                .expect("No validator api endpoint provided");
+            // overwrite env configuration with config URLs
+            client_config = client_config.with_urls(nyxd_url, api_url);
+            let client = validator_client::Client::new_query(client_config)
+                .expect("Could not construct query client");
+            let coconut_api_clients =
+                validator_client::CoconutApiClient::all_coconut_api_clients(&client)
+                    .await
+                    .expect("Could not query api clients");
+            BandwidthController::new(
+                credential_storage::initialise_storage(config.get_base().get_database_path()).await,
+                coconut_api_clients,
+            )
+        };
+        #[cfg(not(feature = "coconut"))]
+        let bandwidth_controller = BandwidthController::new(
             credential_storage::initialise_storage(config.get_base().get_database_path()).await,
-            client,
         )
+        .expect("Could not create bandwidth controller");
+        bandwidth_controller
     }
 
     fn start_socks5_listener(
@@ -193,7 +206,7 @@ impl NymClient {
             self.key_manager,
             Some(Self::create_bandwidth_controller(&self.config).await),
             non_wasm_helpers::setup_fs_reply_surb_backend(
-                Some(self.config.get_base().get_reply_surb_database_path()),
+                self.config.get_base().get_reply_surb_database_path(),
                 self.config.get_debug_settings(),
             )
             .await?,

clients/webassembly/src/client/mod.rs

@@ -11,7 +11,6 @@ use client_core::client::base_client::{
 use client_core::client::replies::reply_storage::browser_backend;
 use client_core::client::{inbound_messages::InputMessage, key_manager::KeyManager};
 use gateway_client::bandwidth::BandwidthController;
-use gateway_client::wasm_mockups::SigningNyxdClient;
 use js_sys::Promise;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::anonymous_replies::requests::AnonymousSenderTag;
@@ -48,7 +47,7 @@ pub struct NymClientBuilder {
     on_message: js_sys::Function,
 
     // unimplemented:
-    bandwidth_controller: Option<BandwidthController<SigningNyxdClient>>,
+    bandwidth_controller: Option<BandwidthController>,
     disabled_credentials: bool,
 }
 

common/client-connections/Cargo.toml

@@ -7,4 +7,4 @@ edition = "2021"
 
 [dependencies]
 futures = "0.3"
-log = { workspace = true }
+log = "0.4.17"

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

@@ -10,7 +10,7 @@ edition = "2021"
 # TODO: (for this and other crates), similarly to 'tokio', import only required "futures" modules rather than
 # the entire crate
 futures = "0.3"
-log = { workspace = true }
+log = "0.4"
 thiserror = "1.0"
 url = "2.2"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
@@ -25,7 +25,7 @@ gateway-requests = { path = "../../../gateway/gateway-requests" }
 network-defaults = { path = "../../network-defaults" }
 nymsphinx = { path = "../../nymsphinx" }
 pemstore = { path = "../../pemstore" }
-validator-client = { path = "../validator-client" }
+validator-client = { path = "../validator-client", optional = true }
 task = { path = "../../task" }
 serde = { version = "1.0", features = ["derive"]}
 
@@ -79,5 +79,5 @@ features = ["js"]
 #url = "2.1"
 
 [features]
-coconut = ["gateway-requests/coconut", "coconut-interface", "credentials/coconut"]
+coconut = ["gateway-requests/coconut", "coconut-interface", "validator-client", "credentials/coconut"]
 wasm = []

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

@@ -1,26 +1,23 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-#[cfg(feature = "coconut")]
 use crate::error::GatewayClientError;
 
 #[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::Storage;
+use crate::wasm_storage::Storage;
 #[cfg(not(target_arch = "wasm32"))]
 use credential_storage::storage::Storage;
 
 #[cfg(all(target_arch = "wasm32", feature = "coconut"))]
-use crate::wasm_mockups::StorageError;
+use crate::wasm_storage::StorageError;
 
 #[cfg(all(not(target_arch = "wasm32"), feature = "coconut"))]
 use credential_storage::error::StorageError;
 
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::{Client, CosmWasmClient};
 #[cfg(feature = "coconut")]
 use std::str::FromStr;
-#[cfg(not(target_arch = "wasm32"))]
-use validator_client::{nyxd::CosmWasmClient, Client};
+#[cfg(feature = "coconut")]
+use validator_client::client::CoconutApiClient;
 #[cfg(feature = "coconut")]
 use {
     coconut_interface::Base58,
@@ -31,34 +28,41 @@ use {
 
 // TODO: make it nicer for wasm (I don't want to touch it for this experiment)
 #[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::PersistentStorage;
+use crate::wasm_storage::PersistentStorage;
 
 #[cfg(not(target_arch = "wasm32"))]
 use credential_storage::PersistentStorage;
 
 #[derive(Clone)]
-#[allow(dead_code)]
-pub struct BandwidthController<C: Clone, St: Storage = PersistentStorage> {
+pub struct BandwidthController<St: Storage = PersistentStorage> {
+    #[allow(dead_code)]
     storage: St,
-    nyxd_client: Client<C>,
+    #[cfg(feature = "coconut")]
+    coconut_api_clients: Vec<CoconutApiClient>,
 }
 
-impl<C, St> BandwidthController<C, St>
+impl<St> BandwidthController<St>
 where
-    C: CosmWasmClient + Sync + Send + Clone,
     St: Storage + Clone + 'static,
 {
-    pub fn new(storage: St, nyxd_client: Client<C>) -> Self {
+    #[cfg(feature = "coconut")]
+    pub fn new(storage: St, coconut_api_clients: Vec<CoconutApiClient>) -> Self {
         BandwidthController {
             storage,
-            nyxd_client,
+            coconut_api_clients,
         }
     }
 
+    #[cfg(not(feature = "coconut"))]
+    pub fn new(storage: St) -> Result<Self, GatewayClientError> {
+        Ok(BandwidthController { storage })
+    }
+
     #[cfg(feature = "coconut")]
     pub async fn prepare_coconut_credential(
         &self,
     ) -> Result<(coconut_interface::Credential, i64), GatewayClientError> {
+        let verification_key = obtain_aggregate_verification_key(&self.coconut_api_clients).await?;
         let bandwidth_credential = self.storage.get_next_coconut_credential().await?;
         let voucher_value = u64::from_str(&bandwidth_credential.voucher_value)
             .map_err(|_| StorageError::InconsistentData)?;
@@ -69,19 +73,6 @@ where
             coconut_interface::Attribute::try_from_bs58(bandwidth_credential.binding_number)?;
         let signature =
             coconut_interface::Signature::try_from_bs58(bandwidth_credential.signature)?;
-        let epoch_id = u64::from_str(&bandwidth_credential.epoch_id)
-            .map_err(|_| StorageError::InconsistentData)?;
-
-        #[cfg(not(target_arch = "wasm32"))]
-        let coconut_api_clients = validator_client::CoconutApiClient::all_coconut_api_clients(
-            &self.nyxd_client,
-            epoch_id,
-        )
-        .await
-        .expect("Could not query api clients");
-        #[cfg(target_arch = "wasm32")]
-        let coconut_api_clients = vec![];
-        let verification_key = obtain_aggregate_verification_key(&coconut_api_clients).await?;
 
         // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
         Ok((
@@ -90,7 +81,6 @@ where
                 voucher_info,
                 serial_number,
                 binding_number,
-                epoch_id,
                 &signature,
                 &verification_key,
             )?,

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

@@ -32,13 +32,9 @@ use coconut_interface::Credential;
 use credential_storage::PersistentStorage;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio_tungstenite::connect_async;
-#[cfg(not(target_arch = "wasm32"))]
-use validator_client::nyxd::CosmWasmClient;
 
 #[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::CosmWasmClient;
-#[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::PersistentStorage;
+use crate::wasm_storage::PersistentStorage;
 #[cfg(target_arch = "wasm32")]
 use wasm_timer;
 #[cfg(target_arch = "wasm32")]
@@ -47,7 +43,7 @@ use wasm_utils::websocket::JSWebsocket;
 const DEFAULT_RECONNECTION_ATTEMPTS: usize = 10;
 const DEFAULT_RECONNECTION_BACKOFF: Duration = Duration::from_secs(5);
 
-pub struct GatewayClient<C: Clone> {
+pub struct GatewayClient {
     authenticated: bool,
     disabled_credentials_mode: bool,
     bandwidth_remaining: i64,
@@ -59,7 +55,7 @@ pub struct GatewayClient<C: Clone> {
     connection: SocketState,
     packet_router: PacketRouter,
     response_timeout_duration: Duration,
-    bandwidth_controller: Option<BandwidthController<C, PersistentStorage>>,
+    bandwidth_controller: Option<BandwidthController<PersistentStorage>>,
 
     // reconnection related variables
     /// Specifies whether client should try to reconnect to gateway on connection failure.
@@ -74,10 +70,7 @@ pub struct GatewayClient<C: Clone> {
     shutdown: TaskClient,
 }
 
-impl<C> GatewayClient<C>
-where
-    C: CosmWasmClient + Sync + Send + Clone,
-{
+impl GatewayClient {
     // TODO: put it all in a Config struct
     #[allow(clippy::too_many_arguments)]
     pub fn new(
@@ -89,7 +82,7 @@ where
         mixnet_message_sender: MixnetMessageSender,
         ack_sender: AcknowledgementSender,
         response_timeout_duration: Duration,
-        bandwidth_controller: Option<BandwidthController<C, PersistentStorage>>,
+        bandwidth_controller: Option<BandwidthController<PersistentStorage>>,
         shutdown: TaskClient,
     ) -> Self {
         GatewayClient {
@@ -145,7 +138,7 @@ where
         let shutdown = TaskClient::dummy();
         let packet_router = PacketRouter::new(ack_tx, mix_tx, shutdown.clone());
 
-        GatewayClient::<C> {
+        GatewayClient {
             authenticated: false,
             disabled_credentials_mode: true,
             bandwidth_remaining: 0,

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #[cfg(target_arch = "wasm32")]
-use crate::wasm_mockups::StorageError;
+use crate::wasm_storage::StorageError;
 #[cfg(not(target_arch = "wasm32"))]
 use credential_storage::error::StorageError;
 use gateway_requests::registration::handshake::error::HandshakeError;

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

@@ -17,7 +17,7 @@ pub mod error;
 pub mod packet_router;
 pub mod socket_state;
 #[cfg(target_arch = "wasm32")]
-pub mod wasm_mockups;
+mod wasm_storage;
 
 /// Helper method for reading from websocket stream. Helps to flatten the structure.
 pub(crate) fn cleanup_socket_message(

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

@@ -2,7 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use async_trait::async_trait;
-use std::marker::PhantomData;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
@@ -15,18 +14,6 @@ pub enum StorageError {
     InconsistentData,
 }
 
-pub trait CosmWasmClient {}
-
-#[derive(Clone)]
-pub struct SigningNyxdClient {}
-
-impl CosmWasmClient for SigningNyxdClient {}
-
-#[derive(Clone)]
-pub struct Client<C> {
-    _phantom: PhantomData<C>,
-}
-
 #[derive(Clone)]
 pub struct PersistentStorage {}
 
@@ -37,7 +24,6 @@ pub struct CoconutCredential {
     pub serial_number: String,
     pub binding_number: String,
     pub signature: String,
-    pub epoch_id: String,
 }
 
 #[async_trait]

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

@@ -8,7 +8,7 @@ edition = "2021"
 
 [dependencies]
 futures = "0.3"
-log = { workspace = true }
+log = "0.4.8"
 tokio = { version = "1.24.1", features = ["time", "net", "rt"] }
 tokio-util = { version = "0.7.4", features = ["codec"] }
 

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

@@ -17,13 +17,12 @@ mixnet-contract-common = { path= "../../cosmwasm-smart-contracts/mixnet-contract
 vesting-contract-common = { path= "../../cosmwasm-smart-contracts/vesting-contract" }
 coconut-bandwidth-contract-common = { path= "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
 multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contract" }
 vesting-contract = { path = "../../../contracts/vesting" }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 reqwest = { version = "0.11", features = ["json"] }
 thiserror = "1"
-log = { workspace = true }
+log = "0.4"
 url = { version = "2.2", features = ["serde"] }
 tokio = { version = "1.24.1", features = ["sync", "time"] }
 futures = "0.3"
@@ -40,7 +39,6 @@ bip39 = { version = "1", features = ["rand"], optional = true }
 config = { path = "../../config", optional = true }
 cosmrs = { git = "https://github.com/neacsu/cosmos-rust", branch = "neacsu/feegrant_support", features = ["rpc", "bip32", "cosmwasm"], optional = true}
 cw3 = { version = "0.13.4", optional = true }
-cw4 = { version = "0.13.4", optional = true }
 prost = { version = "0.10", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
@@ -58,7 +56,6 @@ nyxd-client = [
     "config",
     "cosmrs",
     "cw3",
-    "cw4",
     "prost",
     "flate2",
     "sha2",

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

@@ -21,9 +21,7 @@ use crate::nyxd::traits::{DkgQueryClient, MixnetQueryClient, MultisigQueryClient
 use crate::nyxd::{self, CosmWasmClient, NyxdClient, QueryNyxdClient, SigningNyxdClient};
 #[cfg(feature = "nyxd-client")]
 use coconut_dkg_common::{
-    dealer::ContractDealing,
-    types::{DealerDetails, EpochId},
-    verification_key::ContractVKShare,
+    dealer::ContractDealing, types::DealerDetails, verification_key::ContractVKShare,
 };
 #[cfg(feature = "nyxd-client")]
 use coconut_interface::Base58;
@@ -130,8 +128,7 @@ impl Config {
 }
 
 #[cfg(feature = "nyxd-client")]
-#[derive(Clone)]
-pub struct Client<C: Clone> {
+pub struct Client<C> {
     // TODO: we really shouldn't be storing a mnemonic here, but removing it would be
     // non-trivial amount of work and it's out of scope of the current branch
     mnemonic: Option<bip39::Mnemonic>,
@@ -221,10 +218,7 @@ impl Client<QueryNyxdClient> {
 
 // nyxd wrappers
 #[cfg(feature = "nyxd-client")]
-impl<C> Client<C>
-where
-    C: Clone,
-{
+impl<C> Client<C> {
     // use case: somebody initialised client without a contract in order to upload and initialise one
     // and now they want to actually use it without making new client
 
@@ -682,7 +676,6 @@ where
 
     pub async fn get_all_nyxd_verification_key_shares(
         &self,
-        epoch_id: EpochId,
     ) -> Result<Vec<ContractVKShare>, ValidatorClientError>
     where
         C: CosmWasmClient + Sync + Send,
@@ -692,11 +685,7 @@ where
         loop {
             let mut paged_response = self
                 .nyxd
-                .get_vk_shares_paged(
-                    epoch_id,
-                    start_after.take(),
-                    self.verification_key_page_limit,
-                )
+                .get_vk_shares_paged(start_after.take(), self.verification_key_page_limit)
                 .await?;
             shares.append(&mut paged_response.shares);
 
@@ -741,10 +730,7 @@ where
 
 // validator-api wrappers
 #[cfg(feature = "nyxd-client")]
-impl<C> Client<C>
-where
-    C: Clone,
-{
+impl<C> Client<C> {
     pub fn change_nym_api(&mut self, new_endpoint: Url) {
         self.nym_api.change_url(new_endpoint)
     }
@@ -806,15 +792,14 @@ pub struct CoconutApiClient {
 
 #[cfg(feature = "nyxd-client")]
 impl CoconutApiClient {
-    pub async fn all_coconut_api_clients<C: Clone>(
+    pub async fn all_coconut_api_clients<C>(
         nyxd_client: &Client<C>,
-        epoch_id: EpochId,
     ) -> Result<Vec<Self>, ValidatorClientError>
     where
         C: CosmWasmClient + Sync + Send,
     {
         Ok(nyxd_client
-            .get_all_nyxd_verification_key_shares(epoch_id)
+            .get_all_nyxd_verification_key_shares()
             .await?
             .into_iter()
             .filter_map(Self::try_from)

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

@@ -65,7 +65,6 @@ pub struct Config {
     pub(crate) vesting_contract_address: Option<AccountId>,
     pub(crate) bandwidth_claim_contract_address: Option<AccountId>,
     pub(crate) coconut_bandwidth_contract_address: Option<AccountId>,
-    pub(crate) group_contract_address: Option<AccountId>,
     pub(crate) multisig_contract_address: Option<AccountId>,
     pub(crate) coconut_dkg_contract_address: Option<AccountId>,
     // TODO: add this in later commits
@@ -120,10 +119,6 @@ impl Config {
                     .as_ref(),
                 prefix,
             )?,
-            group_contract_address: Self::parse_optional_account(
-                details.contracts.group_contract_address.as_ref(),
-                prefix,
-            )?,
             multisig_contract_address: Self::parse_optional_account(
                 details.contracts.multisig_contract_address.as_ref(),
                 prefix,
@@ -136,8 +131,8 @@ impl Config {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct NyxdClient<C: Clone> {
+#[derive(Debug)]
+pub struct NyxdClient<C> {
     client: C,
     config: Config,
     client_address: Option<Vec<AccountId>>,
@@ -214,10 +209,7 @@ impl NyxdClient<SigningNyxdClient> {
     }
 }
 
-impl<C> NyxdClient<C>
-where
-    C: Clone,
-{
+impl<C> NyxdClient<C> {
     pub fn current_config(&self) -> &Config {
         &self.config
     }
@@ -284,10 +276,6 @@ where
             .unwrap()
     }
 
-    pub fn group_contract_address(&self) -> &AccountId {
-        self.config.group_contract_address.as_ref().unwrap()
-    }
-
     // TODO: this should get changed into Result<&AccountId, NyxdError> (or Option<&AccountId> in future commits
     // note: what unwrap is doing here is just moving a failure that would have normally
     // occurred in `connect` when attempting to parse an empty address,

common/client-libs/validator-client/src/nyxd/traits/coconut_bandwidth_query_client.rs

@@ -18,7 +18,7 @@ pub trait CoconutBandwidthQueryClient {
 }
 
 #[async_trait]
-impl<C: CosmWasmClient + Sync + Send + Clone> CoconutBandwidthQueryClient for NyxdClient<C> {
+impl<C: CosmWasmClient + Sync + Send> CoconutBandwidthQueryClient for NyxdClient<C> {
     async fn get_spent_credential(
         &self,
         blinded_serial_number: String,

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

@@ -30,9 +30,7 @@ pub trait CoconutBandwidthSigningClient {
 }
 
 #[async_trait]
-impl<C: SigningCosmWasmClient + Sync + Send + Clone> CoconutBandwidthSigningClient
-    for NyxdClient<C>
-{
+impl<C: SigningCosmWasmClient + Sync + Send> CoconutBandwidthSigningClient for NyxdClient<C> {
     async fn deposit(
         &self,
         amount: Coin,

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

@@ -8,7 +8,7 @@ use coconut_dkg_common::dealer::{
     DealerDetailsResponse, PagedDealerResponse, PagedDealingsResponse,
 };
 use coconut_dkg_common::msg::QueryMsg as DkgQueryMsg;
-use coconut_dkg_common::types::{Epoch, EpochId};
+use coconut_dkg_common::types::Epoch;
 use coconut_dkg_common::verification_key::PagedVKSharesResponse;
 use cosmrs::AccountId;
 
@@ -39,7 +39,6 @@ pub trait DkgQueryClient {
     ) -> Result<PagedDealingsResponse, NyxdError>;
     async fn get_vk_shares_paged(
         &self,
-        epoch_id: EpochId,
         start_after: Option<String>,
         page_limit: Option<u32>,
     ) -> Result<PagedVKSharesResponse, NyxdError>;
@@ -48,7 +47,7 @@ pub trait DkgQueryClient {
 #[async_trait]
 impl<C> DkgQueryClient for NyxdClient<C>
 where
-    C: CosmWasmClient + Send + Sync + Clone,
+    C: CosmWasmClient + Send + Sync,
 {
     async fn get_current_epoch(&self) -> Result<Epoch, NyxdError> {
         let request = DkgQueryMsg::GetCurrentEpochState {};
@@ -120,12 +119,10 @@ where
 
     async fn get_vk_shares_paged(
         &self,
-        epoch_id: EpochId,
         start_after: Option<String>,
         page_limit: Option<u32>,
     ) -> Result<PagedVKSharesResponse, NyxdError> {
         let request = DkgQueryMsg::GetVerificationKeys {
-            epoch_id,
             limit: page_limit,
             start_after,
         };

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

@@ -36,7 +36,7 @@ pub trait DkgSigningClient {
 #[async_trait]
 impl<C> DkgSigningClient for NyxdClient<C>
 where
-    C: SigningCosmWasmClient + Send + Sync + Clone,
+    C: SigningCosmWasmClient + Send + Sync,
 {
     async fn advance_dkg_epoch_state(&self, fee: Option<Fee>) -> Result<ExecuteResult, NyxdError> {
         let req = DkgExecuteMsg::AdvanceEpochState {};

common/client-libs/validator-client/src/nyxd/traits/group_query_client.rs

@@ -1,28 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{CosmWasmClient, NyxdClient};
-
-use group_contract_common::msg::QueryMsg;
-
-use async_trait::async_trait;
-use cw4::MemberResponse;
-
-#[async_trait]
-pub trait GroupQueryClient {
-    async fn member(&self, addr: String) -> Result<MemberResponse, NyxdError>;
-}
-
-#[async_trait]
-impl<C: CosmWasmClient + Sync + Send + Clone> GroupQueryClient for NyxdClient<C> {
-    async fn member(&self, addr: String) -> Result<MemberResponse, NyxdError> {
-        let request = QueryMsg::Member {
-            addr,
-            at_height: None,
-        };
-        self.client
-            .query_contract_smart(self.group_contract_address(), &request)
-            .await
-    }
-}

common/client-libs/validator-client/src/nyxd/traits/mixnet_query_client.rs

@@ -395,7 +395,7 @@ pub trait MixnetQueryClient {
 #[async_trait]
 impl<C> MixnetQueryClient for NyxdClient<C>
 where
-    C: CosmWasmClient + Sync + Send + Clone,
+    C: CosmWasmClient + Sync + Send,
 {
     async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NyxdError>
     where
@@ -410,7 +410,7 @@ where
 #[async_trait]
 impl<C> MixnetQueryClient for crate::Client<C>
 where
-    C: CosmWasmClient + Sync + Send + Clone,
+    C: CosmWasmClient + Sync + Send,
 {
     async fn query_mixnet_contract<T>(&self, query: MixnetQueryMsg) -> Result<T, NyxdError>
     where

common/client-libs/validator-client/src/nyxd/traits/mixnet_signing_client.rs

@@ -627,7 +627,7 @@ pub trait MixnetSigningClient {
 #[async_trait]
 impl<C> MixnetSigningClient for NyxdClient<C>
 where
-    C: SigningCosmWasmClient + Sync + Send + Clone,
+    C: SigningCosmWasmClient + Sync + Send,
 {
     async fn execute_mixnet_contract(
         &self,
@@ -653,7 +653,7 @@ where
 #[async_trait]
 impl<C> MixnetSigningClient for crate::Client<C>
 where
-    C: SigningCosmWasmClient + Sync + Send + Clone,
+    C: SigningCosmWasmClient + Sync + Send,
 {
     async fn execute_mixnet_contract(
         &self,

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

@@ -5,7 +5,6 @@ mod coconut_bandwidth_query_client;
 mod coconut_bandwidth_signing_client;
 mod dkg_query_client;
 mod dkg_signing_client;
-mod group_query_client;
 mod mixnet_query_client;
 mod mixnet_signing_client;
 mod multisig_query_client;
@@ -17,7 +16,6 @@ pub use coconut_bandwidth_query_client::CoconutBandwidthQueryClient;
 pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
 pub use dkg_query_client::DkgQueryClient;
 pub use dkg_signing_client::DkgSigningClient;
-pub use group_query_client::GroupQueryClient;
 pub use mixnet_query_client::MixnetQueryClient;
 pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_query_client::MultisigQueryClient;

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

@@ -20,7 +20,7 @@ pub trait MultisigQueryClient {
 }
 
 #[async_trait]
-impl<C: CosmWasmClient + Sync + Send + Clone> MultisigQueryClient for NyxdClient<C> {
+impl<C: CosmWasmClient + Sync + Send> MultisigQueryClient for NyxdClient<C> {
     async fn get_proposal(&self, proposal_id: u64) -> Result<ProposalResponse, NyxdError> {
         let request = QueryMsg::Proposal { proposal_id };
         self.client

common/client-libs/validator-client/src/nyxd/traits/multisig_signing_client.rs

@@ -38,7 +38,7 @@ pub trait MultisigSigningClient {
 }
 
 #[async_trait]
-impl<C: SigningCosmWasmClient + Sync + Send + Clone> MultisigSigningClient for NyxdClient<C> {
+impl<C: SigningCosmWasmClient + Sync + Send> MultisigSigningClient for NyxdClient<C> {
     async fn propose_release_funds(
         &self,
         title: String,

common/client-libs/validator-client/src/nyxd/traits/vesting_query_client.rs

@@ -269,7 +269,7 @@ pub trait VestingQueryClient {
 }
 
 #[async_trait]
-impl<C: CosmWasmClient + Sync + Send + Clone> VestingQueryClient for NyxdClient<C> {
+impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NyxdClient<C> {
     async fn query_vesting_contract<T>(&self, query: VestingQueryMsg) -> Result<T, NyxdError>
     where
         for<'a> T: Deserialize<'a>,

common/client-libs/validator-client/src/nyxd/traits/vesting_signing_client.rs

@@ -129,7 +129,7 @@ pub trait VestingSigningClient {
 }
 
 #[async_trait]
-impl<C: SigningCosmWasmClient + Sync + Send + Clone> VestingSigningClient for NyxdClient<C> {
+impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NyxdClient<C> {
     async fn execute_vesting_contract(
         &self,
         fee: Option<Fee>,

common/coconut-interface/src/lib.rs

@@ -18,8 +18,6 @@ pub struct Credential {
     theta: Theta,
     voucher_value: u64,
     voucher_info: String,
-    #[getset(get = "pub")]
-    epoch_id: u64,
 }
 impl Credential {
     pub fn new(
@@ -27,14 +25,12 @@ impl Credential {
         theta: Theta,
         voucher_value: u64,
         voucher_info: String,
-        epoch_id: u64,
     ) -> Credential {
         Credential {
             n_params,
             theta,
             voucher_value,
             voucher_info,
-            epoch_id,
         }
     }
 
@@ -72,7 +68,6 @@ impl Credential {
         let theta_bytes = self.theta.to_bytes();
         let theta_bytes_len = theta_bytes.len();
         let voucher_value_bytes = self.voucher_value.to_be_bytes();
-        let epoch_id_bytes = self.epoch_id.to_be_bytes();
         let voucher_info_bytes = self.voucher_info.as_bytes();
         let voucher_info_len = voucher_info_bytes.len();
 
@@ -81,7 +76,6 @@ impl Credential {
         bytes.extend_from_slice(&(theta_bytes_len as u64).to_be_bytes());
         bytes.extend_from_slice(&theta_bytes);
         bytes.extend_from_slice(&voucher_value_bytes);
-        bytes.extend_from_slice(&epoch_id_bytes);
         bytes.extend_from_slice(voucher_info_bytes);
 
         bytes
@@ -109,9 +103,7 @@ impl Credential {
             .map_err(|e| CoconutError::Deserialization(e.to_string()))?;
         eight_byte.copy_from_slice(&bytes[12 + theta_len as usize..20 + theta_len as usize]);
         let voucher_value = u64::from_be_bytes(eight_byte);
-        eight_byte.copy_from_slice(&bytes[20 + theta_len as usize..28 + theta_len as usize]);
-        let epoch_id = u64::from_be_bytes(eight_byte);
-        let voucher_info = String::from_utf8(bytes[28 + theta_len as usize..].to_vec())
+        let voucher_info = String::from_utf8(bytes[20 + theta_len as usize..].to_vec())
             .map_err(|e| CoconutError::Deserialization(e.to_string()))?;
 
         Ok(Credential {
@@ -119,7 +111,6 @@ impl Credential {
             theta,
             voucher_value,
             voucher_info,
-            epoch_id,
         })
     }
 }
@@ -175,7 +166,7 @@ mod tests {
             binding_number,
         )
         .unwrap();
-        let credential = Credential::new(4, theta, voucher_value, voucher_info, 42);
+        let credential = Credential::new(4, theta, voucher_value, voucher_info);
 
         let serialized_credential = credential.as_bytes();
         let deserialized_credential = Credential::from_bytes(&serialized_credential).unwrap();

common/commands/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "nym-cli-commands"
 version = "1.0.0"
-authors.workspace = true
+authors = ["Nym Technologies SA"]
 edition = "2021"
 
 [dependencies]
@@ -15,7 +15,7 @@ cw-utils = { version = "0.13.4" }
 handlebars = "3.0.1"
 humantime-serde = "1.0"
 k256 = { version = "0.10", features = ["ecdsa", "sha256"] }
-log = { workspace = true }
+log = "0.4"
 rand = {version = "0.6", features = ["std"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1"

common/config/Cargo.toml

@@ -9,7 +9,7 @@ edition = "2021"
 [dependencies]
 cfg-if = "1.0.0"
 handlebars = "3.0.1"
-log = { workspace = true }
+log = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 toml = "0.5.6"
 url = "2.2"

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

@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, EpochId, TimeConfiguration};
+use crate::types::{ContractSafeBytes, EncodedBTEPublicKeyWithProof, TimeConfiguration};
 use crate::verification_key::VerificationKeyShare;
 use cosmwasm_std::Addr;
 use schemars::JsonSchema;
@@ -35,8 +35,6 @@ pub enum ExecuteMsg {
         owner: Addr,
     },
 
-    SurpassedThreshold {},
-
     AdvanceEpochState {},
 }
 
@@ -62,7 +60,6 @@ pub enum QueryMsg {
         start_after: Option<String>,
     },
     GetVerificationKeys {
-        epoch_id: EpochId,
         limit: Option<u32>,
         start_after: Option<String>,
     },

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

@@ -13,7 +13,6 @@ pub use cosmwasm_std::{Addr, Coin, Timestamp};
 pub type EncodedBTEPublicKeyWithProof = String;
 pub type EncodedBTEPublicKeyWithProofRef<'a> = &'a str;
 pub type NodeIndex = u64;
-pub type EpochId = u64;
 
 // 2 public attributes, 2 private attributes, 1 fixed for coconut credential
 pub const TOTAL_DEALINGS: usize = 2 + 2 + 1;
@@ -73,7 +72,6 @@ impl Default for TimeConfiguration {
 #[serde(rename_all = "snake_case")]
 pub struct Epoch {
     pub state: EpochState,
-    pub epoch_id: EpochId,
     pub time_configuration: TimeConfiguration,
     pub finish_timestamp: Timestamp,
 }
@@ -81,7 +79,6 @@ pub struct Epoch {
 impl Epoch {
     pub fn new(
         state: EpochState,
-        epoch_id: u64,
         time_configuration: TimeConfiguration,
         current_timestamp: Timestamp,
     ) -> Self {
@@ -101,7 +98,6 @@ impl Epoch {
         };
         Epoch {
             state,
-            epoch_id,
             time_configuration,
             finish_timestamp: current_timestamp.plus_seconds(duration),
         }

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use crate::msg::ExecuteMsg;
-use crate::types::{EpochId, NodeIndex};
+use crate::types::NodeIndex;
 use cosmwasm_std::{from_binary, to_binary, Addr, CosmosMsg, StdResult, Timestamp, WasmMsg};
 use cw_utils::Expiration;
 use multisig_contract_common::msg::ExecuteMsg as MultisigExecuteMsg;
@@ -16,7 +16,6 @@ pub struct ContractVKShare {
     pub announce_address: String,
     pub node_index: NodeIndex,
     pub owner: Addr,
-    pub epoch_id: EpochId,
     pub verified: bool,
 }
 

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

@@ -1,11 +0,0 @@
-[package]
-name = "group-contract-common"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cw4 = { version = "0.13.4" }
-schemars = "0.8"
-serde = { version = "1.0.103", default-features = false, features = ["derive"] }

common/cosmwasm-smart-contracts/group-contract/src/lib.rs

@@ -1 +0,0 @@
-pub mod msg;

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

@@ -19,7 +19,7 @@ serde_json = "1.0.0"
 humantime-serde = "1.1.1"
 
 # TO CHECK WHETHER STILL NEEDED:
-log = { workspace = true }
+log = "0.4.14"
 time = { version = "0.3.6", features = ["parsing", "formatting"] }
 ts-rs = { version = "6.1.2", optional = true }
 

common/credential-storage/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 [dependencies]
 async-trait = { version = "0.1.51" }
 
-log = { workspace = true }
+log = "0.4"
 sqlx = { version = "0.5", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]}
 thiserror = "1.0"
 tokio = { version = "1.24.1", features = [ "rt-multi-thread", "net", "signal", "fs" ] }

common/credential-storage/migrations/20230117120000_add_epoch_id_to_coconut.sql

@@ -1,17 +0,0 @@
-/*
- * Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-DROP TABLE coconut_credentials;
-CREATE TABLE coconut_credentials
-(
-    id                  INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    voucher_value       TEXT    NOT NULL,
-    voucher_info        TEXT    NOT NULL,
-    serial_number       TEXT    NOT NULL,
-    binding_number      TEXT    NOT NULL,
-    signature           TEXT    NOT NULL UNIQUE,
-    epoch_id            TEXT    NOT NULL,
-    consumed            BOOLEAN NOT NULL
-);

common/credential-storage/src/coconut.rs

@@ -34,11 +34,10 @@ impl CoconutCredentialManager {
         serial_number: String,
         binding_number: String,
         signature: String,
-        epoch_id: String,
     ) -> Result<(), sqlx::Error> {
         sqlx::query!(
-            "INSERT INTO coconut_credentials(voucher_value, voucher_info, serial_number, binding_number, signature, epoch_id, consumed) VALUES (?, ?, ?, ?, ?, ?, ?)",
-            voucher_value, voucher_info, serial_number, binding_number, signature, epoch_id, false
+            "INSERT INTO coconut_credentials(voucher_value, voucher_info, serial_number, binding_number, signature, consumed) VALUES (?, ?, ?, ?, ?, ?)",
+            voucher_value, voucher_info, serial_number, binding_number, signature, false
         )
         .execute(&self.connection_pool)
         .await?;

common/credential-storage/src/lib.rs

@@ -70,7 +70,6 @@ impl Storage for PersistentStorage {
         serial_number: String,
         binding_number: String,
         signature: String,
-        epoch_id: String,
     ) -> Result<(), StorageError> {
         self.coconut_credential_manager
             .insert_coconut_credential(
@@ -79,7 +78,6 @@ impl Storage for PersistentStorage {
                 serial_number,
                 binding_number,
                 signature,
-                epoch_id,
             )
             .await?;
 

common/credential-storage/src/models.rs

@@ -9,6 +9,5 @@ pub struct CoconutCredential {
     pub serial_number: String,
     pub binding_number: String,
     pub signature: String,
-    pub epoch_id: String,
     pub consumed: bool,
 }

common/credential-storage/src/storage.rs

@@ -12,12 +12,7 @@ pub trait Storage: Send + Sync {
     ///
     /// # Arguments
     ///
-    /// * `voucher_value`: How much bandwidth is in the credential.
-    /// * `voucher_info`: What type of credential it is.
-    /// * `serial_number`: Serial number of the credential.
-    /// * `binding_number`: Binding number of the credential.
     /// * `signature`: Coconut credential in the form of a signature.
-    /// * `epoch_id`: The epoch when it was signed.
     async fn insert_coconut_credential(
         &self,
         voucher_value: String,
@@ -25,7 +20,6 @@ pub trait Storage: Send + Sync {
         serial_number: String,
         binding_number: String,
         signature: String,
-        epoch_id: String,
     ) -> Result<(), StorageError>;
 
     /// Tries to retrieve one of the stored, unused credentials.

common/credentials/src/coconut/bandwidth.rs

@@ -168,7 +168,6 @@ pub fn prepare_for_spending(
     voucher_info: String,
     serial_number: PrivateAttribute,
     binding_number: PrivateAttribute,
-    epoch_id: u64,
     signature: &Signature,
     verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
@@ -180,7 +179,6 @@ pub fn prepare_for_spending(
         voucher_info,
         serial_number,
         binding_number,
-        epoch_id,
         signature,
         verification_key,
     )

common/credentials/src/coconut/utils.rs

@@ -137,14 +137,12 @@ pub async fn obtain_aggregate_signature(
 }
 
 // TODO: better type flow
-#[allow(clippy::too_many_arguments)]
 pub fn prepare_credential_for_spending(
     params: &Parameters,
     voucher_value: u64,
     voucher_info: String,
     serial_number: Attribute,
     binding_number: Attribute,
-    epoch_id: u64,
     signature: &Signature,
     verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
@@ -161,6 +159,5 @@ pub fn prepare_credential_for_spending(
         theta,
         voucher_value,
         voucher_info,
-        epoch_id,
     ))
 }

common/inclusion-probability/Cargo.toml

@@ -6,6 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-log = { workspace = true }
+log = "0.4.17"
 rand = "0.8.5"
 thiserror = "1.0.32"

common/logging/Cargo.toml

@@ -6,5 +6,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-log = { workspace = true }
+log = "0.4.0"
 pretty_env_logger = "0.4.0"

common/logging/src/lib.rs

@@ -34,8 +34,9 @@ pub fn banner(crate_name: &str, crate_version: &str) -> String {
      |_| |_|\__, |_| |_| |_|
             |___/
 
-             ({crate_name} - version {crate_version})
+             ({:} - version {:})
 
-    "#
+    "#,
+        crate_name, crate_version
     )
 }

common/mixnode-common/Cargo.toml

@@ -10,7 +10,7 @@ edition = "2021"
 bytes = "1.0"
 futures = "0.3"
 humantime-serde = "1.0"
-log = { workspace = true }
+log = "0.4"
 rand = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1.24.1", features = ["time", "macros", "rt", "net", "io-util"] }

common/network-defaults/src/lib.rs

@@ -36,7 +36,6 @@ pub struct NymContracts {
     pub vesting_contract_address: Option<String>,
     pub bandwidth_claim_contract_address: Option<String>,
     pub coconut_bandwidth_contract_address: Option<String>,
-    pub group_contract_address: Option<String>,
     pub multisig_contract_address: Option<String>,
     pub coconut_dkg_contract_address: Option<String>,
 }
@@ -96,9 +95,6 @@ impl NymNetworkDetails {
                 var(var_names::COCONUT_BANDWIDTH_CONTRACT_ADDRESS)
                     .expect("coconut bandwidth contract not set"),
             ))
-            .with_group_contract(Some(
-                var(var_names::GROUP_CONTRACT_ADDRESS).expect("group contract not set"),
-            ))
             .with_multisig_contract(Some(
                 var(var_names::MULTISIG_CONTRACT_ADDRESS).expect("multisig contract not set"),
             ))
@@ -129,7 +125,6 @@ impl NymNetworkDetails {
                 coconut_bandwidth_contract_address: parse_optional_str(
                     mainnet::COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
                 ),
-                group_contract_address: parse_optional_str(mainnet::GROUP_CONTRACT_ADDRESS),
                 multisig_contract_address: parse_optional_str(mainnet::MULTISIG_CONTRACT_ADDRESS),
                 coconut_dkg_contract_address: parse_optional_str(
                     mainnet::COCONUT_DKG_CONTRACT_ADDRESS,
@@ -198,12 +193,6 @@ impl NymNetworkDetails {
         self
     }
 
-    #[must_use]
-    pub fn with_group_contract<S: Into<String>>(mut self, contract: Option<S>) -> Self {
-        self.contracts.multisig_contract_address = contract.map(Into::into);
-        self
-    }
-
     #[must_use]
     pub fn with_multisig_contract<S: Into<String>>(mut self, contract: Option<S>) -> Self {
         self.contracts.multisig_contract_address = contract.map(Into::into);

common/network-defaults/src/mainnet.rs

@@ -17,7 +17,6 @@ pub(crate) const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str =
     "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str =
     "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
-pub(crate) const GROUP_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const MULTISIG_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const COCONUT_DKG_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const _ETH_CONTRACT_ADDRESS: [u8; 20] =
@@ -82,7 +81,6 @@ pub fn export_to_env() {
         var_names::COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
         COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
     );
-    set_var_to_default(var_names::GROUP_CONTRACT_ADDRESS, GROUP_CONTRACT_ADDRESS);
     set_var_to_default(
         var_names::MULTISIG_CONTRACT_ADDRESS,
         MULTISIG_CONTRACT_ADDRESS,
@@ -127,7 +125,6 @@ pub fn export_to_env_if_not_set() {
         var_names::COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
         COCONUT_BANDWIDTH_CONTRACT_ADDRESS,
     );
-    set_var_conditionally_to_default(var_names::GROUP_CONTRACT_ADDRESS, GROUP_CONTRACT_ADDRESS);
     set_var_conditionally_to_default(
         var_names::MULTISIG_CONTRACT_ADDRESS,
         MULTISIG_CONTRACT_ADDRESS,

common/network-defaults/src/var_names.rs

@@ -14,7 +14,6 @@ pub const MIXNET_CONTRACT_ADDRESS: &str = "MIXNET_CONTRACT_ADDRESS";
 pub const VESTING_CONTRACT_ADDRESS: &str = "VESTING_CONTRACT_ADDRESS";
 pub const BANDWIDTH_CLAIM_CONTRACT_ADDRESS: &str = "BANDWIDTH_CLAIM_CONTRACT_ADDRESS";
 pub const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str = "COCONUT_BANDWIDTH_CONTRACT_ADDRESS";
-pub const GROUP_CONTRACT_ADDRESS: &str = "GROUP_CONTRACT_ADDRESS";
 pub const MULTISIG_CONTRACT_ADDRESS: &str = "MULTISIG_CONTRACT_ADDRESS";
 pub const COCONUT_DKG_CONTRACT_ADDRESS: &str = "COCONUT_DKG_CONTRACT_ADDRESS";
 pub const REWARDING_VALIDATOR_ADDRESS: &str = "REWARDING_VALIDATOR_ADDRESS";

common/nymcoconut/src/tests/helpers.rs

@@ -89,9 +89,6 @@ pub fn theta_from_keys_and_attributes(
 }
 
 pub fn transpose_matrix<T: Debug>(matrix: Vec<Vec<T>>) -> Vec<Vec<T>> {
-    if matrix.is_empty() {
-        return vec![];
-    }
     let len = matrix[0].len();
     let mut iters: Vec<_> = matrix.into_iter().map(|d| d.into_iter()).collect();
     (0..len)

common/nymsphinx/chunking/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-log = { workspace = true }
+log = "0.4.8"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 thiserror = "1.0.37"
 

common/socks5/ordered-buffer/Cargo.toml

@@ -7,5 +7,5 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-log = { workspace = true }
+log = "0.4"
 thiserror = "1.0.37"

common/socks5/proxy-helpers/Cargo.toml

@@ -13,7 +13,7 @@ tokio-util = { version = "0.7.4", features = [ "io" ] } # reason for getting thi
 # their `read_buf` [from the util crate] replacement rather than having to rethink/reimplement `AvailableReader` with the new AsyncRead trait definition.
 # In the long run, the dependency should probably get removed in favour of pure-tokio implementation, but for time being it's fine.
 futures = "0.3"
-log = { workspace = true }
+log = "0.4"
 
 # internal
 client-connections = { path = "../../client-connections" }

common/statistics/Cargo.toml

@@ -10,7 +10,7 @@ edition = "2021"
 
 [dependencies]
 async-trait = { version = "0.1.51" }
-log = { workspace = true }
+log = "0.4"
 reqwest = { version = "0.11", features = ["json"] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1"

common/task/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 
 [dependencies]
 futures = "0.3"
-log = { workspace = true }
+log = "0.4"
 thiserror = "1.0.37"
 tokio = { version = "1.24.1", features = ["macros", "sync"] }
 

common/topology/Cargo.toml

@@ -8,7 +8,7 @@ edition = "2021"
 
 [dependencies]
 bs58 = "0.4"
-log = { workspace = true }
+log = "0.4"
 rand = { version = "0.7.3", features = ["wasm-bindgen"] }
 thiserror = "1.0.37"
 

common/types/Cargo.toml

@@ -2,13 +2,13 @@
 name = "nym-types"
 version = "1.0.0"
 description = "Nym common types"
-authors.workspace = true
+authors = ["Nym Technologies SA"]
 edition = "2021"
 rust-version = "1.58"
 
 [dependencies]
 eyre = "0.6.5"
-log = { workspace = true }
+log = "0.4"
 itertools = "0.10"
 reqwest = "0.11.9"
 schemars = "0.8"

contracts/coconut-dkg/Cargo.toml

@@ -23,7 +23,4 @@ thiserror = "1.0.23"
 
 [dev-dependencies]
 cw-multi-test = { version = "0.13.4" }
-cw4-group = { path = "../multisig/cw4-group" }
-group-contract-common = { path = "../../common/cosmwasm-smart-contracts/group-contract" }
-lazy_static = "1.4"
-rusty-fork = "0.3"
+cw4-group = { path = "../multisig/cw4-group" }

contracts/coconut-dkg/src/constants.rs

@@ -3,6 +3,3 @@
 
 // Wait time for the verification to take place (currently 24h)
 pub(crate) const BLOCK_TIME_FOR_VERIFICATION_SECS: u64 = 86400;
-
-pub(crate) const VK_SHARES_PK_NAMESPACE: &str = "vksp";
-pub(crate) const VK_SHARES_EPOCH_ID_IDX_NAMESPACE: &str = "vkse";

contracts/coconut-dkg/src/contract.rs

@@ -9,7 +9,7 @@ use crate::dealings::queries::query_dealings_paged;
 use crate::dealings::transactions::try_commit_dealings;
 use crate::epoch_state::queries::{query_current_epoch, query_current_epoch_threshold};
 use crate::epoch_state::storage::CURRENT_EPOCH;
-use crate::epoch_state::transactions::{advance_epoch_state, try_surpassed_threshold};
+use crate::epoch_state::transactions::advance_epoch_state;
 use crate::error::ContractError;
 use crate::state::{State, MULTISIG, STATE};
 use crate::verification_key_shares::queries::query_vk_shares_paged;
@@ -54,7 +54,6 @@ pub fn instantiate(
         deps.storage,
         &Epoch::new(
             EpochState::default(),
-            0,
             msg.time_configuration.unwrap_or_default(),
             env.block.time,
         ),
@@ -85,7 +84,6 @@ pub fn execute(
         ExecuteMsg::VerifyVerificationKeyShare { owner } => {
             try_verify_verification_key_share(deps, info, owner)
         }
-        ExecuteMsg::SurpassedThreshold {} => try_surpassed_threshold(deps, env),
         ExecuteMsg::AdvanceEpochState {} => advance_epoch_state(deps, env),
     }
 }
@@ -111,11 +109,9 @@ pub fn query(deps: Deps<'_>, _env: Env, msg: QueryMsg) -> Result<QueryResponse,
             limit,
             start_after,
         } => to_binary(&query_dealings_paged(deps, idx, start_after, limit)?)?,
-        QueryMsg::GetVerificationKeys {
-            epoch_id,
-            limit,
-            start_after,
-        } => to_binary(&query_vk_shares_paged(deps, epoch_id, start_after, limit)?)?,
+        QueryMsg::GetVerificationKeys { limit, start_after } => {
+            to_binary(&query_vk_shares_paged(deps, start_after, limit)?)?
+        }
     };
 
     Ok(response)
@@ -136,8 +132,8 @@ mod tests {
     use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
     use cosmwasm_std::{coins, Addr};
     use cw4::Member;
+    use cw4_group::msg::InstantiateMsg as GroupInstantiateMsg;
     use cw_multi_test::{App, AppBuilder, AppResponse, ContractWrapper, Executor};
-    use group_contract_common::msg::InstantiateMsg as GroupInstantiateMsg;
 
     fn instantiate_with_group(app: &mut App, members: &[Addr]) -> Addr {
         let group_code_id = app.store_code(Box::new(ContractWrapper::new(

contracts/coconut-dkg/src/epoch_state/transactions.rs

@@ -1,49 +1,11 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::dealers::storage::{current_dealers, past_dealers};
-use crate::dealings::storage::DEALINGS_BYTES;
+use crate::dealers::storage::current_dealers;
 use crate::epoch_state::storage::{CURRENT_EPOCH, THRESHOLD};
-use crate::epoch_state::utils::check_epoch_state;
 use crate::error::ContractError;
-use crate::state::STATE;
 use coconut_dkg_common::types::{Epoch, EpochState};
-use cosmwasm_std::{DepsMut, Env, Order, Response, Storage};
-
-fn reset_epoch_state(storage: &mut dyn Storage) -> Result<(), ContractError> {
-    THRESHOLD.remove(storage);
-    let dealers: Vec<_> = current_dealers()
-        .keys(storage, None, None, Order::Ascending)
-        .collect::<Result<_, _>>()?;
-
-    for dealer_addr in dealers {
-        let details = current_dealers().load(storage, &dealer_addr)?;
-        for dealings in DEALINGS_BYTES {
-            dealings.remove(storage, &details.address);
-        }
-        current_dealers().remove(storage, &dealer_addr)?;
-        past_dealers().save(storage, &dealer_addr, &details)?;
-    }
-    Ok(())
-}
-
-fn dealers_still_active(deps: &DepsMut<'_>) -> Result<usize, ContractError> {
-    let state = STATE.load(deps.storage)?;
-    let mut still_active = 0;
-    for dealer_addr in current_dealers()
-        .keys(deps.storage, None, None, Order::Ascending)
-        .flatten()
-    {
-        if state
-            .group_addr
-            .is_voting_member(&deps.querier, &dealer_addr, None)?
-            .is_some()
-        {
-            still_active += 1;
-        }
-    }
-    Ok(still_active)
-}
+use cosmwasm_std::{DepsMut, Env, Order, Response};
 
 pub(crate) fn advance_epoch_state(deps: DepsMut<'_>, env: Env) -> Result<Response, ContractError> {
     let epoch = CURRENT_EPOCH.load(deps.storage)?;
@@ -56,71 +18,24 @@ pub(crate) fn advance_epoch_state(deps: DepsMut<'_>, env: Env) -> Result<Respons
         ));
     }
 
-    let current_epoch = CURRENT_EPOCH.load(deps.storage)?;
-    let next_epoch = if let Some(state) = current_epoch.state.next() {
-        // We are during DKG process
-        if state == EpochState::DealingExchange {
-            let current_dealer_count = current_dealers()
-                .keys(deps.storage, None, None, Order::Ascending)
-                .count();
-            // note: ceiling in integer division can be achieved via q = (x + y - 1) / y;
-            let threshold = (2 * current_dealer_count as u64 + 3 - 1) / 3;
-            THRESHOLD.save(deps.storage, &threshold)?;
-        }
-        Epoch::new(
-            state,
-            current_epoch.epoch_id,
-            current_epoch.time_configuration,
+    let current_epoch = CURRENT_EPOCH.update::<_, ContractError>(deps.storage, |mut epoch| {
+        // TODO: When defaulting to the first state, some action will probably need to be taken on the
+        // rest of the contract, as we're starting with a new set of signers
+        epoch = Epoch::new(
+            epoch.state.next().unwrap_or_default(),
+            epoch.time_configuration,
             env.block.time,
-        )
-    } else if dealers_still_active(&deps)?
-        == STATE
-            .load(deps.storage)?
-            .group_addr
-            .list_members(&deps.querier, None, None)?
-            .len()
-    {
-        // The dealer set hasn't changed, so we only extend the finish timestamp
-        Epoch::new(
-            current_epoch.state,
-            current_epoch.epoch_id,
-            current_epoch.time_configuration,
-            env.block.time,
-        )
-    } else {
-        // Dealer set changed, we need to redo DKG from scratch
-        reset_epoch_state(deps.storage)?;
-        Epoch::new(
-            EpochState::default(),
-            current_epoch.epoch_id + 1,
-            current_epoch.time_configuration,
-            env.block.time,
-        )
-    };
-    CURRENT_EPOCH.save(deps.storage, &next_epoch)?;
-
-    Ok(Response::default())
-}
-
-pub(crate) fn try_surpassed_threshold(
-    deps: DepsMut<'_>,
-    env: Env,
-) -> Result<Response, ContractError> {
-    check_epoch_state(deps.storage, EpochState::InProgress)?;
-
-    let threshold = THRESHOLD.load(deps.storage)?;
-    if dealers_still_active(&deps)? < threshold as usize {
-        reset_epoch_state(deps.storage)?;
-        CURRENT_EPOCH.update::<_, ContractError>(deps.storage, |epoch| {
-            Ok(Epoch::new(
-                EpochState::default(),
-                epoch.epoch_id + 1,
-                epoch.time_configuration,
-                env.block.time,
-            ))
-        })?;
+        );
+        Ok(epoch)
+    })?;
+    if current_epoch.state == EpochState::DealingExchange {
+        let current_dealer_count = current_dealers()
+            .keys(deps.storage, None, None, Order::Ascending)
+            .count();
+        // note: ceiling in integer division can be achieved via q = (x + y - 1) / y;
+        let threshold = (2 * current_dealer_count as u64 + 3 - 1) / 3;
+        THRESHOLD.save(deps.storage, &threshold)?;
     }
-
     Ok(Response::default())
 }
 
@@ -128,375 +43,160 @@ pub(crate) fn try_surpassed_threshold(
 pub(crate) mod tests {
     use super::*;
     use crate::error::ContractError::EarlyEpochStateAdvancement;
-    use crate::support::tests::fixtures::dealer_details_fixture;
-    use crate::support::tests::helpers::{init_contract, GROUP_MEMBERS};
-    use coconut_dkg_common::types::{
-        ContractSafeBytes, DealerDetails, EpochState, TimeConfiguration,
-    };
+    use crate::support::tests::helpers::init_contract;
+    use coconut_dkg_common::types::{DealerDetails, EpochState, TimeConfiguration};
     use cosmwasm_std::testing::mock_env;
     use cosmwasm_std::Addr;
-    use cw4::Member;
-    use rusty_fork::rusty_fork_test;
 
-    // Because of the global variable handling group, we need individual process for each test
-    rusty_fork_test! {
-        #[test]
-        fn still_active() {
-            let mut deps = init_contract();
-            {
-                let mut group = GROUP_MEMBERS.lock().unwrap();
+    #[test]
+    fn advance_state() {
+        let mut deps = init_contract();
+        let mut env = mock_env();
 
-                group.push(Member {
-                    addr: "owner1".to_string(),
-                    weight: 10,
-                });
-                group.push(Member {
-                    addr: "owner2".to_string(),
-                    weight: 10,
-                });
-                group.push(Member {
-                    addr: "owner3".to_string(),
-                    weight: 10,
-                });
-            }
-            assert_eq!(0, dealers_still_active(&deps.as_mut()).unwrap());
-            for i in 0..3 as u64 {
-                let details = dealer_details_fixture(i + 1);
-                current_dealers()
-                    .save(deps.as_mut().storage, &details.address, &details)
-                    .unwrap();
-                assert_eq!(
-                    i as usize + 1,
-                    dealers_still_active(&deps.as_mut()).unwrap()
-                );
-            }
-        }
-
-        #[test]
-        fn advance_state() {
-            let mut deps = init_contract();
-            let mut env = mock_env();
-            {
-                let mut group = GROUP_MEMBERS.lock().unwrap();
-
-                group.push(Member {
-                    addr: "owner1".to_string(),
-                    weight: 10,
-                });
-                group.push(Member {
-                    addr: "owner2".to_string(),
-                    weight: 10,
-                });
-                group.push(Member {
-                    addr: "owner3".to_string(),
-                    weight: 10,
-                });
-            }
-
-            let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            assert_eq!(epoch.state, EpochState::PublicKeySubmission);
-            assert_eq!(
-                epoch.finish_timestamp,
-                env.block
-                    .time
-                    .plus_seconds(epoch.time_configuration.public_key_submission_time_secs)
-            );
-
-            env.block.time = env
-                .block
+        let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
+        assert_eq!(epoch.state, EpochState::PublicKeySubmission);
+        assert_eq!(
+            epoch.finish_timestamp,
+            env.block
                 .time
-                .plus_seconds(epoch.time_configuration.public_key_submission_time_secs - 1);
-            assert_eq!(
-                advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
-                EarlyEpochStateAdvancement(1)
-            );
+                .plus_seconds(epoch.time_configuration.public_key_submission_time_secs)
+        );
 
-            env.block.time = env.block.time.plus_seconds(1);
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-            let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            assert_eq!(epoch.state, EpochState::DealingExchange);
-            assert_eq!(
-                epoch.finish_timestamp,
-                env.block
-                    .time
-                    .plus_seconds(epoch.time_configuration.dealing_exchange_time_secs)
-            );
+        env.block.time = env
+            .block
+            .time
+            .plus_seconds(epoch.time_configuration.public_key_submission_time_secs - 1);
+        assert_eq!(
+            advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
+            EarlyEpochStateAdvancement(1)
+        );
 
-            env.block.time = env
-                .block
+        env.block.time = env.block.time.plus_seconds(1);
+        advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
+        let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
+        assert_eq!(epoch.state, EpochState::DealingExchange);
+        assert_eq!(
+            epoch.finish_timestamp,
+            env.block
                 .time
-                .plus_seconds(epoch.time_configuration.dealing_exchange_time_secs - 2);
-            assert_eq!(
-                advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
-                EarlyEpochStateAdvancement(2)
-            );
+                .plus_seconds(epoch.time_configuration.dealing_exchange_time_secs)
+        );
 
-            env.block.time = env.block.time.plus_seconds(3);
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-            let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            assert_eq!(epoch.state, EpochState::VerificationKeySubmission);
-            assert_eq!(
-                epoch.finish_timestamp,
-                env.block.time.plus_seconds(
-                    epoch
-                        .time_configuration
-                        .verification_key_submission_time_secs
-                )
-            );
+        env.block.time = env
+            .block
+            .time
+            .plus_seconds(epoch.time_configuration.dealing_exchange_time_secs - 2);
+        assert_eq!(
+            advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
+            EarlyEpochStateAdvancement(2)
+        );
 
-            env.block.time = env.block.time.plus_seconds(
+        env.block.time = env.block.time.plus_seconds(3);
+        advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
+        let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
+        assert_eq!(epoch.state, EpochState::VerificationKeySubmission);
+        assert_eq!(
+            epoch.finish_timestamp,
+            env.block.time.plus_seconds(
                 epoch
                     .time_configuration
                     .verification_key_submission_time_secs
-                    - 2,
-            );
-            assert_eq!(
-                advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
-                EarlyEpochStateAdvancement(2)
-            );
+            )
+        );
 
-            env.block.time = env.block.time.plus_seconds(3);
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-            let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            assert_eq!(epoch.state, EpochState::VerificationKeyValidation);
-            assert_eq!(
-                epoch.finish_timestamp,
-                env.block.time.plus_seconds(
-                    epoch
-                        .time_configuration
-                        .verification_key_validation_time_secs
-                )
-            );
+        env.block.time = env.block.time.plus_seconds(
+            epoch
+                .time_configuration
+                .verification_key_submission_time_secs
+                - 2,
+        );
+        assert_eq!(
+            advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
+            EarlyEpochStateAdvancement(2)
+        );
 
-            env.block.time = env.block.time.plus_seconds(
+        env.block.time = env.block.time.plus_seconds(3);
+        advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
+        let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
+        assert_eq!(epoch.state, EpochState::VerificationKeyValidation);
+        assert_eq!(
+            epoch.finish_timestamp,
+            env.block.time.plus_seconds(
                 epoch
                     .time_configuration
                     .verification_key_validation_time_secs
-                    - 3,
-            );
-            assert_eq!(
-                advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
-                EarlyEpochStateAdvancement(3)
-            );
-
-            env.block.time = env.block.time.plus_seconds(3);
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-            let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            assert_eq!(epoch.state, EpochState::VerificationKeyFinalization);
-            assert_eq!(
-                epoch.finish_timestamp,
-                env.block.time.plus_seconds(
-                    epoch
-                        .time_configuration
-                        .verification_key_finalization_time_secs
-                )
-            );
-
-            env.block.time = env
-                .block
-                .time
-                .plus_seconds(TimeConfiguration::default().verification_key_finalization_time_secs - 1);
-            assert_eq!(
-                advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
-                EarlyEpochStateAdvancement(1)
-            );
-
-            env.block.time = env.block.time.plus_seconds(1);
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-            let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            assert_eq!(epoch.state, EpochState::InProgress);
-            assert_eq!(
-                epoch.finish_timestamp,
-                env.block
-                    .time
-                    .plus_seconds(epoch.time_configuration.in_progress_time_secs)
-            );
-
-            env.block.time = env
-                .block
-                .time
-                .plus_seconds(epoch.time_configuration.in_progress_time_secs - 100);
-            assert_eq!(
-                advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
-                EarlyEpochStateAdvancement(100)
-            );
-
-            env.block.time = env.block.time.plus_seconds(50);
-            assert_eq!(
-                advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
-                EarlyEpochStateAdvancement(50)
-            );
-
-            // setup dealer details
-            let all_details: [_; 3] = std::array::from_fn(|i| dealer_details_fixture(i as u64 + 1));
-            for details in all_details.iter() {
-                current_dealers()
-                    .save(deps.as_mut().storage, &details.address, details)
-                    .unwrap();
-            }
-
-            // Group hasn't changed, so we remain in the same epoch, with updated finish timestamp
-            env.block.time = env.block.time.plus_seconds(100);
-            let prev_epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-            let curr_epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            let expected_epoch = Epoch::new(
-                EpochState::InProgress,
-                prev_epoch.epoch_id,
-                prev_epoch.time_configuration,
-                env.block.time,
-            );
-            assert_eq!(curr_epoch, expected_epoch);
-
-            // Group changed, slightly, so reset dkg state
-            *GROUP_MEMBERS.lock().unwrap().first_mut().unwrap() = Member {
-                addr: "owner4".to_string(),
-                weight: 10,
-            };
-            env.block.time = env
-                .block
-                .time
-                .plus_seconds(epoch.time_configuration.in_progress_time_secs);
-            let prev_epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-            let curr_epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
-            let expected_epoch = Epoch::new(
-                EpochState::default(),
-                prev_epoch.epoch_id + 1,
-                prev_epoch.time_configuration,
-                env.block.time,
-            );
-            assert_eq!(curr_epoch, expected_epoch);
-            assert!(THRESHOLD.may_load(&deps.storage).unwrap().is_none());
-        }
-
-
-    #[test]
-    fn surpass_threshold() {
-        let mut deps = init_contract();
-        let mut env = mock_env();
-        let time_configuration = TimeConfiguration::default();
-        {
-            let mut group = GROUP_MEMBERS.lock().unwrap();
-
-            group.push(Member {
-                addr: "owner1".to_string(),
-                weight: 10,
-            });
-            group.push(Member {
-                addr: "owner2".to_string(),
-                weight: 10,
-            });
-            group.push(Member {
-                addr: "owner3".to_string(),
-                weight: 10,
-            });
-        }
-
-        let ret = try_surpassed_threshold(deps.as_mut(), env.clone()).unwrap_err();
-        assert_eq!(
-            ret,
-            ContractError::IncorrectEpochState {
-                current_state: EpochState::default().to_string(),
-                expected_state: EpochState::InProgress.to_string()
-            }
-        );
-
-        let all_details: [_; 3] = std::array::from_fn(|i| dealer_details_fixture(i as u64 + 1));
-        for details in all_details.iter() {
-            current_dealers()
-                .save(deps.as_mut().storage, &details.address, details)
-                .unwrap();
-        }
-
-        for times in [
-            time_configuration.public_key_submission_time_secs,
-            time_configuration.dealing_exchange_time_secs,
-            time_configuration.verification_key_submission_time_secs,
-            time_configuration.verification_key_validation_time_secs,
-            time_configuration.verification_key_finalization_time_secs,
-        ] {
-            env.block.time = env.block.time.plus_seconds(times);
-            advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
-        }
-        let curr_epoch = CURRENT_EPOCH.load(&deps.storage).unwrap();
-        assert_eq!(THRESHOLD.load(&deps.storage).unwrap(), 2);
-
-        // epoch hasn't advanced as we are still in the threshold range
-        try_surpassed_threshold(deps.as_mut(), env.clone()).unwrap();
-        assert_eq!(THRESHOLD.load(&deps.storage).unwrap(), 2);
-        assert_eq!(CURRENT_EPOCH.load(&deps.storage).unwrap(), curr_epoch);
-
-        *GROUP_MEMBERS.lock().unwrap().first_mut().unwrap() = Member {
-            addr: "owner4".to_string(),
-            weight: 10,
-        };
-        // epoch hasn't advanced as we are still in the threshold range
-        try_surpassed_threshold(deps.as_mut(), env.clone()).unwrap();
-        assert_eq!(THRESHOLD.load(&deps.storage).unwrap(), 2);
-        assert_eq!(CURRENT_EPOCH.load(&deps.storage).unwrap(), curr_epoch);
-
-        *GROUP_MEMBERS.lock().unwrap().last_mut().unwrap() = Member {
-            addr: "owner5".to_string(),
-            weight: 10,
-        };
-        try_surpassed_threshold(deps.as_mut(), env.clone()).unwrap();
-        assert!(THRESHOLD.may_load(&deps.storage).unwrap().is_none());
-        let next_epoch = CURRENT_EPOCH.load(&deps.storage).unwrap();
-        assert_eq!(
-            next_epoch,
-            Epoch::new(
-                EpochState::default(),
-                curr_epoch.epoch_id + 1,
-                curr_epoch.time_configuration,
-                env.block.time,
             )
         );
-    }
-    }
 
-    #[test]
-    fn reset_state() {
-        let mut deps = init_contract();
-        let all_details: [_; 100] = std::array::from_fn(|i| dealer_details_fixture(i as u64));
+        env.block.time = env.block.time.plus_seconds(
+            epoch
+                .time_configuration
+                .verification_key_validation_time_secs
+                - 3,
+        );
+        assert_eq!(
+            advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
+            EarlyEpochStateAdvancement(3)
+        );
 
-        THRESHOLD.save(deps.as_mut().storage, &42).unwrap();
-        for details in all_details.iter() {
-            current_dealers()
-                .save(deps.as_mut().storage, &details.address, details)
-                .unwrap();
-            for dealings in DEALINGS_BYTES {
-                dealings
-                    .save(
-                        deps.as_mut().storage,
-                        &details.address,
-                        &ContractSafeBytes(vec![1, 2, 3]),
-                    )
-                    .unwrap();
-            }
-        }
+        env.block.time = env.block.time.plus_seconds(3);
+        advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
+        let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
+        assert_eq!(epoch.state, EpochState::VerificationKeyFinalization);
+        assert_eq!(
+            epoch.finish_timestamp,
+            env.block.time.plus_seconds(
+                epoch
+                    .time_configuration
+                    .verification_key_finalization_time_secs
+            )
+        );
 
-        reset_epoch_state(deps.as_mut().storage).unwrap();
+        env.block.time = env
+            .block
+            .time
+            .plus_seconds(TimeConfiguration::default().verification_key_finalization_time_secs - 1);
+        assert_eq!(
+            advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
+            EarlyEpochStateAdvancement(1)
+        );
 
-        assert!(THRESHOLD.may_load(&deps.storage).unwrap().is_none());
-        for details in all_details {
-            for dealings in DEALINGS_BYTES {
-                assert!(dealings
-                    .may_load(&deps.storage, &details.address)
-                    .unwrap()
-                    .is_none());
-            }
-            assert!(current_dealers()
-                .may_load(deps.as_mut().storage, &details.address)
-                .unwrap()
-                .is_none());
-            assert_eq!(
-                past_dealers()
-                    .load(&deps.storage, &details.address)
-                    .unwrap(),
-                details
-            );
-        }
+        env.block.time = env.block.time.plus_seconds(1);
+        advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
+        let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
+        assert_eq!(epoch.state, EpochState::InProgress);
+        assert_eq!(
+            epoch.finish_timestamp,
+            env.block
+                .time
+                .plus_seconds(epoch.time_configuration.in_progress_time_secs)
+        );
+
+        env.block.time = env
+            .block
+            .time
+            .plus_seconds(epoch.time_configuration.in_progress_time_secs - 100);
+        assert_eq!(
+            advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
+            EarlyEpochStateAdvancement(100)
+        );
+
+        env.block.time = env.block.time.plus_seconds(50);
+        assert_eq!(
+            advance_epoch_state(deps.as_mut(), env.clone()).unwrap_err(),
+            EarlyEpochStateAdvancement(50)
+        );
+
+        env.block.time = env.block.time.plus_seconds(100);
+        advance_epoch_state(deps.as_mut(), env.clone()).unwrap();
+        let epoch = CURRENT_EPOCH.load(deps.as_mut().storage).unwrap();
+        assert_eq!(epoch.state, EpochState::PublicKeySubmission);
+        assert_eq!(
+            epoch.finish_timestamp,
+            env.block
+                .time
+                .plus_seconds(epoch.time_configuration.public_key_submission_time_secs)
+        );
     }
 
     #[test]