Remove unwraps

Add shared derivation material support for thread-safe key generation
- Add serialization support to DerivationMaterial for persistence/sharing - Implement shared derivation material in BaseClientBuilder with Arc<Mutex<>> for thread safety - Add network monitor support for deterministic key generation from file - Extend MixnetClientBuilder with shared derivation material functionality - Add comprehensive documentation explaining thread-safe sharing and key generation priority This enables multiple clients to derive keys from the same source material while maintaining thread safety, particularly useful for network monitoring where consistent client identities are needed across multiple instances.
2025-06-12 17:30:41 +02:00 · 2025-06-12 17:24:32 +02:00
450 changed files with 101020 additions and 8399 deletions
@@ -57,7 +57,6 @@ jobs:
          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/nym_ecash.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/nym_pool_contract.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_performance_contract.wasm $OUTPUT_DIR

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -0,0 +1,75 @@
+name: ci-nym-wallet-storybook
+
+on:
+  pull_request:
+    paths:
+      - 'nym-wallet/**'
+      - '.github/workflows/ci-nym-wallet-storybook.yml'
+
+jobs:
+  build:
+    runs-on: custom-linux
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install rsync
+        run: sudo apt-get install rsync
+        continue-on-error: true
+
+      - uses: rlespinasse/github-slug-action@v3.x
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Setup yarn
+        run: npm install -g yarn
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Install wasm-pack
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+
+      - name: Build dependencies
+        run: yarn && yarn build
+
+      - name: Build storybook
+        run: yarn storybook:build
+        working-directory: ./nym-wallet
+
+      - name: Deploy branch to CI www (storybook)
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "nym-wallet/storybook-static/"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/wallet-${{ env.GITHUB_REF_SLUG }}
+          EXCLUDE: "/dist/, /node_modules/"
+
+      - name: Matrix - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+
+      - name: Matrix - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: nym-wallet
+          NYM_PROJECT_NAME: "nym-wallet"
+          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+          NYM_CI_WWW_LOCATION: "wallet-${{ env.GITHUB_REF_SLUG }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          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
@@ -19,11 +19,7 @@ jobs:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    strategy:
      fail-fast: false
-      matrix:
-        include:
-          - os: arc-ubuntu-22.04
-            target: x86_64-unknown-linux-gnu
-    runs-on:  ${{ matrix.os }}
+    runs-on: arc-ubuntu-22.04

    outputs:
      release_id: ${{ steps.create-release.outputs.id }}
@@ -5,6 +5,8 @@
 >
 > ➡️➡️➡️➡️➡️ **View output:**
 >
+> `storybook`: https://{{ env.NYM_CI_WWW_LOCATION }}.{{ env.NYM_CI_WWW_BASE }}
+>
 > `branch` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/tree/{{ env.GIT_BRANCH_NAME }}
 >
 > `commit` {{ env.GITHUB_SERVER_URL }}/{{ env.GITHUB_REPOSITORY }}/commit/{{ env.GITHUB_SHA }}
@@ -1923,26 +1923,6 @@ dependencies = [
 "thiserror 1.0.69",
 ]

-[[package]]
-name = "cw-multi-test"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "533b31c94b9e10e77e2468a2b1559aa506505d18c4e52eb64cbfc624ca876ad2"
-dependencies = [
- "anyhow",
- "bech32",
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-storage-plus",
- "cw-utils",
- "itertools 0.14.0",
- "prost 0.13.5",
- "schemars",
- "serde",
- "sha2 0.10.9",
- "thiserror 2.0.12",
-]
-
 [[package]]
 name = "cw-storage-plus"
 version = "2.0.0"
