and cargo lock

peek into headers
better ip address extraction
2025-06-05 15:10:52 +02:00 · 2025-06-05 15:10:44 +02:00 · 2025-06-05 14:05:01 +02:00
680 changed files with 111815 additions and 13547 deletions
@@ -5,6 +5,7 @@ on:
    paths:
      - 'clients/**'
      - 'common/**'
+      - 'explorer-api/**'
      - 'gateway/**'
      - 'integrations/**'
      - 'nym-api/**'
@@ -38,7 +39,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        os: [ arc-ubuntu-22.04, custom-windows-11, custom-macos-15 ]
+        os: [ arc-ubuntu-22.04, custom-windows-11, custom-runner-mac-m1 ]
    runs-on: ${{ matrix.os }}
    env:
      CARGO_TERM_COLOR: always
@@ -44,10 +44,8 @@ jobs:
            echo "Tag is empty"
            exit 1
          fi
-          # first, list all tags for logging purposes
          curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq
-          # check if there's a matching tag
-          exists=$(curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq -r --arg tag "$TAG" 'any(.tags[]; . == $tag)' )
+          exists=$(curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq --arg tag $TAG '.tags | contains([$tag])' )
          if [[ $exists = "true" ]]; then
            echo "Version '$TAG' defined in Cargo.toml ALREADY EXISTS as tag in harbor repo"
            exit 1
@@ -55,5 +53,5 @@ jobs:
            echo "Version '$TAG' doesn't exist on the remote"
          else
            echo "Unknown output '$exists'"
-            exit 2
+            exit 1
          fi
@@ -44,10 +44,8 @@ jobs:
            echo "Tag is empty"
            exit 1
          fi
-          # first, list all tags for logging purposes
          curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq
-          # check if there's a matching tag
-          exists=$(curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq -r --arg tag "$TAG" 'any(.tags[]; . == $tag)' )
+          exists=$(curl -su ${{ secrets.HARBOR_ROBOT_USERNAME }}:${{ secrets.HARBOR_ROBOT_SECRET }} "$registry/v2/$repo_name/tags/list" | jq --arg tag $TAG '.tags | contains([$tag])' )
          if [[ $exists = "true" ]]; then
            echo "Version '$TAG' defined in Cargo.toml ALREADY EXISTS as tag in harbor repo"
            exit 1
@@ -55,5 +53,5 @@ jobs:
            echo "Version '$TAG' doesn't exist on the remote"
          else
            echo "Unknown output '$exists'"
-            exit 2
+            exit 1
          fi
@@ -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 }}
@@ -70,6 +66,7 @@ jobs:
        with:
          name: my-artifact
          path: |
+            target/release/explorer-api
            target/release/nym-client
            target/release/nym-socks5-client
            target/release/nym-api
@@ -78,13 +75,14 @@ jobs:
            target/release/nymvisor
            target/release/nym-node
          retention-days: 30
-    
+
      - id: create-release
        name: Upload to release based on tag name
-        uses: softprops/action-gh-release@da05d552573ad5aba039eaac05058a918a7bf631
+        uses: softprops/action-gh-release@v2
        if: github.event_name == 'release'
        with:
          files: |
+            target/release/explorer-api
            target/release/nym-client
            target/release/nym-socks5-client
            target/release/nym-api
@@ -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 }}
@@ -40,6 +40,7 @@ validator-config
 validator-api-config.toml
 dist
 storybook-static
+envs/qwerty.env
 .parcel-cache
 **/.DS_Store
 cpu-cycles/libcpucycles/build