@@ -5326,7 +5306,6 @@ dependencies = [
 "nym-sphinx 0.1.0",
 "nym-task 0.1.0",
 "sqlx",
- "sqlx-pool-guard",
 "thiserror 2.0.12",
 "time",
 "tokio",
@@ -5471,7 +5450,6 @@ dependencies = [
 name = "nym-contracts-common"
 version = "0.5.0"
 dependencies = [
- "anyhow",
 "bs58",
 "cosmwasm-schema",
 "cosmwasm-std",
@@ -5499,19 +5477,6 @@ dependencies = [
 "vergen",
 ]

-[[package]]
-name = "nym-contracts-common-testing"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "cosmwasm-std",
- "cw-multi-test",
- "cw-storage-plus",
- "rand 0.8.5",
- "rand_chacha 0.3.1",
- "serde",
-]
-
 [[package]]
 name = "nym-cpp-ffi"
 version = "0.1.2"
@@ -5608,7 +5573,6 @@ dependencies = [
 "nym-ecash-time 0.1.0",
 "serde",
 "sqlx",
- "sqlx-pool-guard",
 "thiserror 2.0.12",
 "tokio",
 "zeroize",
@@ -6322,6 +6286,7 @@ dependencies = [
 "schemars",
 "semver 1.0.26",
 "serde",
+ "serde-json-wasm",
 "serde_repr",
 "thiserror 2.0.12",
 "time",
@@ -6684,7 +6649,7 @@ dependencies = [

 [[package]]
 name = "nym-node-status-api"
-version = "3.1.0"
+version = "3.0.0"
 dependencies = [
 "ammonia",
 "anyhow",
@@ -6926,19 +6891,6 @@ dependencies = [
 "tracing",
 ]

-[[package]]
-name = "nym-performance-contract-common"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-controllers",
- "nym-contracts-common 0.5.0",
- "schemars",
- "serde",
- "thiserror 2.0.12",
-]
-
 [[package]]
 name = "nym-pool-contract-common"
 version = "0.1.0"
@@ -7485,7 +7437,7 @@ dependencies = [

 [[package]]
 name = "nym-statistics-api"
-version = "0.1.4"
+version = "0.1.3"
 dependencies = [
 "anyhow",
 "axum 0.7.9",
@@ -7758,7 +7710,6 @@ dependencies = [
 "nym-mixnet-contract-common 0.6.0",
 "nym-multisig-contract-common 0.1.0",
 "nym-network-defaults 0.1.0",
- "nym-performance-contract-common",
 "nym-serde-helpers 0.1.0",
 "nym-vesting-contract-common 0.7.0",
 "prost 0.13.5",
@@ -8740,15 +8691,6 @@ dependencies = [
 "unicode-ident",
 ]

-[[package]]
-name = "proc_pidinfo"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af53dad2390f8df98dda1e4188322bdf2f91c86cf6001f51d10d64451edf463a"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "prometheus"
 version = "0.14.0"
@@ -10336,19 +10278,6 @@ dependencies = [
 "whoami",
 ]

-[[package]]
-name = "sqlx-pool-guard"
-version = "0.1.0"
-dependencies = [
- "proc_pidinfo",
- "sqlx",
- "tempfile",
- "tokio",
- "tracing",
- "tracing-subscriber",
- "windows 0.61.1",
-]
-
 [[package]]
 name = "sqlx-postgres"
 version = "0.8.6"
@@ -10804,7 +10733,6 @@ dependencies = [
 "nym-mixnet-contract-common 0.6.0",
 "nym-multisig-contract-common 0.1.0",
 "nym-pemstore 0.3.0",
- "nym-performance-contract-common",
 "nym-validator-client 0.1.0",
 "nym-vesting-contract-common 0.7.0",
 "rand 0.8.5",
@@ -12364,28 +12292,6 @@ dependencies = [
 "windows-targets 0.52.6",
 ]

-[[package]]
-name = "windows"
-version = "0.61.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
-dependencies = [
- "windows-collections",
- "windows-core 0.61.2",
- "windows-future",
- "windows-link",
- "windows-numerics",
-]
-
-[[package]]
-name = "windows-collections"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
-dependencies = [
- "windows-core 0.61.2",
-]
-
 [[package]]
 name = "windows-core"
 version = "0.52.0"
@@ -12420,30 +12326,6 @@ dependencies = [
 "windows-targets 0.52.6",
 ]

-[[package]]
-name = "windows-core"
-version = "0.61.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
-dependencies = [
- "windows-implement 0.60.0",
- "windows-interface 0.59.1",
- "windows-link",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
-]
-
-[[package]]
-name = "windows-future"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
-dependencies = [
- "windows-core 0.61.2",
- "windows-link",
- "windows-threading",
-]
-
 [[package]]
 name = "windows-implement"
 version = "0.57.0"
@@ -12466,17 +12348,6 @@ dependencies = [
 "syn 2.0.98",
 ]

-[[package]]
-name = "windows-implement"
-version = "0.60.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.98",
-]
-
 [[package]]
 name = "windows-interface"
 version = "0.57.0"
@@ -12499,32 +12370,11 @@ dependencies = [
 "syn 2.0.98",
 ]

-[[package]]
-name = "windows-interface"
-version = "0.59.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.98",
-]
-
 [[package]]
 name = "windows-link"
-version = "0.1.1"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76840935b766e1b0a05c0066835fb9ec80071d4c09a16f6bd5f7e655e3c14c38"
-
-[[package]]
-name = "windows-numerics"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
-dependencies = [
- "windows-core 0.61.2",
- "windows-link",
-]
+checksum = "6dccfd733ce2b1753b03b6d3c65edf020262ea35e20ccdf3e288043e6dd620e3"

 [[package]]
 name = "windows-registry"
@@ -12532,7 +12382,7 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4286ad90ddb45071efd1a66dfa43eb02dd0dfbae1545ad6cc3c51cf34d7e8ba3"
 dependencies = [
- "windows-result 0.3.4",
+ "windows-result 0.3.1",
 "windows-strings 0.3.1",
 "windows-targets 0.53.0",
 ]
@@ -12557,9 +12407,9 @@ dependencies = [

 [[package]]
 name = "windows-result"
-version = "0.3.4"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+checksum = "06374efe858fab7e4f881500e6e86ec8bc28f9462c47e5a9941a0142ad86b189"
 dependencies = [
 "windows-link",
 ]
@@ -12583,15 +12433,6 @@ dependencies = [
 "windows-link",
 ]

-[[package]]
-name = "windows-strings"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.45.0"
@@ -12690,15 +12531,6 @@ dependencies = [
 "windows_x86_64_msvc 0.53.0",
 ]

-[[package]]
-name = "windows-threading"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
-dependencies = [
- "windows-link",
-]
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.42.2"
@@ -34,12 +34,11 @@ members = [
    "common/config",
    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
-    "common/cosmwasm-smart-contracts/contracts-common-testing",
    "common/cosmwasm-smart-contracts/easy_addr",
    "common/cosmwasm-smart-contracts/ecash-contract",
    "common/cosmwasm-smart-contracts/group-contract",
    "common/cosmwasm-smart-contracts/mixnet-contract",
-    "common/cosmwasm-smart-contracts/multisig-contract", "common/cosmwasm-smart-contracts/nym-performance-contract",
+    "common/cosmwasm-smart-contracts/multisig-contract",
    "common/cosmwasm-smart-contracts/nym-pool-contract",
    "common/cosmwasm-smart-contracts/vesting-contract",
    "common/credential-storage",
@@ -127,7 +126,6 @@ members = [
    "service-providers/common",
    "service-providers/ip-packet-router",
    "service-providers/network-requester",
-    "sqlx-pool-guard",
    "tools/echo-server",
    "tools/internal/contract-state-importer/importer-cli",
    "tools/internal/contract-state-importer/importer-contract",
@@ -137,6 +135,7 @@ members = [
    "tools/internal/testnet-manager",
    "tools/internal/testnet-manager",
    "tools/internal/testnet-manager/dkg-bypass-contract",
+    "tools/internal/testnet-manager/dkg-bypass-contract",
    "tools/internal/validator-status-check",
    "tools/nym-cli",
    "tools/nym-id-cli",
@@ -288,7 +287,6 @@ petgraph = "0.6.5"
 pin-project = "1.1"
 pin-project-lite = "0.2.16"
 publicsuffix = "2.3.0"
-proc_pidinfo = "0.1.3"
 quote = "1"
 rand = "0.8.5"
 rand_chacha = "0.3"
@@ -370,6 +368,9 @@ subtle = "2.5.0"
 # cosmwasm-related
 cosmwasm-schema = "=2.2.2"
 cosmwasm-std = "=2.2.2"
+# use 1.0.1 as that's the version used by cosmwasm-std 2.2.1
+# (and ideally we don't want to pull the same dependency twice)
+serde-json-wasm = "=1.0.1"
 # same version as used by cosmwasm
 cw-utils = "=2.0.0"
 cw-storage-plus = "=2.0.0"
@@ -377,7 +378,6 @@ cw2 = { version = "=2.0.0" }
 cw3 = { version = "=2.0.0" }
 cw4 = { version = "=2.0.0" }
 cw-controllers = { version = "=2.0.0" }
-cw-multi-test = "=2.3.2"

 # cosmrs-related
 bip32 = { version = "0.5.3", default-features = false }
@@ -133,7 +133,7 @@ clippy: sdk-wasm-lint
 # Build contracts ready for deploy
 # -----------------------------------------------------------------------------

-CONTRACTS=vesting_contract mixnet_contract nym_ecash cw3_flex_multisig cw4_group nym_coconut_dkg nym_pool_contract nym_performance_contract
+CONTRACTS=vesting_contract mixnet_contract nym_ecash cw3_flex_multisig cw4_group nym_coconut_dkg nym_pool_contract
 CONTRACTS_WASM=$(addsuffix .wasm, $(CONTRACTS))
 CONTRACTS_OUT_DIR=contracts/target/wasm32-unknown-unknown/release

@@ -2,7 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::BadGateway;
-use std::{io, path::PathBuf};
+use std::io;
+use std::path::PathBuf;
 use thiserror::Error;

 #[derive(Debug, Error)]
@@ -18,6 +19,7 @@ pub enum StorageError {

    #[error("failed to perform sqlx migration: {source}")]
    MigrationError {
+        #[source]
        #[from]
        source: sqlx::migrate::MigrateError,
    },
@@ -30,6 +32,7 @@ pub enum StorageError {

    #[error("failed to run the SQL query: {source}")]
    QueryError {
+        #[source]
        #[from]
        source: sqlx::error::Error,
    },
@@ -63,6 +63,7 @@ use std::os::raw::c_int as RawFd;
 use std::path::Path;
 use std::sync::Arc;
 use tokio::sync::mpsc::Sender;
+use tokio::sync::Mutex;
 use url::Url;

 #[cfg(all(
@@ -195,6 +196,10 @@ pub struct BaseClientBuilder<C, S: MixnetClientStorage> {
    connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,

    derivation_material: Option<DerivationMaterial>,
+    // Shared derivation material wrapped in Arc<Mutex<>> for thread-safe access
+    // across multiple clients. This allows multiple clients to share the same
+    // derivation source while maintaining safe concurrent access.
+    shared_derivation_material: Option<Arc<Mutex<DerivationMaterial>>>,
 }

 impl<C, S> BaseClientBuilder<C, S>
@@ -220,6 +225,7 @@ where
            #[cfg(unix)]
            connection_fd_callback: None,
            derivation_material: None,
+            shared_derivation_material: None,
        }
    }

@@ -232,6 +238,18 @@ where
        self
    }

+    /// Set shared derivation material for thread-safe sharing across multiple clients.
+    /// This is useful when multiple clients need to derive keys from the same source
+    /// while ensuring thread-safe access through Arc<Mutex<>>.
+    #[must_use]
+    pub fn with_shared_derivation_material(
+        mut self,
+        derivation_material: Option<Arc<Mutex<DerivationMaterial>>>,
+    ) -> Self {
+        self.shared_derivation_material = derivation_material;
+        self
+    }
+
    #[must_use]
    pub fn with_forget_me(mut self, forget_me: &ForgetMe) -> Self {
        self.config.debug.forget_me = *forget_me;
@@ -704,6 +722,7 @@ where
        key_store: &S::KeyStore,
        details_store: &S::GatewaysDetailsStore,
        derivation_material: Option<DerivationMaterial>,
+        shared_derivation_material: Option<Arc<Mutex<DerivationMaterial>>>,
    ) -> Result<InitialisationResult, ClientCoreError>
    where
        <S::KeyStore as KeyStore>::StorageError: Sync + Send,
@@ -713,12 +732,24 @@ where
        if key_store.load_keys().await.is_err() {
            info!("could not find valid client keys - a new set will be generated");
            let mut rng = OsRng;
-            let keys = if let Some(derivation_material) = derivation_material {
-                ClientKeys::from_master_key(&mut rng, &derivation_material)
-                    .map_err(|_| ClientCoreError::HkdfDerivationError {})?
-            } else {
-                ClientKeys::generate_new(&mut rng)
+
+            // Key generation priority: individual derivation material > shared derivation material > random generation
+            let keys = match (derivation_material, shared_derivation_material) {
+                // Individual derivation material takes precedence if provided
+                (Some(derivation_material), _) => {
+                    ClientKeys::from_master_key(&mut rng, &derivation_material)
+                        .map_err(|_| ClientCoreError::HkdfDerivationError {})?
+                }
+                // Use shared derivation material if no individual material is provided
+                (None, Some(shared_derivation_material)) => {
+                    let shared_derivation_material = shared_derivation_material.lock().await;
+                    ClientKeys::from_master_key(&mut rng, &shared_derivation_material)
+                        .map_err(|_| ClientCoreError::HkdfDerivationError {})?
+                }
+                // Fall back to random key generation if no derivation material is available
+                (None, None) => ClientKeys::generate_new(&mut rng),
            };
+
            store_client_keys(keys, key_store).await?;
        }

@@ -741,6 +772,7 @@ where
            self.client_store.key_store(),
            self.client_store.gateway_details_store(),
            self.derivation_material,
+            self.shared_derivation_material,
        )
        .await?;

@@ -1,18 +1,20 @@
 // Copyright 2022-2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::{
-    client::replies::reply_storage::{fs_backend, CombinedReplyStorage, ReplyStorageBackend},
-    config,
-    config::Config,
-    error::ClientCoreError,
+use crate::client::replies::reply_storage::{
+    fs_backend, CombinedReplyStorage, ReplyStorageBackend,
 };
+use crate::config;
+use crate::config::Config;
+use crate::error::ClientCoreError;
 use log::{error, info, trace};
 use nym_bandwidth_controller::BandwidthController;
 use nym_client_core_gateways_storage::OnDiskGatewaysDetails;
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_validator_client::{nyxd, QueryHttpRpcNyxdClient};
-use std::{io, path::Path};
+use nym_validator_client::nyxd;
+use nym_validator_client::QueryHttpRpcNyxdClient;
+use std::path::Path;
+use std::{fs, io};
 use time::OffsetDateTime;
 use url::Url;

@@ -20,11 +22,11 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
    db_path: P,
    surb_config: &config::ReplySurbs,
 ) -> Result<fs_backend::Backend, ClientCoreError> {
-    info!("Creating fresh surb database");
+    info!("creating fresh surb database");
    let mut storage_backend = match fs_backend::Backend::init(db_path).await {
        Ok(backend) => backend,
        Err(err) => {
-            error!("setup_fresh_backend: Failed to setup persistent storage backend for our reply needs: {err}");
+            error!("failed to setup persistent storage backend for our reply needs: {err}");
            return Err(ClientCoreError::SurbStorageError {
                source: Box::new(err),
            });
@@ -38,15 +40,14 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
        surb_config.minimum_reply_surb_storage_threshold,
        surb_config.maximum_reply_surb_storage_threshold,
    );
-    match storage_backend.init_fresh(&mem_store).await {
-        Ok(()) => Ok(storage_backend),
-        Err(err) => {
-            storage_backend.shutdown().await;
-            Err(ClientCoreError::SurbStorageError {
-                source: Box::new(err),
-            })
-        }
-    }
+    storage_backend
+        .init_fresh(&mem_store)
+        .await
+        .map_err(|err| ClientCoreError::SurbStorageError {
+            source: Box::new(err),
+        })?;
+
+    Ok(storage_backend)
 }

 // fn setup_inactive_backend(surb_config: &config::ReplySurbs) -> fs_backend::Backend {
@@ -57,11 +58,12 @@ async fn setup_fresh_backend<P: AsRef<Path>>(
 //     )
 // }

-async fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {
+fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()> {
    let db_path = db_path.as_ref();
    debug_assert!(db_path.exists());

    let now = OffsetDateTime::now_utc().unix_timestamp();
+
    let suffix = format!("_{now}.corrupted");

    let new_extension =
@@ -70,15 +72,11 @@ async fn archive_corrupted_database<P: AsRef<Path>>(db_path: P) -> io::Result<()
        } else {
            suffix
        };
-    let renamed = db_path.with_extension(new_extension);

-    tokio::fs::rename(db_path, &renamed).await.inspect_err(|_| {
-        error!(
-            "Failed to rename corrupt database file: {} to {}",
-            db_path.display(),
-            renamed.display()
-        );
-    })
+    let mut renamed = db_path.to_owned();
+    renamed.set_extension(new_extension);
+
+    fs::rename(db_path, renamed)
 }

 pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
@@ -89,12 +87,13 @@ pub async fn setup_fs_reply_surb_backend<P: AsRef<Path>>(
    // the existing one
    let db_path = db_path.as_ref();
    if db_path.exists() {
-        info!("Loading existing surb database");
+        info!("loading existing surb database");
        match fs_backend::Backend::try_load(db_path, surb_config.fresh_sender_tags).await {
            Ok(backend) => Ok(backend),
            Err(err) => {
-                error!("setup_fs_reply_surb_backend: 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).await?;
+                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, surb_config).await
            }
        }
@@ -17,26 +17,15 @@ nym-crypto = { path = "../../crypto", optional = true, default-features = false
 nym-sphinx = { path = "../../nymsphinx" }
 nym-task = { path = "../../task" }

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-workspace = true
-features = ["fs"]

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

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx-pool-guard]
-path = "../../../sqlx-pool-guard"
-
 [build-dependencies]
 tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
-sqlx = { workspace = true, features = [
-    "runtime-tokio-rustls",
-    "sqlite",
-    "macros",
-    "migrate",
-] }
+sqlx = { workspace = true, features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }

 [features]
 fs-surb-storage = ["sqlx", "nym-crypto", "nym-crypto/hashing"]
@@ -1,7 +1,8 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::{io, path::PathBuf};
+use std::io;
+use std::path::PathBuf;
 use thiserror::Error;

 #[derive(Debug, Error)]
@@ -29,6 +30,7 @@ pub enum StorageError {

    #[error("failed to perform sqlx migration: {source}")]
    MigrationError {
+        #[source]
        #[from]
        source: sqlx::migrate::MigrateError,
    },
@@ -41,6 +43,7 @@ pub enum StorageError {

    #[error("failed to run the SQL query: {source}")]
    QueryError {
+        #[source]
        #[from]
        source: sqlx::error::Error,
    },
@@ -15,11 +15,9 @@ use sqlx::{
 };
 use std::path::Path;

-use sqlx_pool_guard::SqlitePoolGuard;
-
 #[derive(Debug, Clone)]
 pub struct StorageManager {
-    connection_pool: SqlitePoolGuard,
+    pub connection_pool: sqlx::SqlitePool,
 }

 // all SQL goes here
@@ -39,7 +37,7 @@ impl StorageManager {
            .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal)
            .synchronous(SqliteSynchronous::Normal)
            .auto_vacuum(SqliteAutoVacuum::Incremental)
-            .filename(&database_path)
+            .filename(database_path)
            .create_if_missing(fresh)
            .disable_statement_logging();

@@ -51,15 +49,11 @@ impl StorageManager {
            }
        };

-        let connection_pool =
-            SqlitePoolGuard::new(database_path.as_ref().to_path_buf(), connection_pool);
-
        if let Err(err) = sqlx::migrate!("./fs_surbs_migrations")
-            .run(&*connection_pool)
+            .run(&connection_pool)
            .await
        {
            error!("Failed to initialize SQLx database: {err}");
-            connection_pool.close().await;
            return Err(err.into());
        }

@@ -67,43 +61,38 @@ impl StorageManager {
        Ok(StorageManager { connection_pool })
    }

-    /// Close connection pool waiting for all connections to be closed.
-    pub async fn close_pool(&self) {
-        self.connection_pool.close().await;
-    }
-
    #[allow(dead_code)]
    pub async fn status_table_exists(&self) -> Result<bool, sqlx::Error> {
        sqlx::query!("SELECT name FROM sqlite_master WHERE type='table' AND name='status'")
-            .fetch_optional(&*self.connection_pool)
+            .fetch_optional(&self.connection_pool)
            .await
            .map(|r| r.is_some())
    }

    pub async fn create_status_table(&self) -> Result<(), sqlx::Error> {
        sqlx::query!("INSERT INTO status(flush_in_progress, previous_flush_timestamp, client_in_use) VALUES (0, 0, 1)")
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }

    pub async fn get_flush_status(&self) -> Result<bool, sqlx::Error> {
        sqlx::query!("SELECT flush_in_progress FROM status;")
-            .fetch_one(&*self.connection_pool)
+            .fetch_one(&self.connection_pool)
            .await
            .map(|r| r.flush_in_progress > 0)
    }

    pub async fn set_previous_flush_timestamp(&self, timestamp: i64) -> Result<(), sqlx::Error> {
        sqlx::query!("UPDATE status SET previous_flush_timestamp = ?", timestamp)
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }

    pub async fn get_previous_flush_timestamp(&self) -> Result<i64, sqlx::Error> {
        sqlx::query!("SELECT previous_flush_timestamp FROM status;")
-            .fetch_one(&*self.connection_pool)
+            .fetch_one(&self.connection_pool)
            .await
            .map(|r| r.previous_flush_timestamp)
    }
@@ -111,14 +100,14 @@ impl StorageManager {
    pub async fn set_flush_status(&self, in_progress: bool) -> Result<(), sqlx::Error> {
        let in_progress_int = i64::from(in_progress);
        sqlx::query!("UPDATE status SET flush_in_progress = ?", in_progress_int)
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }

    pub async fn get_client_in_use_status(&self) -> Result<bool, sqlx::Error> {
        sqlx::query!("SELECT client_in_use FROM status;")
-            .fetch_one(&*self.connection_pool)
+            .fetch_one(&self.connection_pool)
            .await
            .map(|r| r.client_in_use > 0)
    }
@@ -126,21 +115,21 @@ impl StorageManager {
    pub async fn set_client_in_use_status(&self, in_use: bool) -> Result<(), sqlx::Error> {
        let in_use_int = i64::from(in_use);
        sqlx::query!("UPDATE status SET client_in_use = ?", in_use_int)
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }

    pub async fn delete_all_tags(&self) -> Result<(), sqlx::Error> {
        sqlx::query!("DELETE FROM sender_tag;")
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }

    pub async fn get_tags(&self) -> Result<Vec<StoredSenderTag>, sqlx::Error> {
        sqlx::query_as!(StoredSenderTag, "SELECT * FROM sender_tag;",)
-            .fetch_all(&*self.connection_pool)
+            .fetch_all(&self.connection_pool)
            .await
    }

@@ -152,21 +141,21 @@ impl StorageManager {
            stored_tag.recipient,
            stored_tag.tag
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }

    pub async fn delete_all_reply_keys(&self) -> Result<(), sqlx::Error> {
        sqlx::query!("DELETE FROM reply_key;")
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }

    pub async fn get_reply_keys(&self) -> Result<Vec<StoredReplyKey>, sqlx::Error> {
        sqlx::query_as!(StoredReplyKey, "SELECT * FROM reply_key;",)
-            .fetch_all(&*self.connection_pool)
+            .fetch_all(&self.connection_pool)
            .await
    }

@@ -182,14 +171,14 @@ impl StorageManager {
            stored_reply_key.reply_key,
            stored_reply_key.sent_at_timestamp
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }

    pub async fn get_surb_senders(&self) -> Result<Vec<StoredSurbSender>, sqlx::Error> {
        sqlx::query_as!(StoredSurbSender, "SELECT * FROM reply_surb_sender;",)
-            .fetch_all(&*self.connection_pool)
+            .fetch_all(&self.connection_pool)
            .await
    }

@@ -204,7 +193,7 @@ impl StorageManager {
            stored_surb_sender.tag,
            stored_surb_sender.last_sent_timestamp
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?
        .last_insert_rowid();
        Ok(id)
@@ -222,17 +211,17 @@ impl StorageManager {
            "#,
            sender_id
        )
-        .fetch_all(&*self.connection_pool)
+        .fetch_all(&self.connection_pool)
        .await
    }

    pub async fn delete_all_reply_surb_data(&self) -> Result<(), sqlx::Error> {
        sqlx::query!("DELETE FROM reply_surb;")
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;

        sqlx::query!("DELETE FROM reply_surb_sender;")
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;

        Ok(())
@@ -250,7 +239,7 @@ impl StorageManager {
            stored_reply_surb.reply_surb,
            stored_reply_surb.encoded_key_rotation
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }
@@ -264,7 +253,7 @@ impl StorageManager {
                SELECT min_reply_surb_threshold as "min_reply_surb_threshold: u32", max_reply_surb_threshold as "max_reply_surb_threshold: u32" FROM reply_surb_storage_metadata;
             "#,
        )
-            .fetch_one(&*self.connection_pool)
+            .fetch_one(&self.connection_pool)
            .await
    }

@@ -278,7 +267,7 @@ impl StorageManager {
        "#,
            metadata.min_reply_surb_threshold,
            metadata.max_reply_surb_threshold,
-        ).execute(&*self.connection_pool).await?;
+        ).execute(&self.connection_pool).await?;
        Ok(())
    }
 }
@@ -1,21 +1,18 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::backend::fs_backend::manager::StorageManager;
+use crate::backend::fs_backend::models::{
+    ReplySurbStorageMetadata, StoredReplyKey, StoredReplySurb, StoredSenderTag, StoredSurbSender,
+};
+use crate::surb_storage::ReceivedReplySurbs;
 use crate::{
-    backend::fs_backend::{
-        manager::StorageManager,
-        models::{
-            ReplySurbStorageMetadata, StoredReplyKey, StoredReplySurb, StoredSenderTag,
-            StoredSurbSender,
-        },
-    },
-    surb_storage::ReceivedReplySurbs,
-    CombinedReplyStorage, ReceivedReplySurbsMap, ReplyStorageBackend, SentReplyKeys,
-    UsedSenderTags,
+    CombinedReplyStorage, ReceivedReplySurbsMap, ReplyStorageBackend, SentReplyKeys, UsedSenderTags,
 };
 use async_trait::async_trait;
 use log::{debug, error, info, warn};
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
+use std::fs;
 use std::path::{Path, PathBuf};
 use time::OffsetDateTime;

@@ -44,17 +41,15 @@ impl Backend {
        }

        let manager = StorageManager::init(database_path, true).await?;
-        match manager.create_status_table().await {
-            Ok(()) => Ok(Backend {
-                temporary_old_path: None,
-                database_path: owned_path,
-                manager,
-            }),
-            Err(err) => {
-                manager.close_pool().await;
-                Err(err.into())
-            }
-        }
+        manager.create_status_table().await?;
+
+        let backend = Backend {
+            temporary_old_path: None,
+            database_path: owned_path,
+            manager,
+        };
+
+        Ok(backend)
    }

    pub async fn try_load<P: AsRef<Path>>(
@@ -69,28 +64,7 @@ impl Backend {
        }

        let manager = StorageManager::init(database_path, false).await?;
-        match Self::try_load_inner(&manager, fresh_sender_tags).await {
-            Ok(()) => Ok(Backend {
-                temporary_old_path: None,
-                database_path: owned_path,
-                manager,
-            }),
-            Err(e) => {
-                manager.close_pool().await;
-                Err(e)
-            }
-        }
-    }

-    /// Gracefully close sqlite connection pool and drop backend.
-    pub async fn shutdown(self) {
-        self.manager.close_pool().await
-    }
-
-    async fn try_load_inner(
-        manager: &StorageManager,
-        fresh_sender_tags: bool,
-    ) -> Result<(), StorageError> {
        // the database flush wasn't fully finished and thus the data is in inconsistent state
        // (we don't really know what's properly saved or what's not)
        if manager.get_flush_status().await? {
@@ -152,11 +126,20 @@ impl Backend {
            manager.delete_all_tags().await?;
        }

-        Ok(())
+        Ok(Backend {
+            temporary_old_path: None,
+            database_path: owned_path,
+            // manager: StorageManagerState::Storage(manager),
+            manager,
+        })
+    }
+
+    async fn close_pool(&mut self) {
+        self.manager.connection_pool.close().await;
    }

    async fn rotate(&mut self) -> Result<(), StorageError> {
-        self.manager.close_pool().await;
+        self.close_pool().await;

        let new_extension = if let Some(existing_extension) =
            self.database_path.extension().and_then(|ext| ext.to_str())
@@ -169,8 +152,7 @@ impl Backend {
        let mut temp_old = self.database_path.clone();
        temp_old.set_extension(new_extension);

-        tokio::fs::rename(&self.database_path, &temp_old)
-            .await
+        fs::rename(&self.database_path, &temp_old)
            .map_err(|err| StorageError::DatabaseRenameError { source: err })?;
        self.manager = StorageManager::init(&self.database_path, true).await?;
        self.manager.create_status_table().await?;
@@ -179,10 +161,9 @@ impl Backend {
        Ok(())
    }

-    async fn remove_old(&mut self) -> Result<(), StorageError> {
+    fn remove_old(&mut self) -> Result<(), StorageError> {
        if let Some(old_path) = self.temporary_old_path.take() {
-            tokio::fs::remove_file(old_path)
-                .await
+            fs::remove_file(old_path)
                .map_err(|err| StorageError::DatabaseOldFileRemoveError { source: err })
        } else {
            warn!("the old database file doesn't seem to exist!");
@@ -354,7 +335,7 @@ impl ReplyStorageBackend for Backend {
        self.dump_reply_surb_storage_metadata(surbs_ref).await?;
        self.dump_reply_surbs(surbs_ref).await?;

-        self.remove_old().await?;
+        self.remove_old()?;
        self.end_storage_flush().await
    }

@@ -33,6 +33,7 @@ where
        self.backend.load_surb_storage().await
    }

+    // this will have to get enabled after merging develop
    pub async fn flush_on_shutdown(
        mut self,
        mem_state: CombinedReplyStorage,
@@ -49,6 +50,7 @@ where
        shutdown.recv().await;

        info!("PersistentReplyStorage is flushing all reply-related data to underlying storage");
+        info!("you MUST NOT forcefully shutdown now or you risk data corruption!");
        if let Err(err) = self.backend.flush_surb_storage(&mem_state).await {
            error!("failed to flush our reply-related data to the persistent storage: {err}")
        } else {
@@ -19,7 +19,6 @@ nym-vesting-contract-common = { path = "../../cosmwasm-smart-contracts/vesting-c
 nym-ecash-contract-common = { path = "../../cosmwasm-smart-contracts/ecash-contract" }
 nym-multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
 nym-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contract" }
-nym-performance-contract-common = { path = "../../cosmwasm-smart-contracts/nym-performance-contract" }
 nym-serde-helpers = { path = "../../serde-helpers", features = ["hex", "base64"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
@@ -13,7 +13,6 @@ pub mod ecash_query_client;
 pub mod group_query_client;
 pub mod mixnet_query_client;
 pub mod multisig_query_client;
-pub mod performance_query_client;
 pub mod vesting_query_client;

 // signing clients
@@ -22,7 +21,6 @@ pub mod ecash_signing_client;
 pub mod group_signing_client;
 pub mod mixnet_signing_client;
 pub mod multisig_signing_client;
-pub mod performance_signing_client;
 pub mod vesting_signing_client;

 // re-export query traits
@@ -31,7 +29,6 @@ pub use ecash_query_client::{EcashQueryClient, PagedEcashQueryClient};
 pub use group_query_client::{GroupQueryClient, PagedGroupQueryClient};
 pub use mixnet_query_client::{MixnetQueryClient, PagedMixnetQueryClient};
 pub use multisig_query_client::{MultisigQueryClient, PagedMultisigQueryClient};
-pub use performance_query_client::{PagedPerformanceQueryClient, PerformanceQueryClient};
 pub use vesting_query_client::{PagedVestingQueryClient, VestingQueryClient};

 // re-export signing traits
@@ -40,7 +37,6 @@ pub use ecash_signing_client::EcashSigningClient;
 pub use group_signing_client::GroupSigningClient;
 pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_signing_client::MultisigSigningClient;
-pub use performance_signing_client::PerformanceSigningClient;
 pub use vesting_signing_client::VestingSigningClient;

 // helper for providing blanket implementation for query clients
@@ -48,7 +44,6 @@ pub trait NymContractsProvider {
    // main
    fn mixnet_contract_address(&self) -> Option<&AccountId>;
    fn vesting_contract_address(&self) -> Option<&AccountId>;
-    fn performance_contract_address(&self) -> Option<&AccountId>;

    // coconut-related
    fn ecash_contract_address(&self) -> Option<&AccountId>;
@@ -61,7 +56,6 @@ pub trait NymContractsProvider {
 pub struct TypedNymContracts {
    pub mixnet_contract_address: Option<AccountId>,
    pub vesting_contract_address: Option<AccountId>,
-    pub performance_contract_address: Option<AccountId>,

    pub ecash_contract_address: Option<AccountId>,
    pub group_contract_address: Option<AccountId>,
@@ -82,10 +76,6 @@ impl TryFrom<NymContracts> for TypedNymContracts {
                .vesting_contract_address
                .map(|addr| addr.parse())
                .transpose()?,
-            performance_contract_address: value
-                .performance_contract_address
-                .map(|addr| addr.parse())
-                .transpose()?,
            ecash_contract_address: value
                .ecash_contract_address
                .map(|addr| addr.parse())
@@ -1,265 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::collect_paged;
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::CosmWasmClient;
-use async_trait::async_trait;
-use cosmrs::AccountId;
-pub use nym_performance_contract_common::{
-    msg::QueryMsg as PerformanceQueryMsg, types::NetworkMonitorResponse,
-};
-use nym_performance_contract_common::{
-    EpochId, EpochMeasurementsPagedResponse, EpochNodePerformance, EpochPerformancePagedResponse,
-    FullHistoricalPerformancePagedResponse, HistoricalPerformance, NetworkMonitorInformation,
-    NetworkMonitorsPagedResponse, NodeId, NodeMeasurement, NodeMeasurementsResponse,
-    NodePerformance, NodePerformancePagedResponse, NodePerformanceResponse, RetiredNetworkMonitor,
-    RetiredNetworkMonitorsPagedResponse,
-};
-use serde::Deserialize;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PerformanceQueryClient {
-    async fn query_performance_contract<T>(
-        &self,
-        query: PerformanceQueryMsg,
-    ) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>;
-
-    async fn admin(&self) -> Result<cw_controllers::AdminResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::Admin {})
-            .await
-    }
-
-    async fn get_node_performance(
-        &self,
-        epoch_id: EpochId,
-        node_id: NodeId,
-    ) -> Result<NodePerformanceResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::NodePerformance { epoch_id, node_id })
-            .await
-    }
-
-    async fn get_node_performance_paged(
-        &self,
-        node_id: NodeId,
-        start_after: Option<EpochId>,
-        limit: Option<u32>,
-    ) -> Result<NodePerformancePagedResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::NodePerformancePaged {
-            node_id,
-            start_after,
-            limit,
-        })
-        .await
-    }
-
-    async fn get_node_measurements(
-        &self,
-        epoch_id: EpochId,
-        node_id: NodeId,
-    ) -> Result<NodeMeasurementsResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::NodeMeasurements { epoch_id, node_id })
-            .await
-    }
-
-    async fn get_epoch_measurements_paged(
-        &self,
-        epoch_id: EpochId,
-        start_after: Option<NodeId>,
-        limit: Option<u32>,
-    ) -> Result<EpochMeasurementsPagedResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::EpochMeasurementsPaged {
-            epoch_id,
-            start_after,
-            limit,
-        })
-        .await
-    }
-
-    async fn get_epoch_performance_paged(
-        &self,
-        epoch_id: EpochId,
-        start_after: Option<NodeId>,
-        limit: Option<u32>,
-    ) -> Result<EpochPerformancePagedResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::EpochPerformancePaged {
-            epoch_id,
-            start_after,
-            limit,
-        })
-        .await
-    }
-
-    async fn get_full_historical_performance_paged(
-        &self,
-        start_after: Option<(EpochId, NodeId)>,
-        limit: Option<u32>,
-    ) -> Result<FullHistoricalPerformancePagedResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::FullHistoricalPerformancePaged {
-            start_after,
-            limit,
-        })
-        .await
-    }
-
-    async fn get_network_monitor(
-        &self,
-        address: &AccountId,
-    ) -> Result<NetworkMonitorResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::NetworkMonitor {
-            address: address.to_string(),
-        })
-        .await
-    }
-
-    async fn get_network_monitors_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<NetworkMonitorsPagedResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::NetworkMonitorsPaged {
-            start_after,
-            limit,
-        })
-        .await
-    }
-
-    async fn get_retired_network_monitors_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<RetiredNetworkMonitorsPagedResponse, NyxdError> {
-        self.query_performance_contract(PerformanceQueryMsg::RetiredNetworkMonitorsPaged {
-            start_after,
-            limit,
-        })
-        .await
-    }
-}
-
-// extension trait to the query client to deal with the paged queries
-// (it didn't feel appropriate to combine it with the existing trait
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PagedPerformanceQueryClient: PerformanceQueryClient {
-    async fn get_all_node_performance(
-        &self,
-        node_id: NodeId,
-    ) -> Result<Vec<EpochNodePerformance>, NyxdError> {
-        collect_paged!(self, get_node_performance_paged, performance, node_id)
-    }
-
-    async fn get_all_epoch_measurements(
-        &self,
-        node_id: NodeId,
-    ) -> Result<Vec<NodeMeasurement>, NyxdError> {
-        collect_paged!(self, get_epoch_measurements_paged, measurements, node_id)
-    }
-
-    async fn get_all_epoch_performance(
-        &self,
-        epoch_id: EpochId,
-    ) -> Result<Vec<NodePerformance>, NyxdError> {
-        collect_paged!(self, get_epoch_performance_paged, performance, epoch_id)
-    }
-
-    async fn get_all_full_historical_performance(
-        &self,
-    ) -> Result<Vec<HistoricalPerformance>, NyxdError> {
-        collect_paged!(self, get_full_historical_performance_paged, performance)
-    }
-
-    async fn get_all_network_monitors(&self) -> Result<Vec<NetworkMonitorInformation>, NyxdError> {
-        collect_paged!(self, get_network_monitors_paged, info)
-    }
-
-    async fn get_all_retired_network_monitors(
-        &self,
-    ) -> Result<Vec<RetiredNetworkMonitor>, NyxdError> {
-        collect_paged!(self, get_retired_network_monitors_paged, info)
-    }
-}
-
-#[async_trait]
-impl<T> PagedPerformanceQueryClient for T where T: PerformanceQueryClient {}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> PerformanceQueryClient for C
-where
-    C: CosmWasmClient + NymContractsProvider + Send + Sync,
-{
-    async fn query_performance_contract<T>(
-        &self,
-        query: PerformanceQueryMsg,
-    ) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>,
-    {
-        let performance_contract_address = &self
-            .performance_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("performance contract"))?;
-        self.query_contract_smart(performance_contract_address, &query)
-            .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_query_variants_are_covered<C: PerformanceQueryClient + Send + Sync>(
-        client: C,
-        msg: PerformanceQueryMsg,
-    ) {
-        match msg {
-            PerformanceQueryMsg::Admin {} => client.admin().ignore(),
-            PerformanceQueryMsg::NodePerformance { epoch_id, node_id } => {
-                client.get_node_performance(epoch_id, node_id).ignore()
-            }
-            PerformanceQueryMsg::NodePerformancePaged {
-                node_id,
-                start_after,
-                limit,
-            } => client
-                .get_node_performance_paged(node_id, start_after, limit)
-                .ignore(),
-            PerformanceQueryMsg::NodeMeasurements { epoch_id, node_id } => {
-                client.get_node_measurements(epoch_id, node_id).ignore()
-            }
-            PerformanceQueryMsg::EpochMeasurementsPaged {
-                epoch_id,
-                start_after,
-                limit,
-            } => client
-                .get_epoch_measurements_paged(epoch_id, start_after, limit)
-                .ignore(),
-            PerformanceQueryMsg::EpochPerformancePaged {
-                epoch_id,
-                start_after,
-                limit,
-            } => client
-                .get_epoch_performance_paged(epoch_id, start_after, limit)
-                .ignore(),
-            PerformanceQueryMsg::FullHistoricalPerformancePaged { start_after, limit } => client
-                .get_full_historical_performance_paged(start_after, limit)
-                .ignore(),
-            PerformanceQueryMsg::NetworkMonitor { address } => client
-                .get_network_monitor(&address.parse().unwrap())
-                .ignore(),
-            PerformanceQueryMsg::NetworkMonitorsPaged { start_after, limit } => client
-                .get_network_monitors_paged(start_after, limit)
-                .ignore(),
-            PerformanceQueryMsg::RetiredNetworkMonitorsPaged { start_after, limit } => client
-                .get_retired_network_monitors_paged(start_after, limit)
-                .ignore(),
-        };
-    }
-}
@@ -1,217 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::coin::Coin;
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::cosmwasm_client::types::ExecuteResult;
-use crate::nyxd::cosmwasm_client::ContractResponseData;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Fee, SigningCosmWasmClient};
-use crate::signing::signer::OfflineSigner;
-use async_trait::async_trait;
-use nym_performance_contract_common::{
-    EpochId, ExecuteMsg as PerformanceExecuteMsg, NodeId, NodePerformance,
-    RemoveEpochMeasurementsResponse,
-};
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PerformanceSigningClient {
-    async fn execute_performance_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: PerformanceExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError>;
-
-    async fn update_admin(
-        &self,
-        admin: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_performance_contract(
-            fee,
-            PerformanceExecuteMsg::UpdateAdmin { admin },
-            "PerformanceContract::UpdateAdmin".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn submit_performance(
-        &self,
-        epoch: EpochId,
-        data: NodePerformance,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_performance_contract(
-            fee,
-            PerformanceExecuteMsg::Submit { epoch, data },
-            "PerformanceContract::Submit".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn batch_submit_performance(
-        &self,
-        epoch: EpochId,
-        data: Vec<NodePerformance>,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_performance_contract(
-            fee,
-            PerformanceExecuteMsg::BatchSubmit { epoch, data },
-            "PerformanceContract::BatchSubmit".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn authorise_network_monitor(
-        &self,
-        address: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_performance_contract(
-            fee,
-            PerformanceExecuteMsg::AuthoriseNetworkMonitor { address },
-            "PerformanceContract::AuthoriseNetworkMonitor".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn retire_network_monitor(
-        &self,
-        address: String,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_performance_contract(
-            fee,
-            PerformanceExecuteMsg::RetireNetworkMonitor { address },
-            "PerformanceContract::RetireNetworkMonitor".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn remove_node_measurements(
-        &self,
-        epoch_id: EpochId,
-        node_id: NodeId,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_performance_contract(
-            fee,
-            PerformanceExecuteMsg::RemoveNodeMeasurements { epoch_id, node_id },
-            "PerformanceContract::RemoveNodeMeasurements".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn partial_remove_epoch_measurements(
-        &self,
-        epoch_id: EpochId,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        self.execute_performance_contract(
-            fee,
-            PerformanceExecuteMsg::RemoveEpochMeasurements { epoch_id },
-            "PerformanceContract::RemoveEpochMeasurements".to_string(),
-            vec![],
-        )
-        .await
-    }
-
-    async fn remove_epoch_measurements(
-        &self,
-        epoch_id: EpochId,
-        fee: Option<Fee>,
-    ) -> Result<(), NyxdError> {
-        loop {
-            let execute_res = self
-                .partial_remove_epoch_measurements(epoch_id, fee.clone())
-                .await?;
-            let response = execute_res
-                .parse_singleton_json_contract_response::<RemoveEpochMeasurementsResponse>()?;
-            if !response.additional_entries_to_remove_remaining {
-                break;
-            }
-        }
-        Ok(())
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> PerformanceSigningClient for C
-where
-    C: SigningCosmWasmClient + NymContractsProvider + Sync,
-    NyxdError: From<<Self as OfflineSigner>::Error>,
-{
-    async fn execute_performance_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: PerformanceExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let performance_contract_address = &self
-            .performance_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("performance contract"))?;
-
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-
-        let signer_address = &self.signer_addresses()?[0];
-        self.execute(
-            signer_address,
-            performance_contract_address,
-            &msg,
-            fee,
-            memo,
-            funds,
-        )
-        .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-    use nym_performance_contract_common::ExecuteMsg;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_execute_variants_are_covered<C: PerformanceSigningClient + Send + Sync>(
-        client: C,
-        msg: PerformanceExecuteMsg,
-    ) {
-        match msg {
-            PerformanceExecuteMsg::UpdateAdmin { admin } => {
-                client.update_admin(admin, None).ignore()
-            }
-            PerformanceExecuteMsg::Submit { epoch, data } => {
-                client.submit_performance(epoch, data, None).ignore()
-            }
-            PerformanceExecuteMsg::BatchSubmit { epoch, data } => {
-                client.batch_submit_performance(epoch, data, None).ignore()
-            }
-            PerformanceExecuteMsg::AuthoriseNetworkMonitor { address } => {
-                client.authorise_network_monitor(address, None).ignore()
-            }
-            PerformanceExecuteMsg::RetireNetworkMonitor { address } => {
-                client.retire_network_monitor(address, None).ignore()
-            }
-            ExecuteMsg::RemoveNodeMeasurements { epoch_id, node_id } => client
-                .remove_node_measurements(epoch_id, node_id, None)
-                .ignore(),
-            ExecuteMsg::RemoveEpochMeasurements { epoch_id } => client
-                .partial_remove_epoch_measurements(epoch_id, None)
-                .ignore(),
-        };
-    }
-}
@@ -12,8 +12,6 @@ use tendermint_rpc::endpoint::broadcast;
 use tracing::error;

 pub use cosmrs::abci::MsgResponse;
-use cosmwasm_std::from_json;
-use serde::de::DeserializeOwned;

 pub fn parse_singleton_u32_from_contract_response(b: Vec<u8>) -> Result<u32, NyxdError> {
    if b.len() != 4 {
@@ -75,11 +73,6 @@ pub fn parse_msg_responses(data: Bytes) -> Vec<MsgResponse> {

 // requires there's a single response message
 pub trait ContractResponseData: Sized {
-    fn parse_singleton_json_contract_response<T: DeserializeOwned>(&self) -> Result<T, NyxdError> {
-        let b = self.to_singleton_contract_data()?;
-        from_json(&b).map_err(|err| err.into())
-    }
-
    fn parse_singleton_u32_contract_data(&self) -> Result<u32, NyxdError> {
        let b = self.to_singleton_contract_data()?;
        parse_singleton_u32_from_contract_response(b)
@@ -276,10 +276,6 @@ impl<C, S> NymContractsProvider for NyxdClient<C, S> {
        self.config.contracts.vesting_contract_address.as_ref()
    }

-    fn performance_contract_address(&self) -> Option<&AccountId> {
-        self.config.contracts.performance_contract_address.as_ref()
-    }
-
    fn ecash_contract_address(&self) -> Option<&AccountId> {
        self.config.contracts.ecash_contract_address.as_ref()
    }
@@ -1,24 +0,0 @@
-[package]
-name = "nym-contracts-common-testing"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-readme.workspace = true
-
-[dependencies]
-anyhow = { workspace = true }
-cosmwasm-std = { workspace = true }
-cw-storage-plus = { workspace = true }
-
-serde = { workspace = true }
-rand_chacha = { workspace = true }
-rand = { workspace = true }
-cw-multi-test = { workspace = true }
-
-[lints]
-workspace = true
@@ -1,127 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_std::testing::{message_info, MockApi, MockQuerier, MockStorage};
-use cosmwasm_std::{
-    coins, Addr, BankMsg, CosmosMsg, Empty, Env, MemoryStorage, MessageInfo, Order, OwnedDeps,
-    Response, StdResult, Storage,
-};
-use cw_storage_plus::{KeyDeserialize, Map, Prefix, PrimaryKey};
-use rand::{RngCore, SeedableRng};
-use rand_chacha::ChaCha20Rng;
-use serde::de::DeserializeOwned;
-use serde::Serialize;
-
-pub const TEST_DENOM: &str = "unym";
-pub const TEST_PREFIX: &str = "n";
-
-pub fn mock_api() -> MockApi {
-    MockApi::default().with_prefix(TEST_PREFIX)
-}
-
-pub fn mock_dependencies() -> OwnedDeps<MemoryStorage, MockApi, MockQuerier<Empty>> {
-    OwnedDeps {
-        storage: MockStorage::default(),
-        api: mock_api(),
-        querier: MockQuerier::default(),
-        custom_query_type: Default::default(),
-    }
-}
-
-pub fn test_rng() -> ChaCha20Rng {
-    let dummy_seed = [42u8; 32];
-    rand_chacha::ChaCha20Rng::from_seed(dummy_seed)
-}
-
-pub fn deps_with_balance(env: &Env) -> OwnedDeps<MemoryStorage, MockApi, MockQuerier<Empty>> {
-    let mut deps = mock_dependencies();
-    deps.querier = MockQuerier::<Empty>::new(&[(
-        env.contract.address.as_str(),
-        coins(100000000000, TEST_DENOM).as_slice(),
-    )]);
-    deps
-}
-
-pub fn generate_sorted_addresses(n: usize) -> Vec<Addr> {
-    let mut rng = test_rng();
-    let mut addrs = Vec::with_capacity(n);
-    for i in 0..n {
-        addrs.push(mock_api().addr_make(&format!("addr{i}{}", rng.next_u64())));
-    }
-    addrs.sort();
-    addrs
-}
-
-pub fn addr<S: AsRef<str>>(raw: S) -> Addr {
-    mock_api().addr_make(raw.as_ref())
-}
-
-pub fn sender<S: AsRef<str>>(raw: S) -> MessageInfo {
-    message_info(&addr(raw), &[])
-}
-
-pub trait ExtractBankMsg {
-    fn unwrap_bank_msg(self) -> Option<BankMsg>;
-}
-
-impl ExtractBankMsg for Response {
-    fn unwrap_bank_msg(self) -> Option<BankMsg> {
-        for msg in self.messages {
-            match msg.msg {
-                CosmosMsg::Bank(bank_msg) => return Some(bank_msg),
-                _ => continue,
-            }
-        }
-
-        None
-    }
-}
-
-pub trait FullReader<'a> {
-    type Key;
-    type Value: Serialize + DeserializeOwned;
-
-    fn all_values(&self, store: &dyn Storage) -> StdResult<Vec<Self::Value>>;
-
-    fn all_key_values(&self, store: &dyn Storage) -> StdResult<Vec<(Self::Key, Self::Value)>>;
-}
-
-impl<'a, K, T> FullReader<'a> for Map<K, T>
-where
-    T: Serialize + DeserializeOwned,
-    K: PrimaryKey<'a> + KeyDeserialize,
-    K::Output: 'static,
-{
-    type Key = K::Output;
-    type Value = T;
-
-    fn all_values(&self, store: &dyn Storage) -> StdResult<Vec<Self::Value>> {
-        self.range(store, None, None, Order::Ascending)
-            .map(|record| record.map(|r| r.1))
-            .collect()
-    }
-
-    fn all_key_values(&self, store: &dyn Storage) -> StdResult<Vec<(Self::Key, Self::Value)>> {
-        self.range(store, None, None, Order::Ascending).collect()
-    }
-}
-
-impl<'a, K, T, B> FullReader<'a> for Prefix<K, T, B>
-where
-    K: KeyDeserialize + 'static,
-    T: Serialize + DeserializeOwned,
-    B: PrimaryKey<'a>,
-{
-    type Key = K::Output;
-    type Value = T;
-
-    fn all_values(&self, store: &dyn Storage) -> StdResult<Vec<Self::Value>> {
-        self.range(store, None, None, Order::Ascending)
-            .map(|record| record.map(|r| r.1))
-            .collect()
-    }
-
-    fn all_key_values(&self, store: &dyn Storage) -> StdResult<Vec<(Self::Key, Self::Value)>> {
-        self.range(store, None, None, Order::Ascending).collect()
-    }
-}
@@ -1,13 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// those are all used exclusively for testing thus unwraps, et al. are allowed
-#![allow(clippy::unwrap_used)]
-#![allow(clippy::expect_used)]
-#![allow(clippy::panic)]
-
-pub mod helpers;
-pub mod tester;
-
-pub use helpers::*;
-pub use tester::*;
@@ -1,239 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{ContractTester, TestableNymContract};
-use cosmwasm_std::testing::{message_info, mock_env};
-use cosmwasm_std::{
-    from_json, Addr, Coin, ContractInfo, Deps, DepsMut, Env, MessageInfo, Response, StdResult,
-    Storage, Timestamp,
-};
-use cw_multi_test::{next_block, AppResponse, Executor};
-use serde::de::DeserializeOwned;
-use serde::Serialize;
-use std::any::type_name;
-use std::fmt::Debug;
-
-pub trait ContractOpts {
-    type ExecuteMsg;
-    type QueryMsg;
-    type ContractError;
-
-    fn deps(&self) -> Deps<'_>;
-
-    fn deps_mut(&mut self) -> DepsMut<'_>;
-
-    fn env(&self) -> Env;
-
-    fn addr_make(&self, input: &str) -> Addr;
-
-    fn deps_mut_env(&mut self) -> (DepsMut<'_>, Env) {
-        let env = self.env().clone();
-        (self.deps_mut(), env)
-    }
-
-    fn storage(&self) -> &dyn Storage;
-
-    fn storage_mut(&mut self) -> &mut dyn Storage;
-
-    fn read_from_contract_storage<T: DeserializeOwned>(&self, key: impl AsRef<[u8]>) -> Option<T>;
-
-    fn set_contract_storage(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>);
-
-    fn unchecked_read_from_contract_storage<T: DeserializeOwned>(
-        &self,
-        key: impl AsRef<[u8]>,
-    ) -> T {
-        let typ = type_name::<T>();
-        self.read_from_contract_storage(key)
-            .unwrap_or_else(|| panic!("value of type {typ} not present in the storage"))
-    }
-
-    fn execute_raw(
-        &mut self,
-        sender: Addr,
-        message: Self::ExecuteMsg,
-    ) -> Result<Response, Self::ContractError> {
-        self.execute_raw_with_balance(sender, &[], message)
-    }
-
-    fn execute_raw_with_balance(
-        &mut self,
-        sender: Addr,
-        coins: &[Coin],
-        message: Self::ExecuteMsg,
-    ) -> Result<Response, Self::ContractError>;
-}
-
-impl<C> ContractOpts for ContractTester<C>
-where
-    C: TestableNymContract,
-{
-    type ExecuteMsg = C::ExecuteMsg;
-    type QueryMsg = C::QueryMsg;
-    type ContractError = C::ContractError;
-
-    fn deps(&self) -> Deps<'_> {
-        Deps {
-            storage: &self.storage,
-            api: self.app.api(),
-            querier: self.app.wrap(),
-        }
-    }
-
-    fn deps_mut(&mut self) -> DepsMut<'_> {
-        DepsMut {
-            storage: &mut self.storage,
-            api: self.app.api(),
-            querier: self.app.wrap(),
-        }
-    }
-
-    fn env(&self) -> Env {
-        Env {
-            block: self.app.block_info(),
-            contract: ContractInfo {
-                address: self.contract_address.clone(),
-            },
-            ..mock_env()
-        }
-    }
-
-    fn addr_make(&self, input: &str) -> Addr {
-        self.app.api().addr_make(input)
-    }
-
-    fn storage(&self) -> &dyn Storage {
-        &self.storage
-    }
-
-    fn storage_mut(&mut self) -> &mut dyn Storage {
-        &mut self.storage
-    }
-
-    fn read_from_contract_storage<T: DeserializeOwned>(&self, key: impl AsRef<[u8]>) -> Option<T> {
-        let raw = self.deps().storage.get(key.as_ref())?;
-        from_json(&raw).ok()
-    }
-
-    fn set_contract_storage(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>) {
-        self.deps_mut().storage.set(key.as_ref(), value.as_ref());
-    }
-
-    fn execute_raw_with_balance(
-        &mut self,
-        sender: Addr,
-        coins: &[Coin],
-        message: C::ExecuteMsg,
-    ) -> Result<Response, C::ContractError> {
-        let env = self.env();
-        let info = message_info(&sender, coins);
-
-        C::execute()(self.deps_mut(), env, info, message)
-    }
-}
-
-pub trait ChainOpts: ContractOpts {
-    fn set_contract_balance(&mut self, balance: Coin);
-
-    fn next_block(&mut self);
-
-    fn set_block_time(&mut self, time: Timestamp);
-
-    fn execute_msg(
-        &mut self,
-        sender: Addr,
-        message: &Self::ExecuteMsg,
-    ) -> anyhow::Result<AppResponse> {
-        self.execute_msg_with_balance(sender, &[], message)
-    }
-
-    fn execute_msg_with_balance(
-        &mut self,
-        sender: Addr,
-        coins: &[Coin],
-        message: &Self::ExecuteMsg,
-    ) -> anyhow::Result<AppResponse>;
-
-    fn execute_arbitrary_contract<T: Serialize + Debug>(
-        &mut self,
-        contract: Addr,
-        sender: MessageInfo,
-        message: &T,
-    ) -> anyhow::Result<AppResponse>;
-
-    fn query_arbitrary_contract<Q: Serialize + Debug, T: DeserializeOwned>(
-        &self,
-        contract: Addr,
-        message: &Q,
-    ) -> StdResult<T>;
-
-    fn query<T: DeserializeOwned>(&self, message: &Self::QueryMsg) -> StdResult<T>;
-}
-
-impl<C> ChainOpts for ContractTester<C>
-where
-    C: TestableNymContract,
-{
-    fn set_contract_balance(&mut self, balance: Coin) {
-        let contract_address = &self.contract_address;
-        self.app
-            .router()
-            .bank
-            .init_balance(
-                &mut self.storage.inner_storage(),
-                contract_address,
-                vec![balance],
-            )
-            .unwrap();
-    }
-    fn next_block(&mut self) {
-        self.app.update_block(next_block)
-    }
-
-    fn set_block_time(&mut self, time: Timestamp) {
-        self.app.update_block(|b| b.time = time)
-    }
-
-    fn execute_msg(
-        &mut self,
-        sender: Addr,
-        message: &C::ExecuteMsg,
-    ) -> anyhow::Result<AppResponse> {
-        self.execute_msg_with_balance(sender, &[], message)
-    }
-
-    fn execute_msg_with_balance(
-        &mut self,
-        sender: Addr,
-        coins: &[Coin],
-        message: &C::ExecuteMsg,
-    ) -> anyhow::Result<AppResponse> {
-        self.app
-            .execute_contract(sender, self.contract_address.clone(), message, coins)
-    }
-
-    fn execute_arbitrary_contract<T: Serialize + Debug>(
-        &mut self,
-        contract: Addr,
-        sender: MessageInfo,
-        message: &T,
-    ) -> anyhow::Result<AppResponse> {
-        let coins = &sender.funds;
-        let sender = sender.sender;
-        self.app.execute_contract(sender, contract, message, coins)
-    }
-
-    fn query_arbitrary_contract<Q: Serialize + Debug, T: DeserializeOwned>(
-        &self,
-        contract: Addr,
-        message: &Q,
-    ) -> StdResult<T> {
-        self.app.wrap().query_wasm_smart(contract, message)
-    }
-
-    fn query<T: DeserializeOwned>(&self, message: &C::QueryMsg) -> StdResult<T> {
-        self.app
-            .wrap()
-            .query_wasm_smart(self.contract_address.as_str(), message)
-    }
-}
@@ -1,305 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{
-    CommonStorageKeys, ContractOpts, ContractTester, StorageWrapper, TestableNymContract,
-    TEST_DENOM,
-};
-use cosmwasm_std::testing::message_info;
-use cosmwasm_std::{
-    coin, coins, from_json, to_json_vec, Addr, Coin, MessageInfo, StdError, StdResult, Storage,
-};
-use cw_multi_test::Executor;
-use cw_storage_plus::{Key, Path, PrimaryKey};
-use rand::RngCore;
-use rand_chacha::ChaCha20Rng;
-use serde::de::DeserializeOwned;
-use serde::Serialize;
-use std::any::type_name;
-use std::ops::Deref;
-
-pub trait StorageReader {
-    fn common_key(&self, key: CommonStorageKeys) -> Option<&[u8]>;
-
-    fn read_common_value<T: DeserializeOwned>(&self, key: CommonStorageKeys) -> Option<T> {
-        self.read_from_contract_storage(self.common_key(key)?)
-    }
-
-    fn unchecked_read_common_value<T: DeserializeOwned>(&self, key: CommonStorageKeys) -> T {
-        self.unchecked_read_from_contract_storage(
-            self.common_key(key)
-                .unwrap_or_else(|| panic!("no key set for {key:?}")),
-        )
-    }
-
-    fn read_from_contract_storage<T: DeserializeOwned>(&self, key: impl AsRef<[u8]>) -> Option<T>;
-
-    fn unchecked_read_from_contract_storage<T: DeserializeOwned>(
-        &self,
-        key: impl AsRef<[u8]>,
-    ) -> T {
-        let typ = type_name::<T>();
-        self.read_from_contract_storage(key)
-            .unwrap_or_else(|| panic!("value of type {typ} not present in the storage"))
-    }
-}
-
-// technically it shouldn't rely on `StorageReader` and `common_key` should be extracted
-// but this makes it a tad easier and it's only testing code so it's fine
-pub trait StorageWriter: StorageReader {
-    fn set_common_value<T: Serialize>(
-        &mut self,
-        key: CommonStorageKeys,
-        value: &T,
-    ) -> StdResult<()> {
-        let key = self
-            .common_key(key)
-            .ok_or(StdError::not_found("key not found"))?
-            .to_vec();
-        self.set_storage_value(key, value)
-    }
-
-    fn set_storage(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>);
-
-    fn set_storage_value<T: Serialize>(
-        &mut self,
-        key: impl AsRef<[u8]>,
-        value: &T,
-    ) -> StdResult<()> {
-        self.set_storage(key, &to_json_vec(value)?);
-        Ok(())
-    }
-}
-
-pub trait ArbitraryContractStorageReader {
-    fn may_read_from_contract_storage(
-        &self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-    ) -> Option<Vec<u8>>;
-
-    fn must_read_from_contract_storage(
-        &self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-    ) -> StdResult<Vec<u8>> {
-        let key = key.as_ref();
-        self.may_read_from_contract_storage(address, key)
-            .ok_or(StdError::not_found(format!("no data under {key:?}")))
-    }
-
-    fn may_read_value_from_contract_storage<T: DeserializeOwned>(
-        &self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-    ) -> StdResult<Option<T>> {
-        let Some(bytes) = self.may_read_from_contract_storage(address, key) else {
-            return Ok(None);
-        };
-
-        from_json(&bytes).map(Some)
-    }
-
-    fn must_read_value_from_contract_storage<T: DeserializeOwned>(
-        &self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-    ) -> StdResult<T> {
-        let bytes = self.must_read_from_contract_storage(address, key)?;
-        from_json(&bytes)
-    }
-}
-
-pub trait ArbitraryContractStorageWriter {
-    fn set_contract_storage(
-        &mut self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-        value: impl AsRef<[u8]>,
-    );
-
-    fn set_contract_storage_value<T: Serialize>(
-        &mut self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-        value: &T,
-    ) -> StdResult<()> {
-        self.set_contract_storage(address, key, &to_json_vec(value)?);
-        Ok(())
-    }
-
-    // attempts to write to an arbitrary contract `cw_storage_plus::Map`
-    fn set_contract_map_value<'a, K, T>(
-        &mut self,
-        address: impl Into<String>,
-        namespace: impl AsRef<[u8]>,
-        key: K,
-        value: &T,
-    ) -> StdResult<()>
-    where
-        K: PrimaryKey<'a>,
-        T: Serialize + DeserializeOwned,
-    {
-        let key_path: Path<T> = Path::new(
-            namespace.as_ref(),
-            &key.key().iter().map(Key::as_ref).collect::<Vec<_>>(),
-        );
-        let storage_key = key_path.deref();
-        self.set_contract_storage_value(address, storage_key, value)
-    }
-}
-
-// contract that has an admin
-pub trait AdminExt: StorageReader + StorageWriter {
-    fn admin(&self) -> Option<Addr> {
-        self.read_common_value(CommonStorageKeys::Admin)
-    }
-
-    fn update_admin(&mut self, admin: &Option<Addr>) -> StdResult<()> {
-        self.set_common_value(CommonStorageKeys::Admin, admin)
-    }
-
-    fn admin_unchecked(&self) -> Addr {
-        self.admin().expect("no admin set")
-    }
-
-    fn admin_msg(&self) -> MessageInfo {
-        message_info(&self.admin_unchecked(), &[])
-    }
-}
-
-// contract that operates on some specific coin denom
-pub trait DenomExt: StorageReader {
-    fn denom(&self) -> String {
-        self.unchecked_read_common_value(CommonStorageKeys::Denom)
-    }
-
-    fn coin(&self, amount: u128) -> Coin {
-        coin(amount, self.denom())
-    }
-
-    fn coins(&self, amount: u128) -> Vec<Coin> {
-        coins(amount, self.denom())
-    }
-}
-
-pub trait RandExt {
-    fn raw_rng(&mut self) -> &mut ChaCha20Rng;
-
-    fn generate_account(&mut self) -> Addr;
-
-    fn generate_account_with_balance(&mut self) -> Addr
-    where
-        Self: BankExt;
-}
-
-pub trait BankExt {
-    fn send_tokens(&mut self, to: Addr, amount: Coin) -> anyhow::Result<()>;
-}
-
-impl<T> AdminExt for T where T: StorageReader + StorageWriter {}
-impl<T> DenomExt for T where T: StorageReader {}
-
-impl<C: TestableNymContract> StorageReader for ContractTester<C> {
-    fn common_key(&self, key: CommonStorageKeys) -> Option<&[u8]> {
-        self.common_storage_keys.get(&key).map(|v| &**v)
-    }
-
-    fn read_from_contract_storage<T: DeserializeOwned>(&self, key: impl AsRef<[u8]>) -> Option<T> {
-        <Self as ContractOpts>::read_from_contract_storage(self, key)
-    }
-}
-
-impl<C: TestableNymContract> StorageWriter for ContractTester<C> {
-    fn set_storage(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>) {
-        <Self as ContractOpts>::set_contract_storage(self, key, value)
-    }
-}
-
-impl<C: TestableNymContract> BankExt for ContractTester<C> {
-    fn send_tokens(&mut self, to: Addr, amount: Coin) -> anyhow::Result<()> {
-        self.app
-            .send_tokens(self.master_address.clone(), to, &[amount])?;
-        Ok(())
-    }
-}
-
-impl<C: TestableNymContract> RandExt for ContractTester<C> {
-    fn raw_rng(&mut self) -> &mut ChaCha20Rng {
-        &mut self.rng
-    }
-
-    fn generate_account(&mut self) -> Addr {
-        self.app
-            .api()
-            .addr_make(&format!("foomp{}", self.rng.next_u64()))
-    }
-
-    fn generate_account_with_balance(&mut self) -> Addr
-    where
-        Self: BankExt,
-    {
-        let addr = self.generate_account();
-        let million = 1_000_000_000_000;
-        self.send_tokens(addr.clone(), coin(million, TEST_DENOM))
-            .unwrap();
-        addr
-    }
-}
-
-impl ArbitraryContractStorageReader for StorageWrapper {
-    fn may_read_from_contract_storage(
-        &self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-    ) -> Option<Vec<u8>> {
-        self.contract_storage_wrapper(&Addr::unchecked(address))
-            .get(key.as_ref())
-    }
-}
-
-impl ArbitraryContractStorageWriter for StorageWrapper {
-    fn set_contract_storage(
-        &mut self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-        value: impl AsRef<[u8]>,
-    ) {
-        // yeah, we're unnecessarily cloning a Rc pointer, but this is a test code, so this inefficiency is fine
-        let mut wrapped_storage = self
-            .clone()
-            .contract_storage_wrapper(&Addr::unchecked(address));
-        wrapped_storage.set(key.as_ref(), value.as_ref());
-    }
-}
-
-impl<C> ArbitraryContractStorageReader for ContractTester<C>
-where
-    C: TestableNymContract,
-{
-    fn may_read_from_contract_storage(
-        &self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-    ) -> Option<Vec<u8>> {
-        self.storage
-            .as_inner_storage()
-            .may_read_from_contract_storage(address, key)
-    }
-}
-
-impl<C> ArbitraryContractStorageWriter for ContractTester<C>
-where
-    C: TestableNymContract,
-{
-    fn set_contract_storage(
-        &mut self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-        value: impl AsRef<[u8]>,
-    ) {
-        self.storage
-            .as_inner_storage_mut()
-            .set_contract_storage(address, key, value);
-    }
-}
@@ -1,276 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{mock_api, test_rng, TEST_DENOM};
-use cosmwasm_std::testing::MockApi;
-use cosmwasm_std::{
-    coin, coins, Addr, Binary, Deps, DepsMut, Empty, Env, MessageInfo, Order, QuerierWrapper,
-    Record, Response, Storage,
-};
-use cw_multi_test::{App, AppBuilder, BankKeeper, Contract, ContractWrapper, Executor};
-use rand_chacha::ChaCha20Rng;
-use serde::de::DeserializeOwned;
-use serde::Serialize;
-use std::collections::HashMap;
-use std::fmt::{Debug, Display};
-use std::marker::PhantomData;
-
-pub use basic_traits::*;
-pub use extensions::*;
-
-pub use crate::tester::storage_wrapper::{ContractStorageWrapper, StorageWrapper};
-
-mod basic_traits;
-mod extensions;
-mod storage_wrapper;
-// copied from cw-multi-test (but removed generics for custom messages and querier for we don't need them for now)
-
-pub type ContractFn<T, E> =
-    fn(deps: DepsMut, env: Env, info: MessageInfo, msg: T) -> Result<Response, E>;
-pub type QueryFn<T, E> = fn(deps: Deps, env: Env, msg: T) -> Result<Binary, E>;
-pub type PermissionedFn<T, E> = fn(deps: DepsMut, env: Env, msg: T) -> Result<Response, E>;
-
-pub type ContractClosure<T, E> = Box<dyn Fn(DepsMut, Env, MessageInfo, T) -> Result<Response, E>>;
-pub type QueryClosure<T, E> = Box<dyn Fn(Deps, Env, T) -> Result<Binary, E>>;
-
-pub trait TestableNymContract {
-    const NAME: &'static str;
-
-    type InitMsg: DeserializeOwned + Serialize + Debug + 'static;
-    type ExecuteMsg: DeserializeOwned + Serialize + Debug + 'static;
-    type QueryMsg: DeserializeOwned + Serialize + Debug + 'static;
-    type MigrateMsg: DeserializeOwned + Serialize + Debug + 'static;
-    type ContractError: Display + Debug + Send + Sync + 'static;
-
-    fn instantiate() -> ContractFn<Self::InitMsg, Self::ContractError>;
-    fn execute() -> ContractFn<Self::ExecuteMsg, Self::ContractError>;
-    fn query() -> QueryFn<Self::QueryMsg, Self::ContractError>;
-    fn migrate() -> PermissionedFn<Self::MigrateMsg, Self::ContractError>;
-
-    fn base_init_msg() -> Self::InitMsg;
-
-    // // for now we don't care about custom queriers
-    // fn contract_wrapper() -> ContractWrapper<
-    //     Self::ExecuteMsg,
-    //     Self::InitMsg,
-    //     Self::QueryMsg,
-    //     Self::ContractError,
-    //     anyhow::Error,
-    //     anyhow::Error,
-    //     Empty,
-    //     Empty,
-    //     Empty,
-    //     Self::ContractError,
-    //     Self::ContractError,
-    //     Self::MigrateMsg,
-    //     Self::ContractError,
-    // > {
-    //     ContractWrapper::new(Self::execute(), Self::instantiate(), Self::query())
-    //         .with_migrate(Self::migrate())
-    // }
-
-    fn dyn_contract() -> Box<dyn Contract<Empty>> {
-        Box::new(
-            ContractWrapper::new(Self::execute(), Self::instantiate(), Self::query())
-                .with_migrate(Self::migrate()),
-        )
-    }
-
-    fn init() -> ContractTester<Self>
-    where
-        Self: Sized,
-    {
-        ContractTesterBuilder::new()
-            .instantiate::<Self>(None)
-            .build()
-    }
-}
-
-pub struct ContractTesterBuilder<C> {
-    contract: PhantomData<C>,
-    master_address: Addr,
-    app: App<BankKeeper, MockApi, StorageWrapper>,
-    storage: StorageWrapper,
-    pub well_known_contracts: HashMap<&'static str, Addr>,
-}
-
-impl<C> ContractTesterBuilder<C> {
-    #[allow(clippy::new_without_default)]
-    pub fn new() -> Self
-    where
-        C: TestableNymContract,
-    {
-        let storage = StorageWrapper::new();
-
-        let api = mock_api();
-        let master_address = api.addr_make("master-owner");
-
-        let app = AppBuilder::new()
-            .with_api(api)
-            .with_storage(storage.clone())
-            .build(|router, _api, storage| {
-                router
-                    .bank
-                    .init_balance(
-                        storage,
-                        &master_address,
-                        coins(1000000000000000, TEST_DENOM),
-                    )
-                    .unwrap()
-            });
-
-        ContractTesterBuilder {
-            contract: Default::default(),
-            master_address,
-            app,
-            storage,
-            well_known_contracts: Default::default(),
-        }
-    }
-
-    pub fn instantiate<D: TestableNymContract>(
-        mut self,
-        custom_init_msg: Option<D::InitMsg>,
-    ) -> ContractTesterBuilder<C> {
-        let code_id = self.app.store_code(D::dyn_contract());
-        let contract_address = self
-            .app
-            .instantiate_contract(
-                code_id,
-                self.master_address.clone(),
-                &custom_init_msg.unwrap_or(D::base_init_msg()),
-                &[],
-                D::NAME,
-                Some(self.master_address.to_string()),
-            )
-            .unwrap();
-
-        // send some tokens to the contract
-        self.app
-            .send_tokens(
-                self.master_address.clone(),
-                contract_address.clone(),
-                &[coin(100000000, TEST_DENOM)],
-            )
-            .unwrap();
-
-        self.well_known_contracts.insert(D::NAME, contract_address);
-        self
-    }
-
-    pub fn build(self) -> ContractTester<C>
-    where
-        C: TestableNymContract,
-    {
-        if !self.well_known_contracts.contains_key(C::NAME) {
-            panic!("{} contract has not been instantiated", C::NAME);
-        }
-
-        let contract_address = self.well_known_contracts[C::NAME].clone();
-
-        ContractTester {
-            contract: self.contract,
-            app: self.app,
-            rng: test_rng(),
-            master_address: self.master_address,
-            storage: self.storage.contract_storage_wrapper(&contract_address),
-            contract_address,
-            common_storage_keys: Default::default(),
-            well_known_contracts: self.well_known_contracts,
-        }
-    }
-
-    pub fn contract_storage_wrapper(&self, contract: &Addr) -> ContractStorageWrapper {
-        self.storage.contract_storage_wrapper(contract)
-    }
-
-    pub fn api(&self) -> MockApi {
-        *self.app.api()
-    }
-
-    pub fn querier(&self) -> QuerierWrapper {
-        self.app.wrap()
-    }
-}
-
-#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
-pub enum CommonStorageKeys {
-    Admin,
-    Denom,
-}
-
-pub struct ContractTester<C: TestableNymContract> {
-    contract: PhantomData<C>,
-    pub app: App<BankKeeper, MockApi, StorageWrapper>,
-    pub rng: ChaCha20Rng,
-    pub contract_address: Addr,
-    pub master_address: Addr,
-    pub(crate) storage: ContractStorageWrapper,
-    pub common_storage_keys: HashMap<CommonStorageKeys, Vec<u8>>,
-
-    // TODO: limitation: doesn't allow multiple contracts of the same type (but that's fine for the time being)
-    pub well_known_contracts: HashMap<&'static str, Addr>,
-}
-
-impl<C> ContractTester<C>
-where
-    C: TestableNymContract,
-{
-    pub fn insert_common_storage_key(&mut self, key: CommonStorageKeys, value: impl AsRef<[u8]>) {
-        self.common_storage_keys
-            .insert(key, value.as_ref().to_vec());
-    }
-
-    pub fn with_common_storage_key(
-        mut self,
-        key: CommonStorageKeys,
-        value: impl AsRef<[u8]>,
-    ) -> Self {
-        self.insert_common_storage_key(key, value);
-        self
-    }
-}
-
-impl<C> Storage for ContractTester<C>
-where
-    C: TestableNymContract,
-{
-    fn get(&self, key: &[u8]) -> Option<Vec<u8>> {
-        self.storage.get(key)
-    }
-
-    fn range<'a>(
-        &'a self,
-        start: Option<&[u8]>,
-        end: Option<&[u8]>,
-        order: Order,
-    ) -> Box<dyn Iterator<Item = Record> + 'a> {
-        self.storage.range(start, end, order)
-    }
-
-    fn range_keys<'a>(
-        &'a self,
-        start: Option<&[u8]>,
-        end: Option<&[u8]>,
-        order: Order,
-    ) -> Box<dyn Iterator<Item = Vec<u8>> + 'a> {
-        self.storage.range_keys(start, end, order)
-    }
-
-    fn range_values<'a>(
-        &'a self,
-        start: Option<&[u8]>,
-        end: Option<&[u8]>,
-        order: Order,
-    ) -> Box<dyn Iterator<Item = Vec<u8>> + 'a> {
-        self.storage.range_values(start, end, order)
-    }
-
-    fn set(&mut self, key: &[u8], value: &[u8]) {
-        self.storage.set(key, value)
-    }
-
-    fn remove(&mut self, key: &[u8]) {
-        self.storage.remove(key)
-    }
-}
@@ -18,7 +18,6 @@ serde = { workspace = true, features = ["derive"] }
 thiserror = { workspace = true }

 [dev-dependencies]
-anyhow = { workspace = true }
 serde_json = { workspace = true }

 [build-dependencies]
@@ -35,7 +35,7 @@ pub enum ContractsCommonError {
 /// Percent represents a value between 0 and 100%
 /// (i.e. between 0.0 and 1.0)
 #[cw_serde]
-#[derive(Copy, Default, PartialOrd, Ord, Eq)]
+#[derive(Copy, Default, PartialOrd)]
 pub struct Percent(#[serde(deserialize_with = "de_decimal_percent")] Decimal);

 impl Percent {
@@ -80,44 +80,6 @@ impl Percent {
    pub fn checked_pow(&self, exp: u32) -> Result<Self, OverflowError> {
        self.0.checked_pow(exp).map(Percent)
    }
-
-    // truncate provided percent to only have 2 decimal places,
-    // e.g. convert "0.1234567" into "0.12"
-    // the purpose of it is to reduce storage space, in particular for the performance contract
-    // since that extra precision gains us nothing
-    #[must_use = "this returns the result of the operation, without modifying the original"]
-    pub fn round_to_two_decimal_places(&self) -> Self {
-        let raw = self.0;
-
-        const DECIMAL_FRACTIONAL: Uint128 = Uint128::new(1_000_000_000_000_000_000u128); // 1*10**18
-        const THRESHOLD: Decimal = Decimal::permille(5); // 0.005
-
-        // in case it ever changes since it's not exposed in the public API
-        debug_assert_eq!(
-            DECIMAL_FRACTIONAL,
-            Uint128::new(10).pow(Decimal::DECIMAL_PLACES)
-        );
-
-        let int = (raw.atomics() * Uint128::new(100)) / DECIMAL_FRACTIONAL;
-
-        #[allow(clippy::unwrap_used)]
-        let floored = Decimal::from_atomics(int, 2).unwrap();
-        let diff = raw - floored;
-        let rounded = if diff >= THRESHOLD {
-            // ceil
-            floored + Decimal::percent(1)
-        } else {
-            floored
-        };
-        Percent(rounded)
-    }
-
-    #[must_use = "this returns the result of the operation, without modifying the original"]
-    pub fn average(&self, other: &Self) -> Self {
-        let sum = self.0 + other.0;
-        let inner = Decimal::from_ratio(sum.numerator(), sum.denominator() * Uint128::new(2));
-        Percent(inner)
-    }
 }

 impl Display for Percent {
@@ -372,7 +334,6 @@ mod tests {
    }

    #[test]
-    #[cfg(feature = "naive_float")]
    fn naive_float_conversion() {
        // around 15 decimal places is the maximum precision we can handle
        // which is still way more than enough for what we use it for
@@ -386,41 +347,4 @@ mod tests {

        assert!(converted.0 - converted.0 < epsilon);
    }
-
-    #[test]
-    fn rounding_percent() {
-        let test_cases = vec![
-            ("0", "0"),
-            ("0.1", "0.1"),
-            ("0.12", "0.12"),
-            ("0.12", "0.123"),
-            ("0.12", "0.123456789"),
-            ("0.13", "0.125"),
-            ("0.13", "0.126"),
-            ("0.13", "0.126436545676"),
-            ("0.99", "0.99"),
-            ("0.99", "0.994"),
-            ("1", "0.999"),
-            ("1", "0.995"),
-        ];
-        for (expected, input) in test_cases {
-            let expected: Percent = expected.parse().unwrap();
-            let pre_truncated: Percent = input.parse().unwrap();
-            assert_eq!(expected, pre_truncated.round_to_two_decimal_places())
-        }
-    }
-
-    #[test]
-    fn calculating_average() -> anyhow::Result<()> {
-        fn p(raw: &str) -> Percent {
-            raw.parse().unwrap()
-        }
-
-        assert_eq!(p("0.1").average(&p("0.1")), p("0.1"));
-        assert_eq!(p("0.1").average(&p("0.2")), p("0.15"));
-        assert_eq!(p("1").average(&p("0")), p("0.5"));
-        assert_eq!(p("0.123").average(&p("0.456")), p("0.2895"));
-
-        Ok(())
-    }
 }
@@ -23,6 +23,7 @@ semver = { workspace = true, features = ["serde"] }
 schemars = { workspace = true }
 thiserror = { workspace = true }
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common", version = "0.5.0" }
+serde-json-wasm = { workspace = true }
 humantime-serde = { workspace = true }
 utoipa = { workspace = true, optional = true }

@@ -3,7 +3,7 @@

 use crate::{IdentityKey, NodeId, SphinxKey};
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{to_json_string, Addr, Coin};
+use cosmwasm_std::{Addr, Coin};
 use std::cmp::Ordering;
 use std::fmt::Display;

@@ -154,7 +154,7 @@ pub struct GatewayConfigUpdate {

 impl GatewayConfigUpdate {
    pub fn to_inline_json(&self) -> String {
-        to_json_string(self).unwrap_or_else(|_| "serialisation failure".into())
+        serde_json_wasm::to_string(self).unwrap_or_else(|_| "serialisation failure".into())
    }
 }

@@ -16,7 +16,7 @@ use crate::{
    Percent, ProfitMarginRange, SphinxKey,
 };
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{to_json_string, Addr, Coin, Decimal, StdResult, Uint128};
+use cosmwasm_std::{Addr, Coin, Decimal, StdResult, Uint128};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
@@ -604,7 +604,7 @@ pub struct NodeCostParams {

 impl NodeCostParams {
    pub fn to_inline_json(&self) -> String {
-        to_json_string(self).unwrap_or_else(|_| "serialisation failure".into())
+        serde_json_wasm::to_string(self).unwrap_or_else(|_| "serialisation failure".into())
    }
 }

@@ -773,7 +773,7 @@ pub struct MixNodeConfigUpdate {

 impl MixNodeConfigUpdate {
    pub fn to_inline_json(&self) -> String {
-        to_json_string(self).unwrap_or_else(|_| "serialisation failure".into())
+        serde_json_wasm::to_string(self).unwrap_or_else(|_| "serialisation failure".into())
    }
 }

@@ -5,7 +5,7 @@ use crate::helpers::IntoBaseDecimal;
 use crate::nym_node::Role;
 use crate::{error::MixnetContractError, Percent};
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{to_json_string, Decimal};
+use cosmwasm_std::Decimal;

 pub type Performance = Percent;
 pub type WorkFactor = Decimal;
@@ -84,7 +84,7 @@ pub struct IntervalRewardParams {

 impl IntervalRewardParams {
    pub fn to_inline_json(&self) -> String {
-        to_json_string(self).unwrap_or_else(|_| "serialisation failure".into())
+        serde_json_wasm::to_string(self).unwrap_or_else(|_| "serialisation failure".into())
    }
 }

@@ -410,7 +410,7 @@ impl IntervalRewardingParamsUpdate {
    }

    pub fn to_inline_json(&self) -> String {
-        to_json_string(self).unwrap_or_else(|_| "serialisation failure".into())
+        serde_json_wasm::to_string(self).unwrap_or_else(|_| "serialisation failure".into())
    }
 }

@@ -1,29 +0,0 @@
-[package]
-name = "nym-performance-contract-common"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-rust-version.workspace = true
-readme.workspace = true
-
-[dependencies]
-thiserror = { workspace = true }
-serde = { workspace = true }
-schemars = { workspace = true }
-
-cosmwasm-std = { workspace = true }
-cosmwasm-schema = { workspace = true }
-cw-controllers = { workspace = true }
-
-nym-contracts-common = { path = "../contracts-common" }
-
-
-[features]
-schema = []
-
-[lints]
-workspace = true
@@ -1,13 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod storage_keys {
-    pub const CONTRACT_ADMIN: &str = "contract-admin";
-    pub const INITIAL_EPOCH_ID: &str = "initial-epoch-id";
-    pub const MIXNET_CONTRACT: &str = "mixnet-contract";
-    pub const AUTHORISED_COUNT: &str = "authorised-count";
-    pub const AUTHORISED: &str = "authorised";
-    pub const RETIRED: &str = "retired";
-    pub const PERFORMANCE_RESULTS: &str = "performance-results";
-    pub const SUBMISSION_METADATA: &str = "submission-metadata";
-}
@@ -1,39 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{EpochId, NodeId};
-use cosmwasm_std::Addr;
-use cw_controllers::AdminError;
-use thiserror::Error;
-
-#[derive(Error, Debug, PartialEq)]
-pub enum NymPerformanceContractError {
-    #[error("could not perform contract migration: {comment}")]
-    FailedMigration { comment: String },
-
-    #[error(transparent)]
-    Admin(#[from] AdminError),
-
-    #[error(transparent)]
-    StdErr(#[from] cosmwasm_std::StdError),
-
-    #[error("{address} is already an authorised network monitor")]
-    AlreadyAuthorised { address: Addr },
-
-    #[error("{address} is not an authorised network monitor")]
-    NotAuthorised { address: Addr },
-
-    #[error("attempted to submit performance data for epoch {epoch_id} and node {node_id} whilst last submitted was {last_epoch_id} for node {last_node_id}")]
-    StalePerformanceSubmission {
-        epoch_id: EpochId,
-        node_id: NodeId,
-        last_epoch_id: EpochId,
-        last_node_id: NodeId,
-    },
-
-    #[error("the batch performance data has not been sorted")]
-    UnsortedBatchSubmission,
-
-    #[error("node {node_id} does not appear to be bonded")]
-    NodeNotBonded { node_id: NodeId },
-}
@@ -1,2 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
@@ -1,12 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod constants;
-pub mod error;
-pub mod helpers;
-pub mod msg;
-pub mod types;
-
-pub use error::*;
-pub use msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
-pub use types::*;
@@ -1,121 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::{EpochId, NodeId, NodePerformance};
-use cosmwasm_schema::cw_serde;
-
-#[cfg(feature = "schema")]
-use crate::types::{
-    EpochMeasurementsPagedResponse, EpochPerformancePagedResponse,
-    FullHistoricalPerformancePagedResponse, NetworkMonitorResponse, NetworkMonitorsPagedResponse,
-    NodeMeasurementsResponse, NodePerformancePagedResponse, NodePerformanceResponse,
-    RetiredNetworkMonitorsPagedResponse,
-};
-
-#[cw_serde]
-pub struct InstantiateMsg {
-    pub mixnet_contract_address: String,
-    pub authorised_network_monitors: Vec<String>,
-}
-
-#[cw_serde]
-pub enum ExecuteMsg {
-    /// Change the admin
-    UpdateAdmin { admin: String },
-
-    /// Attempt to submit performance data of a particular node for given epoch
-    Submit {
-        epoch: EpochId,
-        data: NodePerformance,
-    },
-
-    /// Attempt to submit performance data of a batch of nodes for given epoch
-    BatchSubmit {
-        epoch: EpochId,
-        data: Vec<NodePerformance>,
-    },
-
-    /// Attempt to authorise new network monitor for submitting performance data
-    AuthoriseNetworkMonitor { address: String },
-
-    /// Attempt to retire an existing network monitor and forbid it from submitting any future performance data
-    RetireNetworkMonitor { address: String },
-
-    /// An admin method to remove submitted node measurements. Used as an escape hatch should
-    /// the data stored get too unwieldy.
-    RemoveNodeMeasurements { epoch_id: EpochId, node_id: NodeId },
-
-    /// An admin method to remove submitted nodes measurements. Used as an escape hatch should
-    /// the data stored get too unwieldy. Note: it is expected to get called multiple times
-    /// until the response indicates all the epoch data has been removed.
-    RemoveEpochMeasurements { epoch_id: EpochId },
-}
-
-#[cw_serde]
-#[cfg_attr(feature = "schema", derive(cosmwasm_schema::QueryResponses))]
-pub enum QueryMsg {
-    #[cfg_attr(feature = "schema", returns(cw_controllers::AdminResponse))]
-    Admin {},
-
-    /// Returns performance of particular node for the provided epoch
-    #[cfg_attr(feature = "schema", returns(NodePerformanceResponse))]
-    NodePerformance { epoch_id: EpochId, node_id: NodeId },
-
-    /// Returns historical performance for particular node
-    #[cfg_attr(feature = "schema", returns(NodePerformancePagedResponse))]
-    NodePerformancePaged {
-        node_id: NodeId,
-        start_after: Option<EpochId>,
-        limit: Option<u32>,
-    },
-
-    /// Returns all submitted measurements for the particular node
-    #[cfg_attr(feature = "schema", returns(NodeMeasurementsResponse))]
-    NodeMeasurements { epoch_id: EpochId, node_id: NodeId },
-
-    /// Returns (paged) measurements for particular epoch
-    #[cfg_attr(feature = "schema", returns(EpochMeasurementsPagedResponse))]
-    EpochMeasurementsPaged {
-        epoch_id: EpochId,
-        start_after: Option<NodeId>,
-        limit: Option<u32>,
-    },
-
-    /// Returns (paged) performance for particular epoch
-    #[cfg_attr(feature = "schema", returns(EpochPerformancePagedResponse))]
-    EpochPerformancePaged {
-        epoch_id: EpochId,
-        start_after: Option<NodeId>,
-        limit: Option<u32>,
-    },
-
-    /// Returns full (paged) historical performance of the whole network
-    #[cfg_attr(feature = "schema", returns(FullHistoricalPerformancePagedResponse))]
-    FullHistoricalPerformancePaged {
-        start_after: Option<(EpochId, NodeId)>,
-        limit: Option<u32>,
-    },
-
-    /// Returns information about particular network monitor
-    #[cfg_attr(feature = "schema", returns(NetworkMonitorResponse))]
-    NetworkMonitor { address: String },
-
-    /// Returns information about all network monitors
-    #[cfg_attr(feature = "schema", returns(NetworkMonitorsPagedResponse))]
-    NetworkMonitorsPaged {
-        start_after: Option<String>,
-        limit: Option<u32>,
-    },
-
-    /// Returns information about all retired network monitors
-    #[cfg_attr(feature = "schema", returns(RetiredNetworkMonitorsPagedResponse))]
-    RetiredNetworkMonitorsPaged {
-        start_after: Option<String>,
-        limit: Option<u32>,
-    },
-}
-
-#[cw_serde]
-pub struct MigrateMsg {
-    //
-}
@@ -1,242 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{Addr, Env};
-use nym_contracts_common::Percent;
-
-pub type EpochId = u32;
-pub type NodeId = u32;
-
-#[cw_serde]
-pub struct NetworkMonitorDetails {
-    pub address: Addr,
-    pub authorised_by: Addr,
-    pub authorised_at_height: u64,
-}
-
-impl NetworkMonitorDetails {
-    pub fn retire(self, env: &Env, sender: &Addr) -> RetiredNetworkMonitor {
-        RetiredNetworkMonitor {
-            details: self,
-            retired_by: sender.clone(),
-            retired_at_height: env.block.height,
-        }
-    }
-}
-
-#[cw_serde]
-pub struct RetiredNetworkMonitor {
-    pub details: NetworkMonitorDetails,
-    pub retired_by: Addr,
-    pub retired_at_height: u64,
-}
-
-#[cw_serde]
-#[derive(Copy)]
-pub struct NodePerformance {
-    #[serde(rename = "n")]
-    pub node_id: NodeId,
-
-    // note: value is rounded to 2 decimal places.
-    #[serde(rename = "p")]
-    pub performance: Percent,
-}
-
-#[cw_serde]
-pub struct NetworkMonitorSubmissionMetadata {
-    pub last_submitted_epoch_id: EpochId,
-    pub last_submitted_node_id: NodeId,
-}
-
-// the internal values are always sorted
-#[cw_serde]
-pub struct NodeResults(Vec<Percent>);
-
-impl NodeResults {
-    pub fn new(initial: Percent) -> NodeResults {
-        NodeResults(vec![initial.round_to_two_decimal_places()])
-    }
-
-    // ASSUMPTION: number of NM will be relatively small, so loading the whole vector of values
-    // to insert new one and resave is cheap
-    pub fn insert_new(&mut self, result: Percent) {
-        let result = result.round_to_two_decimal_places();
-        let pos = self.0.binary_search(&result).unwrap_or_else(|e| e);
-        self.0.insert(pos, result);
-    }
-
-    // SAFETY: there are no codepaths that allow constructing empty struct
-    pub fn median(&self) -> Percent {
-        let len = self.0.len();
-        if len % 2 == 1 {
-            // odd number of elements: return the middle one
-            self.0[len / 2]
-        } else {
-            // even number: average the two middle elements
-            let mid1 = self.0[len / 2 - 1];
-            let mid2 = self.0[len / 2];
-            mid1.average(&mid2).round_to_two_decimal_places()
-        }
-    }
-
-    pub fn inner(&self) -> &[Percent] {
-        &self.0
-    }
-}
-
-#[cw_serde]
-pub struct NodePerformanceResponse {
-    pub performance: Option<Percent>,
-}
-
-#[cw_serde]
-pub struct NodeMeasurementsResponse {
-    pub measurements: Option<NodeResults>,
-}
-
-#[cw_serde]
-#[derive(Copy)]
-pub struct EpochNodePerformance {
-    pub epoch: EpochId,
-    pub performance: Option<Percent>,
-}
-
-#[cw_serde]
-pub struct NodePerformancePagedResponse {
-    pub node_id: NodeId,
-    pub performance: Vec<EpochNodePerformance>,
-    pub start_next_after: Option<EpochId>,
-}
-
-#[cw_serde]
-pub struct EpochPerformancePagedResponse {
-    pub epoch_id: EpochId,
-    pub performance: Vec<NodePerformance>,
-    pub start_next_after: Option<NodeId>,
-}
-
-#[cw_serde]
-pub struct NodeMeasurement {
-    pub node_id: NodeId,
-    pub measurements: NodeResults,
-}
-
-#[cw_serde]
-pub struct EpochMeasurementsPagedResponse {
-    pub epoch_id: EpochId,
-    pub measurements: Vec<NodeMeasurement>,
-    pub start_next_after: Option<NodeId>,
-}
-
-#[cw_serde]
-#[derive(Copy)]
-pub struct HistoricalPerformance {
-    pub epoch_id: EpochId,
-    pub node_id: NodeId,
-    pub performance: Percent,
-}
-
-#[cw_serde]
-pub struct FullHistoricalPerformancePagedResponse {
-    pub performance: Vec<HistoricalPerformance>,
-    pub start_next_after: Option<(EpochId, NodeId)>,
-}
-
-#[cw_serde]
-pub struct NetworkMonitorInformation {
-    pub details: NetworkMonitorDetails,
-    pub current_submission_metadata: NetworkMonitorSubmissionMetadata,
-}
-
-#[cw_serde]
-pub struct NetworkMonitorResponse {
-    pub info: Option<NetworkMonitorInformation>,
-}
-
-#[cw_serde]
-pub struct NetworkMonitorsPagedResponse {
-    pub info: Vec<NetworkMonitorInformation>,
-    pub start_next_after: Option<String>,
-}
-
-#[cw_serde]
-pub struct RetiredNetworkMonitorsPagedResponse {
-    pub info: Vec<RetiredNetworkMonitor>,
-    pub start_next_after: Option<String>,
-}
-
-#[cw_serde]
-pub struct RemoveEpochMeasurementsResponse {
-    pub additional_entries_to_remove_remaining: bool,
-}
-
-#[cw_serde]
-#[derive(Default)]
-pub struct BatchSubmissionResult {
-    pub accepted_scores: u64,
-    pub non_existent_nodes: Vec<NodeId>,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn p(raw: impl AsRef<str>) -> Percent {
-        raw.as_ref().parse().unwrap()
-    }
-
-    fn ps(raw: &[&str]) -> Vec<Percent> {
-        raw.iter().map(p).collect()
-    }
-
-    #[test]
-    fn node_results_insertion() {
-        let initial = NodeResults::new(p("0.5"));
-
-        let mut smaller = initial.clone();
-        let mut greater = initial.clone();
-
-        smaller.insert_new(p("0.4"));
-        greater.insert_new(p("0.6"));
-
-        assert_eq!(smaller.0, ps(&["0.4", "0.5"]));
-        assert_eq!(greater.0, ps(&["0.5", "0.6"]));
-
-        let mut another = NodeResults(ps(&["0.1", "0.4", "0.5", "0.6", "0.6", "1.0"]));
-        another.insert_new(p("0.6"));
-        another.insert_new(p("0.2"));
-        another.insert_new(p("0.7"));
-        another.insert_new(p("0.3"));
-        another.insert_new(p("0.3"));
-        another.insert_new(p("0.55"));
-
-        assert_eq!(
-            another.0,
-            ps(&[
-                "0.1", "0.2", "0.3", "0.3", "0.4", "0.5", "0.55", "0.6", "0.6", "0.6", "0.7", "1.0"
-            ])
-        );
-    }
-
-    #[test]
-    fn node_results_median() {
-        let results = NodeResults(ps(&["0.1"]));
-        assert_eq!(results.median(), p("0.1"));
-
-        let results = NodeResults(ps(&["0.1", "0.2"]));
-        assert_eq!(results.median(), p("0.15"));
-
-        let results = NodeResults(ps(&["0.1", "0.2", "0.3"]));
-        assert_eq!(results.median(), p("0.2"));
-
-        let results = NodeResults(ps(&["0.1", "0.2", "0.3", "0.4"]));
-        assert_eq!(results.median(), p("0.25"));
-
-        let results = NodeResults(ps(&["0.1", "0.2", "0.3", "0.4", "0.5"]));
-        assert_eq!(results.median(), p("0.3"));
-
-        let results = NodeResults(ps(&["0", "0", "1", "1", "1", "1", "1"]));
-        assert_eq!(results.median(), p("1"));
-    }
-}
@@ -20,8 +20,6 @@ nym-credentials = { path = "../credentials" }
 nym-compact-ecash = { path = "../nym_offline_compact_ecash" }
 nym-ecash-time = { path = "../ecash-time" }

-[target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx-pool-guard]
-path = "../../sqlx-pool-guard"

 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.sqlx]
 workspace = true
@@ -33,13 +31,8 @@ features = ["rt-multi-thread", "net", "signal", "fs"]


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

 [features]
-persistent-storage = ["bincode", "serde"]
+persistent-storage = ["bincode", "serde"]
@@ -7,11 +7,10 @@ use crate::models::{
 };
 use nym_ecash_time::Date;
 use sqlx::{Executor, Sqlite, Transaction};
-use sqlx_pool_guard::SqlitePoolGuard;

 #[derive(Clone)]
 pub struct SqliteEcashTicketbookManager {
-    connection_pool: SqlitePoolGuard,
+    connection_pool: sqlx::SqlitePool,
 }

 impl SqliteEcashTicketbookManager {
@@ -20,7 +19,7 @@ impl SqliteEcashTicketbookManager {
    /// # Arguments
    ///
    /// * `connection_pool`: database connection pool to use.
-    pub fn new(connection_pool: SqlitePoolGuard) -> Self {
+    pub fn new(connection_pool: sqlx::SqlitePool) -> Self {
        SqliteEcashTicketbookManager { connection_pool }
    }

@@ -34,7 +33,7 @@ impl SqliteEcashTicketbookManager {
            "DELETE FROM ecash_ticketbook WHERE expiration_date <= ?",
            deadline
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }
@@ -61,7 +60,7 @@ impl SqliteEcashTicketbookManager {
            data,
            expiration_date,
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;

        Ok(())
@@ -91,7 +90,7 @@ impl SqliteEcashTicketbookManager {
            epoch_id,
            total_tickets,
            used_tickets,
-        ).execute(&*self.connection_pool).await?;
+        ).execute(&self.connection_pool).await?;

        Ok(())
    }
@@ -106,7 +105,7 @@ impl SqliteEcashTicketbookManager {
            "#,
        )
        .bind(data)
-        .fetch_optional(&*self.connection_pool)
+        .fetch_optional(&self.connection_pool)
        .await?
        .is_some();

@@ -122,7 +121,7 @@ impl SqliteEcashTicketbookManager {
                    FROM ecash_ticketbook
                "#,
        )
-        .fetch_all(&*self.connection_pool)
+        .fetch_all(&self.connection_pool)
        .await
    }

@@ -144,7 +143,7 @@ impl SqliteEcashTicketbookManager {
            ticketbook_id,
            expected_current_total_spent
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?
        .rows_affected();
        Ok(affected > 0)
@@ -154,7 +153,7 @@ impl SqliteEcashTicketbookManager {
        &self,
    ) -> Result<Vec<StoredPendingTicketbook>, sqlx::Error> {
        sqlx::query_as("SELECT * FROM pending_issuance")
-            .fetch_all(&*self.connection_pool)
+            .fetch_all(&self.connection_pool)
            .await
    }

@@ -166,7 +165,7 @@ impl SqliteEcashTicketbookManager {
            "DELETE FROM pending_issuance WHERE deposit_id = ?",
            pending_id
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }
@@ -183,7 +182,7 @@ impl SqliteEcashTicketbookManager {
            "#,
            epoch_id
        )
-        .fetch_optional(&*self.connection_pool)
+        .fetch_optional(&self.connection_pool)
        .await
    }

@@ -209,7 +208,7 @@ impl SqliteEcashTicketbookManager {
            serialisation_revision,
            epoch_id
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }
@@ -226,7 +225,7 @@ impl SqliteEcashTicketbookManager {
            "#,
            epoch_id
        )
-        .fetch_optional(&*self.connection_pool)
+        .fetch_optional(&self.connection_pool)
        .await
    }

@@ -252,7 +251,7 @@ impl SqliteEcashTicketbookManager {
            serialisation_revision,
            epoch_id,
        )
-        .execute(&*self.connection_pool)
+        .execute(&self.connection_pool)
        .await?;
        Ok(())
    }
@@ -270,7 +269,7 @@ impl SqliteEcashTicketbookManager {
            "#,
            expiration_date
        )
-        .fetch_optional(&*self.connection_pool)
+        .fetch_optional(&self.connection_pool)
        .await
    }

@@ -299,7 +298,7 @@ impl SqliteEcashTicketbookManager {
            serialisation_revision,
            expiration_date
        )
-            .execute(&*self.connection_pool)
+            .execute(&self.connection_pool)
            .await?;
        Ok(())
    }
@@ -37,7 +37,6 @@ use sqlx::{
    sqlite::{SqliteAutoVacuum, SqliteSynchronous},
    ConnectOptions,
 };
-use sqlx_pool_guard::SqlitePoolGuard;
 use std::path::Path;
 use zeroize::Zeroizing;

@@ -55,15 +54,15 @@ impl PersistentStorage {
    /// * `database_path`: path to the database.
    pub async fn init<P: AsRef<Path>>(database_path: P) -> Result<Self, StorageError> {
        debug!(
-            "Attempting to connect to database {}",
-            database_path.as_ref().display()
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
        );

        let opts = sqlx::sqlite::SqliteConnectOptions::new()
            .journal_mode(sqlx::sqlite::SqliteJournalMode::Wal)
            .synchronous(SqliteSynchronous::Normal)
            .auto_vacuum(SqliteAutoVacuum::Incremental)
-            .filename(&database_path)
+            .filename(database_path)
            .create_if_missing(true)
            .disable_statement_logging();

@@ -75,17 +74,13 @@ impl PersistentStorage {
            }
        };

-        let connection_pool =
-            SqlitePoolGuard::new(database_path.as_ref().to_path_buf(), connection_pool);
-
-        if let Err(err) = sqlx::migrate!("./migrations").run(&*connection_pool).await {
+        if let Err(err) = sqlx::migrate!("./migrations").run(&connection_pool).await {
            error!("Failed to perform migration on the SQLx database: {err}");
-            connection_pool.close().await;
            return Err(err.into());
        }

        Ok(PersistentStorage {
-            storage_manager: SqliteEcashTicketbookManager::new(connection_pool),
+            storage_manager: SqliteEcashTicketbookManager::new(connection_pool.clone()),
        })
    }
 }
@@ -88,8 +88,7 @@ impl BandwidthStorageManager {
        debug!(available = available_bi2, required = required_bi2);

        self.consume_bandwidth(required_bandwidth).await?;
-        let remaining_bandwidth = self.client_bandwidth.available().await;
-        Ok(remaining_bandwidth)
+        Ok(available_bandwidth)
    }

    async fn expire_bandwidth(&mut self) -> Result<()> {
@@ -8,6 +8,7 @@ use hkdf::{
    },
    Hkdf,
 };
+use serde::{Deserialize, Serialize};
 use sha2::{Sha256, Sha512};

 pub use hkdf::InvalidLength;
@@ -60,7 +61,7 @@ where
 /// // Prepare for the next derivation
 /// let next_material = material.next();
 /// ```
-#[derive(ZeroizeOnDrop)]
+#[derive(ZeroizeOnDrop, Serialize, Deserialize)]
 pub struct DerivationMaterial {
    master_key: [u8; 32],
    index: u32,
@@ -14,7 +14,6 @@ use nym_dkg::bte::{
 };
 use nym_dkg::interpolation::polynomial::Polynomial;
 use nym_dkg::{combine_shares, Dealing, NodeIndex, Share, Threshold};
-use rand::CryptoRng;
 use rand_core::{RngCore, SeedableRng};
 use std::collections::BTreeMap;

@@ -32,7 +31,7 @@ pub fn precomputing_g2_generator_for_miller_loop(c: &mut Criterion) {
 }

 fn prepare_keys(
-    mut rng: impl RngCore + CryptoRng,
+    mut rng: impl RngCore,
    nodes: usize,
 ) -> (BTreeMap<NodeIndex, PublicKey>, Vec<DecryptionKey>) {
    let params = setup();
@@ -51,7 +50,7 @@ fn prepare_keys(
 }

 fn prepare_resharing(
-    mut rng: impl RngCore + CryptoRng,
+    mut rng: impl RngCore,
    params: &Params,
    nodes: usize,
    threshold: Threshold,
@@ -69,7 +68,7 @@ fn prepare_resharing(
    for (i, ref mut dk) in dks.iter_mut().enumerate() {
        let shares = first_dealings
            .iter()
-            .map(|dealing| decrypt_share(params, dk, i, &dealing.ciphertexts, None).unwrap())
+            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
            .collect();

        let recovered_secret =
@@ -155,9 +154,7 @@ pub fn verifying_dealing_made_for_3_parties_and_recovering_share(c: &mut Criteri
        |b| {
            b.iter(|| {
                assert!(dealing.verify(&params, threshold, &receivers, None).is_ok());
-                black_box(
-                    decrypt_share(&params, first_key, 0, &dealing.ciphertexts, None).unwrap(),
-                );
+                black_box(decrypt_share(first_key, 0, &dealing.ciphertexts, None).unwrap());
            })
        },
    );
@@ -240,9 +237,7 @@ pub fn verifying_dealing_made_for_20_parties_and_recovering_share(c: &mut Criter
        |b| {
            b.iter(|| {
                assert!(dealing.verify(&params, threshold, &receivers, None).is_ok());
-                black_box(
-                    decrypt_share(&params, first_key, 0, &dealing.ciphertexts, None).unwrap(),
-                );
+                black_box(decrypt_share(first_key, 0, &dealing.ciphertexts, None).unwrap());
            })
        },
    );
@@ -325,9 +320,7 @@ pub fn verifying_dealing_made_for_100_parties_and_recovering_share(c: &mut Crite
        |b| {
            b.iter(|| {
                assert!(dealing.verify(&params, threshold, &receivers, None).is_ok());
-                black_box(
-                    decrypt_share(&params, first_key, 0, &dealing.ciphertexts, None).unwrap(),
-                );
+                black_box(decrypt_share(first_key, 0, &dealing.ciphertexts, None).unwrap());
            })
        },
    );
@@ -554,7 +547,7 @@ pub fn share_decryption(c: &mut Criterion) {
    let (ciphertexts, _) = encrypt_shares(&[(&share, pk.public_key())], &params, &mut rng);

    c.bench_function("single share decryption", |b| {
-        b.iter(|| black_box(decrypt_share(&params, &dk, 0, &ciphertexts, None)))
+        b.iter(|| black_box(decrypt_share(&dk, 0, &ciphertexts, None)))
    });
 }

@@ -9,7 +9,6 @@ use crate::{Chunk, ChunkedShare, Share};
 use bls12_381::{G1Affine, G1Projective, G2Prepared, G2Projective, Gt, Scalar};
 use ff::Field;
 use group::{Curve, Group, GroupEncoding};
-use rand::CryptoRng;
 use rand_core::RngCore;
 use std::collections::HashMap;
 use std::ops::Neg;
@@ -192,7 +191,7 @@ impl HazmatRandomness {
 pub fn encrypt_shares(
    shares: &[(&Share, &PublicKey)],
    params: &Params,
-    mut rng: impl RngCore + CryptoRng,
+    mut rng: impl RngCore,
 ) -> (Ciphertexts, HazmatRandomness) {
    let g1 = G1Projective::generator();

@@ -263,7 +262,6 @@ pub fn encrypt_shares(
 }

 pub fn decrypt_share(
-    params: &Params,
    dk: &DecryptionKey,
    // in the case of multiple receivers, specifies which index of ciphertext chunks should be used
    i: usize,
@@ -272,10 +270,6 @@ pub fn decrypt_share(
 ) -> Result<Share, DkgError> {
    let mut plaintext = ChunkedShare::default();

-    if !ciphertext.verify_integrity(params) {
-        return Err(DkgError::FailedCiphertextIntegrityCheck);
-    }
-
    if i >= ciphertext.ciphertext_chunks.len() {
        return Err(DkgError::UnavailableCiphertext(i));
    }
@@ -467,22 +461,10 @@ mod tests {
            let (ciphertext, hazmat) = encrypt_shares(shares, &params, &mut rng);
            verify_hazmat_rand(&ciphertext, &hazmat);

-            let recovered1 = decrypt_share(
-                &params,
-                &decryption_key1,
-                0,
-                &ciphertext,
-                Some(lookup_table),
-            )
-            .unwrap();
-            let recovered2 = decrypt_share(
-                &params,
-                &decryption_key2,
-                1,
-                &ciphertext,
-                Some(lookup_table),
-            )
-            .unwrap();
+            let recovered1 =
+                decrypt_share(&decryption_key1, 0, &ciphertext, Some(lookup_table)).unwrap();
+            let recovered2 =
+                decrypt_share(&decryption_key2, 1, &ciphertext, Some(lookup_table)).unwrap();
            assert_eq!(m1, recovered1);
            assert_eq!(m2, recovered2);
        }
@@ -508,22 +490,10 @@ mod tests {
            let (ciphertext, hazmat) = encrypt_shares(shares, &params, &mut rng);
            verify_hazmat_rand(&ciphertext, &hazmat);

-            let recovered1 = decrypt_share(
-                &params,
-                &decryption_key1,
-                0,
-                &ciphertext,
-                Some(lookup_table),
-            )
-            .unwrap();
-            let recovered2 = decrypt_share(
-                &params,
-                &decryption_key2,
-                1,
-                &ciphertext,
-                Some(lookup_table),
-            )
-            .unwrap();
+            let recovered1 =
+                decrypt_share(&decryption_key1, 0, &ciphertext, Some(lookup_table)).unwrap();
+            let recovered2 =
+                decrypt_share(&decryption_key2, 1, &ciphertext, Some(lookup_table)).unwrap();
            assert_eq!(m1, recovered1);
            assert_eq!(m2, recovered2);
        }
@@ -604,10 +574,7 @@ mod tests {

    #[test]
    fn ciphertexts_roundtrip() {
-        fn random_ciphertexts(
-            mut rng: impl RngCore + CryptoRng,
-            num_receivers: usize,
-        ) -> Ciphertexts {
+        fn random_ciphertexts(mut rng: impl RngCore, num_receivers: usize) -> Ciphertexts {
            Ciphertexts {
                rr: (0..NUM_CHUNKS)
                    .map(|_| G1Projective::random(&mut rng))
@@ -9,15 +9,11 @@ use bls12_381::{G1Projective, G2Projective, Scalar};
 use ff::Field;
 use group::GroupEncoding;
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
-use rand::CryptoRng;
 use rand_core::RngCore;
 use zeroize::Zeroize;

 // produces public key and a decryption key for the root of the tree
-pub fn keygen(
-    params: &Params,
-    mut rng: impl RngCore + CryptoRng,
-) -> (DecryptionKey, PublicKeyWithProof) {
+pub fn keygen(params: &Params, mut rng: impl RngCore) -> (DecryptionKey, PublicKeyWithProof) {
    let g1 = G1Projective::generator();
    let g2 = G2Projective::generator();

@@ -248,7 +244,7 @@ pub struct KeyPair {
 }

 impl KeyPair {
-    pub fn new(params: &Params, rng: impl RngCore + CryptoRng) -> Self {
+    pub fn new(params: &Params, rng: impl RngCore) -> Self {
        let (dk, pk) = keygen(params, rng);
        Self {
            private_key: dk,
@@ -10,7 +10,7 @@ use crate::utils::{deserialize_scalar, RandomOracleBuilder};
 use bls12_381::{G1Projective, Scalar};
 use ff::Field;
 use group::{Group, GroupEncoding};
-use rand::{CryptoRng, Rng};
+use rand::Rng;
 use rand_core::{RngCore, SeedableRng};

 const CHUNKING_ORACLE_DOMAIN: &[u8] =
@@ -28,7 +28,6 @@ const SECURITY_PARAMETER: usize = 256;

 /// ceil(SECURITY_PARAMETER / PARALLEL_RUNS) in the paper
 const NUM_CHALLENGE_BITS: usize = SECURITY_PARAMETER.div_ceil(PARALLEL_RUNS);
-const EE: usize = 1 << NUM_CHALLENGE_BITS;

 // type alias for ease of use
 type FirstChallenge = Vec<Vec<Vec<u64>>>;
@@ -95,7 +94,7 @@ impl ProofOfChunking {
    // Scalar(-1) would in reality be Scalar(q - 1), which is greater than Scalar(1) and opposite to
    // what we wanted.
    pub fn construct(
-        mut rng: impl RngCore + CryptoRng,
+        mut rng: impl RngCore,
        instance: Instance,
        witness_r: &[Scalar; NUM_CHUNKS],
        witnesses_s: &[Share],
@@ -111,20 +110,21 @@ impl ProofOfChunking {
        // define bounds for the blinding factors
        let n = instance.public_keys.len();
        let m = NUM_CHUNKS;
+        let ee = 1 << NUM_CHALLENGE_BITS;

-        // ss = (n * m * (CHUNK_SIZE - 1) * (ee - 1))
-        // Z = 2 * l * S
-        let (ss, zz): (u64, u64) = compute_ss_zz(n, m)?;
+        // CHUNK_MAX corresponds to paper's B
+        let ss = (n * m * (CHUNK_SIZE - 1) * (ee - 1)) as u64;
+        let zz = (2 * (PARALLEL_RUNS as u64))
+            .checked_mul(ss)
+            .expect("overflow in Z = 2 * l * S");

        let ss_scalar = Scalar::from(ss);

        // rather than generating blinding factors in [-S, Z-1] directly,
        // do it via [0, Z - 1 + S + 1] and deal with the shift later.
-        //  combined_upper_range = Z - 1 + S + 1
-
-        let combined_upper_range = zz.checked_add(ss).ok_or(DkgError::ArithmeticOverflow {
-            info: "ProofOfChunking::construct |  Z - 1 + S + 1",
-        })?;
+        let combined_upper_range = (zz - 1)
+            .checked_add(ss + 1)
+            .expect("overflow in Z - 1 + S + 1");

        let mut betas = Vec::with_capacity(PARALLEL_RUNS);
        let mut bs = Vec::with_capacity(PARALLEL_RUNS);
@@ -178,23 +178,12 @@ impl ProofOfChunking {
            // I think this part is more readable with a range loop
            #[allow(clippy::needless_range_loop)]
            for l in 0..PARALLEL_RUNS {
-                let mut sum: u64 = 0;
+                let mut sum = 0;

                for (i, witness_i) in witnesses_s.iter().enumerate() {
                    for (j, witness_ij) in witness_i.to_chunks().chunks.iter().enumerate() {
                        debug_assert!(std::mem::size_of::<Chunk>() <= std::mem::size_of::<u64>());
-                        // sum += first_challenge[i][j][l] * (*witness_ij as u64)
-                        sum = sum
-                            .checked_add(
-                                first_challenge[i][j][l]
-                                    .checked_mul(*witness_ij as u64)
-                                    .ok_or(DkgError::ArithmeticOverflow {
-                                        info: "ProofOfChunking::construct | first_challenge[i][j][l] * witness_ij",
-                                    })?,
-                            )
-                            .ok_or(DkgError::ArithmeticOverflow {
-                                info: "ProofOfChunking::construct | sum + (first_challenge[i][j][l] * witness_ij)",
-                            })?;
+                        sum += first_challenge[i][j][l] * (*witness_ij as u64)
                    }
                }

@@ -202,18 +191,7 @@ impl ProofOfChunking {
                    continue 'retry_loop;
                }
                // shifted_blinding_factors[l] - ss restores it to "proper" [-S, Z - 1] range
-                // let response = sum + shifted_blinding_factors[l] - ss;
-                let response = sum
-                    .checked_add(shifted_blinding_factors[l])
-                    .ok_or(DkgError::ArithmeticOverflow {
-                        info:
-                            "ProofOfChunking::construct | sum + (shifted_blinding_factors[l] - ss)",
-                    })?
-                    .checked_sub(ss)
-                    .ok_or(DkgError::ArithmeticUnderflow {
-                        info: "ProofOfChunking::construct | shifted_blinding_factors[l] - ss",
-                    })?;
-
+                let response = sum + shifted_blinding_factors[l] - ss;
                if response < zz {
                    responses_chunks.push(response)
                } else {
@@ -298,13 +276,11 @@ impl ProofOfChunking {
        ensure_len!(&self.responses_r, n);
        ensure_len!(&self.responses_chunks, PARALLEL_RUNS);

-        // ss = (n * m * (CHUNK_SIZE - 1) * (ee - 1))
-        // Z = 2 * l * S
+        let ee = 1 << NUM_CHALLENGE_BITS;

-        let zz: u64 = match compute_ss_zz(n, m) {
-            Ok((_, zz_res)) => zz_res,
-            _ => return false,
-        };
+        // CHUNK_MAX corresponds to paper's B
+        let ss = (n * m * (CHUNK_SIZE - 1) * (ee - 1)) as u64;
+        let zz = 2 * (PARALLEL_RUNS as u64) * ss;

        for response_chunk in &self.responses_chunks {
            if response_chunk >= &zz {
@@ -435,7 +411,7 @@ impl ProofOfChunking {
        random_oracle_builder.update(lambda_e.to_be_bytes());

        let mut oracle = rand_chacha::ChaCha20Rng::from_seed(random_oracle_builder.finalize());
-        let range_max_excl = EE as u64;
+        let range_max_excl = 1 << NUM_CHALLENGE_BITS;

        (0..n)
            .map(|_| {
@@ -661,50 +637,6 @@ impl ProofOfChunking {
    }
 }

-fn compute_ss_zz(n: usize, m: usize) -> Result<(u64, u64), DkgError> {
-    // let ss = (n * m * (CHUNK_SIZE - 1) * (ee - 1)) as u64;
-    // CHUNK_MAX corresponds to paper's B
-
-    let ee = EE;
-
-    let ss = n
-        .checked_mul(m)
-        .ok_or(DkgError::ArithmeticOverflow {
-            info: "ProofOfChunking::compute_ss_zz | n * m",
-        })?
-        .checked_mul(
-            CHUNK_SIZE
-                .checked_sub(1)
-                .ok_or(DkgError::ArithmeticUnderflow {
-                    info: "ProofOfChunking::compute_ss_zz | (CHUNK_SIZE - 1)",
-                })?
-                .checked_mul(ee.checked_sub(1).ok_or(DkgError::ArithmeticUnderflow {
-                    info: "ProofOfChunking::compute_ss_zz | (ee - 1)",
-                })?)
-                .ok_or(DkgError::ArithmeticOverflow {
-                    info: "ProofOfChunking::compute_ss_zz | (CHUNK_SIZE - 1) * (ee - 1)",
-                })?,
-        )
-        .ok_or(DkgError::ArithmeticOverflow {
-            info: "ProofOfChunking::compute_ss_zz | ss_lhs * ss_rhs",
-        })? as u64;
-
-    // let zz = 2 * PARALLEL_RUNS as u64 * ss;
-    // Z = 2 * l * S
-
-    let zz = 2u64
-        .checked_mul(PARALLEL_RUNS as u64)
-        .ok_or(DkgError::ArithmeticOverflow {
-            info: "ProofOfChunking::compute_ss_zz | 2 * l",
-        })?
-        .checked_mul(ss)
-        .ok_or(DkgError::ArithmeticOverflow {
-            info: "ProofOfChunking::compute_ss_zz | (2 * l) * S",
-        })?;
-
-    Ok((ss, zz))
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -720,9 +652,7 @@ mod tests {
        ciphertext_chunks: Vec<[G1Projective; NUM_CHUNKS]>,
    }

-    fn setup(
-        mut rng: impl RngCore + CryptoRng,
-    ) -> (OwnedInstance, [Scalar; NUM_CHUNKS], Vec<Share>) {
+    fn setup(mut rng: impl RngCore) -> (OwnedInstance, [Scalar; NUM_CHUNKS], Vec<Share>) {
        let g1 = G1Projective::generator();

        let mut pks = Vec::with_capacity(NODES);
@@ -5,7 +5,6 @@ use crate::utils::hash_to_scalar;
 use bls12_381::{G1Projective, Scalar};
 use ff::Field;
 use group::GroupEncoding;
-use rand::CryptoRng;
 use rand_core::RngCore;
 use zeroize::Zeroize;

@@ -21,11 +20,7 @@ pub struct ProofOfDiscreteLog {
 }

 impl ProofOfDiscreteLog {
-    pub fn construct(
-        mut rng: impl RngCore + CryptoRng,
-        public: &G1Projective,
-        witness: &Scalar,
-    ) -> Self {
+    pub fn construct(mut rng: impl RngCore, public: &G1Projective, witness: &Scalar) -> Self {
        let mut rand_x = Scalar::random(&mut rng);
        let rand_commitment = G1Projective::generator() * rand_x;
        let challenge = Self::compute_challenge(public, &rand_commitment);
@@ -9,7 +9,6 @@ use crate::{NodeIndex, Share};
 use bls12_381::{G1Projective, G2Projective, Scalar};
 use ff::Field;
 use group::GroupEncoding;
-use rand::CryptoRng;
 use rand_core::RngCore;
 use std::collections::BTreeMap;

@@ -88,7 +87,7 @@ pub struct ProofOfSecretSharing {

 impl ProofOfSecretSharing {
    pub fn construct(
-        mut rng: impl RngCore + CryptoRng,
+        mut rng: impl RngCore,
        instance: Instance,
        witness_r: &Scalar,
        witnesses_s: &[Share],
@@ -310,14 +309,13 @@ mod tests {
    use super::*;
    use crate::interpolation::polynomial::Polynomial;
    use group::Group;
-    use rand::CryptoRng;
    use rand_core::SeedableRng;

    const NODES: u64 = 50;
    const THRESHOLD: u64 = 40;

    fn setup(
-        mut rng: impl RngCore + CryptoRng,
+        mut rng: impl RngCore,
    ) -> (
        BTreeMap<NodeIndex, PublicKey>,
        PublicCoefficients,
@@ -13,7 +13,6 @@ use crate::utils::deserialize_g2;
 use crate::{NodeIndex, Share, Threshold};
 use bls12_381::{G2Projective, Scalar};
 use group::GroupEncoding;
-use rand::CryptoRng;
 use rand_core::RngCore;
 use std::collections::BTreeMap;
 use zeroize::Zeroize;
@@ -95,7 +94,7 @@ impl Dealing {
    // I'm not a big fan of this function signature, but I'm not clear on how to improve it while
    // allowing the dealer to skip decryption of its own share if it was also one of the receivers
    pub fn create(
-        mut rng: impl RngCore + CryptoRng + CryptoRng,
+        mut rng: impl RngCore,
        params: &Params,
        dealer_index: NodeIndex,
        threshold: Threshold,
@@ -485,7 +484,7 @@ mod tests {
        for (i, (ref dk, _)) in full_keys.iter().enumerate() {
            let shares = dealings
                .values()
-                .map(|dealing| decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap())
+                .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
                .collect();
            derived_secrets.push(
                combine_shares(shares, &receivers.keys().copied().collect::<Vec<_>>()).unwrap(),
@@ -594,7 +593,7 @@ mod tests {
        for (i, (dk, _)) in full_keys.iter().enumerate() {
            let shares = dealings
                .values()
-                .map(|dealing| decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap())
+                .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
                .collect();

            let recovered_secret = combine_shares(shares, &dealer_indices).unwrap();
@@ -99,12 +99,6 @@ pub enum DkgError {
        "The reshared dealing has different public constant coefficient than its prior variant"
    )]
    InvalidResharing,
-
-    #[error("Arithmetic Overflow: {info}")]
-    ArithmeticOverflow { info: &'static str },
-
-    #[error("Arithmetic Underflow: {info}")]
-    ArithmeticUnderflow { info: &'static str },
 }

 impl DkgError {
@@ -6,7 +6,6 @@ use crate::utils::deserialize_g2;
 use bls12_381::{G2Projective, Scalar};
 use ff::Field;
 use group::GroupEncoding;
-use rand::CryptoRng;
 use rand_core::RngCore;
 use std::ops::{Add, Index, IndexMut};
 use zeroize::Zeroize;
@@ -121,7 +120,7 @@ impl Polynomial {
    // for polynomial of degree n, we generate n+1 values
    // (for example for degree 1, like y = x + 2, we need [2,1])
    /// Creates new pseudorandom polynomial of specified degree.
-    pub fn new_random(mut rng: impl RngCore + CryptoRng + CryptoRng, degree: u64) -> Self {
+    pub fn new_random(mut rng: impl RngCore, degree: u64) -> Self {
        Polynomial {
            coefficients: (0..=degree).map(|_| Scalar::random(&mut rng)).collect(),
        }
@@ -53,12 +53,11 @@ fn single_sender() {

    // make sure each share is actually decryptable (even though proofs say they must be, perform this sanity check)
    for (i, (ref dk, _)) in full_keys.iter().enumerate() {
-        let _recovered = decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap();
+        let _recovered = decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap();
    }

    // and for good measure, check that the dealer's share matches decryption result
-    let recovered_dealer =
-        decrypt_share(&params, &full_keys[0].0, 0, &dealing.ciphertexts, None).unwrap();
+    let recovered_dealer = decrypt_share(&full_keys[0].0, 0, &dealing.ciphertexts, None).unwrap();
    assert_eq!(recovered_dealer, dealer_share.unwrap());
 }

@@ -116,7 +115,7 @@ fn full_threshold_secret_sharing() {
    for (i, (ref dk, _)) in full_keys.iter().enumerate() {
        let shares = dealings
            .values()
-            .map(|dealing| decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap())
+            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
            .collect();

        // we know dealer_share matches, but it would be inconvenient to try to put them in here,
@@ -190,7 +189,7 @@ fn full_threshold_secret_resharing() {
    for (i, (ref dk, _)) in full_keys.iter().enumerate() {
        let shares = first_dealings
            .values()
-            .map(|dealing| decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap())
+            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
            .collect();

        let recovered_secret =
@@ -241,7 +240,7 @@ fn full_threshold_secret_resharing() {
    for (i, (ref dk, _)) in full_keys.iter().enumerate() {
        let shares = resharing_dealings
            .values()
-            .map(|dealing| decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap())
+            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
            .collect();

        let recovered_secret =
@@ -306,7 +305,7 @@ fn full_threshold_secret_resharing_left_party() {
    for (i, (ref dk, _)) in full_keys.iter().enumerate() {
        let shares = first_dealings
            .values()
-            .map(|dealing| decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap())
+            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
            .collect();

        let recovered_secret =
@@ -370,7 +369,7 @@ fn full_threshold_secret_resharing_left_party() {
    for (i, (ref dk, _)) in full_keys.iter().enumerate() {
        let shares = resharing_dealings
            .values()
-            .map(|dealing| decrypt_share(&params, dk, i, &dealing.ciphertexts, None).unwrap())
+            .map(|dealing| decrypt_share(dk, i, &dealing.ciphertexts, None).unwrap())
            .collect();

        let recovered_secret = combine_shares(shares, &node_indices).unwrap();
@@ -33,8 +33,8 @@ impl PersistentStatsStorage {
    /// * `database_path`: path to the database.
    pub async fn init<P: AsRef<Path> + Send>(database_path: P) -> Result<Self, StatsStorageError> {
        debug!(
-            "Attempting to connect to database {}",
-            database_path.as_ref().display()
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
        );

        // TODO: we can inject here more stuff based on our gateway global config
@@ -82,8 +82,8 @@ impl GatewayStorage {
        message_retrieval_limit: i64,
    ) -> Result<Self, GatewayStorageError> {
        debug!(
-            "Attempting to connect to database {}",
-            database_path.as_ref().display()
+            "Attempting to connect to database {:?}",
+            database_path.as_ref().as_os_str()
        );

        // TODO: we can inject here more stuff based on our gateway global config
@@ -23,6 +23,7 @@ fn main() {
        "REWARDING_VALIDATOR_ADDRESS",
        "NYM_API",
        "NYXD_WS",
+        "EXPLORER_API",
        "NYM_VPN_API",
    ];

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 #[cfg(feature = "network")]
-use crate::{ApiUrlConst, DenomDetails, ValidatorDetails};
+use crate::{DenomDetails, ValidatorDetails};

 pub const NETWORK_NAME: &str = "mainnet";

@@ -17,11 +17,6 @@ pub const MIXNET_CONTRACT_ADDRESS: &str =
    "n17srjznxl9dvzdkpwpw24gg668wc73val88a6m5ajg6ankwvz9wtst0cznr";
 pub const VESTING_CONTRACT_ADDRESS: &str =
    "n1nc5tatafv6eyq7llkr2gv50ff9e22mnf70qgjlv737ktmt4eswrq73f2nw";
-
-// \/ TODO: this has to be updated once the contract is deployed
-pub const PERFORMANCE_CONTRACT_ADDRESS: &str = "";
-// /\ TODO: this has to be updated once the contract is deployed
-
 pub const ECASH_CONTRACT_ADDRESS: &str =
    "n1r7s6aksyc6pqardx88k3rkgfagwvj4z4zum9mmz2sfk3zm2mha0sd4dnun";
 pub const GROUP_CONTRACT_ADDRESS: &str =
@@ -34,37 +29,10 @@ pub const COCONUT_DKG_CONTRACT_ADDRESS: &str =
 pub const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy";

 pub const NYXD_URL: &str = "https://rpc.nymtech.net";
-pub const NYXD_WS: &str = "wss://rpc.nymtech.net/websocket";
-
 pub const NYM_API: &str = "https://validator.nymtech.net/api/";
-#[cfg(feature = "network")]
-pub const NYM_APIS: &[ApiUrlConst] = &[
-    ApiUrlConst {
-        url: NYM_API,
-        front_hosts: None,
-    },
-    ApiUrlConst {
-        url: "https://nym-fronntdoor.vercel.app/api/",
-        front_hosts: Some(&["vercel.app", "vercel.com"]),
-    },
-    ApiUrlConst {
-        url: "https://nym-frontdoor.global.ssl.fastly.net/api/",
-        front_hosts: Some(&["yelp.global.ssl.fastly.net"]),
-    },
-];
-
+pub const NYXD_WS: &str = "wss://rpc.nymtech.net/websocket";
+pub const EXPLORER_API: &str = "https://explorer.nymtech.net/api/";
 pub const NYM_VPN_API: &str = "https://nymvpn.com/api/";
-#[cfg(feature = "network")]
-pub const NYM_VPN_APIS: &[ApiUrlConst] = &[
-    ApiUrlConst {
-        url: NYM_VPN_API,
-        front_hosts: Some(&["vercel.app", "vercel.com"]),
-    },
-    ApiUrlConst {
-        url: "https://nymvpn-frontdoor.global.ssl.fastly.net/api/",
-        front_hosts: Some(&["yelp.global.ssl.fastly.net"]),
-    },
-];

 // I'm making clippy mad on purpose, because that url HAS TO be updated and deployed before merging
 pub const EXIT_POLICY_URL: &str =
@@ -155,6 +123,7 @@ pub fn export_to_env() {
    set_var_to_default(var_names::NYXD, NYXD_URL);
    set_var_to_default(var_names::NYM_API, NYM_API);
    set_var_to_default(var_names::NYXD_WEBSOCKET, NYXD_WS);
+    set_var_to_default(var_names::EXPLORER_API, EXPLORER_API);
    set_var_to_default(var_names::EXIT_POLICY_URL, EXIT_POLICY_URL);
    set_var_to_default(var_names::NYM_VPN_API, NYM_VPN_API);
 }
@@ -196,5 +165,6 @@ pub fn export_to_env_if_not_set() {
    set_var_conditionally_to_default(var_names::NYXD, NYXD_URL);
    set_var_conditionally_to_default(var_names::NYM_API, NYM_API);
    set_var_conditionally_to_default(var_names::NYXD_WEBSOCKET, NYXD_WS);
+    set_var_conditionally_to_default(var_names::EXPLORER_API, EXPLORER_API);
    set_var_conditionally_to_default(var_names::EXIT_POLICY_URL, EXIT_POLICY_URL);
 }
@@ -20,8 +20,6 @@ pub struct ChainDetails {
 pub struct NymContracts {
    pub mixnet_contract_address: Option<String>,
    pub vesting_contract_address: Option<String>,
-    #[serde(default)]
-    pub performance_contract_address: Option<String>,
    pub ecash_contract_address: Option<String>,
    pub group_contract_address: Option<String>,
    pub multisig_contract_address: Option<String>,
@@ -37,38 +35,8 @@ pub struct NymNetworkDetails {
    pub chain_details: ChainDetails,
    pub endpoints: Vec<ValidatorDetails>,
    pub contracts: NymContracts,
+    pub explorer_api: Option<String>,
    pub nym_vpn_api_url: Option<String>,
-    pub nym_api_urls: Option<Vec<ApiUrl>>,
-    pub nym_vpn_api_urls: Option<Vec<ApiUrl>>,
-}
-
-#[derive(Clone, Debug, Deserialize, Eq, Hash, PartialEq, Serialize, JsonSchema)]
-#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
-pub struct ApiUrl {
-    /// Expects a string formatted Url
-    ///
-    /// see https://docs.rs/url/latest/url/struct.Url.html
-    pub url: String,
-    /// Optional alternative equivalent hostnames. Each entry must parse as valid Host
-    ///
-    /// see https://docs.rs/url/latest/url/enum.Host.html
-    pub front_hosts: Option<Vec<String>>,
-}
-
-pub struct ApiUrlConst<'a> {
-    pub url: &'a str,
-    pub front_hosts: Option<&'a [&'a str]>,
-}
-
-impl From<ApiUrlConst<'_>> for ApiUrl {
-    fn from(value: ApiUrlConst) -> Self {
-        ApiUrl {
-            url: value.url.to_string(),
-            front_hosts: value
-                .front_hosts
-                .map(|slice| slice.iter().map(|s| s.to_string()).collect()),
-        }
-    }
 }

 // by default we assume the same defaults as mainnet, i.e. same prefixes and denoms
@@ -97,9 +65,8 @@ impl NymNetworkDetails {
            },
            endpoints: Default::default(),
            contracts: Default::default(),
+            explorer_api: Default::default(),
            nym_vpn_api_url: Default::default(),
-            nym_api_urls: Default::default(),
-            nym_vpn_api_urls: Default::default(),
        }
    }

@@ -157,6 +124,7 @@ impl NymNetworkDetails {
            .with_group_contract(get_optional_env(var_names::GROUP_CONTRACT_ADDRESS))
            .with_multisig_contract(get_optional_env(var_names::MULTISIG_CONTRACT_ADDRESS))
            .with_coconut_dkg_contract(get_optional_env(var_names::COCONUT_DKG_CONTRACT_ADDRESS))
+            .with_explorer_api(get_optional_env(var_names::EXPLORER_API))
            .with_nym_vpn_api_url(get_optional_env(var_names::NYM_VPN_API))
    }

@@ -177,9 +145,6 @@ impl NymNetworkDetails {
            contracts: NymContracts {
                mixnet_contract_address: parse_optional_str(mainnet::MIXNET_CONTRACT_ADDRESS),
                vesting_contract_address: parse_optional_str(mainnet::VESTING_CONTRACT_ADDRESS),
-                performance_contract_address: parse_optional_str(
-                    mainnet::PERFORMANCE_CONTRACT_ADDRESS,
-                ),
                ecash_contract_address: parse_optional_str(mainnet::ECASH_CONTRACT_ADDRESS),
                group_contract_address: parse_optional_str(mainnet::GROUP_CONTRACT_ADDRESS),
                multisig_contract_address: parse_optional_str(mainnet::MULTISIG_CONTRACT_ADDRESS),
@@ -187,9 +152,8 @@ impl NymNetworkDetails {
                    mainnet::COCONUT_DKG_CONTRACT_ADDRESS,
                ),
            },
+            explorer_api: parse_optional_str(mainnet::EXPLORER_API),
            nym_vpn_api_url: parse_optional_str(mainnet::NYM_VPN_API),
-            nym_api_urls: None,
-            nym_vpn_api_urls: None,
        }
    }

@@ -229,6 +193,7 @@ impl NymNetworkDetails {
        set_optional_var(var_names::MULTISIG_CONTRACT_ADDRESS, self.contracts.multisig_contract_address);
        set_optional_var(var_names::COCONUT_DKG_CONTRACT_ADDRESS, self.contracts.coconut_dkg_contract_address);

+        set_optional_var(var_names::EXPLORER_API, self.explorer_api);
        set_optional_var(var_names::NYM_VPN_API, self.nym_vpn_api_url);
    }

@@ -332,6 +297,12 @@ impl NymNetworkDetails {
        self
    }

+    #[must_use]
+    pub fn with_explorer_api<S: Into<String>>(mut self, endpoint: Option<S>) -> Self {
+        self.explorer_api = endpoint.map(Into::into);
+        self
+    }
+
    #[must_use]
    pub fn with_nym_vpn_api_url<S: Into<String>>(mut self, endpoint: Option<S>) -> Self {
        self.nym_vpn_api_url = endpoint.map(Into::into);
@@ -22,6 +22,7 @@ pub const REWARDING_VALIDATOR_ADDRESS: &str = "REWARDING_VALIDATOR_ADDRESS";
 pub const NYXD: &str = "NYXD";
 pub const NYM_API: &str = "NYM_API";
 pub const NYXD_WEBSOCKET: &str = "NYXD_WS";
+pub const EXPLORER_API: &str = "EXPLORER_API";
 pub const EXIT_POLICY_URL: &str = "EXIT_POLICY";
 pub const NYM_VPN_API: &str = "NYM_VPN_API";
 pub const CLIENT_STATS_COLLECTION_PROVIDER: &str = "CLIENT_STATS_COLLECTION_PROVIDER";
@@ -31,9 +31,9 @@ checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"

 [[package]]
 name = "anyhow"
-version = "1.0.98"
+version = "1.0.97"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e16d2d3311acee920a9eb8d33b8cbc1787ce4a264e85f964c2404b969bdcd487"
+checksum = "dcfed56ad506cb2c684a14971b8861fdc3baaaae314b9e5f9bb532cbe3ba7a4f"

 [[package]]
 name = "ark-bls12-381"
@@ -1133,19 +1133,6 @@ dependencies = [
 "vergen",
 ]

-[[package]]
-name = "nym-contracts-common-testing"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "cosmwasm-std",
- "cw-multi-test",
- "cw-storage-plus",
- "rand",
- "rand_chacha",
- "serde",
-]
-
 [[package]]
 name = "nym-crypto"
 version = "0.4.0"
@@ -1227,9 +1214,7 @@ dependencies = [
 "cw2",
 "easy-addr",
 "nym-contracts-common",
- "nym-contracts-common-testing",
 "nym-crypto",
- "nym-mixnet-contract",
 "nym-mixnet-contract-common",
 "nym-vesting-contract-common",
 "rand",
@@ -1253,6 +1238,7 @@ dependencies = [
 "schemars",
 "semver",
 "serde",
+ "serde-json-wasm",
 "serde_repr",
 "thiserror 2.0.12",
 "time",
@@ -1290,38 +1276,6 @@ dependencies = [
 "zeroize",
 ]

-[[package]]
-name = "nym-performance-contract"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-controllers",
- "cw-storage-plus",
- "cw2",
- "nym-contracts-common",
- "nym-contracts-common-testing",
- "nym-crypto",
- "nym-mixnet-contract",
- "nym-mixnet-contract-common",
- "nym-performance-contract-common",
- "serde",
-]
-
-[[package]]
-name = "nym-performance-contract-common"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-controllers",
- "nym-contracts-common",
- "schemars",
- "serde",
- "thiserror 2.0.12",
-]
-
 [[package]]
 name = "nym-pool-contract"
 version = "0.1.0"
@@ -1330,11 +1284,14 @@ dependencies = [
 "cosmwasm-schema",
 "cosmwasm-std",
 "cw-controllers",
+ "cw-multi-test",
 "cw-storage-plus",
 "cw2",
 "nym-contracts-common",
- "nym-contracts-common-testing",
 "nym-pool-contract-common",
+ "rand",
+ "rand_chacha",
+ "serde",
 ]

 [[package]]
@@ -9,7 +9,6 @@ members = [
    "multisig/cw3-flex-multisig",
    "multisig/cw4-group",
    "vesting",
-    "performance",
 ]

 [workspace.package]
@@ -65,4 +64,4 @@ dbg_macro = "deny"
 exit = "deny"
 panic = "deny"
 unimplemented = "deny"
-unreachable = "deny"
+unreachable = "deny"
@@ -26,13 +26,13 @@ name = "mixnet_contract"
 crate-type = ["cdylib", "rlib"]

 [dependencies]
-mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-contract", package = "nym-mixnet-contract-common" }
-vesting-contract-common = { path = "../../common/cosmwasm-smart-contracts/vesting-contract", package = "nym-vesting-contract-common" }
-nym-contracts-common = { path = "../../common/cosmwasm-smart-contracts/contracts-common" }
-nym-contracts-common-testing = { path = "../../common/cosmwasm-smart-contracts/contracts-common-testing", optional = true }
+mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-contract", package = "nym-mixnet-contract-common", version = "0.6.0" }
+vesting-contract-common = { path = "../../common/cosmwasm-smart-contracts/vesting-contract", package = "nym-vesting-contract-common", version = "0.7.0" }
+nym-contracts-common = { path = "../../common/cosmwasm-smart-contracts/contracts-common", version = "0.5.0" }

 cosmwasm-schema = { workspace = true, optional = true }
 cosmwasm-std = { workspace = true }
+
 cw-controllers = { workspace = true }
 cw2 = { workspace = true }
 cw-storage-plus = { workspace = true }
@@ -41,22 +41,16 @@ bs58 = { workspace = true }
 serde = { workspace = true, default-features = false, features = ["derive"] }
 semver = { workspace = true }

-
 [dev-dependencies]
 anyhow.workspace = true
-rand_chacha = { workspace = true }
-rand = { workspace = true }
+rand_chacha = "0.3"
+rand = "0.8.5"
 nym-crypto = { path = "../../common/crypto", features = ["asymmetric", "rand"] }
 easy-addr = { path = "../../common/cosmwasm-smart-contracts/easy_addr" }

-# activate the `testable-mixnet-contract` in tests (weird workaround, but it does the trick)
-nym-mixnet-contract = { path = ".", features = ["testable-mixnet-contract"] }
-nym-contracts-common-testing = { path = "../../common/cosmwasm-smart-contracts/contracts-common-testing" }
-
 [features]
 default = []
 contract-testing = ["mixnet-contract-common/contract-testing"]
-testable-mixnet-contract = ["nym-contracts-common-testing"]
 schema-gen = ["mixnet-contract-common/schema", "cosmwasm-schema"]

 [lints]
@@ -649,7 +649,7 @@ pub fn migrate(
 mod tests {
    use super::*;
    use crate::rewards::storage as rewards_storage;
-    use cosmwasm_std::testing::{message_info, mock_env};
+    use cosmwasm_std::testing::{message_info, mock_dependencies, mock_env};
    use cosmwasm_std::{Decimal, Uint128};
    use mixnet_contract_common::reward_params::{
        IntervalRewardParams, RewardedSetParams, RewardingParams,
@@ -657,7 +657,6 @@ mod tests {
    use mixnet_contract_common::{
        InitialRewardingParams, OperatingCostRange, Percent, ProfitMarginRange,
    };
-    use nym_contracts_common_testing::mock_dependencies;
    use std::time::Duration;

    #[test]
@@ -22,6 +22,3 @@ mod support;
 #[cfg(feature = "contract-testing")]
 mod testing;
 mod vesting_migration;
-
-#[cfg(feature = "testable-mixnet-contract")]
-pub mod testable_mixnet_contract;
@@ -130,22 +130,20 @@ pub mod tests {
    use crate::mixnet_contract_settings::queries::query_rewarding_validator_address;
    use crate::mixnet_contract_settings::storage::rewarding_denom;
    use crate::support::tests::test_helpers;
-    use cosmwasm_std::testing::message_info;
+    use cosmwasm_std::testing::{message_info, MockApi};
    use cosmwasm_std::{Coin, Uint128};
    use cw_controllers::AdminError::NotAdmin;
    use mixnet_contract_common::OperatorsParamsUpdate;
-    use nym_contracts_common_testing::mock_api;

    #[test]
    fn update_contract_rewarding_validator_address() {
        let mut deps = test_helpers::init_contract();
-        let mock_api = mock_api();

        let info = message_info(&deps.api.addr_make("not-the-creator"), &[]);
        let res = try_update_rewarding_validator_address(
            deps.as_mut(),
            info,
-            mock_api.addr_make("not-the-creator").to_string(),
+            MockApi::default().addr_make("not-the-creator").to_string(),
        );
        assert_eq!(res, Err(MixnetContractError::Admin(NotAdmin {})));

@@ -153,14 +151,14 @@ pub mod tests {
        let res = try_update_rewarding_validator_address(
            deps.as_mut(),
            info,
-            mock_api.addr_make("new-good-address").to_string(),
+            MockApi::default().addr_make("new-good-address").to_string(),
        );
        assert_eq!(
            res,
            Ok(
                Response::default().add_event(new_rewarding_validator_address_update_event(
-                    mock_api.addr_make("rewarder"),
-                    mock_api.addr_make("new-good-address")
+                    MockApi::default().addr_make("rewarder"),
+                    MockApi::default().addr_make("new-good-address")
                ))
            )
        );
@@ -168,7 +166,7 @@ pub mod tests {
        let state = storage::CONTRACT_STATE.load(&deps.storage).unwrap();
        assert_eq!(
            state.rewarding_validator_address,
-            mock_api.addr_make("new-good-address")
+            MockApi::default().addr_make("new-good-address")
        );

        assert_eq!(
@@ -51,11 +51,11 @@ pub mod test_helpers {
    use crate::support::helpers::ensure_no_existing_bond;
    use crate::support::tests;
    use crate::support::tests::fixtures::{
-        good_gateway_pledge, good_mixnode_pledge, good_node_plegge,
+        good_gateway_pledge, good_mixnode_pledge, good_node_plegge, TEST_COIN_DENOM,
    };
    use crate::support::tests::{legacy, test_helpers};
-    use crate::testable_mixnet_contract::MixnetContract;
    use cosmwasm_std::testing::message_info;
+    use cosmwasm_std::testing::mock_dependencies;
    use cosmwasm_std::testing::mock_env;
    use cosmwasm_std::testing::MockApi;
    use cosmwasm_std::testing::MockQuerier;
@@ -74,24 +74,22 @@ pub mod test_helpers {
    use mixnet_contract_common::nym_node::{RewardedSetMetadata, Role};
    use mixnet_contract_common::pending_events::{PendingEpochEventData, PendingIntervalEventData};
    use mixnet_contract_common::reward_params::{
-        NodeRewardingParameters, Performance, RewardingParams, WorkFactor,
+        NodeRewardingParameters, Performance, RewardedSetParams, RewardingParams, WorkFactor,
    };
    use mixnet_contract_common::rewarding::simulator::simulated_node::SimulatedNode;
    use mixnet_contract_common::rewarding::simulator::Simulator;
    use mixnet_contract_common::rewarding::RewardDistribution;
    use mixnet_contract_common::{
        ContractStateParamsUpdate, Delegation, EpochEventId, EpochState, EpochStatus, ExecuteMsg,
-        Gateway, GatewayBondingPayload, IdentityKey, Interval, MixNode, MixNodeBond,
-        MixNodeDetails, MixnodeBondingPayload, NodeId, NymNode, NymNodeBond, NymNodeBondingPayload,
-        NymNodeDetails, OperatingCostRange, OperatorsParamsUpdate, ProfitMarginRange,
-        RoleAssignment, SignableGatewayBondingMsg, SignableMixNodeBondingMsg,
-        SignableNymNodeBondingMsg,
+        Gateway, GatewayBondingPayload, IdentityKey, InitialRewardingParams, InstantiateMsg,
+        Interval, MixNode, MixNodeBond, MixNodeDetails, MixnodeBondingPayload, NodeId, NymNode,
+        NymNodeBond, NymNodeBondingPayload, NymNodeDetails, OperatingCostRange,
+        OperatorsParamsUpdate, Percent, ProfitMarginRange, RoleAssignment,
+        SignableGatewayBondingMsg, SignableMixNodeBondingMsg, SignableNymNodeBondingMsg,
    };
    use nym_contracts_common::signing::{
        ContractMessageContent, MessageSignature, SignableMessage, SigningAlgorithm, SigningPurpose,
    };
-    use nym_contracts_common_testing::TestableNymContract;
-    use nym_contracts_common_testing::{mock_api, mock_dependencies};
    use nym_crypto::asymmetric::ed25519;
    use nym_crypto::asymmetric::ed25519::KeyPair;
    use rand::distributions::WeightedIndex;
@@ -102,12 +100,13 @@ pub mod test_helpers {
    use std::collections::HashMap;
    use std::fmt::Debug;
    use std::str::FromStr;
+    use std::time::Duration;

    pub(crate) fn sorted_addresses(n: usize) -> Vec<Addr> {
        let mut rng = test_rng();
        let mut addrs = Vec::with_capacity(n);
        for i in 0..n {
-            addrs.push(mock_api().addr_make(&format!("addr{i}{}", rng.next_u64())));
+            addrs.push(MockApi::default().addr_make(&format!("addr{i}{}", rng.next_u64())));
        }
        addrs.sort();
        addrs
@@ -1821,9 +1820,46 @@ pub mod test_helpers {
        SignableGatewayBondingMsg::new(nonce, content)
    }

+    fn intial_rewarded_set_params() -> RewardedSetParams {
+        RewardedSetParams {
+            entry_gateways: 50,
+            exit_gateways: 70,
+            mixnodes: 120,
+            standby: 50,
+        }
+    }
+
+    fn initial_rewarding_params() -> InitialRewardingParams {
+        let reward_pool = 250_000_000_000_000u128;
+        let staking_supply = 100_000_000_000_000u128;
+
+        InitialRewardingParams {
+            initial_reward_pool: Decimal::from_atomics(reward_pool, 0).unwrap(), // 250M * 1M (we're expressing it all in base tokens)
+            initial_staking_supply: Decimal::from_atomics(staking_supply, 0).unwrap(), // 100M * 1M
+            staking_supply_scale_factor: Percent::hundred(),
+            sybil_resistance: Percent::from_percentage_value(30).unwrap(),
+            active_set_work_factor: Decimal::from_atomics(10u32, 0).unwrap(),
+            interval_pool_emission: Percent::from_percentage_value(2).unwrap(),
+            rewarded_set_params: intial_rewarded_set_params(),
+        }
+    }
+
    pub fn init_contract() -> OwnedDeps<MemoryStorage, MockApi, MockQuerier<Empty>> {
        let mut deps = mock_dependencies();
-        let msg = MixnetContract::base_init_msg();
+        let msg = InstantiateMsg {
+            rewarding_validator_address: deps.api.addr_make("rewarder").to_string(),
+            vesting_contract_address: deps.api.addr_make("vesting-contract").to_string(),
+            rewarding_denom: TEST_COIN_DENOM.to_string(),
+            epochs_in_interval: 720,
+            epoch_duration: Duration::from_secs(60 * 60),
+            initial_rewarding_params: initial_rewarding_params(),
+            current_nym_node_version: "1.1.10".to_string(),
+            version_score_weights: Default::default(),
+            version_score_params: Default::default(),
+            profit_margin: Default::default(),
+            interval_operating_cost: Default::default(),
+            key_validity_in_epochs: None,
+        };
        let env = mock_env();
        let info = sender("creator");
        instantiate(deps.as_mut(), env, info, msg).unwrap();
@@ -1,89 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// fine in test code
-#![allow(clippy::unwrap_used)]
-
-use crate::contract::{execute, instantiate, migrate, query};
-use cosmwasm_std::Decimal;
-use mixnet_contract_common::error::MixnetContractError;
-use mixnet_contract_common::reward_params::RewardedSetParams;
-use mixnet_contract_common::{
-    ExecuteMsg, InitialRewardingParams, InstantiateMsg, MigrateMsg, QueryMsg,
-};
-use nym_contracts_common::Percent;
-use nym_contracts_common_testing::{
-    mock_dependencies, ContractFn, PermissionedFn, QueryFn, TEST_DENOM,
-};
-use std::time::Duration;
-
-pub use nym_contracts_common_testing::TestableNymContract;
-
-pub struct MixnetContract;
-
-fn initial_rewarded_set_params() -> RewardedSetParams {
-    RewardedSetParams {
-        entry_gateways: 50,
-        exit_gateways: 70,
-        mixnodes: 120,
-        standby: 50,
-    }
-}
-
-fn initial_rewarding_params() -> InitialRewardingParams {
-    let reward_pool = 250_000_000_000_000u128;
-    let staking_supply = 100_000_000_000_000u128;
-
-    InitialRewardingParams {
-        initial_reward_pool: Decimal::from_atomics(reward_pool, 0).unwrap(), // 250M * 1M (we're expressing it all in base tokens)
-        initial_staking_supply: Decimal::from_atomics(staking_supply, 0).unwrap(), // 100M * 1M
-        staking_supply_scale_factor: Percent::hundred(),
-        sybil_resistance: Percent::from_percentage_value(30).unwrap(),
-        active_set_work_factor: Decimal::from_atomics(10u32, 0).unwrap(),
-        interval_pool_emission: Percent::from_percentage_value(2).unwrap(),
-        rewarded_set_params: initial_rewarded_set_params(),
-    }
-}
-
-impl TestableNymContract for MixnetContract {
-    const NAME: &'static str = "mixnet-contract";
-    type InitMsg = InstantiateMsg;
-    type ExecuteMsg = ExecuteMsg;
-    type QueryMsg = QueryMsg;
-    type MigrateMsg = MigrateMsg;
-    type ContractError = MixnetContractError;
-
-    fn instantiate() -> ContractFn<Self::InitMsg, Self::ContractError> {
-        instantiate
-    }
-
-    fn execute() -> ContractFn<Self::ExecuteMsg, Self::ContractError> {
-        execute
-    }
-
-    fn query() -> QueryFn<Self::QueryMsg, Self::ContractError> {
-        query
-    }
-
-    fn migrate() -> PermissionedFn<Self::MigrateMsg, Self::ContractError> {
-        migrate
-    }
-
-    fn base_init_msg() -> Self::InitMsg {
-        let deps = mock_dependencies();
-        InstantiateMsg {
-            rewarding_validator_address: deps.api.addr_make("rewarder").to_string(),
-            vesting_contract_address: deps.api.addr_make("vesting-contract").to_string(),
-            rewarding_denom: TEST_DENOM.to_string(),
-            epochs_in_interval: 720,
-            epoch_duration: Duration::from_secs(60 * 60),
-            initial_rewarding_params: initial_rewarding_params(),
-            current_nym_node_version: "1.1.10".to_string(),
-            version_score_weights: Default::default(),
-            version_score_params: Default::default(),
-            profit_margin: Default::default(),
-            interval_operating_cost: Default::default(),
-            key_validity_in_epochs: None,
-        }
-    }
-}
@@ -25,9 +25,13 @@ cosmwasm-schema = { workspace = true, optional = true }
 nym-contracts-common = { path = "../../common/cosmwasm-smart-contracts/contracts-common" }
 nym-pool-contract-common = { path = "../../common/cosmwasm-smart-contracts/nym-pool-contract" }

+
 [dev-dependencies]
 anyhow = { workspace = true }
-nym-contracts-common-testing = { path = "../../common/cosmwasm-smart-contracts/contracts-common-testing" }
+serde = { workspace = true }
+rand_chacha = { workspace = true }
+rand = { workspace = true }
+cw-multi-test = { workspace = true }

 [features]
 schema-gen = ["nym-pool-contract-common/schema", "cosmwasm-schema"]
@@ -193,8 +193,8 @@ mod tests {
        #[cfg(test)]
        mod setting_initial_grants {
            use super::*;
+            use crate::testing::deps_with_balance;
            use cosmwasm_std::{coin, Order, Storage};
-            use nym_contracts_common_testing::deps_with_balance;
            use nym_pool_contract_common::{Allowance, BasicAllowance, Grant, GranteeAddress};
            use std::collections::HashMap;

@@ -26,13 +26,12 @@ pub fn validate_usage_coin(storage: &dyn Storage, coin: &Coin) -> Result<(), Nym
 mod tests {
    use super::*;
    use crate::storage::NymPoolStorage;
-    use crate::testing::init_contract_tester;
+    use crate::testing::TestSetup;
    use cosmwasm_std::coin;
-    use nym_contracts_common_testing::ContractOpts;

    #[test]
    fn validating_coin_usage() -> anyhow::Result<()> {
-        let test = init_contract_tester();
+        let test = TestSetup::init();
        let storage = NymPoolStorage::new();
        let denom = storage.pool_denomination.load(test.storage())?;

@@ -182,22 +182,20 @@ pub fn query_granters_paged(
 mod tests {
    use super::*;
    use crate::contract::instantiate;
-    use crate::testing::{init_contract_tester, NymPoolContractTesterExt, TEST_DENOM};
+    use crate::testing::{TestSetup, TEST_DENOM};
    use cosmwasm_std::testing::{message_info, mock_dependencies_with_balance, mock_env};
    use cosmwasm_std::{coin, Uint128};
-    use nym_contracts_common_testing::{AdminExt, ChainOpts, ContractOpts, DenomExt, RandExt};
    use nym_pool_contract_common::{Allowance, BasicAllowance, GranterInformation, InstantiateMsg};

    #[cfg(test)]
    mod admin_query {
        use super::*;
-        use crate::testing::init_contract_tester;
-        use nym_contracts_common_testing::{AdminExt, ChainOpts, ContractOpts, RandExt};
+        use crate::testing::TestSetup;
        use nym_pool_contract_common::ExecuteMsg;

        #[test]
        fn returns_current_admin() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let initial_admin = test.admin_unchecked();

@@ -257,7 +255,7 @@ mod tests {

    #[test]
    fn total_locked_tokens_query() {
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();

        let locked = query_total_locked_tokens(test.deps()).unwrap().locked;
        assert!(locked.amount.is_zero());
@@ -273,7 +271,7 @@ mod tests {

    #[test]
    fn locked_tokens_query() {
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();

        let grantee1 = test.add_dummy_grant().grantee;
        test.lock_allowance(grantee1.as_str(), Uint128::new(1234));
@@ -297,13 +295,8 @@ mod tests {
    #[cfg(test)]
    mod locked_tokens_paged_query {
        use super::*;
-        use crate::testing::NymPoolContract;
-        use nym_contracts_common_testing::ContractTester;

-        fn lock_sorted(
-            test: &mut ContractTester<NymPoolContract>,
-            count: usize,
-        ) -> Vec<LockedTokens> {
+        fn lock_sorted(test: &mut TestSetup, count: usize) -> Vec<LockedTokens> {
            let mut grantees = Vec::new();

            for _ in 0..count {
@@ -321,7 +314,7 @@ mod tests {

        #[test]
        fn obeys_limits() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _locked = lock_sorted(&mut test, 1000);

            let limit = 42;
@@ -331,7 +324,7 @@ mod tests {

        #[test]
        fn has_default_limit() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _locked = lock_sorted(&mut test, 1000);

            // query without explicitly setting a limit
@@ -344,7 +337,7 @@ mod tests {

        #[test]
        fn has_max_limit() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _locked = lock_sorted(&mut test, 1000);

            // query with a crazily high limit in an attempt to use too many resources
@@ -359,7 +352,7 @@ mod tests {

        #[test]
        fn pagination_works() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let locked = lock_sorted(&mut test, 1000);

            // first page should return 2 results...
@@ -378,7 +371,7 @@ mod tests {

    #[test]
    fn grant_query() {
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();
        let env = test.env();

        // bad address
@@ -440,7 +433,7 @@ mod tests {

    #[test]
    fn granter_query() {
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();
        let admin = test.admin_unchecked();
        let env = test.env();

@@ -489,13 +482,8 @@ mod tests {
    #[cfg(test)]
    mod granters_paged_query {
        use super::*;
-        use crate::testing::NymPoolContract;
-        use nym_contracts_common_testing::ContractTester;

-        fn granters_sorted(
-            test: &mut ContractTester<NymPoolContract>,
-            count: usize,
-        ) -> Vec<GranterDetails> {
+        fn granters_sorted(test: &mut TestSetup, count: usize) -> Vec<GranterDetails> {
            let mut granters = Vec::new();

            for _ in 0..count {
@@ -516,7 +504,7 @@ mod tests {

        #[test]
        fn obeys_limits() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _granters = granters_sorted(&mut test, 1000);

            let limit = 42;
@@ -526,7 +514,7 @@ mod tests {

        #[test]
        fn has_default_limit() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _granters = granters_sorted(&mut test, 1000);

            // query without explicitly setting a limit
@@ -539,7 +527,7 @@ mod tests {

        #[test]
        fn has_max_limit() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _granters = granters_sorted(&mut test, 1000);

            // query with a crazily high limit in an attempt to use too many resources
@@ -554,7 +542,7 @@ mod tests {

        #[test]
        fn pagination_works() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let locked = granters_sorted(&mut test, 1000);

            // first page should return 2 results...
@@ -574,13 +562,8 @@ mod tests {
    #[cfg(test)]
    mod grants_paged_query {
        use super::*;
-        use crate::testing::{init_contract_tester, NymPoolContract};
-        use nym_contracts_common_testing::{ContractOpts, ContractTester};

-        fn grants_sorted(
-            test: &mut ContractTester<NymPoolContract>,
-            count: usize,
-        ) -> Vec<GrantInformation> {
+        fn grants_sorted(test: &mut TestSetup, count: usize) -> Vec<GrantInformation> {
            let mut grantees = Vec::new();

            for _ in 0..count {
@@ -597,7 +580,7 @@ mod tests {

        #[test]
        fn obeys_limits() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _grantees = grants_sorted(&mut test, 1000);

            let limit = 42;
@@ -607,7 +590,7 @@ mod tests {

        #[test]
        fn has_default_limit() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _grantees = grants_sorted(&mut test, 1000);

            // query without explicitly setting a limit
@@ -620,7 +603,7 @@ mod tests {

        #[test]
        fn has_max_limit() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let _grantees = grants_sorted(&mut test, 1000);

            // query with a crazily high limit in an attempt to use too many resources
@@ -636,7 +619,7 @@ mod tests {

        #[test]
        fn pagination_works() {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grants = grants_sorted(&mut test, 1000);

            // first page should return 2 results...
@@ -489,21 +489,19 @@ mod tests {
    #[cfg(test)]
    mod nympool_storage {
        use super::*;
-        use crate::testing::{init_contract_tester, NymPoolContractTesterExt, TEST_DENOM};
+        use crate::testing::{TestSetup, TEST_DENOM};
        use cosmwasm_std::testing::{
            mock_dependencies, mock_env, MockApi, MockQuerier, MockStorage,
        };
        use cosmwasm_std::{coin, coins, Empty, OwnedDeps};
-        use nym_contracts_common_testing::{AdminExt, ContractOpts, RandExt};
        use nym_pool_contract_common::BasicAllowance;

        #[cfg(test)]
        mod initialisation {
            use super::*;
-            use crate::testing::TEST_DENOM;
+            use crate::testing::{deps_with_balance, TEST_DENOM};
            use cosmwasm_std::testing::{mock_dependencies, mock_env};
            use cosmwasm_std::{coin, Order};
-            use nym_contracts_common_testing::deps_with_balance;
            use nym_pool_contract_common::BasicAllowance;

            fn all_grants(storage: &dyn Storage) -> HashMap<GranteeAddress, Grant> {
@@ -916,7 +914,7 @@ mod tests {
        #[test]
        fn loading_granter_information() -> anyhow::Result<()> {
            let storage = NymPoolStorage::new();
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let granter = test.generate_account();

@@ -943,7 +941,7 @@ mod tests {
        #[test]
        fn checking_granter_permission() -> anyhow::Result<()> {
            let storage = NymPoolStorage::new();
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let granter = test.generate_account();
            test.add_granter(&granter);
@@ -959,7 +957,7 @@ mod tests {
        #[test]
        fn ensuring_granter_permission() -> anyhow::Result<()> {
            let storage = NymPoolStorage::new();
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let granter = test.generate_account();
            test.add_granter(&granter);
@@ -1049,7 +1047,7 @@ mod tests {

        #[test]
        fn attempting_to_load_grant() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let storage = NymPoolStorage::new();

            // doesn't exist...
@@ -1072,7 +1070,7 @@ mod tests {

        #[test]
        fn loading_grant() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let storage = NymPoolStorage::new();

            // doesn't exist...
@@ -1096,12 +1094,11 @@ mod tests {
        #[cfg(test)]
        mod adding_new_granter {
            use super::*;
-            use crate::testing::init_contract_tester;
            use cw_controllers::AdminError;

            #[test]
            fn can_only_be_performed_by_contract_admin() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1124,7 +1121,7 @@ mod tests {

            #[test]
            fn can_only_be_performed_if_account_is_not_already_a_granter() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1146,7 +1143,7 @@ mod tests {

            #[test]
            fn saves_basic_metadata() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1197,11 +1194,10 @@ mod tests {
        #[cfg(test)]
        mod removing_granter {
            use super::*;
-            use crate::testing::init_contract_tester;

            #[test]
            fn requires_granter_to_exist() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1221,7 +1217,7 @@ mod tests {

            #[test]
            fn can_only_be_performed_by_admin() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let random_address = test.generate_account();
@@ -1263,7 +1259,7 @@ mod tests {

            #[test]
            fn removes_it_from_granter_list() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1288,12 +1284,11 @@ mod tests {
        #[cfg(test)]
        mod adding_new_grant {
            use super::*;
-            use crate::testing::init_contract_tester;
            use nym_pool_contract_common::ClassicPeriodicAllowance;

            #[test]
            fn can_only_be_done_by_whitelisted_granter() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let not_valid_granter = test.generate_account();
@@ -1324,7 +1319,7 @@ mod tests {

            #[test]
            fn cant_be_done_if_grant_already_existed() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1345,7 +1340,7 @@ mod tests {

            #[test]
            fn only_accepts_valid_allowances() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                // allowance with 0 limit and wrong denom
@@ -1369,7 +1364,7 @@ mod tests {

            #[test]
            fn explicit_limit_cant_be_larger_than_available_tokens() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1406,7 +1401,7 @@ mod tests {
                assert!(res.is_ok());

                // and below the available
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let mut limit = available.clone();
                limit.amount -= Uint128::new(1);
                let allowance = Allowance::Basic(BasicAllowance {
@@ -1423,7 +1418,7 @@ mod tests {

            #[test]
            fn updates_allowances_initial_state_and_saves_it_to_storage() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1461,11 +1456,10 @@ mod tests {
        #[cfg(test)]
        mod spending_part_of_grant {
            use super::*;
-            use crate::testing::init_contract_tester;

            #[test]
            fn requires_grant_to_exist() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let grantee = test.generate_account();
@@ -1491,7 +1485,7 @@ mod tests {

            #[test]
            fn requires_grant_to_be_spendable() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1520,7 +1514,7 @@ mod tests {

            #[test]
            fn updates_stored_grant() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1554,7 +1548,7 @@ mod tests {

            #[test]
            fn removes_grant_from_storage_if_its_used_up() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1618,7 +1612,7 @@ mod tests {

        #[test]
        fn removing_grant() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let storage = NymPoolStorage::new();

            let grantee = test.generate_account();
@@ -1662,11 +1656,10 @@ mod tests {
        #[cfg(test)]
        mod revoking_grant {
            use super::*;
-            use crate::testing::init_contract_tester;

            #[test]
            fn requires_grant_to_exist() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1691,7 +1684,7 @@ mod tests {

            #[test]
            fn can_always_be_called_by_current_admin() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let grantee = test.add_dummy_grant().grantee;
@@ -1724,7 +1717,7 @@ mod tests {

            #[test]
            fn can_be_called_by_original_granter_if_its_still_whitelisted() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1768,7 +1761,7 @@ mod tests {

            #[test]
            fn removes_the_underlying_grant() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                let admin = test.admin_unchecked();
@@ -1787,12 +1780,10 @@ mod tests {
        #[cfg(test)]
        mod locking_part_of_allowance {
            use super::*;
-            use crate::testing::init_contract_tester;
-            use nym_contracts_common_testing::DenomExt;

            #[test]
            fn requires_providing_valid_coin() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let grantee = test.add_dummy_grant().grantee;

@@ -1813,7 +1804,7 @@ mod tests {

            #[test]
            fn requires_grant_to_exist() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let grantee = test.generate_account();
                let env = test.env();
@@ -1835,7 +1826,7 @@ mod tests {

            #[test]
            fn does_not_allow_locking_more_than_spend_limit() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let admin = test.admin_unchecked();
                let env = test.env();
@@ -1862,7 +1853,7 @@ mod tests {

            #[test]
            fn deducts_locked_amount_from_the_allowance() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let admin = test.admin_unchecked();
                let env = test.env();
@@ -1901,7 +1892,7 @@ mod tests {

            #[test]
            fn preserves_grant_even_if_resultant_allowance_is_zero() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let admin = test.admin_unchecked();
                let env = test.env();
@@ -1927,7 +1918,7 @@ mod tests {

            #[test]
            fn updates_internal_locked_counter() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let env = test.env();
                let grantee = test.add_dummy_grant().grantee;
@@ -1962,10 +1953,8 @@ mod tests {
        #[cfg(test)]
        mod unlocking_part_of_allowance {
            use super::*;
-            use crate::testing::{init_contract_tester, NymPoolContract};
-            use nym_contracts_common_testing::{ContractTester, DenomExt};

-            fn setup_locked_grant(test: &mut ContractTester<NymPoolContract>) -> Addr {
+            fn setup_locked_grant(test: &mut TestSetup) -> Addr {
                let grantee = test.add_dummy_grant().grantee;
                test.lock_allowance(&grantee, Uint128::new(100));
                grantee
@@ -1973,7 +1962,7 @@ mod tests {

            #[test]
            fn requires_providing_valid_coin() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let grantee = setup_locked_grant(&mut test);

@@ -1992,7 +1981,7 @@ mod tests {

            #[test]
            fn does_not_allow_unlocking_more_than_currently_locked() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let grantee = setup_locked_grant(&mut test);

@@ -2010,7 +1999,7 @@ mod tests {

            #[test]
            fn requires_grant_to_exist() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let grantee = test.generate_account();

@@ -2029,7 +2018,7 @@ mod tests {

            #[test]
            fn requires_having_locked_coins() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let grantee = test.add_dummy_grant().grantee;

@@ -2047,7 +2036,7 @@ mod tests {

            #[test]
            fn increases_internal_grant_spend_limit() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();
                let admin = test.admin_unchecked();
                let env = test.env();
@@ -2093,7 +2082,7 @@ mod tests {

            #[test]
            fn updates_internal_locked_counter() -> anyhow::Result<()> {
-                let mut test = init_contract_tester();
+                let mut test = TestSetup::init();
                let storage = NymPoolStorage::new();

                // 100tokens locked
@@ -2127,9 +2116,8 @@ mod tests {
    #[cfg(test)]
    mod locked_storage {
        use super::*;
-        use crate::testing::{init_contract_tester, NymPoolContractTesterExt};
+        use crate::testing::TestSetup;
        use cosmwasm_std::testing::mock_dependencies;
-        use nym_contracts_common_testing::{ContractOpts, RandExt};

        #[test]
        fn is_initialised_with_zero_total_locked() -> anyhow::Result<()> {
@@ -2148,7 +2136,7 @@ mod tests {

        #[test]
        fn getting_grantee_locked() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.generate_account();

            let storage = LockedStorage::new();
@@ -2179,7 +2167,7 @@ mod tests {

        #[test]
        fn getting_maybe_grantee_locked() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.generate_account();

            let storage = LockedStorage::new();
@@ -2210,7 +2198,7 @@ mod tests {

        #[test]
        fn locking_tokens() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let storage = LockedStorage::new();

            let grantee1 = test.generate_account();
@@ -2271,7 +2259,7 @@ mod tests {

        #[test]
        fn unlocking_tokens() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let storage = LockedStorage::new();

            let grantee1 = test.generate_account();
@@ -1,70 +1,226 @@
 // Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::contract;
 use crate::contract::{execute, instantiate, migrate, query};
 use crate::storage::NYM_POOL_STORAGE;
-use cosmwasm_std::{Addr, Order, Uint128};
-use nym_contracts_common_testing::{
-    AdminExt, ChainOpts, CommonStorageKeys, ContractFn, ContractOpts, ContractTester, DenomExt,
-    PermissionedFn, QueryFn, RandExt, TestableNymContract,
+use crate::testing::storage::{ContractStorageWrapper, StorageWrapper};
+use cosmwasm_std::testing::{message_info, mock_env, MockApi, MockQuerier, MockStorage};
+use cosmwasm_std::{
+    coin, coins, Addr, Coin, ContractInfo, Deps, DepsMut, Empty, Env, MemoryStorage, MessageInfo,
+    Order, OwnedDeps, Response, StdResult, Storage, Uint128,
+};
+use cw_multi_test::{
+    next_block, App, AppBuilder, AppResponse, BankKeeper, Contract, ContractWrapper, Executor,
 };
-use nym_pool_contract_common::constants::storage_keys;
 use nym_pool_contract_common::{
-    Allowance, BasicAllowance, ExecuteMsg, Grant, InstantiateMsg, MigrateMsg, NymPoolContractError,
-    QueryMsg,
+    Allowance, BasicAllowance, ExecuteMsg, Grant, InstantiateMsg, NymPoolContractError, QueryMsg,
 };
+use rand::{RngCore, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+use serde::de::DeserializeOwned;
 use std::collections::HashMap;

-pub use nym_contracts_common_testing::TEST_DENOM;
+mod storage;

-pub struct NymPoolContract;
+pub fn test_rng() -> ChaCha20Rng {
+    let dummy_seed = [42u8; 32];
+    ChaCha20Rng::from_seed(dummy_seed)
+}

-impl TestableNymContract for NymPoolContract {
-    const NAME: &'static str = "nym-pool-contract";
-    type InitMsg = InstantiateMsg;
-    type ExecuteMsg = ExecuteMsg;
-    type QueryMsg = QueryMsg;
-    type MigrateMsg = MigrateMsg;
-    type ContractError = NymPoolContractError;
-
-    fn instantiate() -> ContractFn<Self::InitMsg, Self::ContractError> {
-        instantiate
+pub fn deps_with_balance(env: &Env) -> OwnedDeps<MemoryStorage, MockApi, MockQuerier<Empty>> {
+    OwnedDeps {
+        storage: MockStorage::default(),
+        api: MockApi::default(),
+        querier: MockQuerier::<Empty>::new(&[(
+            env.contract.address.as_str(),
+            coins(100000000000, TEST_DENOM).as_slice(),
+        )]),
+        custom_query_type: Default::default(),
    }
+}

-    fn execute() -> ContractFn<Self::ExecuteMsg, Self::ContractError> {
-        execute
-    }
+pub const TEST_DENOM: &str = "unym";

-    fn query() -> QueryFn<Self::QueryMsg, Self::ContractError> {
-        query
-    }
+pub struct TestSetup {
+    pub app: App<BankKeeper, MockApi, StorageWrapper>,
+    pub rng: ChaCha20Rng,
+    pub contract_address: Addr,
+    pub master_address: Addr,
+    pub(crate) storage: ContractStorageWrapper,
+}

-    fn migrate() -> PermissionedFn<Self::MigrateMsg, Self::ContractError> {
-        migrate
-    }
+pub fn contract() -> Box<dyn Contract<Empty>> {
+    let contract = ContractWrapper::new(execute, instantiate, query).with_migrate(migrate);
+    Box::new(contract)
+}

-    fn base_init_msg() -> Self::InitMsg {
-        InstantiateMsg {
-            pool_denomination: TEST_DENOM.to_string(),
-            grants: Default::default(),
+impl TestSetup {
+    pub fn init() -> TestSetup {
+        let storage = StorageWrapper::new();
+
+        let api = MockApi::default().with_prefix("n");
+        let master_address = api.addr_make("master-owner");
+
+        let mut app = AppBuilder::new()
+            .with_api(api)
+            .with_storage(storage.clone())
+            .build(|router, _api, storage| {
+                router
+                    .bank
+                    .init_balance(
+                        storage,
+                        &master_address,
+                        coins(1000000000000000, TEST_DENOM),
+                    )
+                    .unwrap()
+            });
+        let code_id = app.store_code(contract());
+        let contract_address = app
+            .instantiate_contract(
+                code_id,
+                master_address.clone(),
+                &InstantiateMsg {
+                    pool_denomination: TEST_DENOM.to_string(),
+                    grants: Default::default(),
+                },
+                &[],
+                "nym-pool-contract",
+                Some(master_address.to_string()),
+            )
+            .unwrap();
+
+        // send some tokens to the contract
+        app.send_tokens(
+            master_address.clone(),
+            contract_address.clone(),
+            &[coin(100000000, TEST_DENOM)],
+        )
+        .unwrap();
+
+        TestSetup {
+            app,
+            rng: test_rng(),
+            storage: storage.contract_storage_wrapper(&contract_address),
+            contract_address,
+            master_address,
        }
    }
-}

-pub fn init_contract_tester() -> ContractTester<NymPoolContract> {
-    NymPoolContract::init()
-        .with_common_storage_key(CommonStorageKeys::Admin, storage_keys::CONTRACT_ADMIN)
-        .with_common_storage_key(CommonStorageKeys::Denom, storage_keys::POOL_DENOMINATION)
-}
+    pub fn set_contract_balance(&mut self, balance: Coin) {
+        let contract_address = &self.contract_address;
+        self.app
+            .router()
+            .bank
+            .init_balance(
+                &mut self.storage.inner_storage(),
+                contract_address,
+                vec![balance],
+            )
+            .unwrap();
+    }

-pub trait NymPoolContractTesterExt:
-    ContractOpts<ExecuteMsg = ExecuteMsg, QueryMsg = QueryMsg, ContractError = NymPoolContractError>
-    + ChainOpts
-    + AdminExt
-    + DenomExt
-    + RandExt
-{
-    fn change_admin(&mut self, new_admin: &Addr) {
+    pub fn deps(&self) -> Deps<'_> {
+        Deps {
+            storage: &self.storage,
+            api: self.app.api(),
+            querier: self.app.wrap(),
+        }
+    }
+
+    pub fn deps_mut(&mut self) -> DepsMut<'_> {
+        DepsMut {
+            storage: &mut self.storage,
+            api: self.app.api(),
+            querier: self.app.wrap(),
+        }
+    }
+
+    pub fn deps_mut_env(&mut self) -> (DepsMut<'_>, Env) {
+        let env = self.env().clone();
+        (self.deps_mut(), env)
+    }
+
+    pub fn storage(&self) -> &dyn Storage {
+        &self.storage
+    }
+
+    pub fn storage_mut(&mut self) -> &mut dyn Storage {
+        &mut self.storage
+    }
+
+    pub fn env(&self) -> Env {
+        Env {
+            block: self.app.block_info(),
+            contract: ContractInfo {
+                address: self.contract_address.clone(),
+            },
+            ..mock_env()
+        }
+    }
+
+    pub fn next_block(&mut self) {
+        self.app.update_block(next_block)
+    }
+
+    pub fn execute_raw(
+        &mut self,
+        sender: Addr,
+        message: ExecuteMsg,
+    ) -> Result<Response, NymPoolContractError> {
+        self.execute_raw_with_balance(sender, &[], message)
+    }
+
+    pub fn execute_raw_with_balance(
+        &mut self,
+        sender: Addr,
+        coins: &[Coin],
+        message: ExecuteMsg,
+    ) -> Result<Response, NymPoolContractError> {
+        let env = self.env();
+        let info = message_info(&sender, coins);
+        contract::execute(self.deps_mut(), env, info, message)
+    }
+
+    pub fn execute_msg(
+        &mut self,
+        sender: Addr,
+        message: &ExecuteMsg,
+    ) -> anyhow::Result<AppResponse> {
+        self.execute_msg_with_balance(sender, &[], message)
+    }
+
+    pub fn execute_msg_with_balance(
+        &mut self,
+        sender: Addr,
+        coins: &[Coin],
+        message: &ExecuteMsg,
+    ) -> anyhow::Result<AppResponse> {
+        self.app
+            .execute_contract(sender, self.contract_address.clone(), message, coins)
+    }
+
+    pub fn query<T: DeserializeOwned>(&self, message: &QueryMsg) -> StdResult<T> {
+        self.app
+            .wrap()
+            .query_wasm_smart(self.contract_address.as_str(), message)
+    }
+
+    pub fn generate_account(&mut self) -> Addr {
+        self.app
+            .api()
+            .addr_make(&format!("foomp{}", self.rng.next_u64()))
+    }
+
+    pub fn admin_unchecked(&self) -> Addr {
+        NYM_POOL_STORAGE
+            .contract_admin
+            .get(self.deps())
+            .unwrap()
+            .unwrap()
+    }
+
+    pub fn change_admin(&mut self, new_admin: &Addr) {
        self.execute_msg(
            self.admin_unchecked(),
            &ExecuteMsg::UpdateAdmin {
@@ -75,14 +231,33 @@ pub trait NymPoolContractTesterExt:
        .unwrap();
    }

+    pub fn admin_msg(&self) -> MessageInfo {
+        message_info(&self.admin_unchecked(), &[])
+    }
+
+    pub fn denom(&self) -> String {
+        NYM_POOL_STORAGE
+            .pool_denomination
+            .load(self.storage())
+            .unwrap()
+    }
+
+    pub fn coin(&self, amount: u128) -> Coin {
+        coin(amount, self.denom())
+    }
+
+    pub fn coins(&self, amount: u128) -> Vec<Coin> {
+        coins(amount, self.denom())
+    }
+
    #[track_caller]
-    fn add_dummy_grant(&mut self) -> Grant {
+    pub fn add_dummy_grant(&mut self) -> Grant {
        let grantee = self.generate_account();
        self.add_dummy_grant_for(&grantee)
    }

    #[track_caller]
-    fn add_dummy_grant_for(&mut self, grantee: impl Into<String>) -> Grant {
+    pub fn add_dummy_grant_for(&mut self, grantee: impl Into<String>) -> Grant {
        let grantee = Addr::unchecked(grantee);
        let granter = self.admin_unchecked();
        let env = self.env();
@@ -100,18 +275,23 @@ pub trait NymPoolContractTesterExt:
    }

    #[track_caller]
-    fn lock_allowance(&mut self, grantee: impl Into<String>, amount: impl Into<Uint128>) {
+    pub fn lock_allowance(&mut self, grantee: impl Into<String>, amount: impl Into<Uint128>) {
+        let denom = NYM_POOL_STORAGE
+            .pool_denomination
+            .load(self.deps().storage)
+            .unwrap();
+
        self.execute_msg(
            Addr::unchecked(grantee),
            &ExecuteMsg::LockAllowance {
-                amount: self.coin(amount.into().u128()),
+                amount: coin(amount.into().u128(), denom),
            },
        )
        .unwrap();
    }

    #[track_caller]
-    fn full_locked_map(&self) -> HashMap<Addr, Uint128> {
+    pub fn full_locked_map(&self) -> HashMap<Addr, Uint128> {
        NYM_POOL_STORAGE
            .locked
            .grantees
@@ -121,7 +301,7 @@ pub trait NymPoolContractTesterExt:
    }

    #[track_caller]
-    fn add_granter(&mut self, granter: &Addr) {
+    pub fn add_granter(&mut self, granter: &Addr) {
        let env = self.env();
        let admin = self.admin_unchecked();
        NYM_POOL_STORAGE
@@ -129,5 +309,3 @@ pub trait NymPoolContractTesterExt:
            .unwrap();
    }
 }
-
-impl NymPoolContractTesterExt for ContractTester<NymPoolContract> {}
@@ -11,7 +11,7 @@ use std::rc::Rc;
 pub struct StorageWrapper(Rc<RefCell<MemoryStorage>>);

 impl StorageWrapper {
-    pub fn contract_storage_wrapper(&self, contract: &Addr) -> ContractStorageWrapper {
+    pub(super) fn contract_storage_wrapper(&self, contract: &Addr) -> ContractStorageWrapper {
        ContractStorageWrapper {
            address: contract.clone(),
            inner: self.clone(),
@@ -24,7 +24,7 @@ impl StorageWrapper {
 }

 #[derive(Debug, Clone)]
-pub struct ContractStorageWrapper {
+pub(crate) struct ContractStorageWrapper {
    address: Addr,
    inner: StorageWrapper,
 }
@@ -33,22 +33,6 @@ impl ContractStorageWrapper {
    pub fn inner_storage(&self) -> StorageWrapper {
        self.inner.clone()
    }
-
-    pub fn as_inner_storage(&self) -> &StorageWrapper {
-        &self.inner
-    }
-
-    pub fn as_inner_storage_mut(&mut self) -> &mut StorageWrapper {
-        &mut self.inner
-    }
-
-    #[must_use = "this returns the result of the operation, without modifying the original"]
-    pub fn change_contract(&self, contract: &Addr) -> Self {
-        ContractStorageWrapper {
-            address: contract.clone(),
-            inner: self.inner.clone(),
-        }
-    }
 }

 impl Storage for StorageWrapper {
@@ -262,22 +262,21 @@ pub fn try_remove_expired(
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::testing::{init_contract_tester, NymPoolContractTesterExt};
-    use nym_contracts_common_testing::{AdminExt, ContractOpts, DenomExt, RandExt};
+    use crate::testing::TestSetup;
    use nym_pool_contract_common::ExecuteMsg;

    #[cfg(test)]
    mod updating_contract_admin {
        use super::*;
+        use crate::testing::TestSetup;
        use cosmwasm_std::{Deps, Order};
        use cw_controllers::AdminError;
-        use nym_contracts_common_testing::{AdminExt, RandExt};
        use nym_pool_contract_common::{ExecuteMsg, GranterAddress, GranterInformation};
        use std::collections::HashMap;

        #[test]
        fn can_only_be_performed_by_current_admin() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let random_acc = test.generate_account();
            let new_admin = test.generate_account();
@@ -311,7 +310,7 @@ mod tests {

        #[test]
        fn requires_providing_valid_address() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let bad_account = "definitely-not-valid-account";
            let res = test.execute_raw(
@@ -348,7 +347,7 @@ mod tests {
                    .collect()
            }

-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let current_admin = test.admin_unchecked();
            let new_admin = test.generate_account();

@@ -370,7 +369,7 @@ mod tests {
            //
            //

-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let current_admin = test.admin_unchecked();
            let new_admin = test.generate_account();
            let old_granters = granters(test.deps());
@@ -393,13 +392,13 @@ mod tests {
    #[cfg(test)]
    mod granting_allowance {
        use super::*;
+        use crate::testing::TestSetup;
        use cosmwasm_std::StdError;
-        use nym_contracts_common_testing::{AdminExt, RandExt};
        use nym_pool_contract_common::BasicAllowance;

        #[test]
        fn requires_providing_valid_grantee_address() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let env = test.env();
            let admin = test.admin_msg();
@@ -434,12 +433,12 @@ mod tests {
    #[cfg(test)]
    mod revoking_allowance {
        use super::*;
+        use crate::testing::TestSetup;
        use cosmwasm_std::StdError;
-        use nym_contracts_common_testing::{AdminExt, RandExt};

        #[test]
        fn requires_providing_valid_grantee_address() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let env = test.env();
            let admin = test.admin_msg();
@@ -488,12 +487,12 @@ mod tests {
    #[cfg(test)]
    mod using_allowance {
        use super::*;
-        use nym_contracts_common_testing::{AdminExt, ChainOpts, RandExt};
+        use crate::testing::TestSetup;
        use nym_pool_contract_common::{BasicAllowance, ExecuteMsg};

        #[test]
        fn requires_at_least_a_single_coin_receiver() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;

            let res = test.execute_raw(grantee, ExecuteMsg::UseAllowance { recipients: vec![] });
@@ -505,7 +504,7 @@ mod tests {
        #[test]
        fn requires_valid_coin_for_each_receiver() -> anyhow::Result<()> {
            // 1 bad receiver
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;

            let res = test.execute_raw(
@@ -520,7 +519,7 @@ mod tests {
            assert!(res.is_err());

            // 3 receivers, one invalid
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;

            let addr1 = test.generate_account();
@@ -548,7 +547,7 @@ mod tests {
            assert!(res.is_err());

            // all fine
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;

            let res = test.execute_raw(
@@ -577,7 +576,7 @@ mod tests {

        #[test]
        fn requires_the_total_to_be_available_for_spending() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let recipient = test.generate_account();

            // contract balance < required
@@ -666,7 +665,7 @@ mod tests {

        #[test]
        fn requires_the_total_to_be_within_spend_limit() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let allowance = Allowance::Basic(BasicAllowance {
                spend_limit: Some(test.coin(100)),
                expiration_unix_timestamp: None,
@@ -713,7 +712,7 @@ mod tests {

        #[test]
        fn attaches_appropriate_bank_message_for_each_receiver() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let grantee = test.add_dummy_grant().grantee;

@@ -775,7 +774,7 @@ mod tests {

        #[test]
        fn requires_grant_to_not_be_expired() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let env = test.env();
            let allowance = Allowance::Basic(BasicAllowance {
                spend_limit: None,
@@ -811,14 +810,13 @@ mod tests {
    #[cfg(test)]
    mod withdrawing_from_allowance {
        use super::*;
-        use crate::testing::{init_contract_tester, NymPoolContractTesterExt};
+        use crate::testing::TestSetup;
        use cosmwasm_std::coin;
-        use nym_contracts_common_testing::{AdminExt, ChainOpts, ContractOpts, DenomExt, RandExt};
        use nym_pool_contract_common::{BasicAllowance, ExecuteMsg};

        #[test]
        fn requires_valid_coin() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;

            let res = test.execute_raw(
@@ -850,7 +848,7 @@ mod tests {

        #[test]
        fn requires_the_amount_to_be_available_for_spending() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            // contract balance < required
            let grantee = test.add_dummy_grant().grantee;
@@ -914,7 +912,7 @@ mod tests {

        #[test]
        fn requires_the_amount_to_be_within_spend_limit() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let allowance = Allowance::Basic(BasicAllowance {
                spend_limit: Some(test.coin(100)),
                expiration_unix_timestamp: None,
@@ -954,7 +952,7 @@ mod tests {

        #[test]
        fn attaches_appropriate_bank_message() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let grantee = test.add_dummy_grant().grantee;

@@ -980,7 +978,7 @@ mod tests {

        #[test]
        fn requires_grant_to_not_be_expired() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let env = test.env();
            let allowance = Allowance::Basic(BasicAllowance {
                spend_limit: None,
@@ -1013,7 +1011,7 @@ mod tests {
    #[test]
    fn locking_allowance() -> anyhow::Result<()> {
        // internals got tested in storage tests, so this is mostly about checking events (TODO)
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();
        let grantee = test.add_dummy_grant().grantee;

        let res = test.execute_raw(
@@ -1037,7 +1035,7 @@ mod tests {
    #[test]
    fn unlocking_allowance() -> anyhow::Result<()> {
        // internals got tested in storage tests, so this is mostly about checking events (TODO)
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();
        let grantee = test.add_dummy_grant().grantee;
        test.lock_allowance(&grantee, Uint128::new(100));

@@ -1062,12 +1060,11 @@ mod tests {
    #[cfg(test)]
    mod using_locked_allowance {
        use super::*;
-        use nym_contracts_common_testing::{AdminExt, ChainOpts, RandExt};
        use nym_pool_contract_common::BasicAllowance;

        #[test]
        fn requires_at_least_a_single_coin_receiver() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;

            let res = test.execute_raw(
@@ -1082,7 +1079,7 @@ mod tests {
        #[test]
        fn requires_valid_coin_for_each_receiver() -> anyhow::Result<()> {
            // 1 bad receiver
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(10000));

@@ -1098,7 +1095,7 @@ mod tests {
            assert!(res.is_err());

            // 3 receivers, one invalid
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(10000));

@@ -1127,7 +1124,7 @@ mod tests {
            assert!(res.is_err());

            // all fine
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(10000));

@@ -1157,7 +1154,7 @@ mod tests {

        #[test]
        fn requires_the_total_to_be_locked_by_grantee() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(100));

@@ -1196,7 +1193,7 @@ mod tests {

        #[test]
        fn attaches_appropriate_bank_message_for_each_receiver() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(10000));
@@ -1259,7 +1256,7 @@ mod tests {

        #[test]
        fn requires_grant_to_not_be_expired() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let env = test.env();
            let allowance = Allowance::Basic(BasicAllowance {
                spend_limit: None,
@@ -1297,12 +1294,11 @@ mod tests {
    mod withdrawing_from_locked_allowance {
        use super::*;
        use cosmwasm_std::coin;
-        use nym_contracts_common_testing::{AdminExt, ChainOpts, RandExt};
        use nym_pool_contract_common::BasicAllowance;

        #[test]
        fn requires_valid_coin() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(10000));

@@ -1335,7 +1331,7 @@ mod tests {

        #[test]
        fn attaches_appropriate_bank_message() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();

            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(10000));
@@ -1362,7 +1358,7 @@ mod tests {

        #[test]
        fn requires_grant_to_not_be_expired() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let env = test.env();
            let allowance = Allowance::Basic(BasicAllowance {
                spend_limit: None,
@@ -1395,7 +1391,7 @@ mod tests {

        #[test]
        fn requires_the_amount_to_be_locked_by_grantee() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let grantee = test.add_dummy_grant().grantee;
            test.lock_allowance(&grantee, Uint128::new(100));

@@ -1428,7 +1424,7 @@ mod tests {

    #[test]
    fn adding_new_granter() -> anyhow::Result<()> {
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();
        let bad_address = "foomp";
        let good_address = test.generate_account();

@@ -1460,7 +1456,7 @@ mod tests {

    #[test]
    fn revoking_granter() -> anyhow::Result<()> {
-        let mut test = init_contract_tester();
+        let mut test = TestSetup::init();
        let bad_address = "foomp";
        let good_address = test.generate_account();
        let granter_address = test.generate_account();
@@ -1504,12 +1500,10 @@ mod tests {
    #[cfg(test)]
    mod removing_expired {
        use super::*;
-        use crate::testing::{init_contract_tester, NymPoolContract, NymPoolContractTesterExt};
-        use nym_contracts_common_testing::{ChainOpts, ContractOpts, ContractTester, RandExt};
        use nym_pool_contract_common::{BasicAllowance, GranteeAddress};

-        fn setup_with_expired_grant() -> (ContractTester<NymPoolContract>, GranteeAddress) {
-            let mut test = init_contract_tester();
+        fn setup_with_expired_grant() -> (TestSetup, GranteeAddress) {
+            let mut test = TestSetup::init();
            let env = test.env();
            let allowance = Allowance::Basic(BasicAllowance {
                spend_limit: None,
@@ -1549,7 +1543,7 @@ mod tests {

        #[test]
        fn requires_grant_to_actually_exist_and_be_expired() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
+            let mut test = TestSetup::init();
            let sender = test.generate_account();
            let grantee = test.add_dummy_grant().grantee;
            let not_grantee = test.generate_account();
@@ -1,4 +0,0 @@
-[alias]
-wasm = "build --release --lib --target wasm32-unknown-unknown"
-unit-test = "test --lib"
-schema = "run --bin schema --features=schema-gen"
@@ -1,42 +0,0 @@
-[package]
-name = "nym-performance-contract"
-version = "0.1.0"
-authors.workspace = true
-repository.workspace = true
-homepage.workspace = true
-documentation.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[[bin]]
-name = "schema"
-required-features = ["schema-gen"]
-
-[lib]
-name = "nym_performance_contract"
-crate-type = ["cdylib", "rlib"]
-
-[dependencies]
-cosmwasm-std = { workspace = true }
-cw2 = { workspace = true }
-cw-storage-plus = { workspace = true }
-cw-controllers = { workspace = true }
-serde = { workspace = true }
-
-cosmwasm-schema = { workspace = true, optional = true }
-
-nym-contracts-common = { path = "../../common/cosmwasm-smart-contracts/contracts-common" }
-nym-performance-contract-common = { path = "../../common/cosmwasm-smart-contracts/nym-performance-contract" }
-nym-mixnet-contract-common = { path = "../../common/cosmwasm-smart-contracts/mixnet-contract" }
-
-[dev-dependencies]
-anyhow = { workspace = true }
-nym-contracts-common-testing = { path = "../../common/cosmwasm-smart-contracts/contracts-common-testing" }
-nym-mixnet-contract = { path = "../mixnet", features = ["testable-mixnet-contract"] }
-nym-crypto = { path = "../../common/crypto", features = ["asymmetric", "rand"] }
-
-[features]
-schema-gen = ["nym-performance-contract-common/schema", "cosmwasm-schema"]
-
-[lints]
-workspace = true
@@ -1,5 +0,0 @@
-wasm:
-	RUSTFLAGS='-C link-arg=-s' cargo build --release --target wasm32-unknown-unknown
-
-generate-schema:
-	cargo schema
@@ -1,14 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::write_api;
-use nym_performance_contract_common::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
-
-fn main() {
-    write_api! {
-        instantiate: InstantiateMsg,
-        query: QueryMsg,
-        execute: ExecuteMsg,
-        migrate: MigrateMsg,
-    }
-}
@@ -1,187 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::queries::{
-    query_admin, query_epoch_measurements_paged, query_epoch_performance_paged,
-    query_full_historical_performance_paged, query_network_monitor_details,
-    query_network_monitors_paged, query_node_measurements, query_node_performance,
-    query_node_performance_paged, query_retired_network_monitors_paged,
-};
-use crate::storage::NYM_PERFORMANCE_CONTRACT_STORAGE;
-use crate::transactions::{
-    try_authorise_network_monitor, try_batch_submit_performance_results,
-    try_remove_epoch_measurements, try_remove_node_measurements, try_retire_network_monitor,
-    try_submit_performance_results, try_update_contract_admin,
-};
-use cosmwasm_std::{
-    entry_point, to_json_binary, Binary, Deps, DepsMut, Env, MessageInfo, Response,
-};
-use nym_contracts_common::set_build_information;
-use nym_performance_contract_common::{
-    ExecuteMsg, InstantiateMsg, MigrateMsg, NymPerformanceContractError, QueryMsg,
-};
-
-const CONTRACT_NAME: &str = "crate:nym-performance-contract";
-const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");
-
-#[entry_point]
-pub fn instantiate(
-    deps: DepsMut,
-    env: Env,
-    info: MessageInfo,
-    msg: InstantiateMsg,
-) -> Result<Response, NymPerformanceContractError> {
-    cw2::set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
-    set_build_information!(deps.storage)?;
-
-    let mixnet_contract_address = deps.api.addr_validate(&msg.mixnet_contract_address)?;
-
-    NYM_PERFORMANCE_CONTRACT_STORAGE.initialise(
-        deps,
-        env,
-        info.sender,
-        mixnet_contract_address.clone(),
-        msg.authorised_network_monitors,
-    )?;
-
-    Ok(Response::default())
-}
-
-#[entry_point]
-pub fn execute(
-    deps: DepsMut,
-    env: Env,
-    info: MessageInfo,
-    msg: ExecuteMsg,
-) -> Result<Response, NymPerformanceContractError> {
-    match msg {
-        ExecuteMsg::UpdateAdmin { admin } => try_update_contract_admin(deps, info, admin),
-        ExecuteMsg::Submit { epoch, data } => {
-            try_submit_performance_results(deps, info, epoch, data)
-        }
-        ExecuteMsg::BatchSubmit { epoch, data } => {
-            try_batch_submit_performance_results(deps, info, epoch, data)
-        }
-        ExecuteMsg::AuthoriseNetworkMonitor { address } => {
-            try_authorise_network_monitor(deps, env, info, address)
-        }
-        ExecuteMsg::RetireNetworkMonitor { address } => {
-            try_retire_network_monitor(deps, env, info, address)
-        }
-        ExecuteMsg::RemoveNodeMeasurements { epoch_id, node_id } => {
-            try_remove_node_measurements(deps, info, epoch_id, node_id)
-        }
-        ExecuteMsg::RemoveEpochMeasurements { epoch_id } => {
-            try_remove_epoch_measurements(deps, info, epoch_id)
-        }
-    }
-}
-
-#[entry_point]
-pub fn query(deps: Deps, _: Env, msg: QueryMsg) -> Result<Binary, NymPerformanceContractError> {
-    match msg {
-        QueryMsg::Admin {} => Ok(to_json_binary(&query_admin(deps)?)?),
-        QueryMsg::NodePerformance { epoch_id, node_id } => Ok(to_json_binary(
-            &query_node_performance(deps, epoch_id, node_id)?,
-        )?),
-        QueryMsg::NodePerformancePaged {
-            node_id,
-            start_after,
-            limit,
-        } => Ok(to_json_binary(&query_node_performance_paged(
-            deps,
-            node_id,
-            start_after,
-            limit,
-        )?)?),
-        QueryMsg::EpochPerformancePaged {
-            epoch_id,
-            start_after,
-            limit,
-        } => Ok(to_json_binary(&query_epoch_performance_paged(
-            deps,
-            epoch_id,
-            start_after,
-            limit,
-        )?)?),
-        QueryMsg::FullHistoricalPerformancePaged { start_after, limit } => Ok(to_json_binary(
-            &query_full_historical_performance_paged(deps, start_after, limit)?,
-        )?),
-        QueryMsg::NetworkMonitor { address } => Ok(to_json_binary(
-            &query_network_monitor_details(deps, address)?,
-        )?),
-        QueryMsg::NetworkMonitorsPaged { start_after, limit } => Ok(to_json_binary(
-            &query_network_monitors_paged(deps, start_after, limit)?,
-        )?),
-        QueryMsg::RetiredNetworkMonitorsPaged { start_after, limit } => Ok(to_json_binary(
-            &query_retired_network_monitors_paged(deps, start_after, limit)?,
-        )?),
-        QueryMsg::NodeMeasurements { epoch_id, node_id } => Ok(to_json_binary(
-            &query_node_measurements(deps, epoch_id, node_id)?,
-        )?),
-        QueryMsg::EpochMeasurementsPaged {
-            epoch_id,
-            start_after,
-            limit,
-        } => Ok(to_json_binary(&query_epoch_measurements_paged(
-            deps,
-            epoch_id,
-            start_after,
-            limit,
-        )?)?),
-    }
-}
-
-#[entry_point]
-pub fn migrate(
-    deps: DepsMut,
-    _: Env,
-    _msg: MigrateMsg,
-) -> Result<Response, NymPerformanceContractError> {
-    set_build_information!(deps.storage)?;
-    cw2::ensure_from_older_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;
-
-    Ok(Default::default())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[cfg(test)]
-    mod contract_instantiation {
-        use super::*;
-        use crate::storage::NYM_PERFORMANCE_CONTRACT_STORAGE;
-        use crate::testing::PreInitContract;
-        use cosmwasm_std::testing::message_info;
-
-        #[test]
-        fn sets_contract_admin_to_the_message_sender() -> anyhow::Result<()> {
-            // we need to mock dependencies in a state where mixnet contract has already been instantiated
-            // (we query it at init)
-            let mut pre_init = PreInitContract::new();
-            let env = pre_init.env();
-            let mixnet_contract_address = pre_init.mixnet_contract_address.to_string();
-            let some_sender = pre_init.addr_make("some_sender");
-            let deps = pre_init.deps_mut();
-
-            instantiate(
-                deps,
-                env,
-                message_info(&some_sender, &[]),
-                InstantiateMsg {
-                    mixnet_contract_address,
-                    authorised_network_monitors: vec![],
-                },
-            )?;
-
-            let deps = pre_init.deps();
-
-            NYM_PERFORMANCE_CONTRACT_STORAGE
-                .contract_admin
-                .assert_admin(deps, &some_sender)?;
-
-            Ok(())
-        }
-    }
-}
@@ -1,118 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_std::{from_json, Binary, CustomQuery, QuerierWrapper, StdError, StdResult};
-use cw_storage_plus::{Key, Namespace, Path, PrimaryKey};
-use nym_mixnet_contract_common::{Interval, MixNodeBond, NymNodeBond};
-use nym_performance_contract_common::{EpochId, NodeId};
-use serde::de::DeserializeOwned;
-use std::ops::Deref;
-
-pub(crate) trait MixnetContractQuerier {
-    #[allow(dead_code)]
-    fn query_mixnet_contract<T: DeserializeOwned>(
-        &self,
-        address: impl Into<String>,
-        msg: &nym_mixnet_contract_common::QueryMsg,
-    ) -> StdResult<T>;
-
-    fn query_mixnet_contract_storage(
-        &self,
-        address: impl Into<String>,
-        key: impl Into<Binary>,
-    ) -> StdResult<Option<Vec<u8>>>;
-
-    fn query_mixnet_contract_storage_value<T: DeserializeOwned>(
-        &self,
-        address: impl Into<String>,
-        key: impl Into<Binary>,
-    ) -> StdResult<Option<T>> {
-        match self.query_mixnet_contract_storage(address, key)? {
-            None => Ok(None),
-            Some(value) => Ok(Some(from_json(&value)?)),
-        }
-    }
-
-    fn query_current_mixnet_interval(&self, address: impl Into<String>) -> StdResult<Interval> {
-        self.query_mixnet_contract_storage_value(address, b"ci")?
-            .ok_or(StdError::not_found(
-                "unable to retrieve interval information from the mixnet contract storage",
-            ))
-    }
-
-    fn query_current_absolute_mixnet_epoch_id(
-        &self,
-        address: impl Into<String>,
-    ) -> StdResult<EpochId> {
-        self.query_current_mixnet_interval(address)
-            .map(|interval| interval.current_epoch_absolute_id())
-    }
-
-    fn check_node_existence(&self, address: impl Into<String>, node_id: NodeId) -> StdResult<bool> {
-        let mixnet_contract_address = address.into();
-
-        // 1. check if it's a nym-node
-        if let Some(nym_node) = self.query_nymnode_bond(mixnet_contract_address.clone(), node_id)? {
-            return Ok(!nym_node.is_unbonding);
-        }
-
-        // 2. try a legacy mixnode
-        if let Some(nym_node) = self.query_mixnode_bond(mixnet_contract_address, node_id)? {
-            return Ok(!nym_node.is_unbonding);
-        }
-        Ok(false)
-    }
-
-    fn query_nymnode_bond(
-        &self,
-        address: impl Into<String>,
-        node_id: NodeId,
-    ) -> StdResult<Option<NymNodeBond>> {
-        // construct proper map key
-        let pk_namespace = "nn";
-        let path: Path<NymNodeBond> = Path::new(
-            Namespace::from_static_str(pk_namespace).as_slice(),
-            &node_id.key().iter().map(Key::as_ref).collect::<Vec<_>>(),
-        );
-        let storage_key = path.deref();
-
-        self.query_mixnet_contract_storage_value(address, storage_key)
-    }
-
-    fn query_mixnode_bond(
-        &self,
-        address: impl Into<String>,
-        node_id: NodeId,
-    ) -> StdResult<Option<MixNodeBond>> {
-        // construct proper map key
-        let pk_namespace = "mnn";
-        let path: Path<MixNodeBond> = Path::new(
-            Namespace::from_static_str(pk_namespace).as_slice(),
-            &node_id.key().iter().map(Key::as_ref).collect::<Vec<_>>(),
-        );
-        let storage_key = path.deref();
-
-        self.query_mixnet_contract_storage_value(address, storage_key)
-    }
-}
-
-impl<C> MixnetContractQuerier for QuerierWrapper<'_, C>
-where
-    C: CustomQuery,
-{
-    fn query_mixnet_contract<T: DeserializeOwned>(
-        &self,
-        address: impl Into<String>,
-        msg: &nym_mixnet_contract_common::QueryMsg,
-    ) -> StdResult<T> {
-        self.query_wasm_smart(address, msg)
-    }
-
-    fn query_mixnet_contract_storage(
-        &self,
-        address: impl Into<String>,
-        key: impl Into<Binary>,
-    ) -> StdResult<Option<Vec<u8>>> {
-        self.query_wasm_raw(address, key)
-    }
-}
@@ -1,13 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod contract;
-pub mod queued_migrations;
-pub mod storage;
-
-mod helpers;
-mod queries;
-mod transactions;
-
-#[cfg(test)]
-pub mod testing;
@@ -1,588 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::storage::{retrieval_limits, NYM_PERFORMANCE_CONTRACT_STORAGE};
-use cosmwasm_std::{Addr, Deps, Order, StdResult};
-use cw_controllers::AdminResponse;
-use cw_storage_plus::Bound;
-use nym_performance_contract_common::{
-    EpochId, EpochMeasurementsPagedResponse, EpochNodePerformance, EpochPerformancePagedResponse,
-    FullHistoricalPerformancePagedResponse, HistoricalPerformance, NetworkMonitorInformation,
-    NetworkMonitorResponse, NetworkMonitorsPagedResponse, NodeId, NodeMeasurement,
-    NodeMeasurementsResponse, NodePerformance, NodePerformancePagedResponse,
-    NodePerformanceResponse, NymPerformanceContractError, RetiredNetworkMonitorsPagedResponse,
-};
-
-pub fn query_admin(deps: Deps) -> Result<AdminResponse, NymPerformanceContractError> {
-    NYM_PERFORMANCE_CONTRACT_STORAGE
-        .contract_admin
-        .query_admin(deps)
-        .map_err(Into::into)
-}
-
-pub fn query_node_performance(
-    deps: Deps,
-    epoch_id: EpochId,
-    node_id: NodeId,
-) -> Result<NodePerformanceResponse, NymPerformanceContractError> {
-    let performance =
-        NYM_PERFORMANCE_CONTRACT_STORAGE.try_load_performance(deps.storage, epoch_id, node_id)?;
-    Ok(NodePerformanceResponse { performance })
-}
-
-pub fn query_node_measurements(
-    deps: Deps,
-    epoch_id: EpochId,
-    node_id: NodeId,
-) -> Result<NodeMeasurementsResponse, NymPerformanceContractError> {
-    let measurements = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .performance_results
-        .results
-        .may_load(deps.storage, (epoch_id, node_id))?;
-    Ok(NodeMeasurementsResponse { measurements })
-}
-
-pub fn query_node_performance_paged(
-    deps: Deps,
-    node_id: NodeId,
-    start_after: Option<EpochId>,
-    limit: Option<u32>,
-) -> Result<NodePerformancePagedResponse, NymPerformanceContractError> {
-    let current_epoch_id = NYM_PERFORMANCE_CONTRACT_STORAGE.current_mixnet_epoch_id(deps)?;
-
-    let start = match start_after {
-        None => NYM_PERFORMANCE_CONTRACT_STORAGE
-            .mixnet_epoch_id_at_creation
-            .load(deps.storage)?,
-        Some(start_after) => start_after + 1,
-    };
-
-    let mut performance = Vec::new();
-
-    if current_epoch_id < start {
-        return Ok(NodePerformancePagedResponse {
-            node_id,
-            performance,
-            start_next_after: None,
-        });
-    }
-
-    let limit = limit
-        .unwrap_or(retrieval_limits::NODE_PERFORMANCE_DEFAULT_LIMIT)
-        .min(retrieval_limits::NODE_PERFORMANCE_MAX_LIMIT) as usize;
-
-    for epoch_id in (start..=current_epoch_id).take(limit) {
-        performance.push(EpochNodePerformance {
-            epoch: epoch_id,
-            performance: NYM_PERFORMANCE_CONTRACT_STORAGE.try_load_performance(
-                deps.storage,
-                epoch_id,
-                node_id,
-            )?,
-        })
-    }
-
-    let start_next_after = performance.last().and_then(|last| {
-        if last.epoch != current_epoch_id {
-            Some(last.epoch)
-        } else {
-            None
-        }
-    });
-
-    Ok(NodePerformancePagedResponse {
-        node_id,
-        performance,
-        start_next_after,
-    })
-}
-
-pub fn query_epoch_performance_paged(
-    deps: Deps,
-    epoch_id: EpochId,
-    start_after: Option<NodeId>,
-    limit: Option<u32>,
-) -> Result<EpochPerformancePagedResponse, NymPerformanceContractError> {
-    let limit = limit
-        .unwrap_or(retrieval_limits::NODE_EPOCH_PERFORMANCE_DEFAULT_LIMIT)
-        .min(retrieval_limits::NODE_EPOCH_PERFORMANCE_MAX_LIMIT) as usize;
-
-    let start = start_after.map(Bound::exclusive);
-
-    let performance = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .performance_results
-        .results
-        .prefix(epoch_id)
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| {
-            record.map(|(node_id, results)| NodePerformance {
-                node_id,
-                performance: results.median(),
-            })
-        })
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = performance.last().map(|last| last.node_id);
-
-    Ok(EpochPerformancePagedResponse {
-        epoch_id,
-        performance,
-        start_next_after,
-    })
-}
-
-pub fn query_epoch_measurements_paged(
-    deps: Deps,
-    epoch_id: EpochId,
-    start_after: Option<NodeId>,
-    limit: Option<u32>,
-) -> Result<EpochMeasurementsPagedResponse, NymPerformanceContractError> {
-    let limit = limit
-        .unwrap_or(retrieval_limits::NODE_EPOCH_MEASUREMENTS_DEFAULT_LIMIT)
-        .min(retrieval_limits::NODE_EPOCH_MEASUREMENTS_MAX_LIMIT) as usize;
-
-    let start = start_after.map(Bound::exclusive);
-
-    let measurements = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .performance_results
-        .results
-        .prefix(epoch_id)
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| {
-            record.map(|(node_id, measurements)| NodeMeasurement {
-                node_id,
-                measurements,
-            })
-        })
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = measurements.last().map(|last| last.node_id);
-
-    Ok(EpochMeasurementsPagedResponse {
-        epoch_id,
-        measurements,
-        start_next_after,
-    })
-}
-
-pub fn query_full_historical_performance_paged(
-    deps: Deps,
-    start_after: Option<(EpochId, NodeId)>,
-    limit: Option<u32>,
-) -> Result<FullHistoricalPerformancePagedResponse, NymPerformanceContractError> {
-    let limit = limit
-        .unwrap_or(retrieval_limits::NODE_HISTORICAL_PERFORMANCE_DEFAULT_LIMIT)
-        .min(retrieval_limits::NODE_HISTORICAL_PERFORMANCE_MAX_LIMIT) as usize;
-
-    let start = start_after.map(Bound::exclusive);
-
-    let performance = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .performance_results
-        .results
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| {
-            record.map(|((epoch_id, node_id), results)| HistoricalPerformance {
-                epoch_id,
-                node_id,
-                performance: results.median(),
-            })
-        })
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = performance.last().map(|last| (last.epoch_id, last.node_id));
-
-    Ok(FullHistoricalPerformancePagedResponse {
-        performance,
-        start_next_after,
-    })
-}
-
-fn get_network_monitor_information(
-    deps: Deps,
-    address: &Addr,
-) -> Result<Option<NetworkMonitorInformation>, NymPerformanceContractError> {
-    let Some(details) = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .network_monitors
-        .authorised
-        .may_load(deps.storage, address)?
-    else {
-        return Ok(None);
-    };
-
-    let current_submission_metadata = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .performance_results
-        .submission_metadata
-        .load(deps.storage, address)?;
-
-    Ok(Some(NetworkMonitorInformation {
-        details,
-        current_submission_metadata,
-    }))
-}
-
-pub fn query_network_monitor_details(
-    deps: Deps,
-    address: String,
-) -> Result<NetworkMonitorResponse, NymPerformanceContractError> {
-    let address = deps.api.addr_validate(&address)?;
-
-    Ok(NetworkMonitorResponse {
-        info: get_network_monitor_information(deps, &address)?,
-    })
-}
-
-pub fn query_network_monitors_paged(
-    deps: Deps,
-    start_after: Option<String>,
-    limit: Option<u32>,
-) -> Result<NetworkMonitorsPagedResponse, NymPerformanceContractError> {
-    let limit = limit
-        .unwrap_or(retrieval_limits::NETWORK_MONITORS_DEFAULT_LIMIT)
-        .min(retrieval_limits::NETWORK_MONITORS_MAX_LIMIT) as usize;
-
-    let addr = start_after
-        .map(|addr| deps.api.addr_validate(&addr))
-        .transpose()?;
-    let start = addr.as_ref().map(Bound::exclusive);
-
-    let info = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .network_monitors
-        .authorised
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| {
-            record.and_then(|(address, details)| {
-                NYM_PERFORMANCE_CONTRACT_STORAGE
-                    .performance_results
-                    .submission_metadata
-                    .load(deps.storage, &address)
-                    .map(|current_submission_metadata| NetworkMonitorInformation {
-                        details,
-                        current_submission_metadata,
-                    })
-            })
-        })
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = info.last().map(|last| last.details.address.to_string());
-
-    Ok(NetworkMonitorsPagedResponse {
-        info,
-        start_next_after,
-    })
-}
-
-pub fn query_retired_network_monitors_paged(
-    deps: Deps,
-    start_after: Option<String>,
-    limit: Option<u32>,
-) -> Result<RetiredNetworkMonitorsPagedResponse, NymPerformanceContractError> {
-    let limit = limit
-        .unwrap_or(retrieval_limits::RETIRED_NETWORK_MONITORS_DEFAULT_LIMIT)
-        .min(retrieval_limits::RETIRED_NETWORK_MONITORS_MAX_LIMIT) as usize;
-
-    let addr = start_after
-        .map(|addr| deps.api.addr_validate(&addr))
-        .transpose()?;
-    let start = addr.as_ref().map(Bound::exclusive);
-
-    let info = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .network_monitors
-        .retired
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| record.map(|(_, details)| details))
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = info.last().map(|last| last.details.address.to_string());
-
-    Ok(RetiredNetworkMonitorsPagedResponse {
-        info,
-        start_next_after,
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::testing::{init_contract_tester, PerformanceContractTesterExt};
-    use nym_contracts_common_testing::{ContractOpts, RandExt};
-
-    #[cfg(test)]
-    mod admin_query {
-        use super::*;
-        use crate::testing::init_contract_tester;
-        use nym_contracts_common_testing::{AdminExt, ChainOpts, ContractOpts, RandExt};
-        use nym_performance_contract_common::ExecuteMsg;
-
-        #[test]
-        fn returns_current_admin() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
-
-            let initial_admin = test.admin_unchecked();
-
-            // initial
-            let res = query_admin(test.deps())?;
-            assert_eq!(res.admin, Some(initial_admin.to_string()));
-
-            let new_admin = test.generate_account();
-
-            // sanity check
-            assert_ne!(initial_admin, new_admin);
-
-            // after update
-            test.execute_msg(
-                initial_admin.clone(),
-                &ExecuteMsg::UpdateAdmin {
-                    admin: new_admin.to_string(),
-                },
-            )?;
-
-            let updated_admin = query_admin(test.deps())?;
-            assert_eq!(updated_admin.admin, Some(new_admin.to_string()));
-
-            Ok(())
-        }
-    }
-
-    #[test]
-    fn querying_node_performance_paged() -> anyhow::Result<()> {
-        let mut test = init_contract_tester();
-
-        let node_id = test.bond_dummy_nymnode()?;
-        let nm = test.generate_account();
-        test.authorise_network_monitor(&nm)?;
-
-        // epoch 0
-        test.insert_raw_performance(&nm, node_id, "0")?;
-
-        // epoch 1
-        test.advance_mixnet_epoch()?;
-        test.insert_raw_performance(&nm, node_id, "0.1")?;
-
-        // epoch 2
-        test.advance_mixnet_epoch()?;
-        test.insert_raw_performance(&nm, node_id, "0.2")?;
-
-        // epoch 3
-        test.advance_mixnet_epoch()?;
-        test.insert_raw_performance(&nm, node_id, "0.3")?;
-
-        // epoch 4
-        test.advance_mixnet_epoch()?;
-        test.insert_raw_performance(&nm, node_id, "0.4")?;
-
-        // epoch 5
-        test.advance_mixnet_epoch()?;
-        test.insert_raw_performance(&nm, node_id, "0.5")?;
-
-        let deps = test.deps();
-        let res = query_node_performance_paged(deps, node_id, Some(5), None)?;
-        assert!(res.start_next_after.is_none());
-        assert!(res.performance.is_empty());
-
-        let res = query_node_performance_paged(deps, node_id, Some(42), None)?;
-        assert!(res.start_next_after.is_none());
-        assert!(res.performance.is_empty());
-
-        let res = query_node_performance_paged(deps, node_id, Some(4), None)?;
-        assert!(res.start_next_after.is_none());
-        assert_eq!(
-            res.performance,
-            vec![EpochNodePerformance {
-                epoch: 5,
-                performance: Some("0.5".parse()?),
-            }]
-        );
-
-        let res = query_node_performance_paged(deps, node_id, Some(2), None)?;
-        assert!(res.start_next_after.is_none());
-        assert_eq!(
-            res.performance,
-            vec![
-                EpochNodePerformance {
-                    epoch: 3,
-                    performance: Some("0.3".parse()?),
-                },
-                EpochNodePerformance {
-                    epoch: 4,
-                    performance: Some("0.4".parse()?),
-                },
-                EpochNodePerformance {
-                    epoch: 5,
-                    performance: Some("0.5".parse()?),
-                }
-            ]
-        );
-
-        let res = query_node_performance_paged(deps, node_id, None, None)?;
-        assert!(res.start_next_after.is_none());
-        assert_eq!(
-            res.performance,
-            vec![
-                EpochNodePerformance {
-                    epoch: 0,
-                    performance: Some("0".parse()?),
-                },
-                EpochNodePerformance {
-                    epoch: 1,
-                    performance: Some("0.1".parse()?),
-                },
-                EpochNodePerformance {
-                    epoch: 2,
-                    performance: Some("0.2".parse()?),
-                },
-                EpochNodePerformance {
-                    epoch: 3,
-                    performance: Some("0.3".parse()?),
-                },
-                EpochNodePerformance {
-                    epoch: 4,
-                    performance: Some("0.4".parse()?),
-                },
-                EpochNodePerformance {
-                    epoch: 5,
-                    performance: Some("0.5".parse()?),
-                }
-            ]
-        );
-
-        let res = query_node_performance_paged(deps, node_id, Some(2), Some(1))?;
-        assert_eq!(res.start_next_after, Some(3));
-        assert_eq!(
-            res.performance,
-            vec![EpochNodePerformance {
-                epoch: 3,
-                performance: Some("0.3".parse()?),
-            }]
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn querying_epoch_performance_paged() -> anyhow::Result<()> {
-        let mut test = init_contract_tester();
-
-        let nm = test.generate_account();
-        test.authorise_network_monitor(&nm)?;
-
-        let mut nodes = Vec::new();
-        for _ in 0..10 {
-            nodes.push(test.bond_dummy_nymnode()?);
-        }
-
-        let epoch_id = 5;
-        test.set_mixnet_epoch(epoch_id)?;
-
-        test.insert_raw_performance(&nm, nodes[1], "0.1")?;
-        test.insert_raw_performance(&nm, nodes[2], "0.2")?;
-        test.insert_raw_performance(&nm, nodes[3], "0.3")?;
-        // 4 is missing
-        test.insert_raw_performance(&nm, nodes[5], "0.5")?;
-        test.insert_raw_performance(&nm, nodes[6], "0.6")?;
-
-        let deps = test.deps();
-        let res = query_epoch_performance_paged(deps, epoch_id, Some(nodes[6]), None)?;
-        assert!(res.start_next_after.is_none());
-        assert!(res.performance.is_empty());
-
-        let res = query_epoch_performance_paged(deps, epoch_id, Some(42), None)?;
-        assert!(res.start_next_after.is_none());
-        assert!(res.performance.is_empty());
-
-        let res = query_epoch_performance_paged(deps, epoch_id, Some(nodes[4]), None)?;
-        assert_eq!(res.start_next_after, Some(nodes[6]));
-        assert_eq!(
-            res.performance,
-            vec![
-                NodePerformance {
-                    node_id: nodes[5],
-                    performance: "0.5".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[6],
-                    performance: "0.6".parse()?,
-                }
-            ]
-        );
-        let res = query_epoch_performance_paged(deps, epoch_id, Some(nodes[3]), None)?;
-        assert_eq!(res.start_next_after, Some(nodes[6]));
-        assert_eq!(
-            res.performance,
-            vec![
-                NodePerformance {
-                    node_id: nodes[5],
-                    performance: "0.5".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[6],
-                    performance: "0.6".parse()?,
-                }
-            ]
-        );
-
-        let res = query_epoch_performance_paged(deps, epoch_id, Some(nodes[2]), None)?;
-        assert_eq!(res.start_next_after, Some(nodes[6]));
-        assert_eq!(
-            res.performance,
-            vec![
-                NodePerformance {
-                    node_id: nodes[3],
-                    performance: "0.3".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[5],
-                    performance: "0.5".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[6],
-                    performance: "0.6".parse()?,
-                }
-            ]
-        );
-
-        let res = query_epoch_performance_paged(deps, epoch_id, None, None)?;
-        assert_eq!(res.start_next_after, Some(nodes[6]));
-        assert_eq!(
-            res.performance,
-            vec![
-                NodePerformance {
-                    node_id: nodes[1],
-                    performance: "0.1".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[2],
-                    performance: "0.2".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[3],
-                    performance: "0.3".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[5],
-                    performance: "0.5".parse()?,
-                },
-                NodePerformance {
-                    node_id: nodes[6],
-                    performance: "0.6".parse()?,
-                }
-            ]
-        );
-
-        let res = query_epoch_performance_paged(deps, epoch_id, Some(nodes[2]), Some(1))?;
-        assert_eq!(res.start_next_after, Some(nodes[3]));
-        assert_eq!(
-            res.performance,
-            vec![NodePerformance {
-                node_id: nodes[3],
-                performance: "0.3".parse()?,
-            }]
-        );
-
-        Ok(())
-    }
-}
@@ -1,2 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
@@ -1,606 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::contract::{execute, instantiate, migrate, query};
-use crate::helpers::MixnetContractQuerier;
-use crate::storage::NYM_PERFORMANCE_CONTRACT_STORAGE;
-use cosmwasm_std::testing::{message_info, mock_env, MockApi};
-use cosmwasm_std::{
-    coin, coins, Addr, Binary, ContractInfo, Deps, DepsMut, Env, MessageInfo, QuerierWrapper,
-    StdError, StdResult,
-};
-use cw_storage_plus::PrimaryKey;
-use mixnet_contract::testable_mixnet_contract::MixnetContract;
-use nym_contracts_common::signing::{ContractMessageContent, MessageSignature};
-use nym_contracts_common::Percent;
-use nym_contracts_common_testing::{
-    addr, AdminExt, ArbitraryContractStorageReader, ArbitraryContractStorageWriter, BankExt,
-    ChainOpts, CommonStorageKeys, ContractFn, ContractOpts, ContractStorageWrapper, ContractTester,
-    ContractTesterBuilder, DenomExt, PermissionedFn, QueryFn, RandExt, TestableNymContract,
-    TEST_DENOM,
-};
-use nym_crypto::asymmetric::ed25519;
-use nym_mixnet_contract_common::nym_node::{NodeDetailsResponse, NodeOwnershipResponse, Role};
-use nym_mixnet_contract_common::{
-    CurrentIntervalResponse, EpochId, Interval, MixNode, MixNodeBond, MixnodeDetailsResponse,
-    NodeCostParams, NodeRewarding, NymNode, NymNodeBondingPayload, RoleAssignment,
-    SignableNymNodeBondingMsg, DEFAULT_INTERVAL_OPERATING_COST_AMOUNT,
-    DEFAULT_PROFIT_MARGIN_PERCENT,
-};
-use nym_performance_contract_common::constants::storage_keys;
-use nym_performance_contract_common::{
-    ExecuteMsg, InstantiateMsg, MigrateMsg, NodeId, NodePerformance, NodeResults,
-    NymPerformanceContractError, QueryMsg,
-};
-use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
-use std::str::FromStr;
-
-pub struct PerformanceContract;
-
-impl TestableNymContract for PerformanceContract {
-    const NAME: &'static str = "performance-contract";
-    type InitMsg = InstantiateMsg;
-    type ExecuteMsg = ExecuteMsg;
-    type QueryMsg = QueryMsg;
-    type MigrateMsg = MigrateMsg;
-    type ContractError = NymPerformanceContractError;
-
-    fn instantiate() -> ContractFn<Self::InitMsg, Self::ContractError> {
-        instantiate
-    }
-
-    fn execute() -> ContractFn<Self::ExecuteMsg, Self::ContractError> {
-        execute
-    }
-
-    fn query() -> QueryFn<Self::QueryMsg, Self::ContractError> {
-        query
-    }
-
-    fn migrate() -> PermissionedFn<Self::MigrateMsg, Self::ContractError> {
-        migrate
-    }
-
-    fn base_init_msg() -> Self::InitMsg {
-        InstantiateMsg {
-            mixnet_contract_address: addr("mixnet-contract").to_string(),
-            authorised_network_monitors: vec![],
-        }
-    }
-
-    fn init() -> ContractTester<Self>
-    where
-        Self: Sized,
-    {
-        let builder = ContractTesterBuilder::new().instantiate::<MixnetContract>(None);
-
-        // we just instantiated it
-        let mixnet_address = builder
-            .well_known_contracts
-            .get(MixnetContract::NAME)
-            .unwrap()
-            .clone();
-
-        builder
-            .instantiate::<Self>(Some(InstantiateMsg {
-                mixnet_contract_address: mixnet_address.to_string(),
-                authorised_network_monitors: vec![],
-            }))
-            .build()
-    }
-}
-
-pub fn init_contract_tester() -> ContractTester<PerformanceContract> {
-    PerformanceContract::init()
-        .with_common_storage_key(CommonStorageKeys::Admin, storage_keys::CONTRACT_ADMIN)
-}
-
-// we need to be able to test instantiation, but for that we require
-// deps in a state that already includes instantiated mixnet contract
-pub(crate) struct PreInitContract {
-    tester_builder: ContractTesterBuilder<PerformanceContract>,
-    pub(crate) mixnet_contract_address: Addr,
-    pub(crate) api: MockApi,
-    storage: ContractStorageWrapper,
-    placeholder_address: Addr,
-}
-
-#[allow(dead_code)]
-impl PreInitContract {
-    pub(crate) fn new() -> PreInitContract {
-        let tester_builder =
-            ContractTesterBuilder::<PerformanceContract>::new().instantiate::<MixnetContract>(None);
-
-        let mixnet_contract = tester_builder
-            .well_known_contracts
-            .get(&MixnetContract::NAME)
-            .unwrap();
-
-        let api = tester_builder.api();
-        let placeholder_address = api.addr_make("to-be-performance-contract");
-
-        let storage = tester_builder.contract_storage_wrapper(&placeholder_address);
-
-        PreInitContract {
-            mixnet_contract_address: mixnet_contract.clone(),
-            tester_builder,
-            api,
-            storage,
-            placeholder_address,
-        }
-    }
-
-    pub(crate) fn deps(&self) -> Deps {
-        Deps {
-            storage: &self.storage,
-            api: &self.api,
-            querier: self.tester_builder.querier(),
-        }
-    }
-
-    pub(crate) fn deps_mut(&mut self) -> DepsMut {
-        DepsMut {
-            storage: &mut self.storage,
-            api: &self.api,
-            querier: self.tester_builder.querier(),
-        }
-    }
-
-    pub(crate) fn querier(&self) -> QuerierWrapper {
-        self.tester_builder.querier()
-    }
-
-    pub(crate) fn env(&self) -> Env {
-        Env {
-            contract: ContractInfo {
-                address: self.placeholder_address.clone(),
-            },
-            ..mock_env()
-        }
-    }
-
-    pub(crate) fn addr_make(&self, input: &str) -> Addr {
-        self.api.addr_make(input)
-    }
-
-    pub(crate) fn write_to_mixnet_contract_storage(
-        &mut self,
-        key: impl AsRef<[u8]>,
-        value: impl AsRef<[u8]>,
-    ) -> StdResult<()> {
-        let address = NYM_PERFORMANCE_CONTRACT_STORAGE
-            .mixnet_contract_address
-            .load(self.deps().storage)?;
-
-        self.set_contract_storage(address, key, value);
-        Ok(())
-    }
-
-    pub(crate) fn write_to_mixnet_contract_storage_value<T: Serialize>(
-        &mut self,
-        key: impl AsRef<[u8]>,
-        value: &T,
-    ) -> StdResult<()> {
-        let address = NYM_PERFORMANCE_CONTRACT_STORAGE
-            .mixnet_contract_address
-            .load(self.deps().storage)?;
-
-        self.set_contract_storage_value(address, key, value)
-    }
-}
-
-impl ArbitraryContractStorageWriter for PreInitContract {
-    fn set_contract_storage(
-        &mut self,
-        address: impl Into<String>,
-        key: impl AsRef<[u8]>,
-        value: impl AsRef<[u8]>,
-    ) {
-        self.storage
-            .as_inner_storage_mut()
-            .set_contract_storage(address, key, value);
-    }
-}
-
-#[allow(dead_code)]
-pub(crate) trait PerformanceContractTesterExt:
-    ContractOpts<
-        ExecuteMsg = ExecuteMsg,
-        QueryMsg = QueryMsg,
-        ContractError = NymPerformanceContractError,
-    > + ChainOpts
-    + AdminExt
-    + DenomExt
-    + RandExt
-    + BankExt
-    + ArbitraryContractStorageReader
-    + ArbitraryContractStorageWriter
-{
-    fn mixnet_contract_address(&self) -> StdResult<Addr> {
-        NYM_PERFORMANCE_CONTRACT_STORAGE
-            .mixnet_contract_address
-            .load(self.deps().storage)
-    }
-
-    fn execute_mixnet_contract(
-        &mut self,
-        sender: MessageInfo,
-        msg: &nym_mixnet_contract_common::ExecuteMsg,
-    ) -> StdResult<()> {
-        let address = self.mixnet_contract_address()?;
-
-        self.execute_arbitrary_contract(address, sender, msg)
-            .map_err(|err| {
-                StdError::generic_err(format!("mixnet contract execution failure: {err}"))
-            })?;
-        Ok(())
-    }
-
-    fn read_from_mixnet_contract_storage<T: DeserializeOwned>(
-        &self,
-        key: impl AsRef<[u8]>,
-    ) -> StdResult<T> {
-        let address = self.mixnet_contract_address()?;
-
-        self.must_read_value_from_contract_storage(address, key)
-    }
-
-    fn write_to_mixnet_contract_storage(
-        &mut self,
-        key: impl AsRef<[u8]>,
-        value: impl AsRef<[u8]>,
-    ) -> StdResult<()> {
-        let address = self.mixnet_contract_address()?;
-
-        <Self as ArbitraryContractStorageWriter>::set_contract_storage(self, address, key, value);
-        Ok(())
-    }
-
-    fn write_to_mixnet_contract_storage_value<T: Serialize>(
-        &mut self,
-        key: impl AsRef<[u8]>,
-        value: &T,
-    ) -> StdResult<()> {
-        let address = self.mixnet_contract_address()?;
-
-        self.set_contract_storage_value(address, key, value)
-    }
-
-    fn current_mixnet_epoch(&self) -> StdResult<EpochId> {
-        let address = self.mixnet_contract_address()?;
-
-        Ok(self
-            .deps()
-            .querier
-            .query_current_mixnet_interval(address.clone())?
-            .current_epoch_absolute_id())
-    }
-
-    fn advance_mixnet_epoch(&mut self) -> StdResult<()> {
-        let interval_details: CurrentIntervalResponse = self.query_arbitrary_contract(
-            self.mixnet_contract_address()?,
-            &nym_mixnet_contract_common::QueryMsg::GetCurrentIntervalDetails {},
-        )?;
-        let until_end = interval_details.time_until_current_epoch_end().as_secs();
-        let timestamp = self.env().block.time.plus_seconds(until_end + 1);
-        self.set_block_time(timestamp);
-        self.next_block();
-
-        // this was hardcoded in mixnet init
-        let mixnet_rewarder = self.addr_make("rewarder");
-        let rewarder = message_info(&mixnet_rewarder, &[]);
-        self.execute_mixnet_contract(
-            rewarder.clone(),
-            &nym_mixnet_contract_common::ExecuteMsg::BeginEpochTransition {},
-        )?;
-        self.execute_mixnet_contract(
-            rewarder.clone(),
-            &nym_mixnet_contract_common::ExecuteMsg::ReconcileEpochEvents { limit: None },
-        )?;
-
-        for role in [
-            Role::ExitGateway,
-            Role::EntryGateway,
-            Role::Layer1,
-            Role::Layer2,
-            Role::Layer3,
-            Role::Standby,
-        ] {
-            self.execute_mixnet_contract(
-                rewarder.clone(),
-                &nym_mixnet_contract_common::ExecuteMsg::AssignRoles {
-                    assignment: RoleAssignment {
-                        role,
-                        nodes: vec![],
-                    },
-                },
-            )?;
-        }
-        Ok(())
-    }
-
-    fn set_mixnet_epoch(&mut self, epoch_id: EpochId) -> StdResult<()> {
-        let address = self.mixnet_contract_address()?;
-
-        let interval = self
-            .deps()
-            .querier
-            .query_current_mixnet_interval(address.clone())?;
-
-        let mut to_update = if interval.current_epoch_absolute_id() <= epoch_id {
-            interval
-        } else {
-            Interval::init_interval(
-                interval.epochs_in_interval(),
-                interval.epoch_length(),
-                &mock_env(),
-            )
-        };
-
-        let current = to_update.current_epoch_absolute_id();
-        let diff = epoch_id - current;
-        for _ in 0..diff {
-            to_update = to_update.advance_epoch();
-        }
-        self.set_contract_storage_value(&address, b"ci", &to_update)
-    }
-
-    fn authorise_network_monitor(
-        &mut self,
-        addr: &Addr,
-    ) -> Result<(), NymPerformanceContractError> {
-        let admin = self.admin_unchecked();
-        self.execute_raw(
-            admin,
-            ExecuteMsg::AuthoriseNetworkMonitor {
-                address: addr.to_string(),
-            },
-        )?;
-        Ok(())
-    }
-
-    fn dummy_node_performance(&mut self) -> NodePerformance {
-        let node_id = self.bond_dummy_nymnode().unwrap();
-        NodePerformance {
-            node_id,
-            performance: Percent::from_percentage_value(69).unwrap(),
-        }
-    }
-
-    fn retire_network_monitor(&mut self, addr: &Addr) -> Result<(), NymPerformanceContractError> {
-        let admin = self.admin_unchecked();
-        self.execute_raw(
-            admin,
-            ExecuteMsg::RetireNetworkMonitor {
-                address: addr.to_string(),
-            },
-        )?;
-        Ok(())
-    }
-
-    fn insert_epoch_performance(
-        &mut self,
-        addr: &Addr,
-        epoch_id: EpochId,
-        node_id: NodeId,
-        performance: Percent,
-    ) -> Result<(), NymPerformanceContractError> {
-        NYM_PERFORMANCE_CONTRACT_STORAGE.submit_performance_data(
-            self.deps_mut(),
-            addr,
-            epoch_id,
-            NodePerformance {
-                node_id,
-                performance,
-            },
-        )
-    }
-
-    fn insert_performance(
-        &mut self,
-        addr: &Addr,
-        node_id: NodeId,
-        performance: Percent,
-    ) -> Result<(), NymPerformanceContractError> {
-        let epoch_id = self.current_mixnet_epoch()?;
-
-        self.insert_epoch_performance(addr, epoch_id, node_id, performance)
-    }
-
-    // makes testing easier
-    fn insert_raw_performance(
-        &mut self,
-        addr: &Addr,
-        node_id: NodeId,
-        raw: &str,
-    ) -> Result<(), NymPerformanceContractError> {
-        self.insert_performance(
-            addr,
-            node_id,
-            Percent::from_str(raw).map_err(|err| {
-                NymPerformanceContractError::StdErr(StdError::parse_err("Percent", err.to_string()))
-            })?,
-        )
-    }
-
-    fn read_raw_scores(
-        &self,
-        epoch_id: EpochId,
-        node_id: NodeId,
-    ) -> Result<NodeResults, NymPerformanceContractError> {
-        let scores = NYM_PERFORMANCE_CONTRACT_STORAGE
-            .performance_results
-            .results
-            .load(self.deps().storage, (epoch_id, node_id))?;
-        Ok(scores)
-    }
-
-    fn bond_dummy_nymnode(&mut self) -> Result<NodeId, NymPerformanceContractError> {
-        let node_owner = self.generate_account_with_balance();
-        let pledge = coins(100_000000, TEST_DENOM);
-        let keypair = ed25519::KeyPair::new(self.raw_rng());
-        let identity_key = keypair.public_key().to_base58_string();
-
-        let node = NymNode {
-            host: "1.2.3.4".to_string(),
-            custom_http_port: None,
-            identity_key,
-        };
-        let cost_params = NodeCostParams {
-            profit_margin_percent: Percent::from_percentage_value(DEFAULT_PROFIT_MARGIN_PERCENT)
-                .unwrap(),
-            interval_operating_cost: coin(DEFAULT_INTERVAL_OPERATING_COST_AMOUNT, TEST_DENOM),
-        };
-        // initial signing nonce is 0 for a new address
-        let signing_nonce = 0;
-
-        let payload = NymNodeBondingPayload::new(node.clone(), cost_params.clone());
-        let content = ContractMessageContent::new(node_owner.clone(), pledge.clone(), payload);
-        let msg = SignableNymNodeBondingMsg::new(signing_nonce, content);
-
-        let owner_signature = keypair.private_key().sign(msg.to_plaintext()?);
-        let owner_signature = MessageSignature::from(owner_signature.to_bytes().as_ref());
-
-        self.execute_mixnet_contract(
-            message_info(&node_owner, &pledge),
-            &nym_mixnet_contract_common::ExecuteMsg::BondNymNode {
-                node,
-                cost_params,
-                owner_signature,
-            },
-        )?;
-
-        let bond: NodeOwnershipResponse = self.query_arbitrary_contract(
-            self.mixnet_contract_address()?,
-            &nym_mixnet_contract_common::QueryMsg::GetOwnedNymNode {
-                address: node_owner.to_string(),
-            },
-        )?;
-
-        Ok(bond.details.unwrap().bond_information.node_id)
-    }
-
-    fn unbond_nymnode(&mut self, node_id: NodeId) -> Result<(), NymPerformanceContractError> {
-        let bond: NodeDetailsResponse = self.query_arbitrary_contract(
-            self.mixnet_contract_address()?,
-            &nym_mixnet_contract_common::QueryMsg::GetNymNodeDetails { node_id },
-        )?;
-
-        let node_owner = bond.details.unwrap().bond_information.owner;
-
-        self.execute_mixnet_contract(
-            message_info(&node_owner, &[]),
-            &nym_mixnet_contract_common::ExecuteMsg::UnbondNymNode {},
-        )?;
-
-        self.advance_mixnet_epoch()?;
-        Ok(())
-    }
-
-    fn bond_dummy_legacy_mixnode(&mut self) -> Result<NodeId, NymPerformanceContractError> {
-        #[derive(Deserialize, Serialize)]
-        pub(crate) struct UniqueRef<T> {
-            // note, we collapse the pk - combining everything under the namespace - even if it is composite
-            pk: Binary,
-            value: T,
-        }
-
-        // there's no proper Execute flow for this anymore, so we have to "hack" the storage a bit,
-        // ensuring all invariants still hold
-        let owner = self.generate_account_with_balance();
-
-        let mixnode = MixNode {
-            host: "1.2.3.4".to_string(),
-            mix_port: 123,
-            verloc_port: 123,
-            http_api_port: 123,
-            sphinx_key: "aaaa".to_string(),
-            identity_key: "bbbbb".to_string(),
-            version: "ccc".to_string(),
-        };
-        let cost_params = NodeCostParams {
-            profit_margin_percent: Percent::from_percentage_value(DEFAULT_PROFIT_MARGIN_PERCENT)
-                .unwrap(),
-            interval_operating_cost: coin(DEFAULT_INTERVAL_OPERATING_COST_AMOUNT, TEST_DENOM),
-        };
-
-        // adjust node counter
-        let node_id_counter: u32 = self.read_from_mixnet_contract_storage("nic")?;
-        let node_id = node_id_counter + 1;
-        self.write_to_mixnet_contract_storage_value("nic", &node_id)?;
-
-        let current_epoch = self.current_mixnet_epoch()?;
-        let pledge = coin(100_000000, TEST_DENOM);
-        let mixnode_rewarding =
-            NodeRewarding::initialise_new(cost_params, &pledge, current_epoch).unwrap();
-        let env = self.env();
-        let mixnode_bond = MixNodeBond {
-            mix_id: node_id,
-            owner,
-            original_pledge: pledge,
-            mix_node: mixnode,
-            proxy: None,
-            bonding_height: env.block.height,
-            is_unbonding: false,
-        };
-
-        // save to the main mixnode storage
-        self.set_contract_map_value(
-            self.mixnet_contract_address()?,
-            "mnn",
-            node_id,
-            &mixnode_bond,
-        )?;
-        // update indices
-        let pk = node_id.joined_key();
-        let unique_ref = UniqueRef {
-            pk: pk.into(),
-            value: mixnode_bond.clone(),
-        };
-
-        // owner index
-        let idx = mixnode_bond.owner.clone();
-        self.set_contract_map_value(self.mixnet_contract_address()?, "mno", idx, &unique_ref)?;
-
-        // identity key index
-        let idx = mixnode_bond.mix_node.identity_key.clone();
-        self.set_contract_map_value(self.mixnet_contract_address()?, "mni", idx, &unique_ref)?;
-
-        // sphinx key index
-        let idx = mixnode_bond.mix_node.sphinx_key.clone();
-        self.set_contract_map_value(self.mixnet_contract_address()?, "mns", idx, &unique_ref)?;
-
-        // update rewarding data
-        self.set_contract_map_value(
-            self.mixnet_contract_address()?,
-            "mnr",
-            node_id,
-            &mixnode_rewarding,
-        )?;
-
-        Ok(node_id)
-    }
-
-    fn unbond_legacy_mixnode(
-        &mut self,
-        node_id: NodeId,
-    ) -> Result<(), NymPerformanceContractError> {
-        let bond: MixnodeDetailsResponse = self.query_arbitrary_contract(
-            self.mixnet_contract_address()?,
-            &nym_mixnet_contract_common::QueryMsg::GetMixnodeDetails { mix_id: node_id },
-        )?;
-
-        let node_owner = bond.mixnode_details.unwrap().bond_information.owner;
-
-        self.execute_mixnet_contract(
-            message_info(&node_owner, &[]),
-            &nym_mixnet_contract_common::ExecuteMsg::UnbondMixnode {},
-        )?;
-
-        self.advance_mixnet_epoch()?;
-        Ok(())
-    }
-}
-
-impl PerformanceContractTesterExt for ContractTester<PerformanceContract> {}
@@ -1,305 +0,0 @@
-// Copyright 2025 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::storage::NYM_PERFORMANCE_CONTRACT_STORAGE;
-use cosmwasm_std::{to_json_binary, DepsMut, Env, Event, MessageInfo, Response};
-use nym_performance_contract_common::{
-    EpochId, NodeId, NodePerformance, NymPerformanceContractError,
-};
-
-pub fn try_update_contract_admin(
-    deps: DepsMut<'_>,
-    info: MessageInfo,
-    new_admin: String,
-) -> Result<Response, NymPerformanceContractError> {
-    let new_admin = deps.api.addr_validate(&new_admin)?;
-
-    let res = NYM_PERFORMANCE_CONTRACT_STORAGE
-        .contract_admin
-        .execute_update_admin(deps, info, Some(new_admin))?;
-
-    Ok(res)
-}
-
-pub fn try_submit_performance_results(
-    deps: DepsMut<'_>,
-    info: MessageInfo,
-    epoch_id: EpochId,
-    data: NodePerformance,
-) -> Result<Response, NymPerformanceContractError> {
-    NYM_PERFORMANCE_CONTRACT_STORAGE.submit_performance_data(deps, &info.sender, epoch_id, data)?;
-
-    // TODO: emit events
-    Ok(Response::new())
-}
-
-pub fn try_batch_submit_performance_results(
-    deps: DepsMut<'_>,
-    info: MessageInfo,
-    epoch_id: EpochId,
-    data: Vec<NodePerformance>,
-) -> Result<Response, NymPerformanceContractError> {
-    let res = NYM_PERFORMANCE_CONTRACT_STORAGE.batch_submit_performance_results(
-        deps,
-        &info.sender,
-        epoch_id,
-        data,
-    )?;
-
-    let response = Response::new().set_data(to_json_binary(&res)?).add_event(
-        Event::new("batch_performance_submission")
-            .add_attribute("accepted_scores", res.accepted_scores.to_string())
-            .add_attribute(
-                "non_existent_nodes",
-                format!("{:?}", res.non_existent_nodes),
-            ),
-    );
-    Ok(response)
-}
-
-pub fn try_authorise_network_monitor(
-    deps: DepsMut<'_>,
-    env: Env,
-    info: MessageInfo,
-    address: String,
-) -> Result<Response, NymPerformanceContractError> {
-    let address = deps.api.addr_validate(&address)?;
-
-    NYM_PERFORMANCE_CONTRACT_STORAGE.authorise_network_monitor(
-        deps,
-        &env,
-        &info.sender,
-        address,
-    )?;
-
-    // TODO: emit events
-    Ok(Response::new())
-}
-
-pub fn try_retire_network_monitor(
-    deps: DepsMut<'_>,
-    env: Env,
-    info: MessageInfo,
-    address: String,
-) -> Result<Response, NymPerformanceContractError> {
-    let address = deps.api.addr_validate(&address)?;
-
-    NYM_PERFORMANCE_CONTRACT_STORAGE.retire_network_monitor(deps, env, &info.sender, address)?;
-
-    // TODO: emit events
-    Ok(Response::new())
-}
-
-pub fn try_remove_node_measurements(
-    deps: DepsMut<'_>,
-    info: MessageInfo,
-    epoch_id: EpochId,
-    node_id: NodeId,
-) -> Result<Response, NymPerformanceContractError> {
-    NYM_PERFORMANCE_CONTRACT_STORAGE.remove_node_measurements(
-        deps,
-        &info.sender,
-        epoch_id,
-        node_id,
-    )?;
-
-    Ok(Response::new())
-}
-
-pub fn try_remove_epoch_measurements(
-    deps: DepsMut<'_>,
-    info: MessageInfo,
-    epoch_id: EpochId,
-) -> Result<Response, NymPerformanceContractError> {
-    let res =
-        NYM_PERFORMANCE_CONTRACT_STORAGE.remove_epoch_measurements(deps, &info.sender, epoch_id)?;
-
-    Ok(Response::new().set_data(to_json_binary(&res)?))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::storage::retrieval_limits;
-    use crate::testing::{init_contract_tester, PerformanceContractTesterExt};
-    use cosmwasm_std::from_json;
-    use nym_contracts_common_testing::{AdminExt, ContractOpts};
-    use nym_performance_contract_common::RemoveEpochMeasurementsResponse;
-
-    #[cfg(test)]
-    mod updating_contract_admin {
-        use super::*;
-        use crate::testing::init_contract_tester;
-        use cw_controllers::AdminError;
-        use nym_contracts_common_testing::{AdminExt, ContractOpts, RandExt};
-        use nym_performance_contract_common::ExecuteMsg;
-
-        #[test]
-        fn can_only_be_performed_by_current_admin() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
-
-            let random_acc = test.generate_account();
-            let new_admin = test.generate_account();
-            let res = test
-                .execute_raw(
-                    random_acc,
-                    ExecuteMsg::UpdateAdmin {
-                        admin: new_admin.to_string(),
-                    },
-                )
-                .unwrap_err();
-
-            assert_eq!(
-                res,
-                NymPerformanceContractError::Admin(AdminError::NotAdmin {})
-            );
-
-            let actual_admin = test.admin_unchecked();
-            let res = test.execute_raw(
-                actual_admin.clone(),
-                ExecuteMsg::UpdateAdmin {
-                    admin: new_admin.to_string(),
-                },
-            );
-            assert!(res.is_ok());
-
-            let updated_admin = test.admin_unchecked();
-            assert_eq!(new_admin, updated_admin);
-
-            Ok(())
-        }
-
-        #[test]
-        fn requires_providing_valid_address() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
-
-            let bad_account = "definitely-not-valid-account";
-            let res = test.execute_raw(
-                test.admin_unchecked(),
-                ExecuteMsg::UpdateAdmin {
-                    admin: bad_account.to_string(),
-                },
-            );
-
-            assert!(res.is_err());
-
-            let empty_account = "";
-            let res = test.execute_raw(
-                test.admin_unchecked(),
-                ExecuteMsg::UpdateAdmin {
-                    admin: empty_account.to_string(),
-                },
-            );
-
-            assert!(res.is_err());
-
-            Ok(())
-        }
-    }
-
-    #[cfg(test)]
-    mod authorising_network_monitor {
-        use super::*;
-        use crate::testing::init_contract_tester;
-        use nym_contracts_common_testing::{AdminExt, ContractOpts, RandExt};
-
-        #[test]
-        fn requires_valid_address() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
-
-            let bad_address = "foomp".to_string();
-            let good_address = test.generate_account();
-
-            let env = test.env();
-            let admin = test.admin_msg();
-
-            assert!(try_authorise_network_monitor(
-                test.deps_mut(),
-                env.clone(),
-                admin.clone(),
-                bad_address
-            )
-            .is_err());
-            assert!(try_authorise_network_monitor(
-                test.deps_mut(),
-                env,
-                admin,
-                good_address.to_string()
-            )
-            .is_ok());
-
-            Ok(())
-        }
-    }
-
-    #[cfg(test)]
-    mod retiring_network_monitor {
-        use super::*;
-        use crate::testing::{init_contract_tester, PerformanceContractTesterExt};
-        use nym_contracts_common_testing::{AdminExt, ContractOpts, RandExt};
-
-        #[test]
-        fn requires_valid_address() -> anyhow::Result<()> {
-            let mut test = init_contract_tester();
-
-            let bad_address = "foomp".to_string();
-            let good_address = test.generate_account();
-            test.authorise_network_monitor(&good_address)?;
-
-            let env = test.env();
-            let admin = test.admin_msg();
-
-            assert!(try_retire_network_monitor(
-                test.deps_mut(),
-                env.clone(),
-                admin.clone(),
-                bad_address
-            )
-            .is_err());
-            assert!(try_retire_network_monitor(
-                test.deps_mut(),
-                env,
-                admin,
-                good_address.to_string()
-            )
-            .is_ok());
-
-            Ok(())
-        }
-    }
-
-    // panics in tests are fine...
-    #[allow(clippy::panic)]
-    #[test]
-    fn removing_epoch_measurements_returns_binary_data() -> anyhow::Result<()> {
-        let mut tester = init_contract_tester();
-
-        let nm = tester.addr_make("network-monitor");
-        tester.authorise_network_monitor(&nm)?;
-
-        tester.advance_mixnet_epoch()?;
-        for _ in 0..2 * retrieval_limits::EPOCH_PERFORMANCE_PURGE_LIMIT {
-            let node_id = tester.bond_dummy_nymnode()?;
-            tester.insert_raw_performance(&nm, node_id, "0.42")?;
-        }
-
-        let admin = tester.admin_msg();
-        let res = try_remove_epoch_measurements(tester.deps_mut(), admin.clone(), 0)?;
-
-        let Some(data) = res.data else {
-            panic!("missing binary response");
-        };
-        let deserialised: RemoveEpochMeasurementsResponse = from_json(&data)?;
-        assert!(!deserialised.additional_entries_to_remove_remaining);
-
-        let res = try_remove_epoch_measurements(tester.deps_mut(), admin, 1)?;
-
-        let Some(data) = res.data else {
-            panic!("missing binary response");
-        };
-        let deserialised: RemoveEpochMeasurementsResponse = from_json(&data)?;
-        assert!(deserialised.additional_entries_to_remove_remaining);
-
-        Ok(())
-    }
-}
@@ -18,6 +18,7 @@ GROUP_CONTRACT_ADDRESS=n1qg5ega6dykkxc307y25pecuufrjkxkaggkkxh7nad0vhyhtuhw3sa07
 MULTISIG_CONTRACT_ADDRESS=n1zwv6feuzhy6a9wekh96cd57lsarmqlwxdypdsplw6zhfncqw6ftqx5a364
 COCONUT_DKG_CONTRACT_ADDRESS=n1aakfpghcanxtc45gpqlx8j3rq0zcpyf49qmhm9mdjrfx036h4z5sy2vfh9

+EXPLORER_API=https://canary-explorer.performance.nymte.ch/api/
 NYXD=https://rpc.canary-validator.performance.nymte.ch
 NYM_API=https://canary-api.performance.nymte.ch/api/
 NYXD_WS=wss://rpc.canary-validator.performance.nymte.ch/websocket
@@ -23,4 +23,5 @@ STATISTICS_SERVICE_DOMAIN_ADDRESS="https://mainnet-stats.nymte.ch:8090"
 NYXD="https://rpc.nymtech.net"
 NYM_API="http://127.0.0.1:8000"
 NYXD_WS="wss://rpc.nymtech.net/websocket"
+EXPLORER_API="https://explorer.nymtech.net/api/"
 NYM_VPN_API="https://nymvpn.com/api"
@@ -24,4 +24,5 @@ STATISTICS_SERVICE_DOMAIN_ADDRESS=https://mainnet-stats.nymte.ch:8090
 NYXD=https://rpc.nymtech.net
 NYM_API=https://validator.nymtech.net/api/
 NYXD_WS=wss://rpc.nymtech.net/websocket
+EXPLORER_API=https://explorer.nymtech.net/api/
 NYM_VPN_API=https://nymvpn.com/api/
@@ -19,6 +19,7 @@ COCONUT_DKG_CONTRACT_ADDRESS=n1v3n2ly2dp3a9ng3ff6rh26yfkn0pc5hed7w2shc5u9ca5c865
 ECASH_CONTRACT_ADDRESS=n1v3vydvs2ued84yv3khqwtgldmgwn0elljsdh08dr5s2j9x4rc5fs9jlwz9

 STATISTICS_SERVICE_DOMAIN_ADDRESS="http://0.0.0.0"
+EXPLORER_API=https://sandbox-explorer.nymtech.net/api/
 NYXD=https://rpc.sandbox.nymtech.net
 NYXD_WS=wss://rpc.sandbox.nymtech.net/websocket
 NYM_API=https://sandbox-nym-api1.nymtech.net/api/
@@ -0,0 +1,3 @@
+{
+  "extends": ["next/core-web-vitals"]
+}
@@ -0,0 +1,36 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+.yarn/install-state.gz
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env*.local
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
@@ -0,0 +1,36 @@
+This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).
+
+## Getting Started
+
+First, run the development server:
+
+```bash
+npm run dev
+# or
+yarn dev
+# or
+pnpm dev
+# or
+bun dev
+```
+
+Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.
+
+You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file.
+
+This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font.
+
+## Learn More
+
+To learn more about Next.js, take a look at the following resources:
+
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.
+
+You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome!
+
+## Deploy on Vercel
+
+The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.
+
+Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details.
@@ -0,0 +1,11 @@
+import React from 'react'
+import { Navbar } from './components/Nav/Navbar'
+import { Providers } from './providers'
+
+const App = ({ children }: { children: React.ReactNode }) => (
+  <Providers>
+    <Navbar>{children}</Navbar>
+  </Providers>
+)
+
+export { App }
@@ -0,0 +1,407 @@
+'use client'
+
+import * as React from 'react'
+import {Alert, AlertTitle, Box, Button, Chip, CircularProgress, Grid, Tooltip, Typography} from '@mui/material'
+import { useParams } from 'next/navigation'
+import { useMainContext } from '@/app/context/main'
+import { Title } from '@/app/components/Title'
+import { MaterialReactTable, MRT_ColumnDef, useMaterialReactTable } from "material-react-table";
+import { useMemo } from "react";
+import { humanReadableCurrencyToString } from "@/app/utils/currency";
+import Table from '@mui/material/Table';
+import TableBody from '@mui/material/TableBody';
+import TableCell from '@mui/material/TableCell';
+import TableContainer from '@mui/material/TableContainer';
+import TableRow from '@mui/material/TableRow';
+import Paper from '@mui/material/Paper';
+import CheckCircleOutlineIcon from '@mui/icons-material/CheckCircleOutline';
+import WarningAmberIcon from '@mui/icons-material/WarningAmber';
+import { PieChart } from '@mui/x-charts/PieChart';
+import { useTheme } from "@mui/material/styles";
+import { useIsMobile } from "@/app/hooks";
+import { StyledLink } from "@/app/components";
+
+const AccumulatedRewards = ({account}: { account?: any}) => {
+  const columns = useMemo<
+    MRT_ColumnDef<any>[]
+  >(() => {
+    return [
+      {
+        id: 'accumulated-rewards-data',
+        header: 'Accumulated Rewards Data',
+        columns: [
+          {
+            id: 'node_id',
+            accessorKey: 'node_id',
+            header: 'Node ID',
+            size: 150,
+            Cell: ({ row }) => (<StyledLink
+              color="text.primary"
+              to={`/network-components/nodes/${row.original.node_id}`}>
+              {row.original.node_id}
+            </StyledLink>),
+          },
+          {
+            id: 'node_still_fully_bonded',
+            accessorKey: 'node_still_fully_bonded',
+            header: 'Node still bonded?',
+            width: 150,
+            Cell: ({ row }) => (
+              <>{row.original.node_still_fully_bonded ? <CheckCircleOutlineIcon/> :
+                <Typography fontSize="inherit" alignItems="center" display="flex" sx={{ color: theme => theme.palette.warning.main }}>
+                  <WarningAmberIcon sx={{ mr: 1 }}/>
+                  Unbonded
+                </Typography>}</>
+            )
+          },
+          {
+            id: 'amount_staked',
+            accessorKey: 'amount_staked',
+            header: 'Amount',
+            width: 150,
+            Cell: ({ row }) => (
+              <>{humanReadableCurrencyToString(row.original.amount_staked)}</>
+            )
+          },
+          {
+            id: 'rewards',
+            accessorKey: 'rewards',
+            header: 'Rewards',
+            width: 150,
+            Cell: ({ row }) => (
+              <Typography fontSize="inherit" color="success.main">{humanReadableCurrencyToString(row.original.rewards)}</Typography>
+            )
+          },
+        ],
+      },
+    ]
+  }, [])
+
+  const table = useMaterialReactTable({
+    columns,
+    data: account?.accumulated_rewards || [],
+    enableFullScreenToggle: false,
+  })
+
+  return (<MaterialReactTable table={table} />);
+}
+
+const DelegationHistory = ({account}: { account?: any}) => {
+  const columns = useMemo<
+    MRT_ColumnDef<any>[]
+  >(() => {
+    return [
+      {
+        id: 'delegation-history-data',
+        header: 'Delegation History',
+        columns: [
+          {
+            id: 'node_id',
+            accessorKey: 'node_id',
+            header: 'Node ID',
+            size: 150,
+          },
+          {
+            id: 'delegated',
+            accessorKey: 'delegated',
+            header: 'Amount',
+            width: 150,
+            Cell: ({ row }) => (
+              <>{humanReadableCurrencyToString(row.original.delegated)}</>
+            )
+          },
+          {
+            id: 'height',
+            accessorKey: 'height',
+            header: 'Delegated at height',
+            width: 150,
+            Cell: ({ row }) => (
+              <>{row.original.height}</>
+            )
+          },
+        ],
+      },
+    ]
+  }, [])
+
+  const table = useMaterialReactTable({
+    columns,
+    data: account?.delegations || [],
+    enableFullScreenToggle: false,
+  })
+
+  return (<MaterialReactTable table={table} />);
+}
+
+
+/**
+ * Shows account details
+ */
+const PageAccountWithState = ({ account }: {
+  account?: any;
+}) => {
+  const theme = useTheme();
+  const isMobile = useIsMobile();
+
+  const pieChartData = React.useMemo(() => {
+    if(!account) {
+      return [];
+    }
+
+    const parts = [];
+
+    const nymBalance = Number.parseFloat(account.balances.find((b: any) => b.denom === "unym")?.amount || "0") / 1e6;
+
+    if(nymBalance > 0) {
+      parts.push({label: "Spendable", value: nymBalance, color: theme.palette.primary.main});
+    }
+
+    if(account.vesting_account) {
+      if (`${account.vesting_account.locked?.amount}` !== "0") {
+        const value = Number.parseFloat(account.vesting_account.locked.amount) / 1e6;
+        if(value > 0) {
+          parts.push({
+            label: "Vesting locked",
+            value,
+            color: 'red'
+          });
+        }
+      }
+      if (`${account.vesting_account.spendable?.amount}` !== "0") {
+        const value = Number.parseFloat(account.vesting_account.spendable.amount) / 1e6;
+        if(value > 0) {
+          parts.push({
+            label: "Vesting spendable",
+            value,
+            color: theme.palette.primary.light
+          });
+        }
+      }
+    }
+
+    if (account.claimable_rewards &&`${account.claimable_rewards.amount}` !== "0") {
+      const value = Number.parseFloat(account.claimable_rewards.amount) / 1e6;
+      if(value > 0) {
+        parts.push({
+          label: "Claimable delegation rewards",
+          value,
+          color: theme.palette.success.light
+        });
+      }
+    }
+    if (account.operator_rewards && `${account.operator_rewards.amount}` !== "0") {
+      const value = Number.parseFloat(account.operator_rewards.amount) / 1e6;
+      if(value > 0) {
+        parts.push({
+          label: "Claimable operator rewards",
+          value,
+          color: theme.palette.success.dark
+        });
+      }
+    }
+    if (account.total_delegations && `${account.total_delegations.amount}` !== "0") {
+      const value = Number.parseFloat(account.total_delegations.amount) / 1e6;
+      if(value > 0) {
+        parts.push({
+          label: "Total delegations",
+          value,
+          color: '#888'
+        });
+      }
+    }
+
+    return parts;
+  }, [account]);
+
+  return (
+    <Box component="main">
+      <Box overflow="scroll">
+        <Title text={`Account ${account.address}`} />
+      </Box>
+
+      <Box mt={4} sx={{ maxWidth: "600px" }}>
+        <PieChart
+          series={[
+            {
+              data: pieChartData,
+              innerRadius: 40,
+              outerRadius: 80,
+              cy: isMobile ? 200 : undefined,
+            },
+          ]}
+          height={300}
+          slotProps={isMobile ? {
+            legend: { position: { vertical: "top", horizontal: "right" } }
+          } : undefined}
+        />
+      </Box>
+
+      <Box mt={4}>
+        <TableContainer component={Paper} sx={{ maxWidth: "400px" }}>
+          <Table>
+            <TableBody>
+              <TableRow sx={{ color: theme => theme.palette.primary.main }}>
+                <TableCell component="th" scope="row" sx={{ color: "inherit" }}>
+                  <strong>Spendable Balance</strong>
+                </TableCell>
+                <TableCell align="right" sx={{ color: "inherit" }}>
+                  {account.balances.map((b: any) => (<strong key={`balance-${b.denom}`}>{humanReadableCurrencyToString(b)}<br/></strong>))}
+                </TableCell>
+              </TableRow>
+              <TableRow>
+                <TableCell component="th" scope="row">
+                  Total delegations
+                </TableCell>
+                <TableCell align="right">
+                  {humanReadableCurrencyToString(account.total_delegations)}
+                </TableCell>
+              </TableRow>
+              {account.claimable_rewards && <TableRow sx={{ color: theme => theme.palette.success.light }}>
+                <TableCell component="th" scope="row" sx={{ color: "inherit" }}>
+                  Claimable delegation rewards
+                </TableCell>
+                <TableCell align="right" sx={{ color: "inherit" }}>
+                  {humanReadableCurrencyToString(account.claimable_rewards)}
+                </TableCell>
+              </TableRow>}
+              {account.operator_rewards && `${account.operator_rewards.amount}` !== "0" && <TableRow sx={{ color: theme => theme.palette.success.light }}>
+                <TableCell component="th" scope="row" sx={{ color: "inherit" }}>
+                  Claimable operator rewards
+                </TableCell>
+                <TableCell align="right" sx={{ color: "inherit" }}>
+                  {humanReadableCurrencyToString(account.operator_rewards)}
+                </TableCell>
+              </TableRow>}
+              {account.vesting_account && (
+                <>
+                  <TableRow>
+                    <TableCell component="th" scope="row" colSpan={2}>
+                      Vesting account
+                    </TableCell>
+                  </TableRow>
+                  {`${account.vesting_account.locked.amount}` !== "0" &&
+                    <TableRow>
+                        <TableCell component="th" scope="row" sx={{ pl: 4 }}>
+                            Locked
+                        </TableCell>
+                        <TableCell align="right" sx={{ color: "inherit" }}>
+                          {humanReadableCurrencyToString(account.vesting_account.locked)}
+                        </TableCell>
+                    </TableRow>
+                  }
+                  {`${account.vesting_account.vested.amount}` !== "0" &&
+                      <TableRow>
+                          <TableCell component="th" scope="row" sx={{ pl: 4 }}>
+                              Vested
+                          </TableCell>
+                          <TableCell align="right" sx={{ color: "inherit" }}>
+                            {humanReadableCurrencyToString(account.vesting_account.vested)}
+                          </TableCell>
+                      </TableRow>
+                  }
+                  {`${account.vesting_account.vesting.amount}` !== "0" &&
+                      <TableRow>
+                          <TableCell component="th" scope="row" sx={{ pl: 4 }}>
+                              Vesting
+                          </TableCell>
+                          <TableCell align="right" sx={{ color: "inherit" }}>
+                            {humanReadableCurrencyToString(account.vesting_account.vesting)}
+                          </TableCell>
+                      </TableRow>
+                  }
+                  {`${account.vesting_account.spendable.amount}` !== "0" &&
+                      <TableRow>
+                          <TableCell component="th" scope="row" sx={{ pl: 4 }}>
+                              Spendable
+                          </TableCell>
+                          <TableCell align="right" sx={{ color: "inherit" }}>
+                            {humanReadableCurrencyToString(account.vesting_account.spendable)}
+                          </TableCell>
+                      </TableRow>
+                  }
+                </>
+              )}
+              <TableRow>
+                <TableCell component="th" scope="row" sx={{ color: "inherit" }}>
+                  <h3>Total value</h3>
+                </TableCell>
+                <TableCell align="right" sx={{ color: "inherit" }}>
+                  <h3>{humanReadableCurrencyToString(account.total_value)}</h3>
+                </TableCell>
+              </TableRow>
+            </TableBody>
+          </Table>
+        </TableContainer>
+      </Box>
+      <Box mt={4}>
+        <AccumulatedRewards account={account}/>
+      </Box>
+      <Box mt={4}>
+        <DelegationHistory account={account}/>
+      </Box>
+    </Box>
+  )
+}
+
+/**
+ * Guard component to handle loading and not found states
+ */
+const PageAccountDetailGuard = ({ account } : { account: string }) => {
+  const [accountDetails, setAccountDetails] = React.useState<any>();
+  const [isLoading, setLoading] = React.useState<boolean>(true);
+  const [error, setError] = React.useState<string>();
+  const { fetchAccountById } = useMainContext()
+  const { id } = useParams()
+
+  React.useEffect(() => {
+    setLoading(true);
+    (async () => {
+      if(typeof(id) === "string") {
+        try {
+          const res = await fetchAccountById(account);
+          setAccountDetails(res);
+        } catch(e: any) {
+          setError(e.message);
+        }
+        finally {
+          setLoading(false);
+        }
+      }
+    })();
+  }, [id])
+
+  if (isLoading) {
+    return <CircularProgress />
+  }
+
+  // loaded, but not found
+  if (error) {
+    return (
+      <Alert severity="warning">
+        <AlertTitle>Account not found</AlertTitle>
+        Sorry, we could not find the account <code>{id || ''}</code>
+      </Alert>
+    )
+  }
+
+  return <PageAccountWithState account={accountDetails} />
+}
+
+/**
+ * Wrapper component that adds the account details based on the `id` in the address URL
+ */
+const PageAccountDetail = () => {
+  const { id } = useParams()
+
+  if (!id || typeof id !== 'string') {
+    return (
+      <Alert severity="error">Oh no! Could not find that account</Alert>
+    )
+  }
+
+  return (
+    <PageAccountDetailGuard account={id} />
+  )
+}
+
+export default PageAccountDetail
@@ -0,0 +1,39 @@
+// master APIs
+export const API_BASE_URL = process.env.NEXT_PUBLIC_EXPLORER_API_URL || 'https://explorer.nymtech.net/api/v1';
+export const NYM_API_BASE_URL = process.env.NEXT_PUBLIC_NYM_API_URL || 'https://validator.nymtech.net';
+
+export const NYX_RPC_BASE_URL = process.env.NEXT_PUBLIC_NYX_RPC_BASE_URL || 'https://rpc.nymtech.net';
+
+export const VALIDATOR_BASE_URL = process.env.NEXT_PUBLIC_VALIDATOR_URL || 'https://rpc.nymtech.net';
+export const BLOCK_EXPLORER_BASE_URL = process.env.NEXT_PUBLIC_BIG_DIPPER_URL || 'https://nym.explorers.guru';
+
+// specific API routes
+export const OVERVIEW_API = `${API_BASE_URL}/overview`;
+export const MIXNODE_PING = `${API_BASE_URL}/ping`;
+export const MIXNODES_API = `${API_BASE_URL}/mix-nodes`;
+export const MIXNODE_API = `${API_BASE_URL}/mix-node`;
+export const VALIDATORS_API = `${NYX_RPC_BASE_URL}/validators`;
+export const BLOCK_API = `${NYX_RPC_BASE_URL}/block`;
+export const COUNTRY_DATA_API = `${API_BASE_URL}/countries`;
+export const UPTIME_STORY_API = `${NYM_API_BASE_URL}/api/v1/status/mixnode`; // add ID then '/history' to this.
+export const UPTIME_STORY_API_GATEWAY = `${NYM_API_BASE_URL}/api/v1/status/gateway`; // add ID then '/history' or '/report' to this
+export const SERVICE_PROVIDERS = `${API_BASE_URL}/service-providers`;
+export const TEMP_UNSTABLE_NYM_NODES = `${API_BASE_URL}/tmp/unstable/nym-nodes`;
+export const TEMP_UNSTABLE_ACCOUNT = `${API_BASE_URL}/tmp/unstable/account`;
+export const NYM_API_NODE_UPTIME = `${NYM_API_BASE_URL}/api/v1/nym-nodes/uptime-history`;
+export const NYM_API_NODE_PERFORMANCE = `${NYM_API_BASE_URL}/api/v1/nym-nodes/performance-history`;
+
+export const LEGACY_MIXNODES_API = `${API_BASE_URL}/tmp/unstable/legacy-mixnode-bonds`;
+export const LEGACY_GATEWAYS_API = `${API_BASE_URL}/tmp/unstable/legacy-gateway-bonds`;
+
+// errors
+export const MIXNODE_API_ERROR = "We're having trouble finding that record, please try again or Contact Us.";
+
+export const NYM_WEBSITE = 'https://nymtech.net';
+
+export const EXPLORER_FOR_ACCOUNTS = ''; // set to empty to use this Nym Explorer and NOT an external one
+
+export const NYM_MIXNET_CONTRACT =
+  process.env.NYM_MIXNET_CONTRACT || 'n17srjznxl9dvzdkpwpw24gg668wc73val88a6m5ajg6ankwvz9wtst0cznr';
+export const COSMOS_KIT_USE_CHAIN = process.env.NEXT_PUBLIC_COSMOS_KIT_USE_CHAIN || 'sandbox';
+export const WALLET_CONNECT_PROJECT_ID = process.env.NEXT_PUBLIC_WALLET_CONNECT_PROJECT_ID || '';
@@ -0,0 +1,217 @@
+import keyBy from 'lodash/keyBy';
+import {
+  API_BASE_URL,
+  BLOCK_API,
+  COUNTRY_DATA_API,
+  UPTIME_STORY_API_GATEWAY,
+  MIXNODE_API,
+  MIXNODE_PING,
+  MIXNODES_API,
+  OVERVIEW_API,
+  UPTIME_STORY_API,
+  VALIDATORS_API,
+  SERVICE_PROVIDERS,
+  TEMP_UNSTABLE_NYM_NODES,
+  NYM_API_NODE_UPTIME,
+  NYM_API_NODE_PERFORMANCE,
+  TEMP_UNSTABLE_ACCOUNT,
+  LEGACY_MIXNODES_API, LEGACY_GATEWAYS_API,
+} from './constants';
+
+import {
+  CountryDataResponse,
+  DelegationsResponse,
+  UniqDelegationsResponse,
+  GatewayReportResponse,
+  UptimeStoryResponse,
+  MixNodeDescriptionResponse,
+  MixNodeResponse,
+  MixNodeResponseItem,
+  MixnodeStatus,
+  MixNodeEconomicDynamicsStatsResponse,
+  StatsResponse,
+  StatusResponse,
+  SummaryOverviewResponse,
+  ValidatorsResponse,
+  Environment,
+  GatewayBondAnnotated,
+  GatewayBond,
+  DirectoryServiceProvider,
+  LocatedGateway,
+} from '../typeDefs/explorer-api';
+
+function getFromCache(key: string) {
+  const ts = Number(localStorage.getItem('ts'));
+  const hasExpired = Date.now() - ts > 5000;
+  const curr = localStorage.getItem(key);
+  if (curr && !hasExpired) {
+    return JSON.parse(curr);
+  }
+  return undefined;
+}
+
+function storeInCache(key: string, data: any) {
+  localStorage.setItem(key, data);
+  localStorage.setItem('ts', Date.now().toString());
+}
+
+export class Api {
+  static fetchOverviewSummary = async (): Promise<SummaryOverviewResponse> => {
+    const cache = getFromCache('overview-summary');
+    if (cache) {
+      return cache;
+    }
+    const res = await fetch(`${OVERVIEW_API}/summary`);
+    const json: SummaryOverviewResponse = await res.json();
+
+    if (json.nymnodes?.roles) {
+      json.mixnodes.count += json.nymnodes.roles.mixnode;
+      json.gateways.count += json.nymnodes.roles.entry;
+      json.gateways.count += Math.max(json.nymnodes.roles.exit_ipr, json.nymnodes.roles.exit_nr);
+    }
+
+    storeInCache('overview-summary', JSON.stringify(json));
+    return json;
+  };
+
+  static fetchMixnodes = async (): Promise<MixNodeResponse> => {
+    const cachedMixnodes = getFromCache('mixnodes');
+    if (cachedMixnodes) {
+      return cachedMixnodes;
+    }
+
+    const res = await fetch(LEGACY_MIXNODES_API);
+    const json = await res.json();
+    storeInCache('mixnodes', JSON.stringify(json));
+    return json;
+  };
+
+  static fetchMixnodesActiveSetByStatus = async (status: MixnodeStatus): Promise<MixNodeResponse> => {
+    const cachedMixnodes = getFromCache(`mixnodes-${status}`);
+    if (cachedMixnodes) {
+      return cachedMixnodes;
+    }
+    const res = await fetch(`${MIXNODES_API}/active-set/${status}`);
+    const json = await res.json();
+    storeInCache(`mixnodes-${status}`, JSON.stringify(json));
+    return json;
+  };
+
+  static fetchMixnodeByID = async (id: string): Promise<MixNodeResponseItem | undefined> => {
+    const response = await fetch(`${MIXNODE_API}/${id}`);
+
+    // when the mixnode is not found, returned undefined
+    if (response.status === 404) {
+      return undefined;
+    }
+
+    return response.json();
+  };
+
+  static fetchGateways = async (): Promise<LocatedGateway[]> => {
+    // const res = await fetch(GATEWAYS_API);
+    // const gatewaysAnnotated: GatewayBondAnnotated[] = await res.json();
+    // const res2 = await fetch(GATEWAYS_EXPLORER_API);
+    // const locatedGateways: LocatedGateway[] = await res2.json();
+    // const locatedGatewaysByOwner = keyBy(locatedGateways, 'owner');
+    // return gatewaysAnnotated.map(({ gateway_bond, node_performance }) => ({
+    //   ...gateway_bond,
+    //   node_performance,
+    //   location: locatedGatewaysByOwner[gateway_bond.owner]?.location,
+    // }));
+
+    const res = await fetch(LEGACY_GATEWAYS_API);
+    const locatedGateways: LocatedGateway[] = await res.json();
+    return locatedGateways;
+  };
+
+  static fetchGatewayUptimeStoryById = async (id: string): Promise<UptimeStoryResponse> =>
+    (await fetch(`${UPTIME_STORY_API_GATEWAY}/${id}/history`)).json();
+
+  static fetchGatewayReportById = async (id: string): Promise<GatewayReportResponse> =>
+    (await fetch(`${UPTIME_STORY_API_GATEWAY}/${id}/report`)).json();
+
+  static fetchValidators = async (): Promise<ValidatorsResponse> => {
+    const res = await fetch(VALIDATORS_API);
+    const json = await res.json();
+    return json.result;
+  };
+
+  static fetchBlock = async (): Promise<number> => {
+    const res = await fetch(BLOCK_API);
+    const json = await res.json();
+    const { height } = json.result.block.header;
+    return height;
+  };
+
+  static fetchCountryData = async (): Promise<CountryDataResponse> => {
+    const result: CountryDataResponse = {};
+    const res = await fetch(COUNTRY_DATA_API);
+    const json = await res.json();
+    Object.keys(json).forEach((ISO3) => {
+      result[ISO3] = { ISO3, nodes: json[ISO3] };
+    });
+    return result;
+  };
+
+  static fetchDelegationsById = async (id: string): Promise<DelegationsResponse> =>
+    (await fetch(`${MIXNODE_API}/${id}/delegations`)).json();
+
+  static fetchUniqDelegationsById = async (id: string): Promise<UniqDelegationsResponse> =>
+    (await fetch(`${MIXNODE_API}/${id}/delegations/summed`)).json();
+
+  static fetchStatsById = async (id: string): Promise<StatsResponse> =>
+    (await fetch(`${MIXNODE_API}/${id}/stats`)).json();
+
+  static fetchMixnodeDescriptionById = async (id: string): Promise<MixNodeDescriptionResponse> =>
+    (await fetch(`${MIXNODE_API}/${id}/description`)).json();
+
+  static fetchMixnodeEconomicDynamicsStatsById = async (id: string): Promise<MixNodeEconomicDynamicsStatsResponse> =>
+    (await fetch(`${MIXNODE_API}/${id}/economic-dynamics-stats`)).json();
+
+  static fetchStatusById = async (id: string): Promise<StatusResponse> => (await fetch(`${MIXNODE_PING}/${id}`)).json();
+
+  static fetchUptimeStoryById = async (id: string): Promise<UptimeStoryResponse> =>
+    (await fetch(`${UPTIME_STORY_API}/${id}/history`)).json();
+
+  static fetchServiceProviders = async (): Promise<DirectoryServiceProvider[]> => {
+    const res = await fetch(SERVICE_PROVIDERS);
+    const json = await res.json();
+    return json;
+  };
+
+  static fetchNodes = async () => {
+    const res = await fetch(TEMP_UNSTABLE_NYM_NODES);
+    const json = await res.json();
+    return json;
+  }
+
+  static fetchNodeById = async (id: number) => {
+    const res = await fetch(`${TEMP_UNSTABLE_NYM_NODES}/${id}`);
+    const json = await res.json();
+    return json;
+  }
+
+  static fetchNymNodeUptimeHistoryById = async (id: number | string) => {
+    const res = await fetch(`${NYM_API_NODE_UPTIME}/${id}`)
+    const json = await res.json();
+    return json;
+  }
+
+  static fetchNymNodePerformanceById = async (id: number | string) => {
+    const res = await fetch(`${NYM_API_NODE_PERFORMANCE}/${id}`)
+    const json = await res.json();
+    return json;
+  }
+
+  static fetchAccountById = async (id: string) => {
+    const res = await fetch(`${TEMP_UNSTABLE_ACCOUNT}/${id}`);
+    const json = await res.json();
+    return json;
+  }
+}
+
+export const getEnvironment = (): Environment => {
+  const matchEnv = (env: Environment) => API_BASE_URL?.toLocaleLowerCase().includes(env) && env;
+  return matchEnv('sandbox') || matchEnv('qa') || 'mainnet';
+};
--- a/Show More
+++ b/Show More