@@ -4,30 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [2025.11-cheddar] (2025-06-10)
-
- No autoremoval of peers ([#5831])
- Set cached storage counters to 0 ([#5812])
- hack: temporarily use next.config.js instead of next.config.ts ([#5805])
- chore: resolve 1.87 clippy warnings ([#5802])
- Nym Statistics API ([#5800])
- QoL: RequestPath trait for http-api-client ([#5788])
- Fix contains ticketbook function that always returned true ([#5787])
- swap a decode into a fromrow to please future postgres feature ([#5785])
- Make address cache configurable ([#5784])
- Track wireguard credential retries ([#5783])
-
-[#5831]: https://github.com/nymtech/nym/pull/5831
-[#5812]: https://github.com/nymtech/nym/pull/5812
-[#5805]: https://github.com/nymtech/nym/pull/5805
-[#5802]: https://github.com/nymtech/nym/pull/5802
-[#5800]: https://github.com/nymtech/nym/pull/5800
-[#5788]: https://github.com/nymtech/nym/pull/5788
-[#5787]: https://github.com/nymtech/nym/pull/5787
-[#5785]: https://github.com/nymtech/nym/pull/5785
-[#5784]: https://github.com/nymtech/nym/pull/5784
-[#5783]: https://github.com/nymtech/nym/pull/5783
-
 ## [2025.10-brie] (2025-05-27)

 - Backport PR 5779 ([#5801])
@@ -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",
@@ -102,6 +101,7 @@ members = [
    "common/wireguard-types",
    "documentation/autodoc",
    "gateway",
+    "integrations/bity",
    "nym-api",
    "nym-api/nym-api-requests",
    "nym-browser-extension/storage",
@@ -127,7 +127,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 +136,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 +288,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 +369,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 +379,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

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.57"
+version = "1.1.56"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.57"
+version = "1.1.56"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -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,
    },
@@ -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 }
@@ -16,8 +16,8 @@ async fn main() {
    let prefix = "n";
    let denom: Denom = "unym".parse().unwrap();
    let signer_mnemonic: bip39::Mnemonic = "<MNEMONIC WITH FUNDS HERE>".parse().unwrap();
-    let validator = "https://rpc.sandbox.nymtech.net";
-    let to_address: AccountId = "n1pefc2utwpy5w78p2kqdsfmpjxfwmn9d39k5mqa".parse().unwrap();
+    let validator = "https://qwerty-validator.qa.nymte.ch";
+    let to_address: AccountId = "n19kdst4srf76xgwe55jg32mpcpcyf6aqgp6qrdk".parse().unwrap();

    let signer = DirectSecp256k1HdWallet::from_mnemonic(prefix, signer_mnemonic);
    let signer_address = signer.try_derive_accounts().unwrap()[0].address().clone();
@@ -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()
    }
@@ -60,7 +60,7 @@ pub async fn send(args: Args, client: &SigningClient) {
        "Nodesguru: https://nym.explorers.guru/transaction/{}",
        &res.hash
    );
-    println!("Mintscan: https://ping.pub/nyx/tx/{}", &res.hash);
+    println!("Mintscan: https://www.mintscan.io/nyx/txs/{}", &res.hash);
    println!("Transaction result code: {}", &res.tx_result.code.value());
    println!("Transaction hash: {}", &res.hash);
 }
@@ -95,7 +95,7 @@ pub async fn send_multiple(args: Args, client: &SigningClient) {
        "Nodesguru: https://nym.explorers.guru/transaction/{}",
        &res.hash
    );
-    println!("Mintscan: https://ping.pub/nyx/tx/{}", &res.hash);
+    println!("Mintscan: https://www.mintscan.io/nyx/txs/{}", &res.hash);
    println!("Transaction result code: {}", &res.tx_result.code.value());
    println!("Transaction hash: {}", &res.hash);

@@ -76,7 +76,7 @@ pub async fn execute(args: Args, client: SigningClient) {
                        &res.transaction_hash
                    );
                    println!(
-                        "Mintscan: https://ping.pub/nyx/tx/{}",
+                        "Mintscan: https://www.mintscan.io/nyx/txs/{}",
                        &res.transaction_hash
                    );
                    println!("Transaction hash: {}", &res.transaction_hash);
@@ -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()),
        })
    }
 }
@@ -40,10 +40,6 @@ impl BandwidthStorageManager {
        }
    }

-    pub fn client_bandwidth(&self) -> ClientBandwidth {
-        self.client_bandwidth.clone()
-    }
-
    pub async fn available_bandwidth(&self) -> i64 {
        self.client_bandwidth.available().await
    }
@@ -88,8 +84,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<()> {
@@ -73,7 +73,7 @@ impl ClientBandwidth {
        false
    }

-    pub async fn available(&self) -> i64 {
+    pub(crate) async fn available(&self) -> i64 {
        self.inner.read().await.bandwidth.bytes
    }

@@ -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";
@@ -45,10 +45,6 @@ pub enum PeerControlRequest {
        key: Key,
        response_tx: oneshot::Sender<QueryBandwidthControlResponse>,
    },
-    GetClientBandwidth {
-        key: Key,
-        response_tx: oneshot::Sender<GetClientBandwidthControlResponse>,
-    },
 }

 pub struct AddPeerControlResponse {
@@ -69,10 +65,6 @@ pub struct QueryBandwidthControlResponse {
    pub bandwidth_data: Option<RemainingBandwidthData>,
 }

-pub struct GetClientBandwidthControlResponse {
-    pub client_bandwidth: Option<ClientBandwidth>,
-}
-
 pub struct PeerController {
    storage: GatewayStorage,

@@ -275,14 +267,6 @@ impl PeerController {
        }))
    }

-    async fn handle_get_client_bandwidth(&self, key: &Key) -> Option<ClientBandwidth> {
-        if let Some(Some(bandwidth_storage_manager)) = self.bw_storage_managers.get(key) {
-            Some(bandwidth_storage_manager.read().await.client_bandwidth())
-        } else {
-            None
-        }
-    }
-
    async fn update_metrics(&self, new_host: &Host) {
        let now = SystemTime::now();
        const ACTIVITY_THRESHOLD: Duration = Duration::from_secs(180);
@@ -404,10 +388,6 @@ impl PeerController {
                                response_tx.send(QueryBandwidthControlResponse { success: false, bandwidth_data: None }).ok();
                            }
                        }
-                        Some(PeerControlRequest::GetClientBandwidth { key, response_tx }) => {
-                            let client_bandwidth = self.handle_get_client_bandwidth(&key).await;
-                            response_tx.send(GetClientBandwidthControlResponse { client_bandwidth }).ok();
-                        }
                        None => {
                            log::trace!("PeerController [main loop]: stopping since channel closed");
                            break;
@@ -13,10 +13,12 @@ use nym_gateway_storage::models::WireguardPeer;
 use nym_task::TaskClient;
 use nym_wireguard_types::DEFAULT_PEER_TIMEOUT_CHECK;
 use std::sync::Arc;
+use std::time::{Duration, SystemTime};
 use tokio::sync::{mpsc, RwLock};
 use tokio_stream::{wrappers::IntervalStream, StreamExt};

 pub(crate) type SharedBandwidthStorageManager = Arc<RwLock<BandwidthStorageManager>>;
+const AUTO_REMOVE_AFTER: Duration = Duration::from_secs(60 * 60); // 1 hour

 pub struct PeerHandle {
    public_key: Key,
@@ -26,6 +28,7 @@ pub struct PeerHandle {
    request_tx: mpsc::Sender<PeerControlRequest>,
    timeout_check_interval: IntervalStream,
    task_client: TaskClient,
+    startup_timestamp: SystemTime,
 }

 impl PeerHandle {
@@ -50,6 +53,7 @@ impl PeerHandle {
            request_tx,
            timeout_check_interval,
            task_client,
+            startup_timestamp: SystemTime::now(),
        }
    }

@@ -69,49 +73,26 @@ impl PeerHandle {
        Ok(success)
    }

-    fn compute_spent_bandwidth(kernel_peer: &Peer, storage_peer: &WireguardPeer) -> Option<u64> {
-        let storage_peer_rx_bytes = u64::try_from(storage_peer.rx_bytes)
-            .inspect_err(|e| tracing::error!("Storage rx bytes could not be converted: {e}"))
-            .ok()?;
-        let storage_peer_tx_bytes = u64::try_from(storage_peer.tx_bytes)
-            .inspect_err(|e| tracing::error!("Storage tx bytes could not be converted: {e}"))
-            .ok()?;
-
-        let kernel_total = kernel_peer
-            .rx_bytes
-            .checked_add(kernel_peer.tx_bytes)
-            .or_else(|| {
-                tracing::error!(
-                    "Overflow on kernel adding bytes: {} + {}",
-                    kernel_peer.rx_bytes,
-                    kernel_peer.tx_bytes
-                );
-                None
-            })?;
-        let storage_total = storage_peer_rx_bytes
-            .checked_add(storage_peer_tx_bytes)
-            .or_else(|| {
-                tracing::error!("Overflow on storage adding bytes: {storage_peer_rx_bytes} + {storage_peer_tx_bytes}");
-                None
-            })?;
-
-        kernel_total.checked_sub(storage_total).or_else(|| {
-            tracing::error!("Overflow on spent bandwidth subtraction: kernel - storage = {kernel_total} - {storage_total}");
-            None
-        })
-    }
-
-    async fn active_peer(&mut self, kernel_peer: &Peer) -> Result<bool, Error> {
-        let Some(storage_peer) = self.peer_storage_manager.get_peer() else {
-            log::debug!(
-                "Peer {:?} not in storage anymore, shutting down handle",
-                self.public_key
-            );
-            return Ok(false);
-        };
-
+    async fn active_peer(
+        &mut self,
+        storage_peer: &WireguardPeer,
+        kernel_peer: &Peer,
+    ) -> Result<bool, Error> {
        if let Some(bandwidth_manager) = &self.bandwidth_storage_manager {
-            let spent_bandwidth = Self::compute_spent_bandwidth(kernel_peer, &storage_peer)
+            if kernel_peer.last_handshake.is_none()
+                && SystemTime::now().duration_since(self.startup_timestamp)? >= AUTO_REMOVE_AFTER
+            {
+                let success = self.remove_peer().await?;
+                self.peer_storage_manager.remove_peer();
+                tracing::debug!(
+                    "Peer {} has not been active for more then {} seconds, removing it",
+                    kernel_peer.public_key.to_string(),
+                    AUTO_REMOVE_AFTER.as_secs()
+                );
+                return Ok(!success);
+            }
+            let spent_bandwidth = (kernel_peer.rx_bytes + kernel_peer.tx_bytes)
+                .checked_sub(storage_peer.rx_bytes as u64 + storage_peer.tx_bytes as u64)
                .unwrap_or_else(|| {
                    // if gateway restarted, the kernel values restart from 0
                    // and we should restart from 0 in storage as well
@@ -119,10 +100,8 @@ impl PeerHandle {
                        self.peer_storage_manager.peer_information.as_mut()
                    {
                        peer_information.force_sync = true;
-                        peer_information.peer.rx_bytes = kernel_peer.rx_bytes;
-                        peer_information.peer.tx_bytes = kernel_peer.tx_bytes;
                    }
-                    0
+                    kernel_peer.rx_bytes + kernel_peer.tx_bytes
                })
                .try_into()
                .map_err(|_| Error::InconsistentConsumedBytes)?;
@@ -145,6 +124,14 @@ impl PeerHandle {
                }
            }
        } else {
+            if SystemTime::now().duration_since(self.startup_timestamp)? >= AUTO_REMOVE_AFTER {
+                log::debug!(
+                    "Peer {} has been present for 30 days, removing it",
+                    self.public_key
+                );
+                let success = self.remove_peer().await?;
+                return Ok(!success);
+            }
            let spent_bandwidth = kernel_peer.rx_bytes + kernel_peer.tx_bytes;
            if spent_bandwidth >= BANDWIDTH_CAP_PER_DAY {
                log::debug!(
@@ -171,7 +158,14 @@ impl PeerHandle {
            // the host information hasn't beed updated yet
            return Ok(true);
        };
-        if !self.active_peer(&kernel_peer).await? {
+        let Some(storage_peer) = self.peer_storage_manager.get_peer() else {
+            log::debug!(
+                "Peer {:?} not in storage anymore, shutting down handle",
+                self.public_key
+            );
+            return Ok(false);
+        };
+        if !self.active_peer(&storage_peer, &kernel_peer).await? {
            log::debug!(
                "Peer {:?} is not active anymore, shutting down handle",
                self.public_key
@@ -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> {}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Simon Wicky	4116319c6a	and cargo lock	2025-06-05 15:10:52 +02:00
Simon Wicky	0053f5523b	peek into headers	2025-06-05 15:10:44 +02:00
Simon Wicky	847aa65d66	better ip address extraction	2025-06-05 14:05:01 +02:00