Testing CI

2021-11-24 18:01:32 +00:00
338 changed files with 18438 additions and 33188 deletions
@@ -0,0 +1,58 @@
+name: ERC20 Bridge Contract
+
+on: [ push, pull_request ]
+
+jobs:
+  matrix_prep:
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      # creates the matrix strategy from build_matrix_includes.json
+      - uses: actions/checkout@v2
+      - id: set-matrix
+        uses: JoshuaTheMiller/conditional-build-matrix@main
+        with:
+          inputFile: '.github/workflows/contract_matrix_includes.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
+  erc20-bridge-contract:
+    needs: matrix_prep
+    strategy:
+      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
+    # since it's going to be compiled into wasm, there's absolutely
+    # no point in running CI on different OS-es
+    runs-on: ubuntu-latest
+    continue-on-error: ${{ matrix.rust == 'nightly' }}
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          target: wasm32-unknown-unknown
+          override: true
+          components: rustfmt, clippy
+
+      - uses: actions-rs/cargo@v1
+        env:
+          RUSTFLAGS: '-C link-arg=-s'
+        with:
+          command: build
+          args: --manifest-path contracts/erc20-bridge/Cargo.toml --target wasm32-unknown-unknown
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --manifest-path contracts/erc20-bridge/Cargo.toml
+
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --manifest-path contracts/erc20-bridge/Cargo.toml -- --check
+
+      - uses: actions-rs/cargo@v1
+        if: ${{ matrix.rust != 'nightly' }}
+        with:
+          command: clippy
+          args: --manifest-path contracts/erc20-bridge/Cargo.toml -- -D warnings
@@ -1,4 +1,4 @@
-name: Contracts
+name: Mixnet Contract

 on:
  push:
@@ -21,7 +21,7 @@ jobs:
        with:
          inputFile: '.github/workflows/contract_matrix_includes.json'
          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
-  contracts:
+  mixnet-contract:
    # since it's going to be compiled into wasm, there's absolutely
    # no point in running CI on different OS-es
    runs-on: ubuntu-latest
@@ -45,20 +45,20 @@ jobs:
          RUSTFLAGS: '-C link-arg=-s'
        with:
          command: build
-          args: --manifest-path contracts/Cargo.toml --all --target wasm32-unknown-unknown
+          args: --manifest-path contracts/mixnet/Cargo.toml --target wasm32-unknown-unknown

      - uses: actions-rs/cargo@v1
        with:
          command: test
-          args: --manifest-path contracts/Cargo.toml
+          args: --manifest-path contracts/mixnet/Cargo.toml

      - uses: actions-rs/cargo@v1
        with:
          command: fmt
-          args: --manifest-path contracts/Cargo.toml --all -- --check
+          args: --manifest-path contracts/mixnet/Cargo.toml -- --check

      - uses: actions-rs/cargo@v1
        if: ${{ matrix.rust != 'nightly' }}
        with:
          command: clippy
-          args: --manifest-path contracts/Cargo.toml --all -- -D warnings
+          args: --manifest-path contracts/mixnet/Cargo.toml -- -D warnings
@@ -22,8 +22,6 @@ jobs:
        node-version: '14'
    - run: npm install
      continue-on-error: true
-    - name: Set environment from the example
-      run: cp .env.prod .env
    - run: npm run test
      continue-on-error: true
    - run: npm run build
@@ -1,4 +1,4 @@
-name: Publish Nym Wallet
+name: Publish Tauri Wallet
 on:
  push:
    tags:
@@ -34,5 +34,4 @@ contracts/mixnet/code_id
 contracts/mixnet/Justfile
 contracts/mixnet/Makefile
 validator-config
-*.patch
-validator-api-config.toml
+*.patch
@@ -868,7 +868,8 @@ dependencies = [
 [[package]]
 name = "cosmos-sdk-proto"
 version = "0.8.0"
-source = "git+https://github.com/cosmos/cosmos-rust?rev=e5a1872083abb3d88fa62dda966e7f5408deba58#e5a1872083abb3d88fa62dda966e7f5408deba58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edb5204c6ddc4352c74297638b5561f2929d6334866c156e5f3c75e1e1a1436a"
 dependencies = [
 "prost",
 "prost-types",
@@ -878,7 +879,8 @@ dependencies = [
 [[package]]
 name = "cosmrs"
 version = "0.3.0"
-source = "git+https://github.com/cosmos/cosmos-rust?rev=e5a1872083abb3d88fa62dda966e7f5408deba58#e5a1872083abb3d88fa62dda966e7f5408deba58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d31147fe89e547e74e2692e4bec35387e1ea406fe8cfb14c0ea177b58fd2a8a9"
 dependencies = [
 "bip32",
 "cosmos-sdk-proto",
@@ -899,9 +901,8 @@ dependencies = [

 [[package]]
 name = "cosmwasm-crypto"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c16b255449b3f5cd7fa4b79acd5225b5185655261087a3d8aaac44f88a0e23e9"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "digest 0.9.0",
 "ed25519-zebra",
@@ -912,18 +913,16 @@ dependencies = [

 [[package]]
 name = "cosmwasm-derive"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abad1a6ff427a2f66890a4dce6354b4563cd07cee91a942300e011c921c09ed2"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "syn",
 ]

 [[package]]
 name = "cosmwasm-std"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1660ee3d5734672e1eb4f0ceda403e2d83345e15143a48845f340f3252ce99a6"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "base64",
 "cosmwasm-crypto",
@@ -1208,17 +1207,6 @@ dependencies = [
 "zeroize",
 ]

-[[package]]
-name = "cw-storage-plus"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3b8b840947313c1a1cccf056836cd79a60b4526bdcd6582995be37dc97be4ae"
-dependencies = [
- "cosmwasm-std",
- "schemars",
- "serde",
-]
-
 [[package]]
 name = "darling"
 version = "0.10.2"
@@ -1614,26 +1602,6 @@ dependencies = [
 "cfg-if 1.0.0",
 ]

-[[package]]
-name = "enum-iterator"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eeac5c5edb79e4e39fe8439ef35207780a11f69c52cbe424ce3dfad4cb78de6"
-dependencies = [
- "enum-iterator-derive",
-]
-
-[[package]]
-name = "enum-iterator-derive"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c134c37760b27a871ba422106eedbb8247da973a09e82558bf26d619c882b159"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "enum_kind"
 version = "0.2.1"
@@ -2305,19 +2273,6 @@ dependencies = [
 "winapi",
 ]

-[[package]]
-name = "git2"
-version = "0.13.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f29229cc1b24c0e6062f6e742aa3e256492a5323365e5ed3413599f8a5eff7d6"
-dependencies = [
- "bitflags",
- "libc",
- "libgit2-sys",
- "log",
- "url",
-]
-
 [[package]]
 name = "glib"
 version = "0.14.5"
@@ -3090,18 +3045,6 @@ version = "0.2.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2a5ac8f984bfcf3a823267e5fde638acc3325f6496633a5da6bb6eb2171e103"

-[[package]]
-name = "libgit2-sys"
-version = "0.12.26+1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19e1c899248e606fbfe68dcb31d8b0176ebab833b103824af31bddf4b7457494"
-dependencies = [
- "cc",
- "libc",
- "libz-sys",
- "pkg-config",
-]
-
 [[package]]
 name = "libm"
 version = "0.2.1"
@@ -3119,18 +3062,6 @@ dependencies = [
 "vcpkg",
 ]

-[[package]]
-name = "libz-sys"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
 [[package]]
 name = "lioness"
 version = "0.1.2"
@@ -3598,7 +3529,6 @@ dependencies = [
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 "websocket-requests",
 ]
@@ -3632,10 +3562,8 @@ name = "nym-gateway"
 version = "0.11.0"
 dependencies = [
 "bip39",
- "bs58",
 "clap",
 "coconut-interface",
- "colored",
 "config",
 "credentials",
 "crypto",
@@ -3657,7 +3585,6 @@ dependencies = [
 "rand 0.7.3",
 "serde",
 "sqlx",
- "subtle-encoding",
 "thiserror",
 "tokio",
 "tokio-stream",
@@ -3665,7 +3592,6 @@ dependencies = [
 "tokio-util",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 "web3",
 ]
@@ -3694,14 +3620,12 @@ dependencies = [
 "rocket",
 "serde",
 "serial_test",
- "subtle-encoding",
 "tokio",
 "tokio-util",
 "toml",
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 ]

@@ -3757,7 +3681,6 @@ dependencies = [
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 ]

@@ -3798,7 +3721,6 @@ dependencies = [
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 ]

@@ -3972,11 +3894,10 @@ dependencies = [

 [[package]]
 name = "okapi"
-version = "0.7.0-rc.1"
+version = "0.6.0-alpha-1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce66b6366e049880a35c378123fddb630b1a1a3c37fa1ca70caaf4a09f6e2893"
+checksum = "bb085e00daf8d75b9dbf0ffdb4738e69503e28898d9641fa8bdc6ad536c7bcf4"
 dependencies = [
- "log",
 "schemars",
 "serde",
 "serde_json",
@@ -5213,12 +5134,10 @@ dependencies = [

 [[package]]
 name = "rocket_okapi"
-version = "0.8.0-rc.1"
+version = "0.7.0-alpha-1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0025aa04994af8cd8e1fcdd5a73579a395c941ae090ecb0a39b41cca7e237a20"
+checksum = "8b2f4f48fb070f9f6c56d5663df5fa8a514406207744f4abd84661bfb24efd7d"
 dependencies = [
- "either",
- "log",
 "okapi",
 "rocket",
 "rocket_okapi_codegen",
@@ -5229,9 +5148,9 @@ dependencies = [

 [[package]]
 name = "rocket_okapi_codegen"
-version = "0.8.0-rc.1"
+version = "0.7.0-alpha-1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc114779fc27afb78179233e966f469e47fd7a98dc15181cff2574cdddb65612"
+checksum = "88ccf1550e1c806461a6b08e2ab64eb10701d41bf50bde59ab9aa3a57ab14d41"
 dependencies = [
 "darling 0.13.0",
 "proc-macro2",
@@ -7210,7 +7129,6 @@ dependencies = [
 "thiserror",
 "ts-rs",
 "url",
- "vesting-contract",
 ]

 [[package]]
@@ -7225,23 +7143,6 @@ version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"

-[[package]]
-name = "vergen"
-version = "5.1.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cf88d94e969e7956d924ba70741316796177fa0c79a2c9f4ab04998d96e966e"
-dependencies = [
- "anyhow",
- "cfg-if 1.0.0",
- "chrono",
- "enum-iterator",
- "getset",
- "git2",
- "rustc_version 0.4.0",
- "rustversion",
- "thiserror",
-]
-
 [[package]]
 name = "version-checker"
 version = "0.1.0"
@@ -7267,19 +7168,6 @@ version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"

-[[package]]
-name = "vesting-contract"
-version = "0.1.0"
-dependencies = [
- "config",
- "cosmwasm-std",
- "cw-storage-plus",
- "mixnet-contract",
- "schemars",
- "serde",
- "thiserror",
-]
-
 [[package]]
 name = "waker-fn"
 version = "1.1.0"
@@ -62,7 +62,6 @@ default-members = [
    "service-providers/network-requester",
    "mixnode",
    "validator-api",
-    "explorer-api",
 ]

 exclude = ["explorer", "contracts", "tokenomics-py"]
@@ -1,31 +0,0 @@
-all: clippy test fmt
-clippy: clippy-main clippy-contracts clippy-wallet
-test: test-main test-contracts test-wallet
-fmt: fmt-main fmt-contracts fmt-wallet
-
-clippy-main:
-	cargo clippy
-
-clippy-contracts:
-	cargo clippy --manifest-path contracts/Cargo.toml
-
-clippy-wallet: 
-	cargo clippy --manifest-path nym-wallet/Cargo.toml
-
-test-main:
-	cargo test
-
-test-contracts:
-	cargo test --manifest-path contracts/Cargo.toml
-
-test-wallet:
-	cargo test --manifest-path nym-wallet/Cargo.toml
-
-fmt-main:
-	cargo fmt --all
-
-fmt-contracts:
-	cargo fmt --manifest-path contracts/Cargo.toml --all
-
-fmt-wallet:
-	cargo fmt --manifest-path nym-wallet/Cargo.toml --all
@@ -13,7 +13,7 @@ The platform is composed of multiple Rust crates. Top-level executable binary cr
 * nym-gateway - acts sort of like a mailbox for mixnet messages, removing the need for directly delivery to potentially offline or firewalled devices.
 * nym-network-monitor - sends packets through the full system to check that they are working as expected, and stores node uptime histories as the basis of a rewards system ("mixmining" or "proof-of-mixing").
 * nym-explorer - a (projected) block explorer and (existing) mixnet viewer.
-* nym-wallet - a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 
+* nym-wallet (currently in development)- a desktop wallet implemented using the [Tauri](https://tauri.studio/en/docs/about/intro) framework. 

 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=for-the-badge)](https://opensource.org/licenses/Apache-2.0)
 [![Build Status](https://img.shields.io/github/workflow/status/nymtech/nym/Continuous%20integration/develop?style=for-the-badge&logo=github-actions)](https://github.com/nymtech/nym/actions?query=branch%3Adevelop)
@@ -51,6 +51,3 @@ coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gate

 [dev-dependencies]
 serde_json = "1.0" # for the "textsend" example
-
-[build-dependencies]
-vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
@@ -1,8 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use vergen::{vergen, Config};
-
-fn main() {
-    vergen(Config::default()).expect("failed to extract build metadata")
-}
@@ -3,5 +3,6 @@ module github.com/nymtech/nym/clients/native/examples/go
 go 1.14

 require (
+	github.com/btcsuite/btcutil v1.0.2 // indirect
 	github.com/gorilla/websocket v1.4.2
 )
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{crate_version, App, ArgMatches};
+use clap::{App, ArgMatches};

 pub mod client;
 pub mod commands;
@@ -13,8 +13,7 @@ fn main() {
    println!("{}", banner());

    let arg_matches = App::new("Nym Client")
-        .version(crate_version!())
-        .long_version(&*long_version())
+        .version(env!("CARGO_PKG_VERSION"))
        .author("Nymtech")
        .about("Implementation of the Nym Client")
        .subcommand(commands::init::command_args())
@@ -51,38 +50,7 @@ fn banner() -> String {
             (client - version {:})

    "#,
-        crate_version!()
-    )
-}
-
-fn long_version() -> String {
-    format!(
-        r#"
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-"#,
-        "Build Timestamp:",
-        env!("VERGEN_BUILD_TIMESTAMP"),
-        "Build Version:",
-        env!("VERGEN_BUILD_SEMVER"),
-        "Commit SHA:",
-        env!("VERGEN_GIT_SHA"),
-        "Commit Date:",
-        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
-        "Commit Branch:",
-        env!("VERGEN_GIT_BRANCH"),
-        "rustc Version:",
-        env!("VERGEN_RUSTC_SEMVER"),
-        "rustc Channel:",
-        env!("VERGEN_RUSTC_CHANNEL"),
-        "cargo Profile:",
-        env!("VERGEN_CARGO_PROFILE"),
+        env!("CARGO_PKG_VERSION")
    )
 }

@@ -43,6 +43,3 @@ network-defaults = { path = "../../common/network-defaults" }

 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]
-
-[build-dependencies]
-vergen = { version = "5", default-features = false, features = ["build", "git", "rustc", "cargo"] }
@@ -1,8 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use vergen::{vergen, Config};
-
-fn main() {
-    vergen(Config::default()).expect("failed to extract build metadata")
-}
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{crate_version, App, ArgMatches};
+use clap::{App, ArgMatches};

 pub mod client;
 mod commands;
@@ -15,7 +15,6 @@ fn main() {
    let arg_matches = App::new("Nym Socks5 Proxy")
        .version(env!("CARGO_PKG_VERSION"))
        .author("Nymtech")
-        .long_version(&*long_version())
        .about("A Socks5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address")
        .subcommand(commands::init::command_args())
        .subcommand(commands::run::command_args())
@@ -51,38 +50,7 @@ fn banner() -> String {
             (socks5 proxy - version {:})

    "#,
-        crate_version!()
-    )
-}
-
-fn long_version() -> String {
-    format!(
-        r#"
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-{:<20}{}
-"#,
-        "Build Timestamp:",
-        env!("VERGEN_BUILD_TIMESTAMP"),
-        "Build Version:",
-        env!("VERGEN_BUILD_SEMVER"),
-        "Commit SHA:",
-        env!("VERGEN_GIT_SHA"),
-        "Commit Date:",
-        env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
-        "Commit Branch:",
-        env!("VERGEN_GIT_BRANCH"),
-        "rustc Version:",
-        env!("VERGEN_RUSTC_SEMVER"),
-        "rustc Channel:",
-        env!("VERGEN_RUSTC_CHANNEL"),
-        "cargo Profile:",
-        env!("VERGEN_CARGO_PROFILE"),
+        env!("CARGO_PKG_VERSION")
    )
 }

@@ -1,83 +1,41 @@
 {
    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+        "@typescript-eslint"
+    ],
    "env": {
-        "browser": true,
        "es6": true,
-        "node": true
+        "node": true,
+        "mocha": true
    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/eslint-recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
    "parserOptions": {
-        "ecmaVersion": 2019,
+        "ecmaVersion": 2018,
        "sourceType": "module"
    },
-    "globals": {
-        "Atomics": "readonly",
-        "SharedArrayBuffer": "readonly"
-    },
-    "plugins": ["prettier", "mocha"],
-    "extends": [
-        "airbnb-base",
-        "airbnb-typescript/base",
-        "prettier"],
    "rules": {
-        "prettier/prettier": "error",
-        "import/prefer-default-export": "off",
-        "import/no-extraneous-dependencies": [
+        "no-console": "off",
+        "linebreak-style": "off",
+        "quotes": [
            "error",
+            "double",
            {
-                "devDependencies": [
-                    "**/*.test.[jt]s",
-                    "**/*.spec.[jt]s"
-                ]
+                "allowTemplateLiterals": true
            }
        ],
-        "import/extensions": [
+        "keyword-spacing": [
            "error",
-            "ignorePackages",
            {
-                "ts": "never",
-                "js": "never"
+                "before": true
            }
+        ],
+        "space-before-blocks": [
+            "error"
        ]
-    },
-    "overrides": [
-        {
-            "files": "**/*.ts",
-            "parser": "@typescript-eslint/parser",
-            "parserOptions": {
-                "project": "./tsconfig.json"
-            },
-            "plugins": ["@typescript-eslint/eslint-plugin"],
-            "extends": [
-                "plugin:@typescript-eslint/eslint-recommended",
-                "plugin:@typescript-eslint/recommended",
-                "prettier"
-            ],
-            "rules": {
-                "@typescript-eslint/explicit-function-return-type": "off",
-                "@typescript-eslint/no-explicit-any": "off",
-                "@typescript-eslint/no-var-requires": "off",
-                "no-use-before-define": [0],
-                "@typescript-eslint/no-use-before-define": [1],
-                "import/no-unresolved": 0,
-                "import/no-extraneous-dependencies": [
-                    "error",
-                    {
-                        "devDependencies": [
-                            "**/*.test.ts",
-                            "**/*.spec.ts"
-                        ]
-                    }
-                ],
-                "quotes": "off",
-                "@typescript-eslint/quotes": [
-                    2,
-                    "single",
-                    {
-                        "avoidEscape": true
-                    }
-                ],
-                "@typescript-eslint/no-unused-vars": [2, { "argsIgnorePattern": "^_" }]
-            }
-        }
-    ]
-}
+    }
+}
@@ -1,6 +0,0 @@
-{
-  "trailingComma": "all",
-  "singleQuote": true,
-  "printWidth": 120,
-  "tabWidth": 2
-}
@@ -1,6 +1,6 @@
 {
  "name": "@nymproject/nym-validator-client",
-  "version": "0.19.0",
+  "version": "0.18.0",
  "description": "A TypeScript client for interacting with smart contracts in Nym validators",
  "repository": "https://github.com/nymtech/nym",
  "main": "./dist/index.js",
@@ -9,8 +9,7 @@
    "build": "tsc",
    "test": "ts-mocha tests/**/*.test.ts",
    "coverage": "nyc npm test",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
+    "lint": "eslint \"**/*.ts\"",
    "docs": "typedoc --out docs src/index.ts"
  },
  "keywords": [],
@@ -24,33 +23,22 @@
    "@types/chai": "^4.2.15",
    "@types/expect": "^24.3.0",
    "@types/mocha": "^8.2.1",
-    "@typescript-eslint/eslint-plugin": "^5.7.0",
-    "@typescript-eslint/parser": "^5.7.0",
+    "@typescript-eslint/eslint-plugin": "^4.14.0",
+    "@typescript-eslint/parser": "^4.14.0",
    "chai": "^4.2.0",
    "eslint": "^7.18.0",
-    "eslint-config-airbnb": "^19.0.2",
-    "eslint-config-airbnb-typescript": "^16.1.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-import-resolver-root-import": "^1.0.4",
-    "eslint-plugin-import": "^2.25.3",
-    "eslint-plugin-mocha": "^10.0.3",
-    "eslint-plugin-prettier": "^4.0.0",
    "mocha": "^8.2.1",
    "moq.ts": "^7.2.0",
    "nyc": "^15.1.0",
-    "prettier": "^2.5.1",
    "ts-mocha": "^8.0.0",
    "typedoc": "^0.20.27",
    "typescript": "^4.1.3"
  },
  "dependencies": {
-    "@cosmjs/cosmwasm-stargate": "^0.27.0-rc2",
-    "@cosmjs/crypto": "^0.27.0-rc2",
-    "@cosmjs/math": "^0.27.0-rc2",
-    "@cosmjs/proto-signing": "^0.27.0-rc2",
-    "@cosmjs/stargate": "^0.27.0-rc2",
-    "@cosmjs/tendermint-rpc": "^0.27.0-rc2",
    "axios": "^0.21.1",
-    "cosmjs-types": "^0.4.0"
+    "@cosmjs/cosmwasm-stargate": "^0.25.5",
+    "@cosmjs/stargate": "^0.25.5",
+    "@cosmjs/math": "^0.25.5",
+    "@cosmjs/proto-signing": "^0.25.5"
  }
-}
+}
@@ -0,0 +1,41 @@
+{
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "env": {
+        "es6": true,
+        "node": true,
+        "mocha": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/eslint-recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "parserOptions": {
+        "ecmaVersion": 2018,
+        "sourceType": "module"
+    },
+    "rules": {
+        "no-console": "off",
+        "linebreak-style": "off",
+        "quotes": [
+            "error",
+            "double",
+            {
+                "allowTemplateLiterals": true
+            }
+        ],
+        "keyword-spacing": [
+            "error",
+            {
+                "before": true
+            }
+        ],
+        "space-before-blocks": [
+            "error"
+        ]
+    }
+}
@@ -0,0 +1 @@
+15.0.1
@@ -0,0 +1,59 @@
+import {GatewayBond, PagedGatewayResponse} from "../types";
+import {INetClient} from "../net-client"
+import {IQueryClient} from "../query-client";
+import {VALIDATOR_API_GATEWAYS, VALIDATOR_API_PORT} from "../index";
+import axios from "axios";
+
+
+/**
+ * There are serious limits in smart contract systems, but we need to keep track of
+ * potentially thousands of nodes. GatewaysCache instances repeatedly make requests for
+ * paged data about what gateways exist, and keep them locally in memory so that they're
+ * available for querying.
+ **/
+export default class GatewaysCache {
+    gateways: GatewayBond[]
+    client: INetClient | IQueryClient
+    perPage: number
+
+    constructor(client: INetClient | IQueryClient, perPage: number) {
+        this.client = client;
+        this.gateways = [];
+        this.perPage = perPage;
+    }
+
+    /// Makes repeated requests to assemble a full list of gateways.
+    /// Requests continue to be make as long as `shouldMakeAnotherRequest()`
+    /// returns true.
+    async refreshGateways(contractAddress: string): Promise<GatewayBond[]> {
+        let newGateways: GatewayBond[] = [];
+        let response: PagedGatewayResponse;
+        let next: string | undefined = undefined;
+        for (;;) {
+            response = await this.client.getGateways(contractAddress, this.perPage, next);
+            newGateways = newGateways.concat(response.nodes)
+            next = response.start_next_after;
+            // if `start_next_after` is not set, we're done
+            if (!next) {
+                break
+            }
+        }
+
+        this.gateways = newGateways
+        return newGateways;
+    }
+
+    /// Makes requests to assemble a full list of gateways from validator-api
+    async refreshValidatorAPIGateways(urls: string[]): Promise<GatewayBond[]> {
+        for (const url of urls) {
+            const validator_api_url = new URL(url);
+            validator_api_url.port = VALIDATOR_API_PORT;
+            validator_api_url.pathname += VALIDATOR_API_GATEWAYS;
+            const response = await axios.get(validator_api_url.toString());
+            if (response.status == 200) {
+                return response.data;
+            }
+        }
+        throw new Error("None of the provided validators seem to be alive")
+    }
+}
@@ -0,0 +1,60 @@
+import {MixNodeBond, PagedMixnodeResponse} from "../types";
+import { INetClient } from "../net-client"
+import {IQueryClient} from "../query-client";
+import {VALIDATOR_API_MIXNODES, VALIDATOR_API_PORT} from "../index";
+import axios from "axios";
+
+export { MixnodesCache };
+
+/**
+ * There are serious limits in smart contract systems, but we need to keep track of
+ * potentially thousands of nodes. MixnodeCache instances repeatedly make requests for
+ *  paged data about what mixnodes exist, and keep them locally in memory so that they're
+ *  available for querying.
+ *  */
+export default class MixnodesCache {
+    mixNodes: MixNodeBond[]
+    client: INetClient | IQueryClient
+    perPage: number
+
+    constructor(client: INetClient | IQueryClient, perPage: number) {
+        this.client = client;
+        this.mixNodes = [];
+        this.perPage = perPage;
+    }
+
+    /// Makes repeated requests to assemble a full list of nodes. 
+    /// Requests continue to be make as long as `shouldMakeAnotherRequest()`
+    // returns true. 
+    async refreshMixNodes(contractAddress: string): Promise<MixNodeBond[]> {
+        let newMixnodes: MixNodeBond[] = [];
+        let response: PagedMixnodeResponse;
+        let next: string | undefined = undefined;
+        for (;;) {
+            response = await this.client.getMixNodes(contractAddress, this.perPage, next);
+            newMixnodes = newMixnodes.concat(response.nodes)
+            next = response.start_next_after;
+            // if `start_next_after` is not set, we're done
+            if (!next) {
+                break
+            }
+        }
+
+        this.mixNodes = newMixnodes
+        return this.mixNodes;
+    }
+
+    /// Makes  requests to assemble a full list of mixnodes from validator-api
+    async refreshValidatorAPIMixNodes(urls: string[]): Promise<MixNodeBond[]> {
+        for (const url of urls) {
+            const validator_api_url = new URL(url);
+            validator_api_url.port = VALIDATOR_API_PORT;
+            validator_api_url.pathname += VALIDATOR_API_MIXNODES;
+            const response = await axios.get(validator_api_url.toString());
+            if (response.status == 200) {
+                return response.data;
+            }
+        }
+        throw new Error("None of the provided validators seem to be alive")
+    }
+}
@@ -1,68 +1,73 @@
-import { Decimal } from '@cosmjs/math';
-import { Coin } from '@cosmjs/stargate';
+import { Decimal } from "@cosmjs/math";
+import { Coin } from ".";

 // NARROW NO-BREAK SPACE (U+202F)
-const thinSpace = '\u202F';
+const thinSpace = "\u202F";

 export function printableCoin(coin?: Coin): string {
-  if (!coin) {
-    return '0';
-  }
-  if (coin.denom.startsWith('u')) {
-    const ticker = coin.denom.slice(1).toUpperCase();
-    return Decimal.fromAtomics(coin.amount, 6).toString() + thinSpace + ticker;
-  }
-  return coin.amount + thinSpace + coin.denom;
+    if (!coin) {
+        return "0";
+    }
+    if (coin.denom.startsWith("u")) {
+        const ticker = coin.denom.slice(1).toUpperCase();
+        return Decimal.fromAtomics(coin.amount, 6).toString() + thinSpace + ticker;
+    } else {
+        return coin.amount + thinSpace + coin.denom;
+    }
 }

 export function printableBalance(balance?: readonly Coin[]): string {
-  if (!balance || balance.length === 0) return '–';
-  return balance.map(printableCoin).join(', ');
+    if (!balance || balance.length === 0) return "–";
+    return balance.map(printableCoin).join(", ");
 }

 // converts display amount, such as "12.0346" to its native token representation,
 // with 6 fractional digits. So in that case it would result in "12034600"
 // Basically does the same job as `displayAmountToNative` but without the requirement
 // of having the coinMap
-export function printableBalanceToNative(amountToDisplay: string): string {
-  const decimalAmount = Decimal.fromUserInput(amountToDisplay, 6);
-  return decimalAmount.atomics;
+export function printableBalanceToNative(amountToDisplay: string): string  {
+    const decimalAmount = Decimal.fromUserInput(amountToDisplay, 6);
+    return decimalAmount.atomics;
 }

 // reciprocal of `printableBalanceToNative`, takes, for example 10000000 and returns 10
 export function nativeToPrintable(nativeValue: string): string {
-  return Decimal.fromAtomics(nativeValue, 6).toString();
+    return Decimal.fromAtomics(nativeValue, 6).toString()
 }

 export interface MappedCoin {
-  readonly denom: string;
-  readonly fractionalDigits: number;
+    readonly denom: string;
+    readonly fractionalDigits: number;
 }

 export interface CoinMap {
-  readonly [key: string]: MappedCoin;
+    readonly [key: string]: MappedCoin;
 }

 export function nativeCoinToDisplay(coin: Coin, coinMap: CoinMap): Coin {
-  if (!coinMap) return coin;
+    if (!coinMap) return coin;

-  const coinToDisplay = coinMap[coin.denom];
-  if (!coinToDisplay) return coin;
+    const coinToDisplay = coinMap[coin.denom];
+    if (!coinToDisplay) return coin;

-  const amountToDisplay = Decimal.fromAtomics(coin.amount, coinToDisplay.fractionalDigits).toString();
+    const amountToDisplay = Decimal.fromAtomics(coin.amount, coinToDisplay.fractionalDigits).toString();

-  return { denom: coinToDisplay.denom, amount: amountToDisplay };
+    return { denom: coinToDisplay.denom, amount: amountToDisplay };
 }

 // display amount is eg "12.0346", return is in native tokens
 // with 6 fractional digits, this would be eg. "12034600"
-export function displayAmountToNative(amountToDisplay: string, coinMap: CoinMap, nativeDenom: string): string {
-  const fractionalDigits = coinMap[nativeDenom]?.fractionalDigits;
-  if (fractionalDigits) {
-    // use https://github.com/CosmWasm/cosmjs/blob/v0.22.2/packages/math/src/decimal.ts
-    const decimalAmount = Decimal.fromUserInput(amountToDisplay, fractionalDigits);
-    return decimalAmount.atomics;
-  }
+export function displayAmountToNative(
+    amountToDisplay: string,
+    coinMap: CoinMap,
+    nativeDenom: string,
+): string {
+    const fractionalDigits = coinMap[nativeDenom]?.fractionalDigits;
+    if (fractionalDigits) {
+        // use https://github.com/CosmWasm/cosmjs/blob/v0.22.2/packages/math/src/decimal.ts
+        const decimalAmount = Decimal.fromUserInput(amountToDisplay, fractionalDigits);
+        return decimalAmount.atomics;
+    }

-  return amountToDisplay;
+    return amountToDisplay;
 }
@@ -0,0 +1,207 @@
+import { SigningCosmWasmClient, SigningCosmWasmClientOptions } from "@cosmjs/cosmwasm-stargate";
+import {
+    Delegation,
+    GatewayOwnershipResponse,
+    MixOwnershipResponse, PagedGatewayDelegationsResponse,
+    PagedGatewayResponse, PagedMixDelegationsResponse,
+    PagedMixnodeResponse,
+    StateParams
+} from "./types";
+import { DirectSecp256k1HdWallet, EncodeObject } from "@cosmjs/proto-signing";
+import { Coin, StdFee } from "@cosmjs/stargate";
+import { BroadcastTxResponse } from "@cosmjs/stargate"
+import { nymGasLimits, nymGasPrice } from "./stargate-helper"
+import {
+    ExecuteResult,
+    InstantiateOptions,
+    InstantiateResult,
+    MigrateResult,
+    UploadMeta,
+    UploadResult
+} from "@cosmjs/cosmwasm-stargate";
+
+export interface INetClient {
+    clientAddress: string;
+
+    getBalance(address: string, denom: string): Promise<Coin | null>;
+
+    getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse>;
+
+    getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse>;
+
+    getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse>
+
+    getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation>
+
+    getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse>
+
+    getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation>
+
+    ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse>;
+
+    ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
+
+    getStateParams(contractAddress: string): Promise<StateParams>;
+
+    signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<BroadcastTxResponse>;
+
+    executeContract(senderAddress: string, contractAddress: string, handleMsg: Record<string, unknown>, memo?: string, transferAmount?: readonly Coin[]): Promise<ExecuteResult>;
+
+    instantiate(senderAddress: string, codeId: number, initMsg: Record<string, unknown>, label: string, options?: InstantiateOptions): Promise<InstantiateResult>;
+
+    sendTokens(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[], memo?: string): Promise<BroadcastTxResponse>;
+
+    upload(senderAddress: string, wasmCode: Uint8Array, meta?: UploadMeta, memo?: string): Promise<UploadResult>;
+
+    changeValidator(newUrl: string): Promise<void>
+}
+
+/**
+ * Takes care of network communication between this code and the validator.
+ * Depends on `SigningCosmWasClient`, which signs all requests using keypairs
+ * derived from on bech32 mnemonics.
+ *
+ * Wraps several methods from CosmWasmSigningClient so we can mock them for
+ * unit testing.
+ */
+export default class NetClient implements INetClient {
+    clientAddress: string;
+    private cosmClient: SigningCosmWasmClient;
+
+    // helpers for changing validators without having to remake the wallet
+    private readonly wallet: DirectSecp256k1HdWallet;
+    private readonly signerOptions: SigningCosmWasmClientOptions;
+
+    private constructor(clientAddress: string, cosmClient: SigningCosmWasmClient, wallet: DirectSecp256k1HdWallet, signerOptions: SigningCosmWasmClientOptions) {
+        this.clientAddress = clientAddress;
+        this.cosmClient = cosmClient;
+        this.wallet = wallet;
+        this.signerOptions = signerOptions;
+    }
+
+    public static async connect(wallet: DirectSecp256k1HdWallet, url: string, prefix: string): Promise<INetClient> {
+        const [{address}] = await wallet.getAccounts();
+        const signerOptions: SigningCosmWasmClientOptions = {
+            gasPrice: nymGasPrice(prefix),
+            gasLimits: nymGasLimits,
+        };
+        const client = await SigningCosmWasmClient.connectWithSigner(url, wallet, signerOptions);
+        return new NetClient(address, client, wallet, signerOptions);
+    }
+
+    async changeValidator(url: string): Promise<void> {
+        this.cosmClient = await SigningCosmWasmClient.connectWithSigner(url, this.wallet, this.signerOptions);
+    }
+
+    public getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit}});
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit, start_after}});
+        }
+    }
+
+    public getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit}});
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit, start_after}});
+        }
+    }
+
+    public getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_mix_delegations: {
+                    mix_identity: mixIdentity,
+                    limit
+                }
+            });
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_mix_delegations: {
+                    mix_identity: mixIdentity,
+                    limit,
+                    start_after
+                }
+            });
+        }
+    }
+
+    public getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation> {
+        return this.cosmClient.queryContractSmart(contractAddress, {
+            get_mix_delegation: {
+                mix_identity: mixIdentity,
+                address: delegatorAddress
+            }
+        });
+    }
+
+    public getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_gateway_delegations: {
+                    gateway_identity: gatewayIdentity,
+                    limit
+                }
+            });
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_gateway_delegations: {
+                    gateway_identity: gatewayIdentity,
+                    limit,
+                    start_after
+                }
+            });
+        }
+    }
+
+    public getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation> {
+        return this.cosmClient.queryContractSmart(contractAddress, {
+            get_gateway_delegation: {
+                gateway_identity: gatewayIdentity,
+                address: delegatorAddress
+            }
+        });
+    }
+
+    public ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse> {
+        return this.cosmClient.queryContractSmart(contractAddress, {owns_mixnode: {address}});
+    }
+
+    public ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+        return this.cosmClient.queryContractSmart(contractAddress, {owns_gateway: {address}});
+    }
+
+    public getBalance(address: string, denom: string): Promise<Coin | null> {
+        return this.cosmClient.getBalance(address, denom);
+    }
+
+    public getStateParams(contractAddress: string): Promise<StateParams> {
+        return this.cosmClient.queryContractSmart(contractAddress, {state_params: {}});
+    }
+
+    public executeContract(senderAddress: string, contractAddress: string, handleMsg: Record<string, unknown>, memo?: string, transferAmount?: readonly Coin[]): Promise<ExecuteResult> {
+        return this.cosmClient.execute(senderAddress, contractAddress, handleMsg, memo, transferAmount);
+    }
+
+    public signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<BroadcastTxResponse> {
+        return this.cosmClient.signAndBroadcast(signerAddress, messages, fee, memo)
+    }
+
+    public sendTokens(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[], memo?: string): Promise<BroadcastTxResponse> {
+        return this.cosmClient.sendTokens(senderAddress, recipientAddress, transferAmount, memo);
+    }
+
+    public upload(senderAddress: string, wasmCode: Uint8Array, meta?: UploadMeta, memo?: string): Promise<UploadResult> {
+        return this.cosmClient.upload(senderAddress, wasmCode, meta, memo);
+    }
+
+    public instantiate(senderAddress: string, codeId: number, initMsg: Record<string, unknown>, label: string, options?: InstantiateOptions): Promise<InstantiateResult> {
+        return this.cosmClient.instantiate(senderAddress, codeId, initMsg, label, options);
+    }
+
+    public migrate(senderAddress: string, contractAddress: string, codeId: number, migrateMsg: Record<string, unknown>, memo?: string): Promise<MigrateResult> {
+        return this.cosmClient.migrate(senderAddress, contractAddress, codeId, migrateMsg, memo)
+    }
+}
@@ -1,182 +0,0 @@
-/*
- * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { JsonObject } from '@cosmjs/cosmwasm-stargate/build/queries';
-// eslint-disable-next-line import/no-cycle
-import { INymdQuery } from './query-client';
-import {
-  ContractStateParams,
-  Delegation,
-  GatewayOwnershipResponse,
-  LayerDistribution,
-  MixnetContractVersion,
-  MixOwnershipResponse,
-  PagedAllDelegationsResponse,
-  PagedDelegatorDelegationsResponse,
-  PagedGatewayResponse,
-  PagedMixDelegationsResponse,
-  PagedMixnodeResponse,
-  RewardingIntervalResponse,
-  RewardingStatus,
-} from './types';
-
-interface SmartContractQuery {
-  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
-}
-
-export default class NymdQuerier implements INymdQuery {
-  client: SmartContractQuery;
-
-  constructor(client: SmartContractQuery) {
-    this.client = client;
-  }
-
-  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_contract_version: {},
-    });
-  }
-
-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_mix_nodes: {
-        limit,
-        start_after: startAfter,
-      },
-    });
-  }
-
-  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_gateways: {
-        limit,
-        start_after: startAfter,
-      },
-    });
-  }
-
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      owns_mixnode: {
-        address,
-      },
-    });
-  }
-
-  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      owns_gateway: {
-        address,
-      },
-    });
-  }
-
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      state_params: {},
-    });
-  }
-
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      current_rewarding_interval: {},
-    });
-  }
-
-  getAllNetworkDelegationsPaged(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: [string, string],
-  ): Promise<PagedAllDelegationsResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_all_network_delegations: {
-        start_after: startAfter,
-        limit,
-      },
-    });
-  }
-
-  getMixNodeDelegationsPaged(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixDelegationsResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_mixnode_delegations: {
-        mix_identity: mixIdentity,
-        start_after: startAfter,
-        limit,
-      },
-    });
-  }
-
-  getDelegatorDelegationsPaged(
-    mixnetContractAddress: string,
-    delegator: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedDelegatorDelegationsResponse> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_delegator_delegations: {
-        delegator,
-        start_after: startAfter,
-        limit,
-      },
-    });
-  }
-
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_delegation_details: {
-        mix_identity: mixIdentity,
-        delegator,
-      },
-    });
-  }
-
-  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      layer_distribution: {},
-    });
-  }
-
-  getRewardPool(mixnetContractAddress: string): Promise<string> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_reward_pool: {},
-    });
-  }
-
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_circulating_supply: {},
-    });
-  }
-
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_epoch_reward_percent: {},
-    });
-  }
-
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_sybil_resistance_percent: {},
-    });
-  }
-
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus> {
-    return this.client.queryContractSmart(mixnetContractAddress, {
-      get_rewarding_status: {
-        mix_identity: mixIdentity,
-        rewarding_interval_nonce: rewardingIntervalNonce,
-      },
-    });
-  }
-}
@@ -1,218 +1,147 @@
-import { CosmWasmClient } from '@cosmjs/cosmwasm-stargate';
-import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
+import { Coin } from "@cosmjs/stargate";
+import { CosmWasmClient } from "@cosmjs/cosmwasm-stargate";
 import {
-  Account,
-  Block,
-  Coin,
-  DeliverTxResponse,
-  IndexedTx,
-  SearchTxFilter,
-  SearchTxQuery,
-  SequenceResponse,
-} from '@cosmjs/stargate';
-import { JsonObject } from '@cosmjs/cosmwasm-stargate/build/queries';
-import { Code, CodeDetails, Contract, ContractCodeHistoryEntry } from '@cosmjs/cosmwasm-stargate/build/cosmwasmclient';
-// eslint-disable-next-line import/no-cycle
-import NymdQuerier from './nymd-querier';
-import {
-  ContractStateParams,
-  Delegation,
-  GatewayBond,
-  GatewayOwnershipResponse,
-  LayerDistribution,
-  MixnetContractVersion,
-  MixNodeBond,
-  MixOwnershipResponse,
-  PagedAllDelegationsResponse,
-  PagedDelegatorDelegationsResponse,
-  PagedGatewayResponse,
-  PagedMixDelegationsResponse,
-  PagedMixnodeResponse,
-  RewardingIntervalResponse,
-  RewardingStatus,
-} from './types';
-import ValidatorApiQuerier, { IValidatorApiQuery } from './validator-api-querier';
+    Delegation,
+    GatewayOwnershipResponse,
+    MixOwnershipResponse, PagedGatewayDelegationsResponse,
+    PagedGatewayResponse, PagedMixDelegationsResponse,
+    PagedMixnodeResponse,
+    StateParams
+} from "./types";

-export interface ICosmWasmQuery {
-  // methods exposed by `CosmWasmClient`
-  getChainId(): Promise<string>;
-  getHeight(): Promise<number>;
-  getAccount(searchAddress: string): Promise<Account | null>;
-  getSequence(address: string): Promise<SequenceResponse>;
-  getBlock(height?: number): Promise<Block>;
-  getBalance(address: string, searchDenom: string): Promise<Coin>;
-  getTx(id: string): Promise<IndexedTx | null>;
-  searchTx(query: SearchTxQuery, filter?: SearchTxFilter): Promise<readonly IndexedTx[]>;
-  disconnect(): void;
-  broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<DeliverTxResponse>;
-  getCodes(): Promise<readonly Code[]>;
-  getCodeDetails(codeId: number): Promise<CodeDetails>;
-  getContracts(codeId: number): Promise<readonly string[]>;
-  getContract(address: string): Promise<Contract>;
-  getContractCodeHistory(address: string): Promise<readonly ContractCodeHistoryEntry[]>;
-  queryContractRaw(address: string, key: Uint8Array): Promise<Uint8Array | null>;
-  queryContractSmart(address: string, queryMsg: Record<string, unknown>): Promise<JsonObject>;
+export interface IQueryClient {
+    getBalance(address: string, stakeDenom: string): Promise<Coin | null>;
+
+    getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse>;
+
+    getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse>;
+
+    getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse>
+
+    getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation>
+
+    getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse>
+
+    getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation>
+
+    ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse>;
+
+    ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
+
+    getStateParams(contractAddress: string): Promise<StateParams>;
+
+    changeValidator(newUrl: string): Promise<void>
 }

-export interface INymdQuery {
-  // nym-specific implemented inside NymQuerier
-  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion>;
+/**
+ * Takes care of network communication between this code and the validator.
+ * Depends on `SigningCosmWasClient`, which signs all requests using keypairs
+ * derived from on bech32 mnemonics.
+ *
+ * Wraps several methods from CosmWasmSigningClient so we can mock them for
+ * unit testing.
+ */
+export default class QueryClient implements IQueryClient {
+    private cosmClient: CosmWasmClient;

-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse>;
-  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse>;
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse>;
-  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse>;
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams>;
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse>;
+    private constructor(cosmClient: CosmWasmClient) {
+        this.cosmClient = cosmClient;
+    }

-  getAllNetworkDelegationsPaged(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: [string, string],
-  ): Promise<PagedAllDelegationsResponse>;
-  getMixNodeDelegationsPaged(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixDelegationsResponse>;
-  getDelegatorDelegationsPaged(
-    mixnetContractAddress: string,
-    delegator: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedDelegatorDelegationsResponse>;
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation>;
+    public static async connect(url: string): Promise<IQueryClient> {
+        const client = await CosmWasmClient.connect(url)
+        return new QueryClient(client)
+    }

-  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution>;
-  getRewardPool(mixnetContractAddress: string): Promise<string>;
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string>;
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number>;
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number>;
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus>;
-}
-
-export interface IQueryClient extends ICosmWasmQuery, INymdQuery, IValidatorApiQuery {}
-
-export default class QueryClient extends CosmWasmClient implements IQueryClient {
-  private nymdQuerier: NymdQuerier;
-
-  private validatorApiQuerier: ValidatorApiQuerier;
-
-  private constructor(tmClient: Tendermint34Client, validatorApiUrl: string) {
-    super(tmClient);
-    this.nymdQuerier = new NymdQuerier(this);
-    this.validatorApiQuerier = new ValidatorApiQuerier(validatorApiUrl);
-  }
-
-  public static async connectWithNym(nymdUrl: string, validatorApiUrl: string): Promise<QueryClient> {
-    const tmClient = await Tendermint34Client.connect(nymdUrl);
-    return new QueryClient(tmClient, validatorApiUrl);
-  }
-
-  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
-    return this.nymdQuerier.getContractVersion(mixnetContractAddress);
-  }
-
-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
-    return this.nymdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
-  }
-
-  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
-    return this.nymdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
-  }
-
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
-    return this.nymdQuerier.ownsMixNode(mixnetContractAddress, address);
-  }
-
-  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
-    return this.nymdQuerier.ownsGateway(mixnetContractAddress, address);
-  }
-
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
-    return this.nymdQuerier.getStateParams(mixnetContractAddress);
-  }
-
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
-  }
-
-  getAllNetworkDelegationsPaged(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: [string, string],
-  ): Promise<PagedAllDelegationsResponse> {
-    return this.nymdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
-  }
-
-  getMixNodeDelegationsPaged(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixDelegationsResponse> {
-    return this.nymdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
-  }
-
-  getDelegatorDelegationsPaged(
-    mixnetContractAddress: string,
-    delegator: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedDelegatorDelegationsResponse> {
-    return this.nymdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
-  }
-
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
-    return this.nymdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
-  }
-
-  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
-    return this.nymdQuerier.getLayerDistribution(mixnetContractAddress);
-  }
-
-  getRewardPool(mixnetContractAddress: string): Promise<string> {
-    return this.nymdQuerier.getRewardPool(mixnetContractAddress);
-  }
-
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
-    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
-  }
-
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
-  }
-
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getSybilResistancePercent(mixnetContractAddress);
-  }
-
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus> {
-    return this.nymdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
-  }
-
-  getCachedGateways(): Promise<GatewayBond[]> {
-    return this.validatorApiQuerier.getCachedGateways();
-  }
-
-  getCachedMixnodes(): Promise<MixNodeBond[]> {
-    return this.validatorApiQuerier.getCachedMixnodes();
-  }
-
-  getActiveMixnodes(): Promise<MixNodeBond[]> {
-    return this.validatorApiQuerier.getActiveMixnodes();
-  }
-
-  getRewardedMixnodes(): Promise<MixNodeBond[]> {
-    return this.validatorApiQuerier.getRewardedMixnodes();
-  }
+    async changeValidator(url: string): Promise<void> {
+        this.cosmClient = await CosmWasmClient.connect(url)
+    }
+
+    public getMixNodes(contractAddress: string, limit: number, start_after?: string): Promise<PagedMixnodeResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit}});
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {get_mix_nodes: {limit, start_after}});
+        }
+    }
+
+    public getGateways(contractAddress: string, limit: number, start_after?: string): Promise<PagedGatewayResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit}});
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {get_gateways: {limit, start_after}});
+        }
+    }
+
+    public getMixDelegations(contractAddress: string, mixIdentity: string, limit: number, start_after?: string): Promise<PagedMixDelegationsResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_mix_delegations: {
+                    mix_identity: mixIdentity,
+                    limit
+                }
+            });
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_mix_delegations: {
+                    mix_identity: mixIdentity,
+                    limit,
+                    start_after
+                }
+            });
+        }
+    }
+
+    public getMixDelegation(contractAddress: string, mixIdentity: string, delegatorAddress: string): Promise<Delegation> {
+        return this.cosmClient.queryContractSmart(contractAddress, {
+            get_mix_delegation: {
+                mix_identity: mixIdentity,
+                address: delegatorAddress
+            }
+        });
+    }
+
+    public getGatewayDelegations(contractAddress: string, gatewayIdentity: string, limit: number, start_after?: string): Promise<PagedGatewayDelegationsResponse> {
+        if (start_after == undefined) { // TODO: check if we can take this out, I'm not sure what will happen if we send an "undefined" so I'm playing it safe here.
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_gateway_delegations: {
+                    gateway_identity: gatewayIdentity,
+                    limit
+                }
+            });
+        } else {
+            return this.cosmClient.queryContractSmart(contractAddress, {
+                get_gateway_delegations: {
+                    gateway_identity: gatewayIdentity,
+                    limit,
+                    start_after
+                }
+            });
+        }
+    }
+
+    public getGatewayDelegation(contractAddress: string, gatewayIdentity: string, delegatorAddress: string): Promise<Delegation> {
+        return this.cosmClient.queryContractSmart(contractAddress, {
+            get_gateway_delegation: {
+                gateway_identity: gatewayIdentity,
+                address: delegatorAddress
+            }
+        });
+    }
+
+    public ownsMixNode(contractAddress: string, address: string): Promise<MixOwnershipResponse> {
+        return this.cosmClient.queryContractSmart(contractAddress, {owns_mixnode: {address}});
+    }
+
+    public ownsGateway(contractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
+        return this.cosmClient.queryContractSmart(contractAddress, {owns_gateway: {address}});
+    }
+
+    public getBalance(address: string, stakeDenom: string): Promise<Coin | null> {
+        return this.cosmClient.getBalance(address, stakeDenom);
+    }
+
+    public getStateParams(contractAddress: string): Promise<StateParams> {
+        return this.cosmClient.queryContractSmart(contractAddress, {state_params: {}});
+    }
 }
@@ -1,467 +0,0 @@
-import {
-  ExecuteResult,
-  InstantiateOptions,
-  InstantiateResult,
-  MigrateResult,
-  SigningCosmWasmClient,
-  SigningCosmWasmClientOptions,
-  UploadResult,
-} from '@cosmjs/cosmwasm-stargate';
-import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing';
-import { Coin, DeliverTxResponse, SignerData, StdFee } from '@cosmjs/stargate';
-import { Tendermint34Client } from '@cosmjs/tendermint-rpc';
-import { ChangeAdminResult } from '@cosmjs/cosmwasm-stargate/build/signingcosmwasmclient';
-import { TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
-import { nymGasPrice } from './stargate-helper';
-import { IQueryClient } from './query-client';
-import NymdQuerier from './nymd-querier';
-import {
-  ContractStateParams,
-  Delegation,
-  Gateway,
-  GatewayBond,
-  GatewayOwnershipResponse,
-  LayerDistribution,
-  MixnetContractVersion,
-  MixNode,
-  MixNodeBond,
-  MixOwnershipResponse,
-  PagedAllDelegationsResponse,
-  PagedDelegatorDelegationsResponse,
-  PagedGatewayResponse,
-  PagedMixDelegationsResponse,
-  PagedMixnodeResponse,
-  RewardingIntervalResponse,
-  RewardingStatus,
-} from './types';
-import ValidatorApiQuerier from './validator-api-querier';
-
-// methods exposed by `SigningCosmWasmClient`
-export interface ICosmWasmSigning {
-  simulate(signerAddress: string, messages: readonly EncodeObject[], memo: string | undefined): Promise<number>;
-
-  upload(
-    senderAddress: string,
-    wasmCode: Uint8Array,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<UploadResult>;
-
-  instantiate(
-    senderAddress: string,
-    codeId: number,
-    msg: Record<string, unknown>,
-    label: string,
-    fee: StdFee | 'auto' | number,
-    options?: InstantiateOptions,
-  ): Promise<InstantiateResult>;
-
-  updateAdmin(
-    senderAddress: string,
-    contractAddress: string,
-    newAdmin: string,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<ChangeAdminResult>;
-
-  clearAdmin(
-    senderAddress: string,
-    contractAddress: string,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<ChangeAdminResult>;
-
-  migrate(
-    senderAddress: string,
-    contractAddress: string,
-    codeId: number,
-    migrateMsg: Record<string, unknown>,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<MigrateResult>;
-
-  execute(
-    senderAddress: string,
-    contractAddress: string,
-    msg: Record<string, unknown>,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-    funds?: readonly Coin[],
-  ): Promise<ExecuteResult>;
-
-  sendTokens(
-    senderAddress: string,
-    recipientAddress: string,
-    amount: readonly Coin[],
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<DeliverTxResponse>;
-
-  delegateTokens(
-    delegatorAddress: string,
-    validatorAddress: string,
-    amount: Coin,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<DeliverTxResponse>;
-
-  undelegateTokens(
-    delegatorAddress: string,
-    validatorAddress: string,
-    amount: Coin,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<DeliverTxResponse>;
-
-  withdrawRewards(
-    delegatorAddress: string,
-    validatorAddress: string,
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<DeliverTxResponse>;
-
-  signAndBroadcast(
-    signerAddress: string,
-    messages: readonly EncodeObject[],
-    fee: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<DeliverTxResponse>;
-
-  sign(
-    signerAddress: string,
-    messages: readonly EncodeObject[],
-    fee: StdFee,
-    memo: string,
-    explicitSignerData?: SignerData,
-  ): Promise<TxRaw>;
-}
-
-export interface INymSigning {
-  clientAddress: string;
-}
-
-export interface ISigningClient extends IQueryClient, ICosmWasmSigning, INymSigning {
-  bondMixNode(
-    mixnetContractAddress: string,
-    mixNode: MixNode,
-    ownerSignature: string,
-    pledge: Coin,
-    fee?: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<ExecuteResult>;
-
-  unbondMixNode(mixnetContractAddress: string, fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult>;
-
-  bondGateway(
-    mixnetContractAddress: string,
-    gateway: Gateway,
-    ownerSignature: string,
-    pledge: Coin,
-    fee?: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<ExecuteResult>;
-
-  unbondGateway(mixnetContractAddress: string, fee?: StdFee | 'auto' | number, memo?: string): Promise<ExecuteResult>;
-
-  delegateToMixNode(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    amount: Coin,
-    fee?: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<ExecuteResult>;
-
-  undelegateFromMixNode(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    fee?: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<ExecuteResult>;
-
-  updateContractStateParams(
-    mixnetContractAddress: string,
-    newParams: ContractStateParams,
-    fee?: StdFee | 'auto' | number,
-    memo?: string,
-  ): Promise<ExecuteResult>;
-
-  // I don't see any point in exposing rewarding / vesting-related (INSIDE mixnet contract, like "BondMixnodeOnBehalf")
-  // functionalities in our typescript client. However, if for some reason, we find we need them
-  // they're rather trivial to add.
-}
-
-export default class SigningClient extends SigningCosmWasmClient implements ISigningClient {
-  private nymdQuerier: NymdQuerier;
-
-  private validatorApiQuerier: ValidatorApiQuerier;
-
-  clientAddress: string;
-
-  private constructor(
-    clientAddress: string,
-    validatorApiUrl: string,
-    tmClient: Tendermint34Client,
-    wallet: DirectSecp256k1HdWallet,
-    signerOptions: SigningCosmWasmClientOptions,
-  ) {
-    super(tmClient, wallet, signerOptions);
-    this.clientAddress = clientAddress;
-    this.nymdQuerier = new NymdQuerier(this);
-    this.validatorApiQuerier = new ValidatorApiQuerier(validatorApiUrl);
-  }
-
-  public static async connectWithNymSigner(
-    wallet: DirectSecp256k1HdWallet,
-    nymdUrl: string,
-    validatorApiUrl: string,
-    prefix: string,
-  ): Promise<SigningClient> {
-    const [{ address }] = await wallet.getAccounts();
-    const signerOptions: SigningCosmWasmClientOptions = {
-      gasPrice: nymGasPrice(prefix),
-    };
-    const tmClient = await Tendermint34Client.connect(nymdUrl);
-    return new SigningClient(address, validatorApiUrl, tmClient, wallet, signerOptions);
-  }
-
-  // query related:
-
-  getContractVersion(mixnetContractAddress: string): Promise<MixnetContractVersion> {
-    return this.nymdQuerier.getContractVersion(mixnetContractAddress);
-  }
-
-  getMixNodesPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedMixnodeResponse> {
-    return this.nymdQuerier.getMixNodesPaged(mixnetContractAddress, limit, startAfter);
-  }
-
-  getGatewaysPaged(mixnetContractAddress: string, limit?: number, startAfter?: string): Promise<PagedGatewayResponse> {
-    return this.nymdQuerier.getGatewaysPaged(mixnetContractAddress, limit, startAfter);
-  }
-
-  ownsMixNode(mixnetContractAddress: string, address: string): Promise<MixOwnershipResponse> {
-    return this.nymdQuerier.ownsMixNode(mixnetContractAddress, address);
-  }
-
-  ownsGateway(mixnetContractAddress: string, address: string): Promise<GatewayOwnershipResponse> {
-    return this.nymdQuerier.ownsGateway(mixnetContractAddress, address);
-  }
-
-  getStateParams(mixnetContractAddress: string): Promise<ContractStateParams> {
-    return this.nymdQuerier.getStateParams(mixnetContractAddress);
-  }
-
-  getCurrentRewardingInterval(mixnetContractAddress: string): Promise<RewardingIntervalResponse> {
-    return this.nymdQuerier.getCurrentRewardingInterval(mixnetContractAddress);
-  }
-
-  getAllNetworkDelegationsPaged(
-    mixnetContractAddress: string,
-    limit?: number,
-    startAfter?: [string, string],
-  ): Promise<PagedAllDelegationsResponse> {
-    return this.nymdQuerier.getAllNetworkDelegationsPaged(mixnetContractAddress, limit, startAfter);
-  }
-
-  getMixNodeDelegationsPaged(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedMixDelegationsResponse> {
-    return this.nymdQuerier.getMixNodeDelegationsPaged(mixnetContractAddress, mixIdentity, limit, startAfter);
-  }
-
-  getDelegatorDelegationsPaged(
-    mixnetContractAddress: string,
-    delegator: string,
-    limit?: number,
-    startAfter?: string,
-  ): Promise<PagedDelegatorDelegationsResponse> {
-    return this.nymdQuerier.getDelegatorDelegationsPaged(mixnetContractAddress, delegator, limit, startAfter);
-  }
-
-  getDelegationDetails(mixnetContractAddress: string, mixIdentity: string, delegator: string): Promise<Delegation> {
-    return this.nymdQuerier.getDelegationDetails(mixnetContractAddress, mixIdentity, delegator);
-  }
-
-  getLayerDistribution(mixnetContractAddress: string): Promise<LayerDistribution> {
-    return this.nymdQuerier.getLayerDistribution(mixnetContractAddress);
-  }
-
-  getRewardPool(mixnetContractAddress: string): Promise<string> {
-    return this.nymdQuerier.getRewardPool(mixnetContractAddress);
-  }
-
-  getCirculatingSupply(mixnetContractAddress: string): Promise<string> {
-    return this.nymdQuerier.getCirculatingSupply(mixnetContractAddress);
-  }
-
-  getEpochRewardPercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getEpochRewardPercent(mixnetContractAddress);
-  }
-
-  getSybilResistancePercent(mixnetContractAddress: string): Promise<number> {
-    return this.nymdQuerier.getSybilResistancePercent(mixnetContractAddress);
-  }
-
-  getRewardingStatus(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    rewardingIntervalNonce: number,
-  ): Promise<RewardingStatus> {
-    return this.nymdQuerier.getRewardingStatus(mixnetContractAddress, mixIdentity, rewardingIntervalNonce);
-  }
-
-  getCachedGateways(): Promise<GatewayBond[]> {
-    return this.validatorApiQuerier.getCachedGateways();
-  }
-
-  getCachedMixnodes(): Promise<MixNodeBond[]> {
-    return this.validatorApiQuerier.getCachedMixnodes();
-  }
-
-  getActiveMixnodes(): Promise<MixNodeBond[]> {
-    return this.validatorApiQuerier.getActiveMixnodes();
-  }
-
-  getRewardedMixnodes(): Promise<MixNodeBond[]> {
-    return this.validatorApiQuerier.getRewardedMixnodes();
-  }
-
-  // signing related:
-
-  bondMixNode(
-    mixnetContractAddress: string,
-    mixNode: MixNode,
-    ownerSignature: string,
-    pledge: Coin,
-    fee: StdFee | 'auto' | number = 'auto',
-    memo = 'Default MixNode Bonding from Typescript',
-  ): Promise<ExecuteResult> {
-    return this.execute(
-      this.clientAddress,
-      mixnetContractAddress,
-      {
-        bond_mixnode: {
-          mix_node: mixNode,
-          owner_signature: ownerSignature,
-        },
-      },
-      fee,
-      memo,
-      [pledge],
-    );
-  }
-
-  unbondMixNode(
-    mixnetContractAddress: string,
-    fee: StdFee | 'auto' | number = 'auto',
-    memo = 'Default MixNode Unbonding from Typescript',
-  ): Promise<ExecuteResult> {
-    return this.execute(
-      this.clientAddress,
-      mixnetContractAddress,
-      {
-        unbond_mixnode: {},
-      },
-      fee,
-      memo,
-    );
-  }
-
-  bondGateway(
-    mixnetContractAddress: string,
-    gateway: Gateway,
-    ownerSignature: string,
-    pledge: Coin,
-    fee: StdFee | 'auto' | number = 'auto',
-    memo = 'Default Gateway Bonding from Typescript',
-  ): Promise<ExecuteResult> {
-    return this.execute(
-      this.clientAddress,
-      mixnetContractAddress,
-      {
-        bond_gateway: {
-          gateway,
-          owner_signature: ownerSignature,
-        },
-      },
-      fee,
-      memo,
-      [pledge],
-    );
-  }
-
-  unbondGateway(
-    mixnetContractAddress: string,
-    fee: StdFee | 'auto' | number = 'auto',
-    memo = 'Default Gateway Unbonding from Typescript',
-  ): Promise<ExecuteResult> {
-    return this.execute(
-      this.clientAddress,
-      mixnetContractAddress,
-      {
-        unbond_gateway: {},
-      },
-      fee,
-      memo,
-    );
-  }
-
-  delegateToMixNode(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    amount: Coin,
-    fee: StdFee | 'auto' | number = 'auto',
-    memo = 'Default MixNode Delegation from Typescript',
-  ): Promise<ExecuteResult> {
-    return this.execute(
-      this.clientAddress,
-      mixnetContractAddress,
-      {
-        delegate_to_mixnode: {
-          mix_identity: mixIdentity,
-        },
-      },
-      fee,
-      memo,
-      [amount],
-    );
-  }
-
-  undelegateFromMixNode(
-    mixnetContractAddress: string,
-    mixIdentity: string,
-    fee: StdFee | 'auto' | number = 'auto',
-    memo = 'Default MixNode Undelegation from Typescript',
-  ): Promise<ExecuteResult> {
-    return this.execute(
-      this.clientAddress,
-      mixnetContractAddress,
-      {
-        undelegate_from_mixnode: {
-          mix_identity: mixIdentity,
-        },
-      },
-      fee,
-      memo,
-    );
-  }
-
-  updateContractStateParams(
-    mixnetContractAddress: string,
-    newParams: ContractStateParams,
-    fee: StdFee | 'auto' | number = 'auto',
-    memo = 'Default Contract State Params Update from Typescript',
-  ): Promise<ExecuteResult> {
-    return this.execute(
-      this.clientAddress,
-      mixnetContractAddress,
-      {
-        update_contract_state_params: newParams,
-      },
-      fee,
-      memo,
-    );
-  }
-}
@@ -1,14 +1,26 @@
-import axios from 'axios';
-import { GasPrice } from '@cosmjs/stargate';
+import axios from "axios";
+import { GasLimits, GasPrice } from "@cosmjs/stargate";
+import { CosmWasmFeeTable, defaultGasLimits } from "@cosmjs/cosmwasm-stargate";
+
+export const nymGasLimits: GasLimits<CosmWasmFeeTable> = {
+    ...defaultGasLimits,
+    upload: 2_500_000,
+    init: 500_000,
+    migrate: 200_000,
+    exec: 250_000,
+    send: 80_000,
+    changeAdmin: 80_000,
+};

 export function nymGasPrice(prefix: string): GasPrice {
-  return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
+    return GasPrice.fromString(`0.025u${prefix}`); // TODO: ideally this ugly conversion shouldn't be hardcoded here.
 }

 export const downloadWasm = async (url: string): Promise<Uint8Array> => {
-  const r = await axios.get(url, { responseType: 'arraybuffer' });
-  if (r.status !== 200) {
-    throw new Error(`Download error: ${r.status}`);
-  }
-  return r.data;
+    const r = await axios.get(url, {responseType: "arraybuffer"});
+    if (r.status !== 200) {
+        throw new Error(`Download error: ${r.status}`);
+    }
+    return r.data;
 };
+
@@ -1,162 +1,125 @@
-import { Coin } from '@cosmjs/stargate';
+import { Coin } from "@cosmjs/stargate";

-// TODO: ideally we'd have re-exported those using that fancy crate that builds ts types from rust
-
-export type MixnetContractVersion = {
-  build_timestamp: string;
-  build_version: string;
-  commit_sha: string;
-  commit_timestamp: string;
-  commit_branch: string;
-  rustc_version: string;
-};

+/// One page of a possible multi-page set of mixnodes. The paging interface is quite
+/// inconvenient, as we don't have the two pieces of information we need to know
+/// in order to do paging nicely (namely `currentPage` and `totalPages` parameters).
+///
+/// Instead, we have only `start_next_page_after`, i.e. the key of the last record
+/// on this page. In order to get the *next* page, CosmWasm looks at that value,
+/// finds the next record, and builds the next page starting there. This happens
+/// **in series** rather than **in parallel** (!).
+///
+/// So we have some consistency problems:
+///
+/// * we can't make requests at a given block height, so the result set
+///    which we assemble over time may change while requests are being made.
+/// * at some point we will make a request for a `start_next_page_after` key
+///   which has just been deleted from the database.
+///
+/// TODO: more robust error handling on the "deleted key" case.
 export type PagedMixnodeResponse = {
-  nodes: MixNodeBond[];
-  per_page: number;
-  start_next_after?: string;
-};
-
-export type PagedGatewayResponse = {
-  nodes: GatewayBond[];
-  per_page: number;
-  start_next_after?: string;
-};
-
-export type MixOwnershipResponse = {
-  address: string;
-  mixnode?: MixNodeBond;
-};
-
-export type GatewayOwnershipResponse = {
-  address: string;
-  gateway?: GatewayBond;
-};
-
-export type ContractStateParams = {
-  // ideally I'd want to define those as `number` rather than `string`, but
-  // rust-side they are defined as Uint128 and that don't have
-  // native javascript representations and therefore are interpreted as strings after deserialization
-  minimum_mixnode_pledge: string;
-  minimum_gateway_pledge: string;
-  mixnode_rewarded_set_size: number;
-  mixnode_active_set_size: number;
-};
-
-export type RewardingIntervalResponse = {
-  current_rewarding_interval_starting_block: number;
-  current_rewarding_interval_nonce: number;
-  rewarding_in_progress: boolean;
-};
-
-export type LayerDistribution = {
-  gateways: number;
-  layer1: number;
-  layer2: number;
-  layer3: number;
-};
-
-export type Delegation = {
-  owner: string;
-  node_identity: string;
-  amount: Coin;
-  block_height: number;
-  proxy?: string;
-};
-
-export type PagedMixDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: string;
-};
-
-export type PagedDelegatorDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: string;
-};
-
-export type PagedAllDelegationsResponse = {
-  delegations: Delegation[];
-  start_next_after?: [string, string];
-};
-
-export type RewardingResult = {
-  operator_reward: string;
-  total_delegator_reward: string;
-};
-
-export type NodeRewardParams = {
-  period_reward_pool: string;
-  k: string;
-  reward_blockstamp: number;
-  circulating_supply: string;
-  uptime: string;
-  sybil_resistance_percent: number;
-};
-
-export type DelegatorRewardParams = {
-  node_reward_params: NodeRewardParams;
-  sigma: number;
-  profit_margin: number;
-  node_profit: number;
-};
-
-export type PendingDelegatorRewarding = {
-  running_results: RewardingResult;
-  next_start: string;
-  rewarding_params: DelegatorRewardParams;
-};
-
-export type RewardingStatus = { Complete: RewardingResult } | { PendingNextDelegatorPage: PendingDelegatorRewarding };
-
-export type MixnodeRewardingStatusResponse = {
-  status?: RewardingStatus;
-};
-
-export enum Layer {
-  Gateway,
-  One,
-  Two,
-  Three,
+    nodes: MixNodeBond[],
+    per_page: number, // TODO: camelCase
+    start_next_after: string, // TODO: camelCase
 }

-export type MixNodeBond = {
-  owner: string;
-  mix_node: MixNode;
-  layer: Layer;
-  bond_amount: Coin;
-  total_delegation: Coin;
-};
+// a temporary way of achieving the same paging behaviour for the gateways
+// the same points made for `PagedResponse` stand here.
+export type PagedGatewayResponse = {
+    nodes: GatewayBond[],
+    per_page: number, // TODO: camelCase
+    start_next_after: string, // TODO: camelCase
+}
+
+export type MixOwnershipResponse = {
+    address: string,
+    has_node: boolean,
+}
+
+export type GatewayOwnershipResponse = {
+    address: string,
+    has_gateway: boolean,
+}
+
+export type StateParams = {
+    epoch_length: number,
+    // ideally I'd want to define those as `number` rather than `string`, but
+    // rust-side they are defined as Uint128 and Decimal that don't have
+    // native javascript representations and therefore are interpreted as strings after deserialization
+    minimum_mixnode_bond: string,
+    minimum_gateway_bond: string,
+    mixnode_bond_reward_rate: string,
+    gateway_bond_reward_rate: string,
+    mixnode_delegation_reward_rate: string,
+    gateway_delegation_reward_rate: string,
+    mixnode_active_set_size: number,
+    gateway_active_set_size: number,
+}
+
+export type Delegation = {
+    owner: string,
+    amount: Coin,
+}
+
+export type PagedMixDelegationsResponse = {
+    node_owner: string,
+    delegations: Delegation[],
+    start_next_after: string
+}
+
+export type PagedGatewayDelegationsResponse = {
+    node_owner: string,
+    delegations: Delegation[],
+    start_next_after: string
+}
+
+
+export enum Layer {
+    Gateway,
+    One,
+    Two,
+    Three,
+}
+
+export type MixNodeBond = { // TODO: change name to MixNodeBond
+    owner: string,
+    mix_node: MixNode,    // TODO: camelCase this later once everything else works
+    layer: Layer,
+    bond_amount: Coin,
+    total_delegation: Coin,
+}

 export type MixNode = {
-  host: string;
-  mix_port: number;
-  verloc_port: number;
-  http_api_port: number;
-  sphinx_key: string;
-  identity_key: string;
-  version: string;
-};
+    host: string,
+    mix_port: number,
+    verloc_port: number,
+    http_api_port: number,
+    sphinx_key: string, // TODO: camelCase this later once everything else works
+    identity_key: string,
+    version: string,
+}

 export type GatewayBond = {
-  owner: string;
-  gateway: Gateway;
-
-  bond_amount: Coin;
-  total_delegation: Coin;
-};
+    owner: string
+    gateway: Gateway,
+    
+    bond_amount: Coin,
+    total_delegation: Coin,
+}

 export type Gateway = {
-  host: string;
-  mix_port: number;
-  clients_port: number;
-  location: string;
-  sphinx_key: string;
-  identity_key: string;
-  version: string;
-};
+    host: string,
+    mix_port: number,
+    clients_port: number,
+    location: string,
+    sphinx_key: string,
+    identity_key: string,
+    version: string
+}

 export type SendRequest = {
-  senderAddress: string;
-  recipientAddress: string;
-  transferAmount: readonly Coin[];
-};
+    senderAddress: string,
+    recipientAddress: string,
+    transferAmount: readonly Coin[]
+}
@@ -1,18 +1,14 @@
 // eslint-disable-next-line @typescript-eslint/no-explicit-any,@typescript-eslint/explicit-module-boundary-types
-import { Coin } from '@cosmjs/stargate';
-import { EncodeObject } from '@cosmjs/proto-signing';
+import { Coin } from "@cosmjs/stargate";
+import { EncodeObject } from "@cosmjs/proto-signing";

-export function makeBankMsgSend(
-  senderAddress: string,
-  recipientAddress: string,
-  transferAmount: readonly Coin[],
-): EncodeObject {
-  return {
-    typeUrl: '/cosmos.bank.v1beta1.MsgSend',
-    value: {
-      fromAddress: senderAddress,
-      toAddress: recipientAddress,
-      amount: transferAmount,
-    },
-  };
-}
+export function makeBankMsgSend(senderAddress: string, recipientAddress: string, transferAmount: readonly Coin[]): EncodeObject {
+    return {
+        typeUrl: "/cosmos.bank.v1beta1.MsgSend",
+        value: {
+            fromAddress: senderAddress,
+            toAddress: recipientAddress,
+            amount: transferAmount,
+        },
+    };
+}
@@ -1,75 +0,0 @@
-/*
- * Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import axios from 'axios';
-import { GatewayBond, MixNodeBond } from './types';
-
-export const VALIDATOR_API_VERSION = '/v1';
-export const VALIDATOR_API_GATEWAYS_PATH = `${VALIDATOR_API_VERSION}/gateways`;
-export const VALIDATOR_API_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes`;
-export const VALIDATOR_API_ACTIVE_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes/active`;
-export const VALIDATOR_API_REWARDED_MIXNODES_PATH = `${VALIDATOR_API_VERSION}/mixnodes/rewarded`;
-
-export interface IValidatorApiQuery {
-  getCachedMixnodes(): Promise<MixNodeBond[]>;
-
-  getCachedGateways(): Promise<GatewayBond[]>;
-
-  getActiveMixnodes(): Promise<MixNodeBond[]>;
-
-  getRewardedMixnodes(): Promise<MixNodeBond[]>;
-}
-
-export default class ValidatorApiQuerier implements IValidatorApiQuery {
-  validatorApiUrl: string;
-
-  constructor(validatorApiUrl: string) {
-    this.validatorApiUrl = validatorApiUrl;
-  }
-
-  async getCachedMixnodes(): Promise<MixNodeBond[]> {
-    const url = new URL(this.validatorApiUrl);
-    url.pathname += VALIDATOR_API_MIXNODES_PATH;
-
-    const response = await axios.get(url.toString());
-    if (response.status === 200) {
-      return response.data;
-    }
-    throw new Error('None of the provided validator APIs seem to be alive');
-  }
-
-  async getCachedGateways(): Promise<GatewayBond[]> {
-    const url = new URL(this.validatorApiUrl);
-    url.pathname += VALIDATOR_API_GATEWAYS_PATH;
-
-    const response = await axios.get(url.toString());
-    if (response.status === 200) {
-      return response.data;
-    }
-    throw new Error('None of the provided validator APIs seem to be alive');
-  }
-
-  async getActiveMixnodes(): Promise<MixNodeBond[]> {
-    const url = new URL(this.validatorApiUrl);
-    url.pathname += VALIDATOR_API_ACTIVE_MIXNODES_PATH;
-
-    const response = await axios.get(url.toString());
-    if (response.status === 200) {
-      return response.data;
-    }
-    throw new Error('None of the provided validator APIs seem to be alive');
-  }
-
-  async getRewardedMixnodes(): Promise<MixNodeBond[]> {
-    const url = new URL(this.validatorApiUrl);
-    url.pathname += VALIDATOR_API_REWARDED_MIXNODES_PATH;
-
-    const response = await axios.get(url.toString());
-    if (response.status === 200) {
-      return response.data;
-    }
-    throw new Error('None of the provided validator APIs seem to be alive');
-  }
-}
@@ -0,0 +1,100 @@
+import { assert } from "chai";
+import INetClient from "../../src/net-client";
+import { Fixtures } from "../fixtures"
+import { Mock, Times } from "moq.ts";
+import GatewaysCache from "../../src/caches/gateways";
+
+describe("Caching gateways: when the validator returns", () => {
+    context("an empty list", () => {
+        it("Should return an empty list", async () => {
+            const perPage = 100;
+            const contractAddress = "mockContractAddress";
+            const emptyPromise = Promise.resolve(Fixtures.GatewaysResp.empty());
+            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(emptyPromise);
+            const cache = new GatewaysCache(mockClient.object(), perPage);
+
+            await cache.refreshGateways(contractAddress);
+
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
+            assert.deepEqual([], cache.gateways);
+        });
+    })
+
+    context("a list of gatways that fits in a page", () => {
+        it("Should return that one page list", async () => {
+            const perPage = 2;
+            const contractAddress = "mockContractAddress";
+            const onePagePromise = Promise.resolve(Fixtures.GatewaysResp.onePage());
+            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(onePagePromise);
+            const cache = new GatewaysCache(mockClient.object(), perPage);
+
+            await cache.refreshGateways(contractAddress);
+
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
+            assert.deepEqual(Fixtures.Gateways.list2(), cache.gateways);
+        })
+    })
+
+    context("a list of gateways that is longer than one page", () => {
+        it("Should return the full list assembled from all pages", async () => {
+            const perPage = 2; // we get back 2 per page
+            const contractAddress = "mockContractAddress";
+            const fullPageResult = Fixtures.GatewaysResp.page1of2();
+            const halfPageResult = Fixtures.GatewaysResp.halfPage2of2();
+            const mockClient = new Mock<INetClient>()
+            mockClient.setup(instance => instance.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult));
+            mockClient.setup(instance => instance.getGateways(contractAddress, perPage, fullPageResult.start_next_after)).returns(Promise.resolve(halfPageResult));
+            const cache = new GatewaysCache(mockClient.object(), perPage);
+
+            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
+            mockClient.verify(instance => instance.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
+            mockClient.verify(instance => instance.getGateways(contractAddress, perPage, fullPageResult.start_next_after), Times.Exactly(1));
+
+            assert.deepEqual(Fixtures.Gateways.list3(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
+        })
+    })
+
+    context("a list of gateways that is two filled pages", () => {
+        it("Should return the full list assembled from all pages", async () => {
+            const perPage = 2; // we get back 2 per page
+            const contractAddress = "mockContractAddress";
+            const fullPageResult1 = Fixtures.GatewaysResp.page1of2();
+            const fullPageResult2 = Fixtures.GatewaysResp.fullPage2of2();
+            const mockClient = new Mock<INetClient>()
+            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
+            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
+
+            const cache = new GatewaysCache(mockClient.object(), perPage);
+
+            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
+
+            assert.deepEqual(Fixtures.Gateways.list4(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
+        })
+    })
+
+    context("refreshing the cache twice", () => {
+        it("returns one full list assembled from all pages", async () => {
+            const perPage = 2; // we get back 2 per page
+            const contractAddress = "mockContractAddress";
+            const fullPageResult1 = Fixtures.GatewaysResp.page1of2();
+            const fullPageResult2 = Fixtures.GatewaysResp.fullPage2of2();
+            const mockClient = new Mock<INetClient>()
+            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
+            mockClient.setup(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
+
+            const cache = new GatewaysCache(mockClient.object(), perPage);
+
+            await cache.refreshGateways(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(1));
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
+
+            await cache.refreshGateways(contractAddress);
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, undefined), Times.Exactly(2));
+            mockClient.verify(netClient => netClient.getGateways(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(2));
+
+            assert.deepEqual(Fixtures.Gateways.list4(), cache.gateways); // there are a total of 3 nodes in the validator lists, we get them all back
+        })
+    })
+});
@@ -0,0 +1,96 @@
+import { assert } from "chai";
+import INetClient from "../../src/net-client";
+import { Fixtures } from "../fixtures"
+import { Mock, Times } from "moq.ts";
+import { MixnodesCache } from "../../src/caches/mixnodes"
+
+describe("Caching mixnodes: when the validator returns", () => {
+    context("an empty list", () => {
+        it("Should return an empty list", async () => {
+            const perPage = 100;
+            const contractAddress = "mockContractAddress";
+            const emptyPromise = Promise.resolve(Fixtures.MixNodesResp.empty());
+            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(emptyPromise);
+            const cache = new MixnodesCache(mockClient.object(), perPage);
+
+            await cache.refreshMixNodes(contractAddress);
+
+            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
+            assert.deepEqual([], cache.mixNodes);
+        });
+    })
+    context("a list of nodes that fits in a page", () => {
+        it("Should return that one page list", async () => {
+            const perPage = 2;
+            const contractAddress = "mockContractAddress";
+            const onePagePromise = Promise.resolve(Fixtures.MixNodesResp.onePage());
+            const mockClient = new Mock<INetClient>().setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(onePagePromise);
+            const cache = new MixnodesCache(mockClient.object(), perPage);
+
+            await cache.refreshMixNodes(contractAddress);
+
+            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
+            assert.deepEqual(Fixtures.MixNodes.list2(), cache.mixNodes);
+        })
+    })
+
+    context("a list of nodes that is longer than one page", () => {
+        it("Should return the full list assembled from all pages", async () => {
+            const perPage = 2; // we get back 2 per page
+            const contractAddress = "mockContractAddress";
+            const fullPageResult = Fixtures.MixNodesResp.page1of2();
+            const halfPageResult = Fixtures.MixNodesResp.halfPage2of2();
+            const mockClient = new Mock<INetClient>()
+            mockClient.setup(instance => instance.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult));
+            mockClient.setup(instance => instance.getMixNodes(contractAddress, perPage, fullPageResult.start_next_after)).returns(Promise.resolve(halfPageResult));
+            const cache = new MixnodesCache(mockClient.object(), perPage);
+
+            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
+            mockClient.verify(instance => instance.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
+            mockClient.verify(instance => instance.getMixNodes(contractAddress, perPage, fullPageResult.start_next_after), Times.Exactly(1));
+
+            assert.deepEqual(Fixtures.MixNodes.list3(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
+        })
+    })
+
+    context("a list of nodes that is two filled pages", () => {
+        it("Should return the full list assembled from all pages", async () => {
+            const perPage = 2; // we get back 2 per page
+            const contractAddress = "mockContractAddress";
+            const fullPageResult1 = Fixtures.MixNodesResp.page1of2();
+            const fullPageResult2 = Fixtures.MixNodesResp.fullPage2of2();
+            const mockClient = new Mock<INetClient>()
+            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
+            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
+
+            const cache = new MixnodesCache(mockClient.object(), perPage);
+
+            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
+            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
+            mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
+
+            assert.deepEqual(Fixtures.MixNodes.list4(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
+        })
+    })
+
+    context("refreshing the cache twice", () => {
+        it("returns one full list assembled from all pages", async () => {
+            const perPage = 2; // we get back 2 per page
+            const contractAddress = "mockContractAddress";
+            const fullPageResult1 = Fixtures.MixNodesResp.page1of2();
+            const fullPageResult2 = Fixtures.MixNodesResp.fullPage2of2();
+            const mockClient = new Mock<INetClient>()
+            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, undefined)).returns(Promise.resolve(fullPageResult1));
+            mockClient.setup(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after)).returns(Promise.resolve(fullPageResult2));
+
+            const cache = new MixnodesCache(mockClient.object(), perPage);
+
+            await cache.refreshMixNodes(contractAddress); // should make multiple paginated requests because there are two pages in the response fixture
+            await cache.refreshMixNodes(contractAddress);
+            // mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, undefined), Times.Exactly(1));
+            // mockClient.verify(netClient => netClient.getMixNodes(contractAddress, perPage, fullPageResult1.start_next_after), Times.Exactly(1));
+
+            assert.deepEqual(Fixtures.MixNodes.list4(), cache.mixNodes); // there are a total of 3 nodes in the validator lists, we get them all back
+        })
+    })
+});
@@ -0,0 +1,156 @@
+import { coins } from "@cosmjs/launchpad";
+import {PagedGatewayResponse, PagedMixnodeResponse} from "../src/net-client";
+import {GatewayBond, MixNodeBond} from "../src/types"
+
+export namespace Fixtures {
+    export class MixNodes {
+        static single(): MixNodeBond {
+            return {
+                amount: coins(666, "unym"),
+                owner: "bob",
+                mix_node: {
+                    host: "1.1.1.1",
+                    layer: 1,
+                    location: "London, UK",
+                    sphinx_key: "foo",
+                    version: "0.10.0",
+                }
+            };
+        }
+
+        static list1(): MixNodeBond[] {
+            return [MixNodes.single()]
+        }
+
+        static list2(): MixNodeBond[] {
+            return [MixNodes.single(), MixNodes.single()]
+        }
+
+        static list3(): MixNodeBond[] {
+            return [MixNodes.single(), MixNodes.single(), MixNodes.single()]
+        }
+
+        static list4(): MixNodeBond[] {
+            return [MixNodes.single(), MixNodes.single(), MixNodes.single(), MixNodes.single()]
+        }
+    }
+
+    export class MixNodesResp {
+        static empty(): PagedResponse {
+            return {
+                nodes: [],
+                per_page: 2,
+                start_next_after: null,
+            }
+        }
+
+        static onePage(): PagedResponse {
+            return {
+                nodes: MixNodes.list2(),
+                per_page: 2,
+                start_next_after: null
+            }
+        }
+
+        static page1of2(): PagedResponse {
+            return {
+                nodes: MixNodes.list2(),
+                per_page: 2,
+                start_next_after: "2"
+            }
+        }
+
+        static halfPage2of2(): PagedResponse {
+            return {
+                nodes: MixNodes.list1(),
+                per_page: 2,
+                start_next_after: null
+
+            }
+        }
+
+        static fullPage2of2(): PagedResponse {
+            return {
+                nodes: MixNodes.list2(),
+                per_page: 2,
+                start_next_after: null,
+            }
+        }
+    }
+
+    export class Gateways {
+        static single(): GatewayBond {
+            return {
+                amount: coins(666, "unym"),
+                owner: "bob",
+                gateway: {
+                    mix_host: "1.1.1.1:1234",
+                    clients_host: "ws://1.1.1.1:1235",
+                    location: "London, UK",
+                    identity_key: "bar",
+                    sphinx_key: "foo",
+                    version: "0.10.0",
+                }
+            };
+        }
+
+        static list1(): GatewayBond[] {
+            return [Gateways.single()]
+        }
+
+        static list2(): GatewayBond[] {
+            return [Gateways.single(), Gateways.single()]
+        }
+
+        static list3(): GatewayBond[] {
+            return [Gateways.single(), Gateways.single(), Gateways.single()]
+        }
+
+        static list4(): GatewayBond[] {
+            return [Gateways.single(), Gateways.single(), Gateways.single(), Gateways.single()]
+        }
+    }
+
+    export class GatewaysResp {
+        static empty(): PagedGatewayResponse {
+            return {
+                nodes: [],
+                per_page: 2,
+                start_next_after: "",
+            }
+        }
+
+        static onePage(): PagedGatewayResponse {
+            return {
+                nodes: Gateways.list2(),
+                per_page: 2,
+                start_next_after: "",
+            }
+        }
+
+        static page1of2(): PagedGatewayResponse {
+            return {
+                nodes: Gateways.list2(),
+                per_page: 2,
+                start_next_after: "2"
+            }
+        }
+
+        static halfPage2of2(): PagedGatewayResponse {
+            return {
+                nodes: Gateways.list1(),
+                per_page: 2,
+                start_next_after: "",
+
+            }
+        }
+
+        static fullPage2of2(): PagedGatewayResponse {
+            return {
+                nodes: Gateways.list2(),
+                per_page: 2,
+                start_next_after: "",
+            }
+        }
+    }
+}
@@ -10,7 +10,6 @@ rust-version = "1.56"
 [dependencies]
 base64 = "0.13"
 mixnet-contract = { path="../../../common/mixnet-contract" }
-vesting-contract = { path="../../../contracts/vesting" }
 serde = { version="1", features=["derive"] }
 serde_json = "1"
 reqwest = { version="0.11", features=["json"] }
@@ -27,13 +26,12 @@ network-defaults = { path = "../../network-defaults" }
 async-trait = { version = "0.1.51", optional = true }
 bip39 = { version = "1", features = ["rand"], optional = true }
 config = { path = "../../config", optional = true }
-#cosmrs = { version = "0.3", features = ["rpc", "bip32", "cosmwasm"], optional = true }
-cosmrs = { git = "https://github.com/cosmos/cosmos-rust", rev="e5a1872083abb3d88fa62dda966e7f5408deba58", features = ["rpc", "bip32", "cosmwasm"], optional = true }
+cosmrs = { version = "0.3", features = ["rpc", "bip32", "cosmwasm"], optional = true }
 prost = { version = "0.9", default-features = false, optional = true }
 flate2 = { version = "1.0.20", optional = true }
 sha2 = { version = "0.9.5", optional = true }
 itertools = { version = "0.10", optional = true }
-cosmwasm-std = { version = "1.0.0-beta2", optional = true }
+cosmwasm-std = { git = "https://github.com/jstuczyn/cosmwasm", branch="0.14.1-updatedk256", optional = true }
 ts-rs = {version = "5.1", optional = true}

 [features]
@@ -6,18 +6,13 @@ use crate::nymd::{
    error::NymdError, CosmWasmClient, NymdClient, QueryNymdClient, SigningNymdClient,
 };
 #[cfg(feature = "nymd-client")]
-use mixnet_contract::ContractStateParams;
+use mixnet_contract::StateParams;

 use crate::{validator_api, ValidatorClientError};
 use coconut_interface::{BlindSignRequestBody, BlindedSignatureResponse, VerificationKeyResponse};
+use mixnet_contract::{GatewayBond, MixNodeBond, MixnodeRewardingStatusResponse};
 #[cfg(feature = "nymd-client")]
-use mixnet_contract::{
-    Delegation, MixnetContractVersion, MixnodeRewardingStatusResponse, RewardingIntervalResponse,
-};
-use mixnet_contract::{GatewayBond, MixNodeBond};
-
-#[cfg(feature = "nymd-client")]
-use std::str::FromStr;
+use mixnet_contract::{RawDelegationData, RewardingIntervalResponse};
 use url::Url;

 #[cfg(feature = "nymd-client")]
@@ -25,7 +20,6 @@ pub struct Config {
    api_url: Url,
    nymd_url: Url,
    mixnet_contract_address: Option<cosmrs::AccountId>,
-    vesting_contract_address: Option<cosmrs::AccountId>,

    mixnode_page_limit: Option<u32>,
    gateway_page_limit: Option<u32>,
@@ -38,12 +32,10 @@ impl Config {
        nymd_url: Url,
        api_url: Url,
        mixnet_contract_address: Option<cosmrs::AccountId>,
-        vesting_contract_address: Option<cosmrs::AccountId>,
    ) -> Self {
        Config {
            nymd_url,
            mixnet_contract_address,
-            vesting_contract_address,
            api_url,
            mixnode_page_limit: None,
            gateway_page_limit: None,
@@ -70,7 +62,6 @@ impl Config {
 #[cfg(feature = "nymd-client")]
 pub struct Client<C> {
    mixnet_contract_address: Option<cosmrs::AccountId>,
-    vesting_contract_address: Option<cosmrs::AccountId>,
    mnemonic: Option<bip39::Mnemonic>,

    mixnode_page_limit: Option<u32>,
@@ -92,14 +83,11 @@ impl Client<SigningNymdClient> {
        let nymd_client = NymdClient::connect_with_mnemonic(
            config.nymd_url.as_str(),
            config.mixnet_contract_address.clone(),
-            config.vesting_contract_address.clone(),
            mnemonic.clone(),
-            None,
        )?;

        Ok(Client {
            mixnet_contract_address: config.mixnet_contract_address,
-            vesting_contract_address: config.vesting_contract_address,
            mnemonic: Some(mnemonic),
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
@@ -113,9 +101,7 @@ impl Client<SigningNymdClient> {
        self.nymd = NymdClient::connect_with_mnemonic(
            new_endpoint.as_ref(),
            self.mixnet_contract_address.clone(),
-            self.vesting_contract_address.clone(),
            self.mnemonic.clone().unwrap(),
-            None,
        )?;
        Ok(())
    }
@@ -127,19 +113,16 @@ impl Client<QueryNymdClient> {
        let validator_api_client = validator_api::Client::new(config.api_url.clone());
        let nymd_client = NymdClient::connect(
            config.nymd_url.as_str(),
-            config.mixnet_contract_address.clone().unwrap_or_else(|| {
-                cosmrs::AccountId::from_str(network_defaults::DEFAULT_MIXNET_CONTRACT_ADDRESS)
-                    .unwrap()
-            }),
-            config.vesting_contract_address.clone().unwrap_or_else(|| {
-                cosmrs::AccountId::from_str(network_defaults::DEFAULT_VESTING_CONTRACT_ADDRESS)
-                    .unwrap()
-            }),
+            config
+                .mixnet_contract_address
+                .clone()
+                .ok_or(ValidatorClientError::NymdError(
+                    NymdError::NoContractAddressAvailable,
+                ))?,
        )?;

        Ok(Client {
            mixnet_contract_address: config.mixnet_contract_address,
-            vesting_contract_address: config.vesting_contract_address,
            mnemonic: None,
            mixnode_page_limit: config.mixnode_page_limit,
            gateway_page_limit: config.gateway_page_limit,
@@ -153,7 +136,6 @@ impl Client<QueryNymdClient> {
        self.nymd = NymdClient::connect(
            new_endpoint.as_ref(),
            self.mixnet_contract_address.clone().unwrap(),
-            self.vesting_contract_address.clone().unwrap(),
        )?;
        Ok(())
    }
@@ -183,18 +165,11 @@ impl<C> Client<C> {
        Ok(self.validator_api.get_gateways().await?)
    }

-    pub async fn get_contract_settings(&self) -> Result<ContractStateParams, ValidatorClientError>
+    pub async fn get_state_params(&self) -> Result<StateParams, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
    {
-        Ok(self.nymd.get_contract_settings().await?)
-    }
-
-    pub async fn get_mixnet_contract_version(&self) -> Result<MixnetContractVersion, NymdError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self.nymd.get_mixnet_contract_version().await?)
+        Ok(self.nymd.get_state_params().await?)
    }

    pub async fn get_current_rewarding_interval(
@@ -325,7 +300,9 @@ impl<C> Client<C> {
        Ok(delegations)
    }

-    pub async fn get_all_network_delegations(&self) -> Result<Vec<Delegation>, ValidatorClientError>
+    pub async fn get_all_nymd_mixnode_delegations(
+        &self,
+    ) -> Result<Vec<mixnet_contract::UnpackedDelegation<RawDelegationData>>, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
    {
@@ -334,7 +311,7 @@ impl<C> Client<C> {
        loop {
            let mut paged_response = self
                .nymd
-                .get_all_network_delegations_paged(
+                .get_all_mix_delegations_paged(
                    start_after.take(),
                    self.mixnode_delegations_page_limit,
                )
@@ -351,10 +328,10 @@ impl<C> Client<C> {
        Ok(delegations)
    }

-    pub async fn get_all_delegator_delegations(
+    pub async fn get_all_nymd_reverse_mixnode_delegations(
        &self,
        delegation_owner: &cosmrs::AccountId,
-    ) -> Result<Vec<Delegation>, ValidatorClientError>
+    ) -> Result<Vec<mixnet_contract::IdentityKey>, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
    {
@@ -363,13 +340,13 @@ impl<C> Client<C> {
        loop {
            let mut paged_response = self
                .nymd
-                .get_delegator_delegations_paged(
-                    delegation_owner.to_string(),
+                .get_reverse_mix_delegations_paged(
+                    mixnet_contract::Addr::unchecked(delegation_owner.as_ref()),
                    start_after.take(),
                    self.mixnode_delegations_page_limit,
                )
                .await?;
-            delegations.append(&mut paged_response.delegations);
+            delegations.append(&mut paged_response.delegated_nodes);

            if let Some(start_after_res) = paged_response.start_next_after {
                start_after = Some(start_after_res)
@@ -381,6 +358,28 @@ impl<C> Client<C> {
        Ok(delegations)
    }

+    pub async fn get_all_nymd_mixnode_delegations_of_owner(
+        &self,
+        delegation_owner: &cosmrs::AccountId,
+    ) -> Result<Vec<mixnet_contract::Delegation>, ValidatorClientError>
+    where
+        C: CosmWasmClient + Sync,
+    {
+        let mut delegations = Vec::new();
+        for node_identity in self
+            .get_all_nymd_reverse_mixnode_delegations(delegation_owner)
+            .await?
+        {
+            let delegation = self
+                .nymd
+                .get_mix_delegation(node_identity, delegation_owner)
+                .await?;
+            delegations.push(delegation);
+        }
+
+        Ok(delegations)
+    }
+
    pub async fn blind_sign(
        &self,
        request_body: &BlindSignRequestBody,
@@ -4,7 +4,7 @@
 use crate::nymd::cosmwasm_client::helpers::create_pagination;
 use crate::nymd::cosmwasm_client::types::{
    Account, Code, CodeDetails, Contract, ContractCodeHistoryEntry, ContractCodeId,
-    SequenceResponse, SimulateResponse,
+    SequenceResponse,
 };
 use crate::nymd::error::NymdError;
 use async_trait::async_trait;
@@ -14,19 +14,15 @@ use cosmrs::proto::cosmos::auth::v1beta1::{
 use cosmrs::proto::cosmos::bank::v1beta1::{
    QueryAllBalancesRequest, QueryAllBalancesResponse, QueryBalanceRequest, QueryBalanceResponse,
 };
-use cosmrs::proto::cosmos::tx::v1beta1::{
-    SimulateRequest, SimulateResponse as ProtoSimulateResponse,
-};
-use cosmrs::proto::cosmwasm::wasm::v1::*;
+use cosmrs::proto::cosmwasm::wasm::v1beta1::*;
 use cosmrs::rpc::endpoint::block::Response as BlockResponse;
 use cosmrs::rpc::endpoint::broadcast;
 use cosmrs::rpc::endpoint::tx::Response as TxResponse;
 use cosmrs::rpc::query::Query;
 use cosmrs::rpc::{self, HttpClient, Order};
-use cosmrs::tendermint::abci::Code as AbciCode;
 use cosmrs::tendermint::abci::Transaction;
 use cosmrs::tendermint::{abci, block, chain};
-use cosmrs::{tx, AccountId, Coin, Denom, Tx};
+use cosmrs::{tx, AccountId, Coin, Denom};
 use prost::Message;
 use serde::{Deserialize, Serialize};
 use std::convert::{TryFrom, TryInto};
@@ -53,11 +49,6 @@ pub trait CosmWasmClient: rpc::Client {

        let res = self.abci_query(path, buf, None, false).await?;

-        match res.code {
-            AbciCode::Err(code) => return Err(NymdError::AbciError(code, res.log)),
-            AbciCode::Ok => (),
-        }
-
        Ok(Res::decode(res.value.as_ref())?)
    }

@@ -222,7 +213,7 @@ pub trait CosmWasmClient: rpc::Client {
    }

    async fn get_codes(&self) -> Result<Vec<Code>, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1.Query/Codes".parse().unwrap());
+        let path = Some("/cosmwasm.wasm.v1beta1.Query/Codes".parse().unwrap());

        let mut raw_codes = Vec::new();
        let mut pagination = None;
@@ -249,7 +240,7 @@ pub trait CosmWasmClient: rpc::Client {
    }

    async fn get_code_details(&self, code_id: ContractCodeId) -> Result<CodeDetails, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1.Query/Code".parse().unwrap());
+        let path = Some("/cosmwasm.wasm.v1beta1.Query/Code".parse().unwrap());

        let req = QueryCodeRequest { code_id };

@@ -264,7 +255,11 @@ pub trait CosmWasmClient: rpc::Client {
        }
    }
    async fn get_contracts(&self, code_id: ContractCodeId) -> Result<Vec<AccountId>, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1.Query/ContractsByCode".parse().unwrap());
+        let path = Some(
+            "/cosmwasm.wasm.v1beta1.Query/ContractsByCode"
+                .parse()
+                .unwrap(),
+        );

        let mut raw_contracts = Vec::new();
        let mut pagination = None;
@@ -295,7 +290,7 @@ pub trait CosmWasmClient: rpc::Client {
    }

    async fn get_contract(&self, address: &AccountId) -> Result<Contract, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1.Query/ContractInfo".parse().unwrap());
+        let path = Some("/cosmwasm.wasm.v1beta1.Query/ContractInfo".parse().unwrap());

        let req = QueryContractInfoRequest {
            address: address.to_string(),
@@ -320,7 +315,11 @@ pub trait CosmWasmClient: rpc::Client {
        &self,
        address: &AccountId,
    ) -> Result<Vec<ContractCodeHistoryEntry>, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1.Query/ContractHistory".parse().unwrap());
+        let path = Some(
+            "/cosmwasm.wasm.v1beta1.Query/ContractHistory"
+                .parse()
+                .unwrap(),
+        );

        let mut raw_entries = Vec::new();
        let mut pagination = None;
@@ -354,7 +353,11 @@ pub trait CosmWasmClient: rpc::Client {
        address: &AccountId,
        query_data: Vec<u8>,
    ) -> Result<Vec<u8>, NymdError> {
-        let path = Some("/cosmwasm.wasm.v1.Query/RawContractState".parse().unwrap());
+        let path = Some(
+            "/cosmwasm.wasm.v1beta1.Query/RawContractState"
+                .parse()
+                .unwrap(),
+        );

        let req = QueryRawContractStateRequest {
            address: address.to_string(),
@@ -378,7 +381,7 @@ pub trait CosmWasmClient: rpc::Client {
        for<'a> T: Deserialize<'a>,
    {
        let path = Some(
-            "/cosmwasm.wasm.v1.Query/SmartContractState"
+            "/cosmwasm.wasm.v1beta1.Query/SmartContractState"
                .parse()
                .unwrap(),
        );
@@ -397,27 +400,4 @@ pub trait CosmWasmClient: rpc::Client {

        Ok(serde_json::from_slice(&res.data)?)
    }
-
-    // deprecation warning is due to the fact the protobuf files built were based on cosmos-sdk 0.44,
-    // where they prefer using tx_bytes directly. However, in 0.42, which we are using at the time
-    // of writing this, the option does not work
-    #[allow(deprecated)]
-    async fn query_simulate(
-        &self,
-        tx: Option<Tx>,
-        tx_bytes: Vec<u8>,
-    ) -> Result<SimulateResponse, NymdError> {
-        let path = Some("/cosmos.tx.v1beta1.Service/Simulate".parse().unwrap());
-
-        let req = SimulateRequest {
-            tx: tx.map(Into::into),
-            tx_bytes,
-        };
-
-        let res = self
-            .make_abci_query::<_, ProtoSimulateResponse>(path, req)
-            .await?;
-
-        res.try_into()
-    }
 }
@@ -29,7 +29,7 @@ pub(crate) fn find_attribute<'a>(
 ) -> Option<&'a cosmwasm_std::Attribute> {
    logs.iter()
        .flat_map(|log| log.events.iter())
-        .find(|event| event.ty == event_type)?
+        .find(|event| event.kind == event_type)?
        .attributes
        .iter()
        .find(|attr| attr.key == attribute_key)
@@ -61,7 +61,7 @@ mod tests {
        assert_eq!(parsed.len(), 1);
        assert_eq!(parsed[0].msg_index, 0);
        assert_eq!(parsed[0].events.len(), 1);
-        assert_eq!(parsed[0].events[0].ty, "message");
+        assert_eq!(parsed[0].events[0].kind, "message");
        assert_eq!(parsed[0].events[0].attributes[3].key, "code_id");
        assert_eq!(parsed[0].events[0].attributes[3].value, "1");
    }
@@ -76,12 +76,12 @@ mod tests {
        assert_eq!(parsed[2].msg_index, 2);

        assert_eq!(parsed[0].events.len(), 1);
-        assert_eq!(parsed[0].events[0].ty, "message");
+        assert_eq!(parsed[0].events[0].kind, "message");
        assert_eq!(parsed[0].events[0].attributes[3].key, "code_id");
        assert_eq!(parsed[0].events[0].attributes[3].value, "9");

        assert_eq!(parsed[2].events.len(), 1);
-        assert_eq!(parsed[2].events[0].ty, "message");
+        assert_eq!(parsed[2].events[0].kind, "message");
        assert_eq!(parsed[2].events[0].attributes[2].key, "signer");
        assert_eq!(
            parsed[2].events[0].attributes[2].value,
@@ -3,7 +3,6 @@

 use crate::nymd::error::NymdError;
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
-use crate::nymd::GasPrice;
 use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl};
 use std::convert::TryInto;

@@ -24,10 +23,9 @@ where
 pub fn connect_with_signer<U>(
    endpoint: U,
    signer: DirectSecp256k1HdWallet,
-    gas_price: Option<GasPrice>,
 ) -> Result<signing_client::Client, NymdError>
 where
    U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
 {
-    signing_client::Client::connect_with_signer(endpoint, signer, gas_price)
+    signing_client::Client::connect_with_signer(endpoint, signer)
 }
@@ -1,100 +1,37 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::convert::TryInto;
-
-use async_trait::async_trait;
-use cosmrs::bank::MsgSend;
-use cosmrs::distribution::MsgWithdrawDelegatorReward;
-use cosmrs::proto::cosmos::tx::signing::v1beta1::SignMode;
-use cosmrs::rpc::endpoint::broadcast;
-use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl, SimpleRequest};
-use cosmrs::staking::{MsgDelegate, MsgUndelegate};
-use cosmrs::tx::{self, Msg, SignDoc, SignerInfo};
-use cosmrs::{cosmwasm, rpc, AccountId, Any, Coin, Tx};
-use log::debug;
-use serde::Serialize;
-use sha2::Digest;
-use sha2::Sha256;
-
 use crate::nymd::cosmwasm_client::client::CosmWasmClient;
 use crate::nymd::cosmwasm_client::helpers::{compress_wasm_code, CheckResponse};
 use crate::nymd::cosmwasm_client::logs::{self, parse_raw_logs};
 use crate::nymd::cosmwasm_client::types::*;
 use crate::nymd::error::NymdError;
-use crate::nymd::fee::{Fee, DEFAULT_SIMULATED_GAS_MULTIPLIER};
 use crate::nymd::wallet::DirectSecp256k1HdWallet;
-use crate::nymd::{CosmosCoin, GasPrice};
-
-// we need to have **a** valid secp256k1 signature for simulation purposes.
-// it doesn't matter what it is as long as it parses correctly
-const DUMMY_SECP256K1_SIGNATURE: &[u8] = &[
-    54, 167, 169, 61, 100, 173, 231, 87, 1, 113, 179, 49, 102, 141, 67, 22, 170, 153, 52, 88, 178,
-    159, 200, 11, 37, 138, 76, 221, 187, 70, 104, 123, 98, 216, 190, 249, 149, 81, 1, 158, 0, 220,
-    32, 147, 101, 60, 64, 77, 44, 83, 221, 119, 170, 124, 109, 177, 73, 116, 46, 57, 102, 181, 98,
-    91,
-];
+use async_trait::async_trait;
+use cosmrs::bank::MsgSend;
+use cosmrs::distribution::MsgWithdrawDelegatorReward;
+use cosmrs::rpc::endpoint::broadcast;
+use cosmrs::rpc::{Error as TendermintRpcError, HttpClient, HttpClientUrl, SimpleRequest};
+use cosmrs::staking::{MsgDelegate, MsgUndelegate};
+use cosmrs::tx::{Fee, Msg, SignDoc, SignerInfo};
+use cosmrs::{cosmwasm, rpc, tx, AccountId, Any, Coin};
+use log::debug;
+use serde::Serialize;
+use sha2::Digest;
+use sha2::Sha256;
+use std::convert::TryInto;

 #[async_trait]
 pub trait SigningCosmWasmClient: CosmWasmClient {
    fn signer(&self) -> &DirectSecp256k1HdWallet;

-    fn gas_price(&self) -> &GasPrice;
-
-    fn signer_public_key(&self, signer_address: &AccountId) -> Option<tx::SignerPublicKey> {
-        let signer_accounts = self.signer().try_derive_accounts().ok()?;
-        let account_from_signer = signer_accounts
-            .iter()
-            .find(|account| &account.address == signer_address)?;
-        let public_key = account_from_signer.public_key;
-        Some(public_key.into())
-    }
-
-    async fn simulate(
-        &self,
-        signer_address: &AccountId,
-        messages: Vec<Any>,
-        memo: impl Into<String> + Send + 'static,
-    ) -> Result<SimulateResponse, NymdError> {
-        let public_key = self.signer_public_key(signer_address);
-        let sequence_response = self.get_sequence(signer_address).await?;
-
-        let partial_tx = Tx {
-            body: tx::Body {
-                messages,
-                memo: memo.into(),
-                timeout_height: 0u32.into(),
-                extension_options: vec![],
-                non_critical_extension_options: vec![],
-            },
-            auth_info: tx::AuthInfo {
-                signer_infos: vec![tx::SignerInfo {
-                    public_key,
-                    mode_info: tx::ModeInfo::Single(tx::mode_info::Single {
-                        mode: SignMode::Unspecified,
-                    }),
-                    sequence: sequence_response.sequence,
-                }],
-                fee: tx::Fee::from_amount_and_gas(
-                    CosmosCoin {
-                        denom: "".parse().unwrap(),
-                        amount: 0u64.into(),
-                    },
-                    0,
-                ),
-            },
-            signatures: vec![DUMMY_SECP256K1_SIGNATURE.try_into().unwrap()],
-        };
-
-        self.query_simulate(Some(partial_tx), Vec::new()).await
-    }
-
    async fn upload(
        &self,
        sender_address: &AccountId,
        wasm_code: Vec<u8>,
        fee: Fee,
        memo: impl Into<String> + Send + 'static,
+        mut meta: Option<UploadMeta>,
    ) -> Result<UploadResult, NymdError> {
        let compressed = compress_wasm_code(&wasm_code)?;
        let compressed_size = compressed.len();
@@ -105,6 +42,14 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        let upload_msg = cosmwasm::MsgStoreCode {
            sender: sender_address.clone(),
            wasm_byte_code: compressed,
+            source: meta
+                .as_mut()
+                .map(|meta| meta.source.take())
+                .unwrap_or_default(),
+            builder: meta
+                .as_mut()
+                .map(|meta| meta.builder.take())
+                .unwrap_or_default(),
            instantiate_permission: Default::default(),
        }
        .to_any()
@@ -116,13 +61,12 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .check_response()?;

        let logs = parse_raw_logs(tx_res.deliver_tx.log)?;
-        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);

        // TODO: should those strings be extracted into some constants?
        // the reason I think unwrap here is fine is that if the transaction succeeded and those
        // fields do not exist or code_id is not a number, there's no way we can recover, we're probably connected
        // to wrong validator or something
-        let code_id = logs::find_attribute(&logs, "store_code", "code_id")
+        let code_id = logs::find_attribute(&logs, "message", "code_id")
            .unwrap()
            .value
            .parse()
@@ -136,7 +80,6 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            code_id,
            logs,
            transaction_hash: tx_res.hash,
-            gas_info,
        })
    }

@@ -168,7 +111,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            // now this is a weird one. the protobuf files say this field is optional,
            // but if you omit it, the initialisation will fail CheckTx
            label: Some(label),
-            msg: serde_json::to_vec(msg)?,
+            init_msg: serde_json::to_vec(msg)?,
            funds: options.map(|options| options.funds).unwrap_or_default(),
        }
        .to_any()
@@ -180,13 +123,12 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .check_response()?;

        let logs = parse_raw_logs(tx_res.deliver_tx.log)?;
-        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);

        // TODO: should those strings be extracted into some constants?
        // the reason I think unwrap here is fine is that if the transaction succeeded and those
        // fields do not exist or address is malformed, there's no way we can recover, we're probably connected
        // to wrong validator or something
-        let contract_address = logs::find_attribute(&logs, "instantiate", "_contract_address")
+        let contract_address = logs::find_attribute(&logs, "message", "contract_address")
            .unwrap()
            .value
            .parse()
@@ -196,7 +138,6 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            contract_address,
            logs,
            transaction_hash: tx_res.hash,
-            gas_info,
        })
    }

@@ -221,12 +162,9 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .await?
            .check_response()?;

-        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
-
        Ok(ChangeAdminResult {
            logs: parse_raw_logs(tx_res.deliver_tx.log)?,
            transaction_hash: tx_res.hash,
-            gas_info,
        })
    }

@@ -249,12 +187,9 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .await?
            .check_response()?;

-        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
-
        Ok(ChangeAdminResult {
            logs: parse_raw_logs(tx_res.deliver_tx.log)?,
            transaction_hash: tx_res.hash,
-            gas_info,
        })
    }

@@ -274,7 +209,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            sender: sender_address.clone(),
            contract: contract_address.clone(),
            code_id,
-            msg: serde_json::to_vec(msg)?,
+            migrate_msg: serde_json::to_vec(msg)?,
        }
        .to_any()
        .map_err(|_| NymdError::SerializationError("MsgMigrateContract".to_owned()))?;
@@ -284,12 +219,9 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .await?
            .check_response()?;

-        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
-
        Ok(MigrateResult {
            logs: parse_raw_logs(tx_res.deliver_tx.log)?,
            transaction_hash: tx_res.hash,
-            gas_info,
        })
    }

@@ -319,12 +251,9 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .await?
            .check_response()?;

-        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
-
        Ok(ExecuteResult {
            logs: parse_raw_logs(tx_res.deliver_tx.log)?,
            transaction_hash: tx_res.hash,
-            gas_info,
        })
    }

@@ -359,12 +288,14 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
            .await?
            .check_response()?;

-        let gas_info = GasInfo::new(tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used);
+        debug!(
+            "gas wanted: {:?}, gas used: {:?}",
+            tx_res.deliver_tx.gas_wanted, tx_res.deliver_tx.gas_used
+        );

        Ok(ExecuteResult {
            logs: parse_raw_logs(tx_res.deliver_tx.log)?,
            transaction_hash: tx_res.hash,
-            gas_info,
        })
    }

@@ -385,36 +316,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        .map_err(|_| NymdError::SerializationError("MsgSend".to_owned()))?;

        self.sign_and_broadcast_commit(sender_address, vec![send_msg], fee, memo)
-            .await?
-            .check_response()
-    }
-
-    async fn send_tokens_multiple<I>(
-        &self,
-        sender_address: &AccountId,
-        msgs: I,
-        fee: Fee,
-        memo: impl Into<String> + Send + 'static,
-    ) -> Result<broadcast::tx_commit::Response, NymdError>
-    where
-        I: IntoIterator<Item = (AccountId, Vec<Coin>)> + Send,
-    {
-        let messages = msgs
-            .into_iter()
-            .map(|(to_address, amount)| {
-                MsgSend {
-                    from_address: sender_address.clone(),
-                    to_address,
-                    amount,
-                }
-                .to_any()
-                .map_err(|_| NymdError::SerializationError("MsgExecuteContract".to_owned()))
-            })
-            .collect::<Result<_, _>>()?;
-
-        self.sign_and_broadcast_commit(sender_address, messages, fee, memo)
-            .await?
-            .check_response()
+            .await
    }

    async fn delegate_tokens(
@@ -434,8 +336,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        .map_err(|_| NymdError::SerializationError("MsgDelegate".to_owned()))?;

        self.sign_and_broadcast_commit(delegator_address, vec![delegate_msg], fee, memo)
-            .await?
-            .check_response()
+            .await
    }

    async fn undelegate_tokens(
@@ -455,8 +356,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        .map_err(|_| NymdError::SerializationError("MsgUndelegate".to_owned()))?;

        self.sign_and_broadcast_commit(delegator_address, vec![undelegate_msg], fee, memo)
-            .await?
-            .check_response()
+            .await
    }

    async fn withdraw_rewards(
@@ -474,45 +374,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        .map_err(|_| NymdError::SerializationError("MsgWithdrawDelegatorReward".to_owned()))?;

        self.sign_and_broadcast_commit(delegator_address, vec![withdraw_msg], fee, memo)
-            .await?
-            .check_response()
-    }
-
-    // in this particular case we cannot generalise the argument to `&str` due to lifetime constraints
-    #[allow(clippy::ptr_arg)]
-    async fn determine_transaction_fee(
-        &self,
-        signer_address: &AccountId,
-        messages: &[Any],
-        fee: Fee,
-        memo: &String,
-    ) -> Result<tx::Fee, NymdError> {
-        let fee = match fee {
-            Fee::Manual(fee) => fee,
-            Fee::Auto(multiplier) => {
-                debug!("Trying to simulate gas costs...");
-                // from what I've seen in manual testing, gas estimation does not exist if transaction
-                // fails to get executed (for example if you send 'BondMixnode" with invalid signature)
-                let gas_estimation = self
-                    .simulate(signer_address, messages.to_vec(), memo.clone())
-                    .await?
-                    .gas_info
-                    .ok_or(NymdError::GasEstimationFailure)?
-                    .gas_used;
-
-                let multiplier = multiplier.unwrap_or(DEFAULT_SIMULATED_GAS_MULTIPLIER);
-                let gas = ((gas_estimation.value() as f32 * multiplier) as u64).into();
-
-                debug!("Gas estimation: {}", gas_estimation);
-                debug!("Multiplying the estimation by {}", multiplier);
-                debug!("Final gas limit used: {}", gas);
-
-                let fee = self.gas_price() * gas;
-                tx::Fee::from_amount_and_gas(fee, gas)
-            }
-        };
-        debug!("Fee used for the transaction: {:?}", fee);
-        Ok(fee)
+            .await
    }

    /// Broadcast a transaction, returning immediately.
@@ -523,10 +385,6 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        fee: Fee,
        memo: impl Into<String> + Send + 'static,
    ) -> Result<broadcast::tx_async::Response, NymdError> {
-        let memo = memo.into();
-        let fee = self
-            .determine_transaction_fee(signer_address, &messages, fee, &memo)
-            .await?;
        let tx_raw = self.sign(signer_address, messages, fee, memo).await?;
        let tx_bytes = tx_raw
            .to_bytes()
@@ -543,10 +401,6 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        fee: Fee,
        memo: impl Into<String> + Send + 'static,
    ) -> Result<broadcast::tx_sync::Response, NymdError> {
-        let memo = memo.into();
-        let fee = self
-            .determine_transaction_fee(signer_address, &messages, fee, &memo)
-            .await?;
        let tx_raw = self.sign(signer_address, messages, fee, memo).await?;
        let tx_bytes = tx_raw
            .to_bytes()
@@ -563,11 +417,6 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        fee: Fee,
        memo: impl Into<String> + Send + 'static,
    ) -> Result<broadcast::tx_commit::Response, NymdError> {
-        let memo = memo.into();
-        let fee = self
-            .determine_transaction_fee(signer_address, &messages, fee, &memo)
-            .await?;
-
        let tx_raw = self.sign(signer_address, messages, fee, memo).await?;
        let tx_bytes = tx_raw
            .to_bytes()
@@ -580,7 +429,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        &self,
        signer_address: &AccountId,
        messages: Vec<Any>,
-        fee: tx::Fee,
+        fee: Fee,
        memo: impl Into<String> + Send + 'static,
        signer_data: SignerData,
    ) -> Result<tx::Raw, NymdError> {
@@ -618,7 +467,7 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
        &self,
        signer_address: &AccountId,
        messages: Vec<Any>,
-        fee: tx::Fee,
+        fee: Fee,
        memo: impl Into<String> + Send + 'static,
    ) -> Result<tx::Raw, NymdError> {
        // TODO: Future optimisation: rather than grabbing current account_number and sequence
@@ -636,28 +485,22 @@ pub trait SigningCosmWasmClient: CosmWasmClient {
    }
 }

-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct Client {
    rpc_client: HttpClient,
    signer: DirectSecp256k1HdWallet,
-    gas_price: GasPrice,
 }

 impl Client {
    pub fn connect_with_signer<U>(
        endpoint: U,
        signer: DirectSecp256k1HdWallet,
-        gas_price: Option<GasPrice>,
    ) -> Result<Self, NymdError>
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
        let rpc_client = HttpClient::new(endpoint)?;
-        Ok(Client {
-            rpc_client,
-            signer,
-            gas_price: gas_price.unwrap_or_default(),
-        })
+        Ok(Client { rpc_client, signer })
    }
 }

@@ -679,8 +522,4 @@ impl SigningCosmWasmClient for Client {
    fn signer(&self) -> &DirectSecp256k1HdWallet {
        &self.signer
    }
-
-    fn gas_price(&self) -> &GasPrice {
-        &self.gas_price
-    }
 }
@@ -7,19 +7,15 @@ use crate::nymd::cosmwasm_client::logs::Log;
 use crate::nymd::error::NymdError;
 use cosmrs::crypto::PublicKey;
 use cosmrs::proto::cosmos::auth::v1beta1::BaseAccount;
-use cosmrs::proto::cosmos::base::abci::v1beta1::{
-    GasInfo as ProtoGasInfo, Result as ProtoAbciResult,
-};
-use cosmrs::proto::cosmos::tx::v1beta1::SimulateResponse as ProtoSimulateResponse;
-use cosmrs::proto::cosmwasm::wasm::v1::{
+use cosmrs::proto::cosmwasm::wasm::v1beta1::{
    CodeInfoResponse, ContractCodeHistoryEntry as ProtoContractCodeHistoryEntry,
    ContractCodeHistoryOperationType, ContractInfo as ProtoContractInfo,
 };
-use cosmrs::tendermint::{abci, chain};
-use cosmrs::tx::{AccountNumber, Gas, SequenceNumber};
+use cosmrs::tendermint::chain;
+use cosmrs::tx::{AccountNumber, SequenceNumber};
 use cosmrs::{tx, AccountId, Coin};
 use serde::Serialize;
-use std::convert::{TryFrom, TryInto};
+use std::convert::TryFrom;

 pub type ContractCodeId = u64;

@@ -74,6 +70,18 @@ pub struct Code {

    /// sha256 hash of the code stored
    pub data_hash: Vec<u8>,
+
+    /// An URL to a .tar.gz archive of the source code of the contract,
+    /// which can be used to reproducibly build the Wasm bytecode.
+    ///
+    /// @see https://github.com/CosmWasm/cosmwasm-verify
+    pub source: Option<String>,
+
+    /// A docker image (including version) to reproducibly build the Wasm bytecode from the source code.
+    ///
+    /// @example ```cosmwasm/rust-optimizer:0.8.0```
+    /// @see https://github.com/CosmWasm/cosmwasm-verify
+    pub builder: Option<String>,
 }

 impl TryFrom<CodeInfoResponse> for Code {
@@ -84,16 +92,31 @@ impl TryFrom<CodeInfoResponse> for Code {
            code_id,
            creator,
            data_hash,
+            source,
+            builder,
        } = value;

        let creator = creator
            .parse()
            .map_err(|_| NymdError::MalformedAccountAddress(creator))?;

+        let source = if source.is_empty() {
+            None
+        } else {
+            Some(source)
+        };
+        let builder = if builder.is_empty() {
+            None
+        } else {
+            Some(builder)
+        };
+
        Ok(Code {
            code_id,
            creator,
            data_hash,
+            source,
+            builder,
        })
    }
 }
@@ -219,101 +242,6 @@ impl TryFrom<ProtoContractCodeHistoryEntry> for ContractCodeHistoryEntry {
    }
 }

-#[derive(Debug)]
-pub struct GasInfo {
-    /// GasWanted is the maximum units of work we allow this tx to perform.
-    pub gas_wanted: Gas,
-
-    /// GasUsed is the amount of gas actually consumed.
-    pub gas_used: Gas,
-}
-
-impl From<ProtoGasInfo> for GasInfo {
-    fn from(value: ProtoGasInfo) -> Self {
-        GasInfo {
-            gas_wanted: value.gas_wanted.into(),
-            gas_used: value.gas_used.into(),
-        }
-    }
-}
-
-impl GasInfo {
-    pub fn new(gas_wanted: Gas, gas_used: Gas) -> Self {
-        GasInfo {
-            gas_wanted,
-            gas_used,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct AbciResult {
-    /// Data is any data returned from message or handler execution. It MUST be
-    /// length prefixed in order to separate data from multiple message executions.
-    pub data: Vec<u8>,
-
-    /// Log contains the log information from message or handler execution.
-    // todo: try to parse into Log?
-    pub log: String,
-
-    /// Events contains a slice of Event objects that were emitted during message
-    /// or handler execution.
-    pub events: Vec<abci::Event>,
-}
-
-impl TryFrom<ProtoAbciResult> for AbciResult {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoAbciResult) -> Result<Self, Self::Error> {
-        let mut events = Vec::with_capacity(value.events.len());
-
-        for proto_event in value.events.into_iter() {
-            let type_str = proto_event.r#type;
-
-            let mut attributes = Vec::with_capacity(proto_event.attributes.len());
-            for proto_attribute in proto_event.attributes.into_iter() {
-                let stringified_ked = String::from_utf8(proto_attribute.key)
-                    .map_err(|_| NymdError::DeserializationError("EventAttributeKey".to_owned()))?;
-                let stringified_value = String::from_utf8(proto_attribute.value)
-                    .map_err(|_| NymdError::DeserializationError("EventAttributeKey".to_owned()))?;
-
-                attributes.push(abci::tag::Tag {
-                    key: stringified_ked.parse().unwrap(),
-                    value: stringified_value.parse().unwrap(),
-                })
-            }
-
-            events.push(abci::Event {
-                type_str,
-                attributes,
-            })
-        }
-
-        Ok(AbciResult {
-            data: value.data,
-            log: value.log,
-            events,
-        })
-    }
-}
-
-#[derive(Debug)]
-pub struct SimulateResponse {
-    pub gas_info: Option<GasInfo>,
-    pub result: Option<AbciResult>,
-}
-
-impl TryFrom<ProtoSimulateResponse> for SimulateResponse {
-    type Error = NymdError;
-
-    fn try_from(value: ProtoSimulateResponse) -> Result<Self, Self::Error> {
-        Ok(SimulateResponse {
-            gas_info: value.gas_info.map(|gas_info| gas_info.into()),
-            result: value.result.map(|result| result.try_into()).transpose()?,
-        })
-    }
-}
-
 // ##############################################################################
 // types specific to the signing client (perhaps they should go to separate file)
 // ##############################################################################
@@ -326,6 +254,21 @@ pub struct SignerData {
    pub chain_id: chain::Id,
 }

+#[derive(Debug)]
+pub struct UploadMeta {
+    /// An URL to a .tar.gz archive of the source code of the contract,
+    /// which can be used to reproducibly build the Wasm bytecode.
+    ///
+    /// @see https://github.com/CosmWasm/cosmwasm-verify
+    pub source: Option<String>,
+
+    /// A docker image (including version) to reproducibly build the Wasm bytecode from the source code.
+    ///
+    /// @example ```cosmwasm/rust-optimizer:0.8.0```
+    /// @see https://github.com/CosmWasm/cosmwasm-verify
+    pub builder: Option<String>,
+}
+
 #[derive(Debug)]
 pub struct UploadResult {
    /// Size of the original wasm code in bytes
@@ -347,8 +290,6 @@ pub struct UploadResult {

    /// Transaction hash (might be used as transaction ID)
    pub transaction_hash: tx::Hash,
-
-    pub gas_info: GasInfo,
 }

 #[derive(Debug)]
@@ -375,8 +316,6 @@ pub struct InstantiateResult {

    /// Transaction hash (might be used as transaction ID)
    pub transaction_hash: tx::Hash,
-
-    pub gas_info: GasInfo,
 }

 #[derive(Debug)]
@@ -385,8 +324,6 @@ pub struct ChangeAdminResult {

    /// Transaction hash (might be used as transaction ID)
    pub transaction_hash: tx::Hash,
-
-    pub gas_info: GasInfo,
 }

 #[derive(Debug)]
@@ -395,8 +332,6 @@ pub struct MigrateResult {

    /// Transaction hash (might be used as transaction ID)
    pub transaction_hash: tx::Hash,
-
-    pub gas_info: GasInfo,
 }

 #[derive(Debug)]
@@ -405,6 +340,4 @@ pub struct ExecuteResult {

    /// Transaction hash (might be used as transaction ID)
    pub transaction_hash: tx::Hash,
-
-    pub gas_info: GasInfo,
 }
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::nymd::cosmwasm_client::types::ContractCodeId;
-use cosmrs::tendermint::{abci, block};
+use cosmrs::tendermint::block;
 use cosmrs::{bip32, tx, AccountId};
 use std::io;
 use thiserror::Error;
@@ -102,12 +102,6 @@ pub enum NymdError {

    #[error("The provided gas price is malformed")]
    MalformedGasPrice,
-
-    #[error("Failed to estimate gas price for the transaction")]
-    GasEstimationFailure,
-
-    #[error("Abci query failed with code {0} - {1}")]
-    AbciError(u32, abci::Log),
 }

 impl NymdError {
@@ -1,33 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmrs::tx;
-
-pub mod gas_price;
-pub mod helpers;
-
-pub const DEFAULT_SIMULATED_GAS_MULTIPLIER: f32 = 1.3;
-
-#[derive(Debug, Clone)]
-pub enum Fee {
-    Manual(tx::Fee),
-    Auto(Option<f32>),
-}
-
-impl From<tx::Fee> for Fee {
-    fn from(fee: tx::Fee) -> Self {
-        Fee::Manual(fee)
-    }
-}
-
-impl From<f32> for Fee {
-    fn from(multiplier: f32) -> Self {
-        Fee::Auto(Some(multiplier))
-    }
-}
-
-impl Default for Fee {
-    fn default() -> Self {
-        Fee::Auto(Some(DEFAULT_SIMULATED_GAS_MULTIPLIER))
-    }
-}
@@ -17,29 +17,17 @@ pub enum Operation {
    Send,

    BondMixnode,
-    BondMixnodeOnBehalf,
    UnbondMixnode,
-    UnbondMixnodeOnBehalf,
    DelegateToMixnode,
-    DelegateToMixnodeOnBehalf,
    UndelegateFromMixnode,
-    UndelegateFromMixnodeOnBehalf,

    BondGateway,
-    BondGatewayOnBehalf,
    UnbondGateway,
-    UnbondGatewayOnBehalf,

-    UpdateContractSettings,
+    UpdateStateParams,

    BeginMixnodeRewarding,
    FinishMixnodeRewarding,
-
-    TrackUnbondGateway,
-    TrackUnbondMixnode,
-    WithdrawVestedCoins,
-    TrackUndelegation,
-    CreatePeriodicVestingAccount,
 }

 pub(crate) fn calculate_fee(gas_price: &GasPrice, gas_limit: Gas) -> Coin {
@@ -55,27 +43,14 @@ impl fmt::Display for Operation {
            Operation::ChangeAdmin => f.write_str("ChangeAdmin"),
            Operation::Send => f.write_str("Send"),
            Operation::BondMixnode => f.write_str("BondMixnode"),
-            Operation::BondMixnodeOnBehalf => f.write_str("BondMixnodeOnBehalf"),
            Operation::UnbondMixnode => f.write_str("UnbondMixnode"),
-            Operation::UnbondMixnodeOnBehalf => f.write_str("UnbondMixnodeOnBehalf"),
            Operation::BondGateway => f.write_str("BondGateway"),
-            Operation::BondGatewayOnBehalf => f.write_str("BondGatewayOnBehalf"),
            Operation::UnbondGateway => f.write_str("UnbondGateway"),
-            Operation::UnbondGatewayOnBehalf => f.write_str("UnbondGatewayOnBehalf"),
            Operation::DelegateToMixnode => f.write_str("DelegateToMixnode"),
-            Operation::DelegateToMixnodeOnBehalf => f.write_str("DelegateToMixnodeOnBehalf"),
            Operation::UndelegateFromMixnode => f.write_str("UndelegateFromMixnode"),
-            Operation::UndelegateFromMixnodeOnBehalf => {
-                f.write_str("UndelegateFromMixnodeOnBehalf")
-            }
-            Operation::UpdateContractSettings => f.write_str("UpdateContractSettings"),
+            Operation::UpdateStateParams => f.write_str("UpdateStateParams"),
            Operation::BeginMixnodeRewarding => f.write_str("BeginMixnodeRewarding"),
            Operation::FinishMixnodeRewarding => f.write_str("FinishMixnodeRewarding"),
-            Operation::TrackUnbondGateway => f.write_str("TrackUnbondGateway"),
-            Operation::TrackUnbondMixnode => f.write_str("TrackUnbondMixnode"),
-            Operation::WithdrawVestedCoins => f.write_str("WithdrawVestedCoins"),
-            Operation::TrackUndelegation => f.write_str("TrackUndelegation"),
-            Operation::CreatePeriodicVestingAccount => f.write_str("CreatePeriodicVestingAccount"),
        }
    }
 }
@@ -84,34 +59,23 @@ impl Operation {
    // TODO: some value tweaking
    pub fn default_gas_limit(&self) -> Gas {
        match self {
-            Operation::Upload => 3_000_000u64.into(),
+            Operation::Upload => 2_500_000u64.into(),
            Operation::Init => 500_000u64.into(),
            Operation::Migrate => 200_000u64.into(),
            Operation::ChangeAdmin => 80_000u64.into(),
            Operation::Send => 80_000u64.into(),

            Operation::BondMixnode => 175_000u64.into(),
-            Operation::BondMixnodeOnBehalf => 200_000u64.into(),
            Operation::UnbondMixnode => 175_000u64.into(),
-            Operation::UnbondMixnodeOnBehalf => 175_000u64.into(),
            Operation::DelegateToMixnode => 175_000u64.into(),
-            Operation::DelegateToMixnodeOnBehalf => 175_000u64.into(),
            Operation::UndelegateFromMixnode => 175_000u64.into(),
-            Operation::UndelegateFromMixnodeOnBehalf => 175_000u64.into(),

            Operation::BondGateway => 175_000u64.into(),
-            Operation::BondGatewayOnBehalf => 200_000u64.into(),
            Operation::UnbondGateway => 175_000u64.into(),
-            Operation::UnbondGatewayOnBehalf => 200_000u64.into(),

-            Operation::UpdateContractSettings => 175_000u64.into(),
+            Operation::UpdateStateParams => 175_000u64.into(),
            Operation::BeginMixnodeRewarding => 175_000u64.into(),
            Operation::FinishMixnodeRewarding => 175_000u64.into(),
-            Operation::TrackUnbondGateway => 175_000u64.into(),
-            Operation::TrackUnbondMixnode => 175_000u64.into(),
-            Operation::WithdrawVestedCoins => 175_000u64.into(),
-            Operation::TrackUndelegation => 175_000u64.into(),
-            Operation::CreatePeriodicVestingAccount => 175_000u64.into(),
        }
    }

@@ -125,8 +89,9 @@ impl Operation {
        Fee::from_amount_and_gas(fee, gas_limit)
    }

-    pub fn default_fee(&self, gas_price: &GasPrice) -> Fee {
-        Self::determine_custom_fee(gas_price, self.default_gas_limit())
+    pub(crate) fn determine_fee(&self, gas_price: &GasPrice, gas_limit: Option<Gas>) -> Fee {
+        let gas_limit = gas_limit.unwrap_or_else(|| self.default_gas_limit());
+        Self::determine_custom_fee(gas_price, gas_limit)
    }
 }

@@ -38,7 +38,7 @@ impl<'a> Mul<Gas> for &'a GasPrice {
        // however, realistically that is impossible to happen as the resultant value
        // would have to be way higher than our token limit of 10^15 (1 billion of tokens * 1 million for denomination)
        // and max value of u128 is approximately 10^38
-        if limit_uint128 * gas_price_numerator > amount * gas_price_denominator {
+        if limit_uint128.u128() * gas_price_numerator > amount.u128() * gas_price_denominator {
            amount += Uint128::new(1);
        }

@@ -1,8 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-mod vesting_query_client;
-mod vesting_signing_client;
-
-pub use vesting_query_client::VestingQueryClient;
-pub use vesting_signing_client::VestingSigningClient;
@@ -1,176 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub use crate::nymd::cosmwasm_client::client::CosmWasmClient;
-use crate::nymd::error::NymdError;
-use crate::nymd::NymdClient;
-use async_trait::async_trait;
-use cosmwasm_std::{Coin, Timestamp};
-use vesting_contract::messages::QueryMsg as VestingQueryMsg;
-
-#[async_trait]
-pub trait VestingQueryClient {
-    async fn locked_coins(
-        &self,
-        address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError>;
-
-    async fn spendable_coins(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError>;
-
-    async fn vested_coins(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError>;
-
-    async fn vesting_coins(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError>;
-
-    async fn vesting_start_time(
-        &self,
-        vesting_account_address: &str,
-    ) -> Result<Timestamp, NymdError>;
-
-    async fn vesting_end_time(&self, vesting_account_address: &str)
-        -> Result<Timestamp, NymdError>;
-
-    async fn original_vesting(&self, vesting_account_address: &str) -> Result<Coin, NymdError>;
-
-    async fn delegated_free(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError>;
-
-    async fn delegated_vesting(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError>;
-}
-
-#[async_trait]
-impl<C: CosmWasmClient + Sync + Send> VestingQueryClient for NymdClient<C> {
-    async fn locked_coins(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError> {
-        let request = VestingQueryMsg::LockedCoins {
-            vesting_account_address: vesting_account_address.to_string(),
-            block_time,
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-
-    async fn spendable_coins(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError> {
-        let request = VestingQueryMsg::SpendableCoins {
-            vesting_account_address: vesting_account_address.to_string(),
-            block_time,
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-    async fn vested_coins(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError> {
-        let request = VestingQueryMsg::GetVestedCoins {
-            vesting_account_address: vesting_account_address.to_string(),
-            block_time,
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-    async fn vesting_coins(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError> {
-        let request = VestingQueryMsg::GetVestingCoins {
-            vesting_account_address: vesting_account_address.to_string(),
-            block_time,
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-
-    async fn vesting_start_time(
-        &self,
-        vesting_account_address: &str,
-    ) -> Result<Timestamp, NymdError> {
-        let request = VestingQueryMsg::GetStartTime {
-            vesting_account_address: vesting_account_address.to_string(),
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-
-    async fn vesting_end_time(
-        &self,
-        vesting_account_address: &str,
-    ) -> Result<Timestamp, NymdError> {
-        let request = VestingQueryMsg::GetEndTime {
-            vesting_account_address: vesting_account_address.to_string(),
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-
-    async fn original_vesting(&self, vesting_account_address: &str) -> Result<Coin, NymdError> {
-        let request = VestingQueryMsg::GetOriginalVesting {
-            vesting_account_address: vesting_account_address.to_string(),
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-
-    async fn delegated_free(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError> {
-        let request = VestingQueryMsg::GetDelegatedFree {
-            vesting_account_address: vesting_account_address.to_string(),
-            block_time,
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-
-    async fn delegated_vesting(
-        &self,
-        vesting_account_address: &str,
-        block_time: Option<Timestamp>,
-    ) -> Result<Coin, NymdError> {
-        let request = VestingQueryMsg::GetDelegatedVesting {
-            vesting_account_address: vesting_account_address.to_string(),
-            block_time,
-        };
-        self.client
-            .query_contract_smart(self.vesting_contract_address()?, &request)
-            .await
-    }
-}
@@ -1,294 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub use crate::nymd::cosmwasm_client::signing_client::SigningCosmWasmClient;
-use crate::nymd::cosmwasm_client::types::ExecuteResult;
-use crate::nymd::error::NymdError;
-use crate::nymd::fee::helpers::Operation;
-use crate::nymd::{cosmwasm_coin_to_cosmos_coin, NymdClient};
-use async_trait::async_trait;
-use cosmwasm_std::Coin;
-use mixnet_contract::{Gateway, IdentityKey, IdentityKeyRef, MixNode};
-use vesting_contract::messages::ExecuteMsg as VestingExecuteMsg;
-
-#[async_trait]
-pub trait VestingSigningClient {
-    async fn vesting_bond_gateway(
-        &self,
-        gateway: Gateway,
-        owner_signature: &str,
-        pledge: Coin,
-    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn vesting_unbond_gateway(&self) -> Result<ExecuteResult, NymdError>;
-
-    async fn vesting_track_unbond_gateway(
-        &self,
-        owner: &str,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn vesting_bond_mixnode(
-        &self,
-        mix_node: MixNode,
-        owner_signature: &str,
-        pledge: Coin,
-    ) -> Result<ExecuteResult, NymdError>;
-    async fn vesting_unbond_mixnode(&self) -> Result<ExecuteResult, NymdError>;
-
-    async fn vesting_track_unbond_mixnode(
-        &self,
-        owner: &str,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn withdraw_vested_coins(&self, amount: Coin) -> Result<ExecuteResult, NymdError>;
-
-    async fn vesting_track_undelegation(
-        &self,
-        address: &str,
-        mix_identity: IdentityKey,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn vesting_delegate_to_mixnode<'a>(
-        &self,
-        mix_identity: IdentityKeyRef<'a>,
-        amount: &Coin,
-    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn vesting_undelegate_from_mixnode<'a>(
-        &self,
-        mix_identity: IdentityKeyRef<'a>,
-    ) -> Result<ExecuteResult, NymdError>;
-
-    async fn create_periodic_vesting_account(
-        &self,
-        address: &str,
-        start_time: Option<u64>,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError>;
-}
-
-#[async_trait]
-impl<C: SigningCosmWasmClient + Sync + Send> VestingSigningClient for NymdClient<C> {
-    async fn vesting_bond_gateway(
-        &self,
-        gateway: Gateway,
-        owner_signature: &str,
-        pledge: Coin,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::BondGateway);
-        let req = VestingExecuteMsg::BondGateway {
-            gateway,
-            owner_signature: owner_signature.to_string(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::BondGateway",
-                vec![cosmwasm_coin_to_cosmos_coin(pledge)],
-            )
-            .await
-    }
-
-    async fn vesting_unbond_gateway(&self) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UnbondGateway);
-        let req = VestingExecuteMsg::UnbondGateway {};
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::UnbondGateway",
-                vec![],
-            )
-            .await
-    }
-
-    async fn vesting_track_unbond_gateway(
-        &self,
-        owner: &str,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::TrackUnbondGateway);
-        let req = VestingExecuteMsg::TrackUnbondGateway {
-            owner: owner.to_string(),
-            amount,
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::TrackUnbondGateway",
-                vec![],
-            )
-            .await
-    }
-
-    async fn vesting_bond_mixnode(
-        &self,
-        mix_node: MixNode,
-        owner_signature: &str,
-        pledge: Coin,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::BondMixnode);
-        let req = VestingExecuteMsg::BondMixnode {
-            mix_node,
-            owner_signature: owner_signature.to_string(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::BondMixnode",
-                vec![cosmwasm_coin_to_cosmos_coin(pledge)],
-            )
-            .await
-    }
-
-    async fn vesting_unbond_mixnode(&self) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UnbondMixnode);
-        let req = VestingExecuteMsg::UnbondMixnode {};
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::UnbondMixnode",
-                vec![],
-            )
-            .await
-    }
-
-    async fn vesting_track_unbond_mixnode(
-        &self,
-        owner: &str,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::TrackUnbondMixnode);
-        let req = VestingExecuteMsg::TrackUnbondMixnode {
-            owner: owner.to_string(),
-            amount,
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::TrackUnbondMixnode",
-                vec![],
-            )
-            .await
-    }
-
-    async fn withdraw_vested_coins(&self, amount: Coin) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::WithdrawVestedCoins);
-        let req = VestingExecuteMsg::WithdrawVestedCoins { amount };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::WithdrawVested",
-                vec![],
-            )
-            .await
-    }
-
-    async fn vesting_track_undelegation(
-        &self,
-        address: &str,
-        mix_identity: IdentityKey,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::TrackUndelegation);
-        let req = VestingExecuteMsg::TrackUndelegation {
-            owner: address.to_string(),
-            mix_identity,
-            amount,
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::TrackUndelegation",
-                vec![],
-            )
-            .await
-    }
-    async fn vesting_delegate_to_mixnode<'a>(
-        &self,
-        mix_identity: IdentityKeyRef<'a>,
-        amount: &Coin,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::DelegateToMixnode);
-        let req = VestingExecuteMsg::DelegateToMixnode {
-            mix_identity: mix_identity.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::DeledateToMixnode",
-                vec![cosmwasm_coin_to_cosmos_coin(amount.to_owned())],
-            )
-            .await
-    }
-    async fn vesting_undelegate_from_mixnode<'a>(
-        &self,
-        mix_identity: IdentityKeyRef<'a>,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::UndelegateFromMixnode);
-        let req = VestingExecuteMsg::UndelegateFromMixnode {
-            mix_identity: mix_identity.into(),
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::UndelegateFromMixnode",
-                vec![],
-            )
-            .await
-    }
-    async fn create_periodic_vesting_account(
-        &self,
-        address: &str,
-        start_time: Option<u64>,
-        amount: Coin,
-    ) -> Result<ExecuteResult, NymdError> {
-        let fee = self.operation_fee(Operation::CreatePeriodicVestingAccount);
-        let req = VestingExecuteMsg::CreateAccount {
-            address: address.to_string(),
-            start_time,
-        };
-        self.client
-            .execute(
-                self.address(),
-                self.vesting_contract_address()?,
-                &req,
-                fee,
-                "VestingContract::CreatePeriodicVestingAccount",
-                vec![cosmwasm_coin_to_cosmos_coin(amount)],
-            )
-            .await
-    }
-}
@@ -10,7 +10,7 @@ use cosmrs::tx::SignDoc;
 use cosmrs::{tx, AccountId};

 /// Derivation information required to derive a keypair and an address from a mnemonic.
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct Secp256k1Derivation {
    hd_path: DerivationPath,
    prefix: String,
@@ -40,7 +40,7 @@ impl AccountData {

 type Secp256k1Keypair = (SigningKey, PublicKey);

-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DirectSecp256k1HdWallet {
    /// Base secret
    secret: bip39::Mnemonic,
@@ -207,9 +207,9 @@ mod tests {
    fn generating_account_addresses() {
        // test vectors produced from our js wallet
        let mnemonic_address = vec![
-            ("crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove", "nymt1jw6mp7d5xqc7w6xm79lha27glmd0vdt339me94"),
-            ("acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel", "nymt1h5hgn94nsq4kh99rjj794hr5h5q6yfm23rjshv"),
-            ("step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball", "nymt17n9flp6jflljg6fp05dsy07wcprf2uuufgn4d4")
+            ("crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove", "punk1jw6mp7d5xqc7w6xm79lha27glmd0vdt32a3fj2"),
+            ("acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel", "punk1h5hgn94nsq4kh99rjj794hr5h5q6yfm22mcqqn"),
+            ("step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball", "punk17n9flp6jflljg6fp05dsy07wcprf2uuujse962")
        ];

        for (mnemonic, address) in mnemonic_address.into_iter() {
@@ -1,4 +0,0 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
-
-
@@ -1,7 +1,7 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-pub use ed25519_dalek::ed25519::signature::Signature as SignatureTrait;
+use ed25519_dalek::ed25519::signature::Signature as SignatureTrait;
 pub use ed25519_dalek::SignatureError;
 pub use ed25519_dalek::{Verifier, PUBLIC_KEY_LENGTH, SECRET_KEY_LENGTH, SIGNATURE_LENGTH};
 use nymsphinx_types::{DestinationAddressBytes, DESTINATION_ADDRESS_LENGTH};
@@ -10,33 +10,33 @@ use rand::{CryptoRng, RngCore};
 use std::fmt::{self, Display, Formatter};

 #[derive(Debug)]
-pub enum Ed25519RecoveryError {
+pub enum KeyRecoveryError {
    MalformedBytes(SignatureError),
    MalformedString(bs58::decode::Error),
 }

-impl From<SignatureError> for Ed25519RecoveryError {
+impl From<SignatureError> for KeyRecoveryError {
    fn from(err: SignatureError) -> Self {
-        Ed25519RecoveryError::MalformedBytes(err)
+        KeyRecoveryError::MalformedBytes(err)
    }
 }

-impl From<bs58::decode::Error> for Ed25519RecoveryError {
+impl From<bs58::decode::Error> for KeyRecoveryError {
    fn from(err: bs58::decode::Error) -> Self {
-        Ed25519RecoveryError::MalformedString(err)
+        KeyRecoveryError::MalformedString(err)
    }
 }

-impl fmt::Display for Ed25519RecoveryError {
+impl fmt::Display for KeyRecoveryError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
-            Ed25519RecoveryError::MalformedBytes(err) => write!(f, "malformed bytes - {}", err),
-            Ed25519RecoveryError::MalformedString(err) => write!(f, "malformed string - {}", err),
+            KeyRecoveryError::MalformedBytes(err) => write!(f, "malformed bytes - {}", err),
+            KeyRecoveryError::MalformedString(err) => write!(f, "malformed string - {}", err),
        }
    }
 }

-impl std::error::Error for Ed25519RecoveryError {}
+impl std::error::Error for KeyRecoveryError {}

 /// Keypair for usage in ed25519 EdDSA.
 pub struct KeyPair {
@@ -62,7 +62,7 @@ impl KeyPair {
        &self.public_key
    }

-    pub fn from_bytes(priv_bytes: &[u8], pub_bytes: &[u8]) -> Result<Self, Ed25519RecoveryError> {
+    pub fn from_bytes(priv_bytes: &[u8], pub_bytes: &[u8]) -> Result<Self, KeyRecoveryError> {
        Ok(KeyPair {
            private_key: PrivateKey::from_bytes(priv_bytes)?,
            public_key: PublicKey::from_bytes(pub_bytes)?,
@@ -115,7 +115,7 @@ impl PublicKey {
        self.0.to_bytes()
    }

-    pub fn from_bytes(b: &[u8]) -> Result<Self, Ed25519RecoveryError> {
+    pub fn from_bytes(b: &[u8]) -> Result<Self, KeyRecoveryError> {
        Ok(PublicKey(ed25519_dalek::PublicKey::from_bytes(b)?))
    }

@@ -123,7 +123,7 @@ impl PublicKey {
        bs58::encode(self.to_bytes()).into_string()
    }

-    pub fn from_base58_string<I: AsRef<[u8]>>(val: I) -> Result<Self, Ed25519RecoveryError> {
+    pub fn from_base58_string<I: AsRef<[u8]>>(val: I) -> Result<Self, KeyRecoveryError> {
        let bytes = bs58::decode(val).into_vec()?;
        Self::from_bytes(&bytes)
    }
@@ -134,7 +134,7 @@ impl PublicKey {
 }

 impl PemStorableKey for PublicKey {
-    type Error = Ed25519RecoveryError;
+    type Error = KeyRecoveryError;

    fn pem_type() -> &'static str {
        "ED25519 PUBLIC KEY"
@@ -170,7 +170,7 @@ impl PrivateKey {
        self.0.to_bytes()
    }

-    pub fn from_bytes(b: &[u8]) -> Result<Self, Ed25519RecoveryError> {
+    pub fn from_bytes(b: &[u8]) -> Result<Self, KeyRecoveryError> {
        Ok(PrivateKey(ed25519_dalek::SecretKey::from_bytes(b)?))
    }

@@ -178,7 +178,7 @@ impl PrivateKey {
        bs58::encode(&self.to_bytes()).into_string()
    }

-    pub fn from_base58_string<I: AsRef<[u8]>>(val: I) -> Result<Self, Ed25519RecoveryError> {
+    pub fn from_base58_string<I: AsRef<[u8]>>(val: I) -> Result<Self, KeyRecoveryError> {
        let bytes = bs58::decode(val).into_vec()?;
        Self::from_bytes(&bytes)
    }
@@ -192,7 +192,7 @@ impl PrivateKey {
 }

 impl PemStorableKey for PrivateKey {
-    type Error = Ed25519RecoveryError;
+    type Error = KeyRecoveryError;

    fn pem_type() -> &'static str {
        "ED25519 PRIVATE KEY"
@@ -211,20 +211,11 @@ impl PemStorableKey for PrivateKey {
 pub struct Signature(ed25519_dalek::Signature);

 impl Signature {
-    pub fn to_base58_string(&self) -> String {
-        bs58::encode(&self.to_bytes()).into_string()
-    }
-
-    pub fn from_base58_string<I: AsRef<[u8]>>(val: I) -> Result<Self, Ed25519RecoveryError> {
-        let bytes = bs58::decode(val).into_vec()?;
-        Self::from_bytes(&bytes)
-    }
-
    pub fn to_bytes(&self) -> [u8; SIGNATURE_LENGTH] {
        self.0.to_bytes()
    }

-    pub fn from_bytes(bytes: &[u8]) -> Result<Self, Ed25519RecoveryError> {
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self, SignatureError> {
        Ok(Signature(ed25519_dalek::Signature::from_bytes(bytes)?))
    }
 }
@@ -7,7 +7,9 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-cosmwasm-std = "1.0.0-beta2"
+# this branch is identical to 0.14.1 with addition of updated k256 dependency required to help poor cargo choose correct version
+cosmwasm-std = { git = "https://github.com/jstuczyn/cosmwasm", branch = "0.14.1-updatedk256" }
+#cosmwasm-std = { version = "0.14.1" }

 serde = { version = "1.0", features = ["derive"] }
 serde_repr = "0.1"
@@ -1,6 +1,3 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
 // due to code generated by JsonSchema
 #![allow(clippy::field_reassign_with_default)]

@@ -10,41 +7,51 @@ use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;

-#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, JsonSchema)]
-pub struct Delegation {
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct UnpackedDelegation<T> {
    pub owner: Addr,
    pub node_identity: IdentityKey,
-    pub amount: Coin,
+    pub delegation_data: T,
+}
+
+impl<T> UnpackedDelegation<T> {
+    pub fn new(owner: Addr, node_identity: IdentityKey, delegation_data: T) -> Self {
+        UnpackedDelegation {
+            owner,
+            node_identity,
+            delegation_data,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct RawDelegationData {
+    pub amount: Uint128,
    pub block_height: u64,
-    pub proxy: Option<Addr>, // proxy address used to delegate the funds on behalf of anouther address
+}
+
+impl RawDelegationData {
+    pub fn new(amount: Uint128, block_height: u64) -> Self {
+        RawDelegationData {
+            amount,
+            block_height,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct Delegation {
+    owner: Addr,
+    amount: Coin,
+    block_height: u64,
 }

 impl Delegation {
-    pub fn new(
-        owner: Addr,
-        node_identity: IdentityKey,
-        amount: Coin,
-        block_height: u64,
-        proxy: Option<Addr>,
-    ) -> Self {
+    pub fn new(owner: Addr, amount: Coin, block_height: u64) -> Self {
        Delegation {
            owner,
-            node_identity,
            amount,
            block_height,
-            proxy,
-        }
-    }
-
-    // TODO: change that to use .joined_key() and return Vec<u8>
-    pub fn storage_key(&self) -> (IdentityKey, Addr) {
-        (self.node_identity(), self.owner())
-    }
-
-    pub fn increment_amount(&mut self, amount: Uint128, at_height: Option<u64>) {
-        self.amount.amount += amount;
-        if let Some(at_height) = at_height {
-            self.block_height = at_height;
        }
    }

@@ -52,10 +59,6 @@ impl Delegation {
        &self.amount
    }

-    pub fn node_identity(&self) -> IdentityKey {
-        self.node_identity.clone()
-    }
-
    pub fn owner(&self) -> Addr {
        self.owner.clone()
    }
@@ -69,36 +72,27 @@ impl Display for Delegation {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            f,
-            "{} delegated towards {} by {} at block {}",
-            self.amount, self.node_identity, self.owner, self.block_height
+            "{} {} delegated by {} at block {}",
+            self.amount.amount, self.amount.denom, self.owner, self.block_height
        )
    }
 }

 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct PagedMixDelegationsResponse {
+    pub node_identity: IdentityKey,
    pub delegations: Vec<Delegation>,
-    pub start_next_after: Option<String>,
+    pub start_next_after: Option<Addr>,
 }

 impl PagedMixDelegationsResponse {
-    pub fn new(delegations: Vec<Delegation>, start_next_after: Option<Addr>) -> Self {
+    pub fn new(
+        node_identity: IdentityKey,
+        delegations: Vec<Delegation>,
+        start_next_after: Option<Addr>,
+    ) -> Self {
        PagedMixDelegationsResponse {
-            delegations,
-            start_next_after: start_next_after.map(|s| s.to_string()),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
-pub struct PagedDelegatorDelegationsResponse {
-    pub delegations: Vec<Delegation>,
-    pub start_next_after: Option<IdentityKey>,
-}
-
-impl PagedDelegatorDelegationsResponse {
-    pub fn new(delegations: Vec<Delegation>, start_next_after: Option<IdentityKey>) -> Self {
-        PagedDelegatorDelegationsResponse {
+            node_identity,
            delegations,
            start_next_after,
        }
@@ -106,19 +100,37 @@ impl PagedDelegatorDelegationsResponse {
 }

 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
-pub struct PagedAllDelegationsResponse {
-    pub delegations: Vec<Delegation>,
-    pub start_next_after: Option<(IdentityKey, String)>,
+pub struct PagedReverseMixDelegationsResponse {
+    pub delegation_owner: Addr,
+    pub delegated_nodes: Vec<IdentityKey>,
+    pub start_next_after: Option<IdentityKey>,
 }

-impl PagedAllDelegationsResponse {
+impl PagedReverseMixDelegationsResponse {
    pub fn new(
-        delegations: Vec<Delegation>,
-        start_next_after: Option<(IdentityKey, Addr)>,
+        delegation_owner: Addr,
+        delegated_nodes: Vec<IdentityKey>,
+        start_next_after: Option<IdentityKey>,
    ) -> Self {
-        PagedAllDelegationsResponse {
-            delegations,
-            start_next_after: start_next_after.map(|(id, addr)| (id, addr.to_string())),
+        PagedReverseMixDelegationsResponse {
+            delegation_owner,
+            delegated_nodes,
+            start_next_after,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
+pub struct PagedAllDelegationsResponse<T> {
+    pub delegations: Vec<UnpackedDelegation<T>>,
+    pub start_next_after: Option<Vec<u8>>,
+}
+
+impl<T> PagedAllDelegationsResponse<T> {
+    pub fn new(delegations: Vec<UnpackedDelegation<T>>, start_next_after: Option<Vec<u8>>) -> Self {
+        PagedAllDelegationsResponse {
+            delegations,
+            start_next_after,
        }
    }
 }
@@ -23,27 +23,19 @@ pub struct Gateway {

 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct GatewayBond {
-    pub pledge_amount: Coin,
+    pub bond_amount: Coin,
    pub owner: Addr,
    pub block_height: u64,
    pub gateway: Gateway,
-    pub proxy: Option<Addr>,
 }

 impl GatewayBond {
-    pub fn new(
-        pledge_amount: Coin,
-        owner: Addr,
-        block_height: u64,
-        gateway: Gateway,
-        proxy: Option<Addr>,
-    ) -> Self {
+    pub fn new(bond_amount: Coin, owner: Addr, block_height: u64, gateway: Gateway) -> Self {
        GatewayBond {
-            pledge_amount,
+            bond_amount,
            owner,
            block_height,
            gateway,
-            proxy,
        }
    }

@@ -51,8 +43,8 @@ impl GatewayBond {
        &self.gateway.identity_key
    }

-    pub fn pledge_amount(&self) -> Coin {
-        self.pledge_amount.clone()
+    pub fn bond_amount(&self) -> Coin {
+        self.bond_amount.clone()
    }

    pub fn owner(&self) -> &Addr {
@@ -67,17 +59,17 @@ impl GatewayBond {
 impl PartialOrd for GatewayBond {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        // first remove invalid cases
-        if self.pledge_amount.denom != other.pledge_amount.denom {
+        if self.bond_amount.denom != other.bond_amount.denom {
            return None;
        }

-        // try to order by total pledge
-        let pledge_cmp = self
-            .pledge_amount
+        // try to order by total bond
+        let bond_cmp = self
+            .bond_amount
            .amount
-            .partial_cmp(&other.pledge_amount.amount)?;
-        if pledge_cmp != Ordering::Equal {
-            return Some(pledge_cmp);
+            .partial_cmp(&other.bond_amount.amount)?;
+        if bond_cmp != Ordering::Equal {
+            return Some(bond_cmp);
        }

        // then check block height
@@ -102,10 +94,7 @@ impl Display for GatewayBond {
        write!(
            f,
            "amount: {} {}, owner: {}, identity: {}",
-            self.pledge_amount.amount,
-            self.pledge_amount.denom,
-            self.owner,
-            self.gateway.identity_key
+            self.bond_amount.amount, self.bond_amount.denom, self.owner, self.gateway.identity_key
        )
    }
 }
@@ -134,7 +123,7 @@ impl PagedGatewayResponse {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct GatewayOwnershipResponse {
    pub address: Addr,
-    pub gateway: Option<GatewayBond>,
+    pub has_gateway: bool,
 }

 #[cfg(test)]
@@ -161,43 +150,38 @@ mod tests {
        let _0foos = Coin::new(0, "foo");

        let gate1 = GatewayBond {
-            pledge_amount: _150foos.clone(),
+            bond_amount: _150foos.clone(),
            owner: Addr::unchecked("foo1"),
            block_height: 100,
            gateway: gateway_fixture(),
-            proxy: None,
        };

        let gate2 = GatewayBond {
-            pledge_amount: _150foos,
+            bond_amount: _150foos,
            owner: Addr::unchecked("foo2"),
            block_height: 120,
            gateway: gateway_fixture(),
-            proxy: None,
        };

        let gate3 = GatewayBond {
-            pledge_amount: _50foos,
+            bond_amount: _50foos,
            owner: Addr::unchecked("foo3"),
            block_height: 120,
            gateway: gateway_fixture(),
-            proxy: None,
        };

        let gate4 = GatewayBond {
-            pledge_amount: _140foos,
+            bond_amount: _140foos,
            owner: Addr::unchecked("foo4"),
            block_height: 120,
            gateway: gateway_fixture(),
-            proxy: None,
        };

        let gate5 = GatewayBond {
-            pledge_amount: _0foos,
+            bond_amount: _0foos,
            owner: Addr::unchecked("foo5"),
            block_height: 120,
            gateway: gateway_fixture(),
-            proxy: None,
        };

        // summary:
@@ -12,10 +12,10 @@ pub const MIXNODE_DELEGATORS_PAGE_LIMIT: usize = 250;

 pub use cosmwasm_std::{Addr, Coin};
 pub use delegation::{
-    Delegation, PagedAllDelegationsResponse, PagedDelegatorDelegationsResponse,
-    PagedMixDelegationsResponse,
+    Delegation, PagedAllDelegationsResponse, PagedMixDelegationsResponse,
+    PagedReverseMixDelegationsResponse, RawDelegationData, UnpackedDelegation,
 };
 pub use gateway::{Gateway, GatewayBond, GatewayOwnershipResponse, PagedGatewayResponse};
 pub use mixnode::{Layer, MixNode, MixNodeBond, MixOwnershipResponse, PagedMixnodeResponse};
-pub use msg::*;
+pub use msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
 pub use types::*;
@@ -5,7 +5,7 @@ use crate::{IdentityKey, SphinxKey};
 use az::CheckedCast;
 use cosmwasm_std::{coin, Addr, Coin, Uint128};
 use log::error;
-use network_defaults::DEFAULT_OPERATOR_EPOCH_COST;
+use network_defaults::{DEFAULT_OPERATOR_EPOCH_COST, DEFAULT_PROFIT_MARGIN};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
@@ -29,7 +29,6 @@ pub struct MixNode {
    /// Base58 encoded ed25519 EdDSA public key.
    pub identity_key: IdentityKey,
    pub version: String,
-    pub profit_margin_percent: u8,
 }

 #[derive(
@@ -56,68 +55,32 @@ pub enum Layer {
 #[derive(Debug, Clone, JsonSchema, PartialEq, Serialize, Deserialize, Copy)]
 pub struct NodeRewardParams {
    period_reward_pool: Uint128,
-    rewarded_set_size: Uint128,
-    active_set_size: Uint128,
+    k: Uint128,
    reward_blockstamp: u64,
    circulating_supply: Uint128,
    uptime: Uint128,
    sybil_resistance_percent: u8,
-    in_active_set: bool,
-    active_set_work_factor: u8,
 }

 impl NodeRewardParams {
-    #[allow(clippy::too_many_arguments)]
    pub fn new(
        period_reward_pool: u128,
-        rewarded_set_size: u128,
-        active_set_size: u128,
+        k: u128,
        reward_blockstamp: u64,
        circulating_supply: u128,
        uptime: u128,
        sybil_resistance_percent: u8,
-        in_active_set: bool,
-        active_set_work_factor: u8,
    ) -> NodeRewardParams {
        NodeRewardParams {
-            period_reward_pool: Uint128::new(period_reward_pool),
-            rewarded_set_size: Uint128::new(rewarded_set_size),
-            active_set_size: Uint128::new(active_set_size),
+            period_reward_pool: Uint128(period_reward_pool),
+            k: Uint128(k),
            reward_blockstamp,
-            circulating_supply: Uint128::new(circulating_supply),
-            uptime: Uint128::new(uptime),
+            circulating_supply: Uint128(circulating_supply),
+            uptime: Uint128(uptime),
            sybil_resistance_percent,
-            in_active_set,
-            active_set_work_factor,
        }
    }

-    pub fn omega(&self) -> U128 {
-        // As per keybase://chat/nymtech#tokeneconomics/1179
-        let denom = self.active_set_work_factor() * U128::from_num(self.rewarded_set_size())
-            - (self.active_set_work_factor() - ONE) * U128::from_num(self.idle_nodes().u128());
-
-        if self.in_active_set() {
-            // work_active = factor / (factor * self.network.k[month] - (factor - 1) * idle_nodes)
-            self.active_set_work_factor() / denom * self.rewarded_set_size()
-        } else {
-            // work_idle = 1 / (factor * self.network.k[month] - (factor - 1) * idle_nodes)
-            ONE / denom * self.rewarded_set_size()
-        }
-    }
-
-    pub fn idle_nodes(&self) -> Uint128 {
-        self.rewarded_set_size - self.active_set_size
-    }
-
-    pub fn active_set_work_factor(&self) -> U128 {
-        U128::from_num(self.active_set_work_factor)
-    }
-
-    pub fn in_active_set(&self) -> bool {
-        self.in_active_set
-    }
-
    pub fn performance(&self) -> U128 {
        U128::from_num(self.uptime.u128()) / U128::from_num(100)
    }
@@ -134,8 +97,8 @@ impl NodeRewardParams {
        self.period_reward_pool.u128()
    }

-    pub fn rewarded_set_size(&self) -> u128 {
-        self.rewarded_set_size.u128()
+    pub fn k(&self) -> u128 {
+        self.k.u128()
    }

    pub fn circulating_supply(&self) -> u128 {
@@ -151,7 +114,7 @@ impl NodeRewardParams {
    }

    pub fn one_over_k(&self) -> U128 {
-        ONE / U128::from_num(self.rewarded_set_size.u128())
+        ONE / U128::from_num(self.k.u128())
    }

    pub fn alpha(&self) -> U128 {
@@ -266,45 +229,46 @@ impl NodeRewardResult {

 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct MixNodeBond {
-    pub pledge_amount: Coin,
+    pub bond_amount: Coin,
    pub total_delegation: Coin,
    pub owner: Addr,
    pub layer: Layer,
    pub block_height: u64,
    pub mix_node: MixNode,
-    pub proxy: Option<Addr>,
+    pub profit_margin_percent: Option<u8>,
 }

 impl MixNodeBond {
    pub fn new(
-        pledge_amount: Coin,
+        bond_amount: Coin,
        owner: Addr,
        layer: Layer,
        block_height: u64,
        mix_node: MixNode,
-        proxy: Option<Addr>,
+        profit_margin_percent: Option<u8>,
    ) -> Self {
        MixNodeBond {
-            total_delegation: coin(0, &pledge_amount.denom),
-            pledge_amount,
+            total_delegation: coin(0, &bond_amount.denom),
+            bond_amount,
            owner,
            layer,
            block_height,
            mix_node,
-            proxy,
+            profit_margin_percent,
        }
    }

    pub fn profit_margin(&self) -> U128 {
-        U128::from_num(self.mix_node.profit_margin_percent) / U128::from_num(100)
+        U128::from_num(self.profit_margin_percent.unwrap_or(DEFAULT_PROFIT_MARGIN))
+            / U128::from_num(100)
    }

    pub fn identity(&self) -> &String {
        &self.mix_node.identity_key
    }

-    pub fn pledge_amount(&self) -> Coin {
-        self.pledge_amount.clone()
+    pub fn bond_amount(&self) -> Coin {
+        self.bond_amount.clone()
    }

    pub fn owner(&self) -> &Addr {
@@ -316,10 +280,10 @@ impl MixNodeBond {
    }

    pub fn total_stake(&self) -> Option<u128> {
-        if self.pledge_amount.denom != self.total_delegation.denom {
+        if self.bond_amount.denom != self.total_delegation.denom {
            None
        } else {
-            Some(self.pledge_amount.amount.u128() + self.total_delegation.amount.u128())
+            Some(self.bond_amount.amount.u128() + self.total_delegation.amount.u128())
        }
    }

@@ -327,37 +291,38 @@ impl MixNodeBond {
        self.total_delegation.clone()
    }

-    pub fn pledge_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
-        U128::from_num(self.pledge_amount().amount.u128()) / U128::from_num(circulating_supply)
+    pub fn bond_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
+        U128::from_num(self.bond_amount().amount.u128()) / U128::from_num(circulating_supply)
    }

-    pub fn total_bond_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
-        U128::from_num(self.pledge_amount().amount.u128() + self.total_delegation().amount.u128())
+    pub fn total_stake_to_circulating_supply(&self, circulating_supply: u128) -> U128 {
+        U128::from_num(self.bond_amount().amount.u128() + self.total_delegation().amount.u128())
            / U128::from_num(circulating_supply)
    }

    pub fn lambda(&self, params: &NodeRewardParams) -> U128 {
        // Ratio of a bond to the token circulating supply
-        let pledge_to_circulating_supply_ratio =
-            self.pledge_to_circulating_supply(params.circulating_supply());
-        pledge_to_circulating_supply_ratio.min(params.one_over_k())
+        let bond_to_circulating_supply_ratio =
+            self.bond_to_circulating_supply(params.circulating_supply());
+        bond_to_circulating_supply_ratio.min(params.one_over_k())
    }

    pub fn sigma(&self, params: &NodeRewardParams) -> U128 {
        // Ratio of a delegation to the the token circulating supply
-        let total_bond_to_circulating_supply_ratio =
-            self.total_bond_to_circulating_supply(params.circulating_supply());
-        total_bond_to_circulating_supply_ratio.min(params.one_over_k())
+        let total_stake_to_circulating_supply_ratio =
+            self.total_stake_to_circulating_supply(params.circulating_supply());
+        total_stake_to_circulating_supply_ratio.min(params.one_over_k())
    }

    pub fn reward(&self, params: &NodeRewardParams) -> NodeRewardResult {
+        // Assuming uniform work distribution across the network this is one_over_k * k
+        let omega_k = ONE;
        let lambda = self.lambda(params);
        let sigma = self.sigma(params);

        let reward = params.performance()
            * params.period_reward_pool()
-            * (sigma * params.omega()
-                + params.alpha() * lambda * sigma * params.rewarded_set_size())
+            * (sigma * omega_k + params.alpha() * lambda * sigma * params.k())
            / (ONE + params.alpha());

        NodeRewardResult {
@@ -402,9 +367,9 @@ impl MixNodeBond {
    }

    pub fn sigma_ratio(&self, params: &NodeRewardParams) -> U128 {
-        if self.total_bond_to_circulating_supply(params.circulating_supply()) < params.one_over_k()
+        if self.total_stake_to_circulating_supply(params.circulating_supply()) < params.one_over_k()
        {
-            self.total_bond_to_circulating_supply(params.circulating_supply())
+            self.total_stake_to_circulating_supply(params.circulating_supply())
        } else {
            params.one_over_k()
        }
@@ -419,33 +384,33 @@ impl MixNodeBond {
 impl PartialOrd for MixNodeBond {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        // first remove invalid cases
-        if self.pledge_amount.denom != self.total_delegation.denom {
+        if self.bond_amount.denom != self.total_delegation.denom {
            return None;
        }

-        if other.pledge_amount.denom != other.total_delegation.denom {
+        if other.bond_amount.denom != other.total_delegation.denom {
            return None;
        }

-        if self.pledge_amount.denom != other.pledge_amount.denom {
+        if self.bond_amount.denom != other.bond_amount.denom {
            return None;
        }

        // try to order by total bond + delegation
-        let total_cmp = (self.pledge_amount.amount + self.total_delegation.amount)
-            .partial_cmp(&(self.pledge_amount.amount + self.total_delegation.amount))?;
+        let total_cmp = (self.bond_amount.amount + self.total_delegation.amount)
+            .partial_cmp(&(self.bond_amount.amount + self.total_delegation.amount))?;

        if total_cmp != Ordering::Equal {
            return Some(total_cmp);
        }

        // then if those are equal, prefer higher bond over delegation
-        let pledge_cmp = self
-            .pledge_amount
+        let bond_cmp = self
+            .bond_amount
            .amount
-            .partial_cmp(&other.pledge_amount.amount)?;
-        if pledge_cmp != Ordering::Equal {
-            return Some(pledge_cmp);
+            .partial_cmp(&other.bond_amount.amount)?;
+        if bond_cmp != Ordering::Equal {
+            return Some(bond_cmp);
        }

        // then look at delegation (I'm not sure we can get here, but better safe than sorry)
@@ -484,10 +449,7 @@ impl Display for MixNodeBond {
        write!(
            f,
            "amount: {} {}, owner: {}, identity: {}",
-            self.pledge_amount.amount,
-            self.pledge_amount.denom,
-            self.owner,
-            self.mix_node.identity_key
+            self.bond_amount.amount, self.bond_amount.denom, self.owner, self.mix_node.identity_key
        )
    }
 }
@@ -516,7 +478,7 @@ impl PagedMixnodeResponse {
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, JsonSchema)]
 pub struct MixOwnershipResponse {
    pub address: Addr,
-    pub mixnode: Option<MixNodeBond>,
+    pub has_node: bool,
 }

 #[cfg(test)]
@@ -532,7 +494,6 @@ mod tests {
            sphinx_key: "sphinxkey".to_string(),
            identity_key: "identitykey".to_string(),
            version: "0.11.0".to_string(),
-            profit_margin_percent: 10,
        }
    }

@@ -543,53 +504,53 @@ mod tests {
        let _0foos = Coin::new(0, "foo");

        let mix1 = MixNodeBond {
-            pledge_amount: _150foos.clone(),
+            bond_amount: _150foos.clone(),
            total_delegation: _50foos.clone(),
            owner: Addr::unchecked("foo1"),
            layer: Layer::One,
            block_height: 100,
            mix_node: mixnode_fixture(),
-            proxy: None,
+            profit_margin_percent: Some(10),
        };

        let mix2 = MixNodeBond {
-            pledge_amount: _150foos.clone(),
+            bond_amount: _150foos.clone(),
            total_delegation: _50foos.clone(),
            owner: Addr::unchecked("foo2"),
            layer: Layer::One,
            block_height: 120,
            mix_node: mixnode_fixture(),
-            proxy: None,
+            profit_margin_percent: Some(10),
        };

        let mix3 = MixNodeBond {
-            pledge_amount: _50foos,
+            bond_amount: _50foos,
            total_delegation: _150foos.clone(),
            owner: Addr::unchecked("foo3"),
            layer: Layer::One,
            block_height: 120,
            mix_node: mixnode_fixture(),
-            proxy: None,
+            profit_margin_percent: Some(10),
        };

        let mix4 = MixNodeBond {
-            pledge_amount: _150foos.clone(),
+            bond_amount: _150foos.clone(),
            total_delegation: _0foos.clone(),
            owner: Addr::unchecked("foo4"),
            layer: Layer::One,
            block_height: 120,
            mix_node: mixnode_fixture(),
-            proxy: None,
+            profit_margin_percent: Some(10),
        };

        let mix5 = MixNodeBond {
-            pledge_amount: _0foos,
+            bond_amount: _0foos,
            total_delegation: _150foos,
            owner: Addr::unchecked("foo5"),
            layer: Layer::One,
            block_height: 120,
            mix_node: mixnode_fixture(),
-            proxy: None,
+            profit_margin_percent: Some(10),
        };

        // summary:
@@ -2,30 +2,27 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::mixnode::NodeRewardParams;
-use crate::ContractStateParams;
+use crate::StateParams;
 use crate::{Gateway, IdentityKey, MixNode};
+use cosmwasm_std::Addr;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct InstantiateMsg {
-    pub rewarding_validator_address: String,
-}
+pub struct InstantiateMsg {}

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ExecuteMsg {
    BondMixnode {
        mix_node: MixNode,
-        owner_signature: String,
    },
    UnbondMixnode {},
    BondGateway {
        gateway: Gateway,
-        owner_signature: String,
    },
    UnbondGateway {},
-    UpdateContractStateParams(ContractStateParams),
+    UpdateStateParams(StateParams),

    DelegateToMixnode {
        mix_identity: IdentityKey,
@@ -45,7 +42,7 @@ pub enum ExecuteMsg {
        rewarding_interval_nonce: u32,
    },

-    RewardMixnode {
+    RewardMixnodeV2 {
        identity: IdentityKey,
        // percentage value in range 0-100
        params: NodeRewardParams,
@@ -53,41 +50,17 @@ pub enum ExecuteMsg {
        // nonce of the current rewarding interval
        rewarding_interval_nonce: u32,
    },
+
    RewardNextMixDelegators {
        mix_identity: IdentityKey,
        // nonce of the current rewarding interval
        rewarding_interval_nonce: u32,
    },
-    DelegateToMixnodeOnBehalf {
-        mix_identity: IdentityKey,
-        delegate: String,
-    },
-    UndelegateFromMixnodeOnBehalf {
-        mix_identity: IdentityKey,
-        delegate: String,
-    },
-    BondMixnodeOnBehalf {
-        mix_node: MixNode,
-        owner: String,
-        owner_signature: String,
-    },
-    UnbondMixnodeOnBehalf {
-        owner: String,
-    },
-    BondGatewayOnBehalf {
-        gateway: Gateway,
-        owner: String,
-        owner_signature: String,
-    },
-    UnbondGatewayOnBehalf {
-        owner: String,
-    },
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum QueryMsg {
-    GetContractVersion {},
    GetMixNodes {
        limit: Option<u32>,
        start_after: Option<IdentityKey>,
@@ -97,39 +70,30 @@ pub enum QueryMsg {
        limit: Option<u32>,
    },
    OwnsMixnode {
-        address: String,
+        address: Addr,
    },
    OwnsGateway {
-        address: String,
+        address: Addr,
    },
    StateParams {},
    CurrentRewardingInterval {},
-    // gets all [paged] delegations in the entire network
-    // TODO: do we even want that?
-    GetAllNetworkDelegations {
-        start_after: Option<(IdentityKey, String)>,
-        limit: Option<u32>,
-    },
-    // gets all [paged] delegations associated with particular mixnode
-    GetMixnodeDelegations {
+    GetMixDelegations {
        mix_identity: IdentityKey,
-        // since `start_after` is user-provided input, we can't use `Addr` as we
-        // can't guarantee it's validated.
-        start_after: Option<String>,
+        start_after: Option<Addr>,
        limit: Option<u32>,
    },
-    // gets all [paged] delegations associated with particular delegator
-    GetDelegatorDelegations {
-        // since `delegator` is user-provided input, we can't use `Addr` as we
-        // can't guarantee it's validated.
-        delegator: String,
+    GetAllMixDelegations {
+        start_after: Option<Vec<u8>>,
+        limit: Option<u32>,
+    },
+    GetReverseMixDelegations {
+        delegation_owner: Addr,
        start_after: Option<IdentityKey>,
        limit: Option<u32>,
    },
-    // gets delegation associated with particular mixnode, delegator pair
-    GetDelegationDetails {
+    GetMixDelegation {
        mix_identity: IdentityKey,
-        delegator: String,
+        address: Addr,
    },
    LayerDistribution {},
    GetRewardPool {},
@@ -3,7 +3,7 @@

 use crate::mixnode::DelegatorRewardParams;
 use crate::Layer;
-use cosmwasm_std::{Addr, Uint128};
+use cosmwasm_std::Uint128;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::fmt::{self, Display, Formatter};
@@ -35,13 +35,13 @@ pub struct RewardingIntervalResponse {
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct ContractStateParams {
+pub struct StateParams {
    // so currently epoch_length is being unused and validator API performs rewarding
    // based on its own epoch length config value. I guess that's fine for time being
    // however, in the future, the contract constant should be controlling it instead.
    // pub epoch_length: u32, // length of a rewarding epoch/interval, expressed in hours
-    pub minimum_mixnode_pledge: Uint128, // minimum amount a mixnode must pledge to get into the system
-    pub minimum_gateway_pledge: Uint128, // minimum amount a gateway must pledge to get into the system
+    pub minimum_mixnode_bond: Uint128, // minimum amount a mixnode must bond to get into the system
+    pub minimum_gateway_bond: Uint128, // minimum amount a gateway must bond to get into the system

    // number of mixnode that are going to get rewarded during current rewarding interval (k_m)
    // based on overall demand for private bandwidth-
@@ -50,22 +50,13 @@ pub struct ContractStateParams {
    // subset of rewarded mixnodes that are actively receiving mix traffic
    // used to handle shorter-term (e.g. hourly) fluctuations of demand
    pub mixnode_active_set_size: u32,
-    pub active_set_work_factor: u8,
 }

-impl Display for ContractStateParams {
+impl Display for StateParams {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "Contract state parameters: [ ")?;
-        write!(
-            f,
-            "minimum mixnode pledge: {}; ",
-            self.minimum_mixnode_pledge
-        )?;
-        write!(
-            f,
-            "minimum gateway pledge: {}; ",
-            self.minimum_gateway_pledge
-        )?;
+        write!(f, "minimum mixnode bond: {}; ", self.minimum_mixnode_bond)?;
+        write!(f, "minimum gateway bond: {}; ", self.minimum_gateway_bond)?;
        write!(
            f,
            "mixnode rewarded set size: {}",
@@ -75,11 +66,6 @@ impl Display for ContractStateParams {
            f,
            "mixnode active set size: {}",
            self.mixnode_active_set_size
-        )?;
-        write!(
-            f,
-            "mixnode active set work factor: {}",
-            self.active_set_work_factor
        )
    }
 }
@@ -95,7 +81,7 @@ pub struct PendingDelegatorRewarding {
    // keep track of the running rewarding results so we'd known how much was the operator and its delegators rewarded
    pub running_results: RewardingResult,

-    pub next_start: Addr,
+    pub next_start: String,

    pub rewarding_params: DelegatorRewardParams,
 }
@@ -111,27 +97,6 @@ pub struct MixnodeRewardingStatusResponse {
    pub status: Option<RewardingStatus>,
 }

-#[derive(Debug, Serialize, Deserialize)]
-pub struct MixnetContractVersion {
-    // VERGEN_BUILD_TIMESTAMP
-    pub build_timestamp: String,
-
-    // VERGEN_BUILD_SEMVER
-    pub build_version: String,
-
-    // VERGEN_GIT_SHA
-    pub commit_sha: String,
-
-    // VERGEN_GIT_COMMIT_TIMESTAMP
-    pub commit_timestamp: String,
-
-    // VERGEN_GIT_BRANCH
-    pub commit_branch: String,
-
-    // VERGEN_RUSTC_SEMVER
-    pub rustc_version: String,
-}
-
 // type aliases for better reasoning about available data
 pub type IdentityKey = String;
 pub type IdentityKeyRef<'a> = &'a str;
@@ -1,11 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-fn main() {
-    match option_env!("NETWORK") {
-        None | Some("milhon") => println!("cargo:rustc-cfg=network=\"milhon\"",),
-        Some("sandbox") => println!("cargo:rustc-cfg=network=\"sandbox\"",),
-        Some("qa") => println!("cargo:rustc-cfg=network=\"qa\""),
-        _ => panic!("No such network"),
-    }
-}
@@ -6,15 +6,6 @@ use time::OffsetDateTime;
 use url::Url;

 pub mod eth_contract;
-#[cfg(network = "milhon")]
-pub mod milhon;
-#[cfg(network = "sandbox")]
-pub mod sandbox;
-
-#[cfg(network = "milhon")]
-pub use milhon::*;
-#[cfg(network = "sandbox")]
-pub use sandbox::*;

 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct ValidatorDetails {
@@ -47,7 +38,6 @@ impl ValidatorDetails {
    }
 }

-#[cfg(network = "milhon")]
 pub fn default_validators() -> Vec<ValidatorDetails> {
    vec![
        ValidatorDetails::new(
@@ -58,14 +48,6 @@ pub fn default_validators() -> Vec<ValidatorDetails> {
    ]
 }

-#[cfg(network = "sandbox")]
-pub fn default_validators() -> Vec<ValidatorDetails> {
-    vec![ValidatorDetails::new(
-        "https://sandbox-validator.nymtech.net",
-        Some("https://sandbox-validator.nymtech.net/api"),
-    )]
-}
-
 pub fn default_nymd_endpoints() -> Vec<Url> {
    default_validators()
        .iter()
@@ -80,7 +62,9 @@ pub fn default_api_endpoints() -> Vec<Url> {
        .collect()
 }

-// Ethereum constants used for token bridge
+pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = "punk10pyejy66429refv3g35g2t7am0was7yalwrzen";
+pub const REWARDING_VALIDATOR_ADDRESS: &str = "punk1v9qauwdq5terag6uvfsdytcs2d0sdmfdy7hgk3";
+
 /// How much bandwidth (in bytes) one token can buy
 const BYTES_PER_TOKEN: u64 = 1024 * 1024 * 1024;
 /// How many ERC20 tokens should be burned to buy bandwidth
@@ -88,10 +72,20 @@ pub const TOKENS_TO_BURN: u64 = 10;
 /// Default bandwidth (in bytes) that we try to buy
 pub const BANDWIDTH_VALUE: u64 = TOKENS_TO_BURN * BYTES_PER_TOKEN;

+// Ethereum constants used for token bridge
+pub const ETH_CONTRACT_ADDRESS: [u8; 20] =
+    hex_literal::hex!("9fEE3e28c17dbB87310A51F13C4fbf4331A6f102");
 pub const ETH_MIN_BLOCK_DEPTH: usize = 7;
+pub const COSMOS_CONTRACT_ADDRESS: &str = "punk1jld76tqw4wnpfenmay2xkv86nr3j0w426eka82";
+// Name of the event triggered by the eth contract. If the event name is changed,
+// this would also need to be changed; It is currently tested against the json abi
+pub const ETH_EVENT_NAME: &str = "Burned";
+pub const ETH_BURN_FUNCTION_NAME: &str = "burnTokenForAccessCode";

 /// Defaults Cosmos Hub/ATOM path
 pub const COSMOS_DERIVATION_PATH: &str = "m/44'/118'/0'/0/0";
+pub const BECH32_PREFIX: &str = "punk";
+pub const DENOM: &str = "upunk";
 // as set by validators in their configs
 // (note that the 'amount' postfix is relevant here as the full gas price also includes denom)
 pub const GAS_PRICE_AMOUNT: f64 = 0.025;
@@ -1,17 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub const BECH32_PREFIX: &str = "punk";
-pub const DENOM: &str = "upunk";
-
-pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = "punk10pyejy66429refv3g35g2t7am0was7yalwrzen";
-pub const DEFAULT_VESTING_CONTRACT_ADDRESS: &str = "";
-pub const COSMOS_CONTRACT_ADDRESS: &str = "punk1jld76tqw4wnpfenmay2xkv86nr3j0w426eka82";
-pub const REWARDING_VALIDATOR_ADDRESS: &str = "punk1v9qauwdq5terag6uvfsdytcs2d0sdmfdy7hgk3";
-pub const ETH_CONTRACT_ADDRESS: [u8; 20] =
-    hex_literal::hex!("9fEE3e28c17dbB87310A51F13C4fbf4331A6f102");
-
-// Name of the event triggered by the eth contract. If the event name is changed,
-// this would also need to be changed; It is currently tested against the json abi
-pub const ETH_EVENT_NAME: &str = "Burned";
-pub const ETH_BURN_FUNCTION_NAME: &str = "burnTokenForAccessCode";
@@ -1,17 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub const BECH32_PREFIX: &str = "nymt";
-pub const DENOM: &str = "unymt";
-
-pub const DEFAULT_MIXNET_CONTRACT_ADDRESS: &str = "nymt14hj2tavq8fpesdwxxcu44rty3hh90vhuysqrsr";
-pub const DEFAULT_VESTING_CONTRACT_ADDRESS: &str = "nymt1nc5tatafv6eyq7llkr2gv50ff9e22mnfp9pc5s";
-pub const COSMOS_CONTRACT_ADDRESS: &str = "nymt17p9rzwnnfxcjp32un9ug7yhhzgtkhvl9f8xzkv";
-pub const REWARDING_VALIDATOR_ADDRESS: &str = "nymt17zujduc46wvkwvp6f062mm5xhr7jc3fewvqu9e";
-pub const ETH_CONTRACT_ADDRESS: [u8; 20] =
-    hex_literal::hex!("9fEE3e28c17dbB87310A51F13C4fbf4331A6f102");
-
-// Name of the event triggered by the eth contract. If the event name is changed,
-// this would also need to be changed; It is currently tested against the json abi
-pub const ETH_EVENT_NAME: &str = "Burned";
-pub const ETH_BURN_FUNCTION_NAME: &str = "burnTokenForAccessCode";
@@ -22,9 +22,9 @@ const CLIENT_IDENTITY_SIZE: usize = identity::PUBLIC_KEY_LENGTH;
 #[derive(Debug)]
 pub enum RecipientFormattingError {
    MalformedRecipientError,
-    MalformedIdentityError(identity::Ed25519RecoveryError),
+    MalformedIdentityError(identity::KeyRecoveryError),
    MalformedEncryptionKeyError(encryption::KeyRecoveryError),
-    MalformedGatewayError(identity::Ed25519RecoveryError),
+    MalformedGatewayError(identity::KeyRecoveryError),
 }

 impl fmt::Display for RecipientFormattingError {
@@ -13,7 +13,7 @@ use std::net::SocketAddr;

 #[derive(Debug)]
 pub enum GatewayConversionError {
-    InvalidIdentityKey(identity::Ed25519RecoveryError),
+    InvalidIdentityKey(identity::KeyRecoveryError),
    InvalidSphinxKey(encryption::KeyRecoveryError),
    InvalidAddress(String, io::Error),
    InvalidStake,
@@ -26,8 +26,8 @@ impl From<encryption::KeyRecoveryError> for GatewayConversionError {
    }
 }

-impl From<identity::Ed25519RecoveryError> for GatewayConversionError {
-    fn from(err: identity::Ed25519RecoveryError) -> Self {
+impl From<identity::KeyRecoveryError> for GatewayConversionError {
+    fn from(err: identity::KeyRecoveryError) -> Self {
        GatewayConversionError::InvalidIdentityKey(err)
    }
 }
@@ -125,7 +125,7 @@ impl<'a> TryFrom<&'a GatewayBond> for Node {

        Ok(Node {
            owner: bond.owner.as_str().to_owned(),
-            stake: bond.pledge_amount.amount.into(),
+            stake: bond.bond_amount.amount.into(),
            location: bond.gateway.location.clone(),
            host,
            mix_host,
@@ -13,7 +13,7 @@ use std::net::SocketAddr;

 #[derive(Debug)]
 pub enum MixnodeConversionError {
-    InvalidIdentityKey(identity::Ed25519RecoveryError),
+    InvalidIdentityKey(identity::KeyRecoveryError),
    InvalidSphinxKey(encryption::KeyRecoveryError),
    InvalidAddress(String, io::Error),
    InvalidStake,
@@ -26,8 +26,8 @@ impl From<encryption::KeyRecoveryError> for MixnodeConversionError {
    }
 }

-impl From<identity::Ed25519RecoveryError> for MixnodeConversionError {
-    fn from(err: identity::Ed25519RecoveryError) -> Self {
+impl From<identity::KeyRecoveryError> for MixnodeConversionError {
+    fn from(err: identity::KeyRecoveryError) -> Self {
        MixnodeConversionError::InvalidIdentityKey(err)
    }
 }
@@ -117,7 +117,7 @@ impl<'a> TryFrom<&'a MixNodeBond> for Node {

        Ok(Node {
            owner: bond.owner.as_str().to_owned(),
-            stake: bond.pledge_amount.amount.into(),
+            stake: bond.bond_amount.amount.into(),
            delegation: bond.total_delegation.amount.into(),
            host,
            mix_host,
@@ -1,13 +0,0 @@
-[workspace]
-members = ["erc20-bridge", "mixnet", "vesting"]
-
-[profile.release]
-opt-level = 3
-debug = false
-rpath = false
-lto = true
-debug-assertions = false
-codegen-units = 1
-panic = 'abort'
-incremental = false
-overflow-checks = true
@@ -89,9 +89,8 @@ dependencies = [

 [[package]]
 name = "cosmwasm-crypto"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c16b255449b3f5cd7fa4b79acd5225b5185655261087a3d8aaac44f88a0e23e9"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "digest 0.9.0",
 "ed25519-zebra",
@@ -102,18 +101,16 @@ dependencies = [

 [[package]]
 name = "cosmwasm-derive"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abad1a6ff427a2f66890a4dce6354b4563cd07cee91a942300e011c921c09ed2"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "syn",
 ]

 [[package]]
 name = "cosmwasm-std"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1660ee3d5734672e1eb4f0ceda403e2d83345e15143a48845f340f3252ce99a6"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "base64",
 "cosmwasm-crypto",
@@ -127,9 +124,8 @@ dependencies = [

 [[package]]
 name = "cosmwasm-storage"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf3b4efe3b4f86df668520a02e9a29c23eea99b64dfcacb0e59b98346418af7f"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "cosmwasm-std",
 "serde",
@@ -5,9 +5,22 @@ edition = "2018"

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

+[workspace] # adding a blank workspace to keep it out of the global workspace.
+
 [lib]
 crate-type = ["cdylib", "rlib"]

+[profile.release]
+opt-level = 3
+debug = false
+rpath = false
+lto = true
+debug-assertions = false
+codegen-units = 1
+panic = 'abort'
+incremental = false
+overflow-checks = true
+
 [features]
 # for more explicit tests, cargo test --features=backtraces
 backtraces = ["cosmwasm-std/backtraces"]
@@ -18,8 +31,9 @@ config = { path = "../../common/config"}
 [dependencies]
 erc20-bridge-contract = { path = "../../common/erc20-bridge-contract" }

-cosmwasm-std = "1.0.0-beta2"
-cosmwasm-storage = "1.0.0-beta2"
+# this branch is identical to 0.14.1 with addition of updated k256 dependency required to help poor cargo choose correct version
+cosmwasm-std = { git = "https://github.com/jstuczyn/cosmwasm", branch="0.14.1-updatedk256", features = ["iterator"] }
+cosmwasm-storage = { git = "https://github.com/jstuczyn/cosmwasm", branch="0.14.1-updatedk256", features = ["iterator"] }

 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
@@ -68,7 +68,7 @@ pub mod tests {

    #[test]
    fn initialize_contract() {
-        let mut deps = mock_dependencies();
+        let mut deps = mock_dependencies(&[]);
        let env = mock_env();
        let msg = InstantiateMsg {};
        let info = mock_info("creator", &[]);
@@ -11,7 +11,7 @@ pub mod helpers {
    use erc20_bridge_contract::payment::Payment;

    pub fn init_contract() -> OwnedDeps<MemoryStorage, MockApi, MockQuerier<Empty>> {
-        let mut deps = mock_dependencies();
+        let mut deps = mock_dependencies(&[]);
        let msg = InstantiateMsg {};
        let env = mock_env();
        let info = mock_info("creator", &[]);
@@ -2,43 +2,6 @@
 # It is not intended for manual editing.
 version = 3

-[[package]]
-name = "aes"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
-dependencies = [
- "cfg-if",
- "cipher",
- "cpufeatures",
- "ctr",
- "opaque-debug 0.3.0",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.48"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62e1f47f7dc0422027a4e370dd4548d4d66b26782e513e98dca1e689e058a80e"
-
-[[package]]
-name = "arrayref"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
-
-[[package]]
-name = "arrayvec"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
-
-[[package]]
-name = "autocfg"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
-
 [[package]]
 name = "az"
 version = "1.1.2"
@@ -51,39 +14,6 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"

-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "blake2"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94cb07b0da6a73955f8fb85d24c466778e70cda767a568229b104f0264089330"
-dependencies = [
- "byte-tools",
- "crypto-mac 0.7.0",
- "digest 0.8.1",
- "opaque-debug 0.2.3",
-]
-
-[[package]]
-name = "blake3"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "526c210b4520e416420759af363083471656e819a75e831b8d2c9d5a584f2413"
-dependencies = [
- "arrayref",
- "arrayvec",
- "cc",
- "cfg-if",
- "constant_time_eq",
- "crypto-mac 0.11.1",
- "digest 0.9.0",
-]
-
 [[package]]
 name = "block-buffer"
 version = "0.7.3"
@@ -114,18 +44,6 @@ dependencies = [
 "byte-tools",
 ]

-[[package]]
-name = "bs58"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
-
-[[package]]
-name = "bumpalo"
-version = "3.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f1e260c3a9040a7c19a12468758f4c16f31a81a1fe087482be9570ec864bb6c"
-
 [[package]]
 name = "byte-tools"
 version = "0.3.1"
@@ -144,53 +62,12 @@ version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"

-[[package]]
-name = "cc"
-version = "1.0.72"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22a9137b95ea06864e018375b72adfb7db6e6f68cfc8df5a04d00288050485ee"
-dependencies = [
- "jobserver",
-]
-
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

-[[package]]
-name = "chacha"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddf3c081b5fba1e5615640aae998e0fbd10c24cbd897ee39ed754a77601a4862"
-dependencies = [
- "byteorder",
- "keystream",
-]
-
-[[package]]
-name = "chrono"
-version = "0.4.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
-dependencies = [
- "libc",
- "num-integer",
- "num-traits",
- "time 0.1.43",
- "winapi",
-]
-
-[[package]]
-name = "cipher"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
-dependencies = [
- "generic-array 0.14.4",
-]
-
 [[package]]
 name = "config"
 version = "0.1.0"
@@ -209,17 +86,10 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d6f2aa4d0537bcc1c74df8755072bd31c1ef1a3a1b85a68e8404a8c353b7b8b"

-[[package]]
-name = "constant_time_eq"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
-
 [[package]]
 name = "cosmwasm-crypto"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c16b255449b3f5cd7fa4b79acd5225b5185655261087a3d8aaac44f88a0e23e9"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "digest 0.9.0",
 "ed25519-zebra",
@@ -230,18 +100,17 @@ dependencies = [

 [[package]]
 name = "cosmwasm-derive"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abad1a6ff427a2f66890a4dce6354b4563cd07cee91a942300e011c921c09ed2"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "syn",
 ]

 [[package]]
 name = "cosmwasm-schema"
-version = "1.0.0-beta2"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe52b19d45fe3f8359db6cc24df44dbe05e5ae32539afc0f5b7f790a21aa6fd0"
+checksum = "04159eec9b583671db7923ff2b979736dfb8f0152347cab9fd02373c22e1a870"
 dependencies = [
 "schemars",
 "serde_json",
@@ -249,9 +118,8 @@ dependencies = [

 [[package]]
 name = "cosmwasm-std"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1660ee3d5734672e1eb4f0ceda403e2d83345e15143a48845f340f3252ce99a6"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "base64",
 "cosmwasm-crypto",
@@ -265,9 +133,8 @@ dependencies = [

 [[package]]
 name = "cosmwasm-storage"
-version = "1.0.0-beta2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf3b4efe3b4f86df668520a02e9a29c23eea99b64dfcacb0e59b98346418af7f"
+version = "0.14.1"
+source = "git+https://github.com/jstuczyn/cosmwasm?branch=0.14.1-updatedk256#308781cd5f33b0e996176c6b500793d3648c0f7b"
 dependencies = [
 "cosmwasm-std",
 "serde",
@@ -288,26 +155,6 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"

-[[package]]
-name = "crypto"
-version = "0.1.0"
-dependencies = [
- "aes",
- "blake3",
- "bs58",
- "cipher",
- "digest 0.9.0",
- "ed25519-dalek",
- "generic-array 0.14.4",
- "hkdf",
- "hmac",
- "log",
- "nymsphinx-types",
- "pemstore",
- "rand",
- "x25519-dalek",
-]
-
 [[package]]
 name = "crypto-bigint"
 version = "0.2.11"
@@ -316,20 +163,10 @@ checksum = "f83bd3bb4314701c568e340cd8cf78c975aa0ca79e03d3f6d1677d5b0c9c0c03"
 dependencies = [
 "generic-array 0.14.4",
 "rand_core 0.6.3",
- "subtle 2.4.1",
+ "subtle",
 "zeroize",
 ]

-[[package]]
-name = "crypto-mac"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
-dependencies = [
- "generic-array 0.12.4",
- "subtle 1.0.0",
-]
-
 [[package]]
 name = "crypto-mac"
 version = "0.11.1"
@@ -337,16 +174,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b1d1a86f49236c215f271d40892d5fc950490551400b02ef360692c29815c714"
 dependencies = [
 "generic-array 0.14.4",
- "subtle 2.4.1",
-]
-
-[[package]]
-name = "ctr"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
-dependencies = [
- "cipher",
+ "subtle",
 ]

 [[package]]
@@ -358,21 +186,10 @@ dependencies = [
 "byteorder",
 "digest 0.9.0",
 "rand_core 0.5.1",
- "subtle 2.4.1",
+ "subtle",
 "zeroize",
 ]

-[[package]]
-name = "cw-storage-plus"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3b8b840947313c1a1cccf056836cd79a60b4526bdcd6582995be37dc97be4ae"
-dependencies = [
- "cosmwasm-std",
- "schemars",
- "serde",
-]
-
 [[package]]
 name = "der"
 version = "0.4.4"
@@ -418,29 +235,6 @@ dependencies = [
 "signature",
 ]

-[[package]]
-name = "ed25519"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74e1069e39f1454367eb2de793ed062fac4c35c2934b76a81d90dd9abcd28816"
-dependencies = [
- "signature",
-]
-
-[[package]]
-name = "ed25519-dalek"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d"
-dependencies = [
- "curve25519-dalek",
- "ed25519",
- "rand",
- "serde",
- "sha2",
- "zeroize",
-]
-
 [[package]]
 name = "ed25519-zebra"
 version = "2.2.0"
@@ -467,30 +261,10 @@ dependencies = [
 "group",
 "pkcs8",
 "rand_core 0.6.3",
- "subtle 2.4.1",
+ "subtle",
 "zeroize",
 ]

-[[package]]
-name = "enum-iterator"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eeac5c5edb79e4e39fe8439ef35207780a11f69c52cbe424ce3dfad4cb78de6"
-dependencies = [
- "enum-iterator-derive",
-]
-
-[[package]]
-name = "enum-iterator-derive"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c134c37760b27a871ba422106eedbb8247da973a09e82558bf26d619c882b159"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "fake-simd"
 version = "0.1.2"
@@ -504,7 +278,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0f40b2dcd8bc322217a5f6559ae5f9e9d1de202a2ecee2e9eafcbece7562a4f"
 dependencies = [
 "rand_core 0.6.3",
- "subtle 2.4.1",
+ "subtle",
 ]

 [[package]]
@@ -556,10 +330,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
 dependencies = [
 "cfg-if",
- "js-sys",
 "libc",
 "wasi 0.9.0+wasi-snapshot-preview1",
- "wasm-bindgen",
 ]

 [[package]]
@@ -573,31 +345,6 @@ dependencies = [
 "wasi 0.10.2+wasi-snapshot-preview1",
 ]

-[[package]]
-name = "getset"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24b328c01a4d71d2d8173daa93562a73ab0fe85616876f02500f53d82948c504"
-dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "git2"
-version = "0.13.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "845e007a28f1fcac035715988a234e8ec5458fd825b20a20c7dec74237ef341f"
-dependencies = [
- "bitflags",
- "libc",
- "libgit2-sys",
- "log",
- "url",
-]
-
 [[package]]
 name = "group"
 version = "0.10.0"
@@ -606,7 +353,7 @@ checksum = "1c363a5301b8f153d80747126a04b3c82073b9fe3130571a9d170cacdeaf7912"
 dependencies = [
 "ff",
 "rand_core 0.6.3",
- "subtle 2.4.1",
+ "subtle",
 ]

 [[package]]
@@ -641,23 +388,13 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21e4590e13640f19f249fe3e4eca5113bc4289f2497710378190e7f4bd96f45b"

-[[package]]
-name = "hkdf"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01706d578d5c281058480e673ae4086a9f4710d8df1ad80a5b03e39ece5f886b"
-dependencies = [
- "digest 0.9.0",
- "hmac",
-]
-
 [[package]]
 name = "hmac"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2a2a2320eb7ec0ebe8da8f744d7812d9fc4cb4d09344ac01898dbcb6a20ae69b"
 dependencies = [
- "crypto-mac 0.11.1",
+ "crypto-mac",
 "digest 0.9.0",
 ]

@@ -694,24 +431,6 @@ version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"

-[[package]]
-name = "jobserver"
-version = "0.1.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "js-sys"
-version = "0.3.55"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cc9ffccd38c451a86bf13657df244e9c3f37493cce8e5e21e940963777acc84"
-dependencies = [
- "wasm-bindgen",
-]
-
 [[package]]
 name = "k256"
 version = "0.9.6"
@@ -724,66 +443,12 @@ dependencies = [
 "sha2",
 ]

-[[package]]
-name = "keystream"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c33070833c9ee02266356de0c43f723152bd38bd96ddf52c82b3af10c9138b28"
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
 [[package]]
 name = "libc"
 version = "0.2.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "869d572136620d55835903746bcb5cdc54cb2851fd0aeec53220b4bb65ef3013"

-[[package]]
-name = "libgit2-sys"
-version = "0.12.25+1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68169ef08d6519b2fe133ecc637408d933c0174b23b80bb2f79828966fbaab"
-dependencies = [
- "cc",
- "libc",
- "libz-sys",
- "pkg-config",
-]
-
-[[package]]
-name = "libm"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7d73b3f436185384286bd8098d17ec07c9a7d2388a6599f824d8502b529702a"
-
-[[package]]
-name = "libz-sys"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de5435b8549c16d423ed0c03dbaafe57cf6c3344744f1242520d59c9d8ecec66"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "lioness"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae926706ba42c425c9457121178330d75e273df2e82e28b758faf3de3a9acb9"
-dependencies = [
- "arrayref",
- "blake2",
- "chacha",
- "keystream",
-]
-
 [[package]]
 name = "log"
 version = "0.4.14"
@@ -824,21 +489,15 @@ dependencies = [
 name = "mixnet-contracts"
 version = "0.1.0"
 dependencies = [
- "bs58",
 "config",
 "cosmwasm-schema",
 "cosmwasm-std",
 "cosmwasm-storage",
- "crypto",
- "cw-storage-plus",
 "fixed",
 "mixnet-contract",
- "rand",
- "rand_chacha",
 "schemars",
 "serde",
 "thiserror",
- "vergen",
 ]

 [[package]]
@@ -847,43 +506,10 @@ version = "0.1.0"
 dependencies = [
 "hex-literal",
 "serde",
- "time 0.3.4",
+ "time",
 "url",
 ]

-[[package]]
-name = "num-integer"
-version = "0.1.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
-dependencies = [
- "autocfg",
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
-dependencies = [
- "autocfg",
- "libm",
-]
-
-[[package]]
-name = "nymsphinx-types"
-version = "0.1.0"
-dependencies = [
- "sphinx",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
-
 [[package]]
 name = "opaque-debug"
 version = "0.2.3"
@@ -896,24 +522,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"

-[[package]]
-name = "pem"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd56cbd21fea48d0c440b41cd69c589faacade08c992d9a54e471b79d0fd13eb"
-dependencies = [
- "base64",
- "once_cell",
- "regex",
-]
-
-[[package]]
-name = "pemstore"
-version = "0.1.0"
-dependencies = [
- "pem",
-]
-
 [[package]]
 name = "percent-encoding"
 version = "2.1.0"
@@ -973,42 +581,6 @@ dependencies = [
 "spki",
 ]

-[[package]]
-name = "pkg-config"
-version = "0.3.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12295df4f294471248581bc09bef3c38a5e46f1e36d6a37353621a0c6c357e1f"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed0cfbc8191465bed66e1718596ee0b0b35d5ee1f41c5df2189d0fe8bde535ba"
-
-[[package]]
-name = "proc-macro-error"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
-dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
-dependencies = [
- "proc-macro2",
- "quote",
- "version_check",
-]
-
 [[package]]
 name = "proc-macro2"
 version = "1.0.32"
@@ -1033,29 +605,6 @@ dependencies = [
 "proc-macro2",
 ]

-[[package]]
-name = "rand"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
-dependencies = [
- "getrandom 0.1.16",
- "libc",
- "rand_chacha",
- "rand_core 0.5.1",
- "rand_hc",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
-dependencies = [
- "ppv-lite86",
- "rand_core 0.5.1",
-]
-
 [[package]]
 name = "rand_core"
 version = "0.5.1"
@@ -1074,55 +623,6 @@ dependencies = [
 "getrandom 0.2.3",
 ]

-[[package]]
-name = "rand_distr"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9e9532ada3929fb8b2e9dbe28d1e06c9b2cc65813f074fcb6bd5fbefeff9d56"
-dependencies = [
- "num-traits",
- "rand",
-]
-
-[[package]]
-name = "rand_hc"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
-dependencies = [
- "rand_core 0.5.1",
-]
-
-[[package]]
-name = "regex"
-version = "1.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
-dependencies = [
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.25"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
-
-[[package]]
-name = "rustc_version"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
-dependencies = [
- "semver",
-]
-
-[[package]]
-name = "rustversion"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61b3909d758bb75c79f23d4736fac9433868679d3ad2ea7a61e3c25cfda9a088"
-
 [[package]]
 name = "ryu"
 version = "1.0.5"
@@ -1153,12 +653,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "semver"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "568a8e6258aa33c13358f81fd834adb854c6f7c9468520910a9b1e8fac068012"
-
 [[package]]
 name = "serde"
 version = "1.0.130"
@@ -1256,29 +750,6 @@ dependencies = [
 "rand_core 0.6.3",
 ]

-[[package]]
-name = "sphinx"
-version = "0.1.0"
-source = "git+https://github.com/nymtech/sphinx?rev=c494250f2a78bed33a618d470792418eee932859#c494250f2a78bed33a618d470792418eee932859"
-dependencies = [
- "aes",
- "arrayref",
- "blake2",
- "bs58",
- "byteorder",
- "chacha",
- "curve25519-dalek",
- "digest 0.9.0",
- "hkdf",
- "hmac",
- "lioness",
- "log",
- "rand",
- "rand_distr",
- "sha2",
- "subtle 2.4.1",
-]
-
 [[package]]
 name = "spki"
 version = "0.4.1"
@@ -1294,12 +765,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

-[[package]]
-name = "subtle"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
-
 [[package]]
 name = "subtle"
 version = "2.4.1"
@@ -1317,18 +782,6 @@ dependencies = [
 "unicode-xid",
 ]

-[[package]]
-name = "synstructure"
-version = "0.12.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "unicode-xid",
-]
-
 [[package]]
 name = "thiserror"
 version = "1.0.30"
@@ -1349,16 +802,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "time"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
-dependencies = [
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "time"
 version = "0.3.4"
@@ -1456,29 +899,6 @@ dependencies = [
 "percent-encoding",
 ]

-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
-[[package]]
-name = "vergen"
-version = "5.1.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cf88d94e969e7956d924ba70741316796177fa0c79a2c9f4ab04998d96e966e"
-dependencies = [
- "anyhow",
- "cfg-if",
- "chrono",
- "enum-iterator",
- "getset",
- "git2",
- "rustc_version",
- "rustversion",
- "thiserror",
-]
-
 [[package]]
 name = "version_check"
 version = "0.9.3"
@@ -1497,110 +917,8 @@ version = "0.10.2+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"

-[[package]]
-name = "wasm-bindgen"
-version = "0.2.78"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce"
-dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.78"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a317bf8f9fba2476b4b2c85ef4c4af8ff39c3c7f0cdfeed4f82c34a880aa837b"
-dependencies = [
- "bumpalo",
- "lazy_static",
- "log",
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.78"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d56146e7c495528bf6587663bea13a8eb588d39b36b679d83972e1a2dbbdacf9"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.78"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7803e0eea25835f8abdc585cd3021b3deb11543c6fe226dcd30b228857c5c5ab"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.78"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0237232789cf037d5480773fe568aac745bfe2afbc11a863e97901780a6b47cc"
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "x25519-dalek"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2392b6b94a576b4e2bf3c5b2757d63f10ada8020a2e4d08ac849ebcf6ea8e077"
-dependencies = [
- "curve25519-dalek",
- "rand_core 0.5.1",
- "zeroize",
-]
-
 [[package]]
 name = "zeroize"
-version = "1.3.0"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
-dependencies = [
- "zeroize_derive",
-]
-
-[[package]]
-name = "zeroize_derive"
-version = "1.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65f1a51723ec88c66d5d1fe80c841f17f63587d6691901d66be9bec6c3b51f73"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "synstructure",
-]
+checksum = "bf68b08513768deaa790264a7fac27a58cbf2705cfcdc9448362229217d7e970"
@@ -12,9 +12,22 @@ exclude = [

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

+[workspace] # adding a blank workspace to keep it out of the global workspace.
+
 [lib]
 crate-type = ["cdylib", "rlib"]

+[profile.release]
+opt-level = 3
+debug = false
+rpath = false
+lto = true
+debug-assertions = false
+codegen-units = 1
+panic = 'abort'
+incremental = false
+overflow-checks = true
+
 [features]
 # for more explicit tests, cargo test --features=backtraces
 backtraces = ["cosmwasm-std/backtraces"]
@@ -22,23 +35,18 @@ backtraces = ["cosmwasm-std/backtraces"]
 [dependencies]
 mixnet-contract = { path = "../../common/mixnet-contract" }
 config = { path = "../../common/config"}
-vesting-contract = { path = "../vesting" }

-cosmwasm-std = "1.0.0-beta2"
-cosmwasm-storage = "1.0.0-beta2"
-cw-storage-plus = "0.10.3"
+# this branch is identical to 0.14.1 with addition of updated k256 dependency required to help poor cargo choose correct version
+cosmwasm-std = { git = "https://github.com/jstuczyn/cosmwasm", branch="0.14.1-updatedk256", features = ["iterator"] }
+cosmwasm-storage = { git = "https://github.com/jstuczyn/cosmwasm", branch="0.14.1-updatedk256", features = ["iterator"] }
+
+#cosmwasm-std = { version = "0.14.1", features = ["iterator"] }
+#cosmwasm-storage = { version = "0.14.1", features = ["iterator"] }

-bs58 = "0.4.0"
 schemars = "0.8"
 serde = { version = "1.0.103", default-features = false, features = ["derive"] }
 thiserror = { version = "1.0.23" }

 [dev-dependencies]
-cosmwasm-schema = "1.0.0-beta2"
+cosmwasm-schema = { version = "0.14.0" }
 fixed = "1.1"
-rand_chacha = "0.2"
-rand = "0.7"
-crypto = { path = "../../common/crypto" }
-
-[build-dependencies]
-vergen = { version = "5", default-features = false, features = ["build", "git", "rustc"] }
@@ -1,8 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use vergen::{vergen, Config};
-
-fn main() {
-    vergen(Config::default()).expect("failed to extract build metadata")
-}
@@ -5,6 +5,7 @@ extern crate mixnet_contract;

 use cosmwasm_schema::{export_schema, remove_schemas, schema_for};
 use mixnet_contract::{ExecuteMsg, InstantiateMsg, MixNodeBond, QueryMsg};
+use mixnet_contracts::state::State;
 use std::env::current_dir;
 use std::fs::create_dir_all;

@@ -17,5 +18,6 @@ fn main() {
    export_schema(&schema_for!(InstantiateMsg), &out_dir);
    export_schema(&schema_for!(ExecuteMsg), &out_dir);
    export_schema(&schema_for!(QueryMsg), &out_dir);
+    export_schema(&schema_for!(State), &out_dir);
    export_schema(&schema_for!(MixNodeBond), &out_dir);
 }
@@ -69,10 +69,10 @@
    {
      "type": "object",
      "required": [
-        "update_contract_settings"
+        "update_state_params"
      ],
      "properties": {
-        "update_contract_settings": {
+        "update_state_params": {
          "$ref": "#/definitions/StateParams"
        }
      },
@@ -346,4 +346,4 @@
      "type": "string"
    }
  }
-}
+}
@@ -101,10 +101,10 @@
    {
      "type": "object",
      "required": [
-        "contract_settings_params"
+        "state_params"
      ],
      "properties": {
-        "contract_settings_params": {
+        "state_params": {
          "type": "object"
        }
      },
@@ -321,4 +321,4 @@
      "type": "string"
    }
  }
-}
+}
@@ -1,35 +1,22 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::delegations::queries::query_all_network_delegations_paged;
-use crate::delegations::queries::query_delegator_delegations_paged;
-use crate::delegations::queries::query_mixnode_delegation;
-use crate::delegations::queries::query_mixnode_delegations_paged;
-use crate::error::ContractError;
-use crate::gateways::queries::query_gateways_paged;
-use crate::gateways::queries::query_owns_gateway;
-use crate::mixnet_contract_settings::models::ContractState;
-use crate::mixnet_contract_settings::queries::query_rewarding_interval;
-use crate::mixnet_contract_settings::queries::{
-    query_contract_settings_params, query_contract_version,
-};
-use crate::mixnet_contract_settings::storage as mixnet_params_storage;
-use crate::mixnodes::bonding_queries as mixnode_queries;
-use crate::mixnodes::bonding_queries::query_mixnodes_paged;
-use crate::mixnodes::layer_queries::query_layer_distribution;
-use crate::rewards::queries::query_reward_pool;
-use crate::rewards::queries::{query_circulating_supply, query_rewarding_status};
-use crate::rewards::storage as rewards_storage;
+use std::u128;
+
+use crate::state::State;
+use crate::storage::{config, layer_distribution};
+use crate::{error::ContractError, queries, transactions};
+use config::defaults::REWARDING_VALIDATOR_ADDRESS;
 use cosmwasm_std::{
    entry_point, to_binary, Addr, Deps, DepsMut, Env, MessageInfo, QueryResponse, Response, Uint128,
 };
-use mixnet_contract::{ContractStateParams, ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
+use mixnet_contract::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg, StateParams};

 /// Constant specifying minimum of coin required to bond a gateway
-pub const INITIAL_GATEWAY_PLEDGE: Uint128 = Uint128::new(100_000_000);
+pub const INITIAL_GATEWAY_BOND: Uint128 = Uint128(100_000000);

 /// Constant specifying minimum of coin required to bond a mixnode
-pub const INITIAL_MIXNODE_PLEDGE: Uint128 = Uint128::new(100_000_000);
+pub const INITIAL_MIXNODE_BOND: Uint128 = Uint128(100_000000);

 pub const INITIAL_MIXNODE_REWARDED_SET_SIZE: u32 = 200;
 pub const INITIAL_MIXNODE_ACTIVE_SET_SIZE: u32 = 100;
@@ -37,22 +24,19 @@ pub const INITIAL_MIXNODE_ACTIVE_SET_SIZE: u32 = 100;
 pub const INITIAL_REWARD_POOL: u128 = 250_000_000_000_000;
 pub const EPOCH_REWARD_PERCENT: u8 = 2; // Used to calculate epoch reward pool
 pub const DEFAULT_SYBIL_RESISTANCE_PERCENT: u8 = 30;
-pub const DEFAULT_ACTIVE_SET_WORK_FACTOR: u8 = 10;

-fn default_initial_state(
-    owner: Addr,
-    rewarding_validator_address: Addr,
-    env: Env,
-) -> ContractState {
-    ContractState {
+// We'll be assuming a few more things, profit margin and cost function. Since we don't have reliable package measurement, we'll be using uptime. We'll also set the value of 1 Nym to 1 $, to be able to translate epoch costs to Nyms. We'll also assume a cost of 40$ per epoch(month), converting that to Nym at our 1$ rate translates to 40_000_000 uNyms
+pub const DEFAULT_COST_PER_EPOCH: u32 = 40_000_000;
+
+fn default_initial_state(owner: Addr, env: Env) -> State {
+    State {
        owner,
-        rewarding_validator_address,
-        params: ContractStateParams {
-            minimum_mixnode_pledge: INITIAL_MIXNODE_PLEDGE,
-            minimum_gateway_pledge: INITIAL_GATEWAY_PLEDGE,
+        rewarding_validator_address: Addr::unchecked(REWARDING_VALIDATOR_ADDRESS), // we trust our hardcoded value
+        params: StateParams {
+            minimum_mixnode_bond: INITIAL_MIXNODE_BOND,
+            minimum_gateway_bond: INITIAL_GATEWAY_BOND,
            mixnode_rewarded_set_size: INITIAL_MIXNODE_REWARDED_SET_SIZE,
            mixnode_active_set_size: INITIAL_MIXNODE_ACTIVE_SET_SIZE,
-            active_set_work_factor: DEFAULT_ACTIVE_SET_WORK_FACTOR,
        },
        rewarding_interval_starting_block: env.block.height,
        latest_rewarding_interval_nonce: 0,
@@ -70,15 +54,12 @@ pub fn instantiate(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
-    msg: InstantiateMsg,
+    _msg: InstantiateMsg,
 ) -> Result<Response, ContractError> {
-    let rewarding_validator_address = deps.api.addr_validate(&msg.rewarding_validator_address)?;
-    let state = default_initial_state(info.sender, rewarding_validator_address, env);
-
-    mixnet_params_storage::CONTRACT_STATE.save(deps.storage, &state)?;
-    mixnet_params_storage::LAYERS.save(deps.storage, &Default::default())?;
-    rewards_storage::REWARD_POOL.save(deps.storage, &Uint128::new(INITIAL_REWARD_POOL))?;
+    let state = default_initial_state(info.sender, env);

+    config(deps.storage).save(&state)?;
+    layer_distribution(deps.storage).save(&Default::default())?;
    Ok(Response::default())
 }

@@ -91,42 +72,22 @@ pub fn execute(
    msg: ExecuteMsg,
 ) -> Result<Response, ContractError> {
    match msg {
-        ExecuteMsg::BondMixnode {
-            mix_node,
-            owner_signature,
-        } => crate::mixnodes::transactions::try_add_mixnode(
-            deps,
-            env,
-            info,
-            mix_node,
-            owner_signature,
-        ),
-        ExecuteMsg::UnbondMixnode {} => {
-            crate::mixnodes::transactions::try_remove_mixnode(deps, info)
+        ExecuteMsg::BondMixnode { mix_node } => {
+            transactions::try_add_mixnode(deps, env, info, mix_node)
        }
-        ExecuteMsg::BondGateway {
-            gateway,
-            owner_signature,
-        } => crate::gateways::transactions::try_add_gateway(
-            deps,
-            env,
-            info,
-            gateway,
-            owner_signature,
-        ),
-        ExecuteMsg::UnbondGateway {} => {
-            crate::gateways::transactions::try_remove_gateway(deps, info)
+        ExecuteMsg::UnbondMixnode {} => transactions::try_remove_mixnode(deps, info),
+        ExecuteMsg::BondGateway { gateway } => {
+            transactions::try_add_gateway(deps, env, info, gateway)
        }
-        ExecuteMsg::UpdateContractStateParams(params) => {
-            crate::mixnet_contract_settings::transactions::try_update_contract_settings(
-                deps, info, params,
-            )
+        ExecuteMsg::UnbondGateway {} => transactions::try_remove_gateway(deps, info),
+        ExecuteMsg::UpdateStateParams(params) => {
+            transactions::try_update_state_params(deps, info, params)
        }
-        ExecuteMsg::RewardMixnode {
+        ExecuteMsg::RewardMixnodeV2 {
            identity,
            params,
            rewarding_interval_nonce,
-        } => crate::rewards::transactions::try_reward_mixnode(
+        } => transactions::try_reward_mixnode_v2(
            deps,
            env,
            info,
@@ -135,143 +96,88 @@ pub fn execute(
            rewarding_interval_nonce,
        ),
        ExecuteMsg::DelegateToMixnode { mix_identity } => {
-            crate::delegations::transactions::try_delegate_to_mixnode(deps, env, info, mix_identity)
+            transactions::try_delegate_to_mixnode(deps, env, info, mix_identity)
        }
        ExecuteMsg::UndelegateFromMixnode { mix_identity } => {
-            crate::delegations::transactions::try_remove_delegation_from_mixnode(
-                deps,
-                info,
-                mix_identity,
-            )
+            transactions::try_remove_delegation_from_mixnode(deps, info, mix_identity)
        }
        ExecuteMsg::BeginMixnodeRewarding {
            rewarding_interval_nonce,
-        } => crate::rewards::transactions::try_begin_mixnode_rewarding(
-            deps,
-            env,
-            info,
-            rewarding_interval_nonce,
-        ),
+        } => transactions::try_begin_mixnode_rewarding(deps, env, info, rewarding_interval_nonce),
        ExecuteMsg::FinishMixnodeRewarding {
            rewarding_interval_nonce,
-        } => crate::rewards::transactions::try_finish_mixnode_rewarding(
-            deps,
-            info,
-            rewarding_interval_nonce,
-        ),
+        } => transactions::try_finish_mixnode_rewarding(deps, info, rewarding_interval_nonce),
        ExecuteMsg::RewardNextMixDelegators {
            mix_identity,
            rewarding_interval_nonce,
-        } => crate::rewards::transactions::try_reward_next_mixnode_delegators(
+        } => transactions::try_reward_next_mixnode_delegators_v2(
            deps,
            info,
            mix_identity,
            rewarding_interval_nonce,
        ),
-        ExecuteMsg::DelegateToMixnodeOnBehalf {
-            mix_identity,
-            delegate,
-        } => crate::delegations::transactions::try_delegate_to_mixnode_on_behalf(
-            deps,
-            env,
-            info,
-            mix_identity,
-            delegate,
-        ),
-        ExecuteMsg::UndelegateFromMixnodeOnBehalf {
-            mix_identity,
-            delegate,
-        } => crate::delegations::transactions::try_remove_delegation_from_mixnode_on_behalf(
-            deps,
-            info,
-            mix_identity,
-            delegate,
-        ),
-        ExecuteMsg::BondMixnodeOnBehalf {
-            mix_node,
-            owner,
-            owner_signature,
-        } => crate::mixnodes::transactions::try_add_mixnode_on_behalf(
-            deps,
-            env,
-            info,
-            mix_node,
-            owner,
-            owner_signature,
-        ),
-        ExecuteMsg::UnbondMixnodeOnBehalf { owner } => {
-            crate::mixnodes::transactions::try_remove_mixnode_on_behalf(deps, info, owner)
-        }
-        ExecuteMsg::BondGatewayOnBehalf {
-            gateway,
-            owner,
-            owner_signature,
-        } => crate::gateways::transactions::try_add_gateway_on_behalf(
-            deps,
-            env,
-            info,
-            gateway,
-            owner,
-            owner_signature,
-        ),
-        ExecuteMsg::UnbondGatewayOnBehalf { owner } => {
-            crate::gateways::transactions::try_remove_gateway_on_behalf(deps, info, owner)
-        }
    }
 }

 #[entry_point]
 pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Result<QueryResponse, ContractError> {
    let query_res = match msg {
-        QueryMsg::GetContractVersion {} => to_binary(&query_contract_version()),
        QueryMsg::GetMixNodes { start_after, limit } => {
-            to_binary(&query_mixnodes_paged(deps, start_after, limit)?)
+            to_binary(&queries::query_mixnodes_paged(deps, start_after, limit)?)
        }
        QueryMsg::GetGateways { limit, start_after } => {
-            to_binary(&query_gateways_paged(deps, start_after, limit)?)
+            to_binary(&queries::query_gateways_paged(deps, start_after, limit)?)
        }
        QueryMsg::OwnsMixnode { address } => {
-            to_binary(&mixnode_queries::query_owns_mixnode(deps, address)?)
+            to_binary(&queries::query_owns_mixnode(deps, address)?)
        }
-        QueryMsg::OwnsGateway { address } => to_binary(&query_owns_gateway(deps, address)?),
-        QueryMsg::StateParams {} => to_binary(&query_contract_settings_params(deps)?),
-        QueryMsg::CurrentRewardingInterval {} => to_binary(&query_rewarding_interval(deps)?),
-        QueryMsg::LayerDistribution {} => to_binary(&query_layer_distribution(deps)?),
-        QueryMsg::GetMixnodeDelegations {
+        QueryMsg::OwnsGateway { address } => {
+            to_binary(&queries::query_owns_gateway(deps, address)?)
+        }
+        QueryMsg::StateParams {} => to_binary(&queries::query_state_params(deps)),
+        QueryMsg::CurrentRewardingInterval {} => {
+            to_binary(&queries::query_rewarding_interval(deps))
+        }
+        QueryMsg::LayerDistribution {} => to_binary(&queries::query_layer_distribution(deps)),
+        QueryMsg::GetMixDelegations {
            mix_identity,
            start_after,
            limit,
-        } => to_binary(&query_mixnode_delegations_paged(
+        } => to_binary(&queries::query_mixnode_delegations_paged(
            deps,
            mix_identity,
            start_after,
            limit,
        )?),
-        QueryMsg::GetAllNetworkDelegations { start_after, limit } => to_binary(
-            &query_all_network_delegations_paged(deps, start_after, limit)?,
+        QueryMsg::GetAllMixDelegations { start_after, limit } => to_binary(
+            &queries::query_all_mixnode_delegations_paged(deps, start_after, limit)?,
        ),
-        QueryMsg::GetDelegatorDelegations {
-            delegator: delegation_owner,
+        QueryMsg::GetReverseMixDelegations {
+            delegation_owner,
            start_after,
            limit,
-        } => to_binary(&query_delegator_delegations_paged(
+        } => to_binary(&queries::query_reverse_mixnode_delegations_paged(
            deps,
            delegation_owner,
            start_after,
            limit,
        )?),
-        QueryMsg::GetDelegationDetails {
+        QueryMsg::GetMixDelegation {
            mix_identity,
-            delegator,
-        } => to_binary(&query_mixnode_delegation(deps, mix_identity, delegator)?),
-        QueryMsg::GetRewardPool {} => to_binary(&query_reward_pool(deps)?),
-        QueryMsg::GetCirculatingSupply {} => to_binary(&query_circulating_supply(deps)?),
+            address,
+        } => to_binary(&queries::query_mixnode_delegation(
+            deps,
+            mix_identity,
+            address,
+        )?),
+        QueryMsg::GetRewardPool {} => to_binary(&queries::query_reward_pool(deps)),
+        QueryMsg::GetCirculatingSupply {} => to_binary(&queries::query_circulating_supply(deps)),
        QueryMsg::GetEpochRewardPercent {} => to_binary(&EPOCH_REWARD_PERCENT),
        QueryMsg::GetSybilResistancePercent {} => to_binary(&DEFAULT_SYBIL_RESISTANCE_PERCENT),
        QueryMsg::GetRewardingStatus {
            mix_identity,
            rewarding_interval_nonce,
-        } => to_binary(&query_rewarding_status(
+        } => to_binary(&queries::query_rewarding_status(
            deps,
            mix_identity,
            rewarding_interval_nonce,
@@ -282,14 +188,13 @@ pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> Result<QueryResponse, Cont
 }
 #[entry_point]
 pub fn migrate(_deps: DepsMut, _env: Env, _msg: MigrateMsg) -> Result<Response, ContractError> {
-    todo!("ACTIVE_STATE_WORK_FACTOR to State");
-    // Ok(Default::default())
+    Ok(Default::default())
 }

 #[cfg(test)]
 pub mod tests {
    use super::*;
-    use crate::support::tests::test_helpers;
+    use crate::support::tests::helpers::*;
    use config::defaults::DENOM;
    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
    use cosmwasm_std::{coins, from_binary};
@@ -297,11 +202,9 @@ pub mod tests {

    #[test]
    fn initialize_contract() {
-        let mut deps = mock_dependencies();
+        let mut deps = mock_dependencies(&[]);
        let env = mock_env();
-        let msg = InstantiateMsg {
-            rewarding_validator_address: config::defaults::REWARDING_VALIDATOR_ADDRESS.to_string(),
-        };
+        let msg = InstantiateMsg {};
        let info = mock_info("creator", &[]);

        let res = instantiate(deps.as_mut(), env.clone(), info, msg).unwrap();
@@ -323,7 +226,7 @@ pub mod tests {
        // Contract balance should match what we initialized it as
        assert_eq!(
            coins(0, DENOM),
-            test_helpers::query_contract_balance(env.contract.address, deps)
+            query_contract_balance(env.contract.address, deps)
        );
    }
 }
@@ -1,6 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub(crate) mod queries;
-pub(crate) mod storage;
-pub(crate) mod transactions;
@@ -1,649 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::storage;
-use crate::error::ContractError;
-use cosmwasm_std::Deps;
-use cosmwasm_std::Order;
-use cosmwasm_std::StdResult;
-use cw_storage_plus::{Bound, PrimaryKey};
-use mixnet_contract::PagedAllDelegationsResponse;
-use mixnet_contract::PagedDelegatorDelegationsResponse;
-use mixnet_contract::PagedMixDelegationsResponse;
-use mixnet_contract::{Delegation, IdentityKey};
-
-pub(crate) fn query_all_network_delegations_paged(
-    deps: Deps,
-    start_after: Option<(IdentityKey, String)>,
-    limit: Option<u32>,
-) -> StdResult<PagedAllDelegationsResponse> {
-    let limit = limit
-        .unwrap_or(storage::DELEGATION_PAGE_DEFAULT_LIMIT)
-        .min(storage::DELEGATION_PAGE_MAX_LIMIT) as usize;
-
-    let start = start_after
-        .map(|start| start.joined_key())
-        .map(Bound::exclusive);
-
-    let delegations = storage::delegations()
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| record.map(|r| r.1))
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = delegations
-        .last()
-        .map(|delegation| delegation.storage_key());
-
-    Ok(PagedAllDelegationsResponse::new(
-        delegations,
-        start_next_after,
-    ))
-}
-
-pub(crate) fn query_delegator_delegations_paged(
-    deps: Deps,
-    delegation_owner: String,
-    start_after: Option<IdentityKey>,
-    limit: Option<u32>,
-) -> StdResult<PagedDelegatorDelegationsResponse> {
-    let validated_owner = deps.api.addr_validate(&delegation_owner)?;
-
-    let limit = limit
-        .unwrap_or(storage::DELEGATION_PAGE_DEFAULT_LIMIT)
-        .min(storage::DELEGATION_PAGE_MAX_LIMIT) as usize;
-    let start = start_after
-        .map(|mix_identity| Bound::Exclusive((mix_identity, validated_owner.clone()).joined_key()));
-
-    let delegations = storage::delegations()
-        .idx
-        .owner
-        .prefix(validated_owner)
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| record.map(|r| r.1))
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = delegations
-        .last()
-        .map(|delegation| delegation.node_identity());
-
-    Ok(PagedDelegatorDelegationsResponse::new(
-        delegations,
-        start_next_after,
-    ))
-}
-
-// queries for delegation value of given address for particular node
-pub(crate) fn query_mixnode_delegation(
-    deps: Deps,
-    mix_identity: IdentityKey,
-    delegator: String,
-) -> Result<Delegation, ContractError> {
-    let validated_delegator = deps.api.addr_validate(&delegator)?;
-    let storage_key = (mix_identity.clone(), validated_delegator.clone()).joined_key();
-
-    storage::delegations()
-        .may_load(deps.storage, storage_key)?
-        .ok_or(ContractError::NoMixnodeDelegationFound {
-            identity: mix_identity,
-            address: validated_delegator,
-        })
-}
-
-pub(crate) fn query_mixnode_delegations_paged(
-    deps: Deps,
-    mix_identity: IdentityKey,
-    start_after: Option<String>,
-    limit: Option<u32>,
-) -> StdResult<PagedMixDelegationsResponse> {
-    let limit = limit
-        .unwrap_or(storage::DELEGATION_PAGE_DEFAULT_LIMIT)
-        .min(storage::DELEGATION_PAGE_MAX_LIMIT) as usize;
-
-    let start = start_after
-        .map(|addr| deps.api.addr_validate(&addr))
-        .transpose()?
-        .map(|addr| Bound::Exclusive((mix_identity.clone(), addr).joined_key()));
-
-    let delegations = storage::delegations()
-        .idx
-        .mixnode
-        .prefix(mix_identity)
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|record| record.map(|r| r.1))
-        .collect::<StdResult<Vec<_>>>()?;
-
-    let start_next_after = delegations.last().map(|delegation| delegation.owner());
-
-    Ok(PagedMixDelegationsResponse::new(
-        delegations,
-        start_next_after,
-    ))
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::*;
-    use crate::support::tests::test_helpers;
-    use config::defaults::DENOM;
-    use cosmwasm_std::{coin, Addr, Storage};
-
-    pub fn store_n_mix_delegations(n: u32, storage: &mut dyn Storage, node_identity: &str) {
-        for i in 0..n {
-            let address = format!("address{}", i);
-            test_helpers::save_dummy_delegation(storage, node_identity, address);
-        }
-    }
-
-    #[cfg(test)]
-    mod querying_for_mixnode_delegations_paged {
-        use super::*;
-        use mixnet_contract::IdentityKey;
-
-        #[test]
-        fn retrieval_obeys_limits() {
-            let mut deps = test_helpers::init_contract();
-            let limit = 2;
-            let node_identity: IdentityKey = "foo".into();
-            store_n_mix_delegations(100, &mut deps.storage, &node_identity);
-
-            let page1 = query_mixnode_delegations_paged(
-                deps.as_ref(),
-                node_identity,
-                None,
-                Option::from(limit),
-            )
-            .unwrap();
-            assert_eq!(limit, page1.delegations.len() as u32);
-        }
-
-        #[test]
-        fn retrieval_has_default_limit() {
-            let mut deps = test_helpers::init_contract();
-            let node_identity: IdentityKey = "foo".into();
-            store_n_mix_delegations(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-                &mut deps.storage,
-                &node_identity,
-            );
-
-            // query without explicitly setting a limit
-            let page1 =
-                query_mixnode_delegations_paged(deps.as_ref(), node_identity, None, None).unwrap();
-            assert_eq!(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT,
-                page1.delegations.len() as u32
-            );
-        }
-
-        #[test]
-        fn retrieval_has_max_limit() {
-            let mut deps = test_helpers::init_contract();
-            let node_identity: IdentityKey = "foo".into();
-            store_n_mix_delegations(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-                &mut deps.storage,
-                &node_identity,
-            );
-
-            // query with a crazily high limit in an attempt to use too many resources
-            let crazy_limit = 1000 * storage::DELEGATION_PAGE_DEFAULT_LIMIT;
-            let page1 = query_mixnode_delegations_paged(
-                deps.as_ref(),
-                node_identity,
-                None,
-                Option::from(crazy_limit),
-            )
-            .unwrap();
-
-            // we default to a decent sized upper bound instead
-            let expected_limit = storage::DELEGATION_PAGE_MAX_LIMIT;
-            assert_eq!(expected_limit, page1.delegations.len() as u32);
-        }
-
-        #[test]
-        fn pagination_works() {
-            let mut deps = test_helpers::init_contract();
-            let node_identity: IdentityKey = "foo".into();
-
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "100");
-
-            let per_page = 2;
-            let page1 = query_mixnode_delegations_paged(
-                deps.as_ref(),
-                node_identity.clone(),
-                None,
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            // page should have 1 result on it
-            assert_eq!(1, page1.delegations.len());
-
-            // save another
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "200");
-
-            // page1 should have 2 results on it
-            let page1 = query_mixnode_delegations_paged(
-                deps.as_ref(),
-                node_identity.clone(),
-                None,
-                Option::from(per_page),
-            )
-            .unwrap();
-            assert_eq!(2, page1.delegations.len());
-
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "300");
-
-            // page1 still has 2 results
-            let page1 = query_mixnode_delegations_paged(
-                deps.as_ref(),
-                node_identity.clone(),
-                None,
-                Option::from(per_page),
-            )
-            .unwrap();
-            assert_eq!(2, page1.delegations.len());
-            assert_eq!("200".to_string(), page1.start_next_after.unwrap());
-
-            // retrieving the next page should start after the last key on this page
-            let start_after = "200".to_string();
-            let page2 = query_mixnode_delegations_paged(
-                deps.as_ref(),
-                node_identity.clone(),
-                Option::from(start_after),
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            assert_eq!(1, page2.delegations.len());
-
-            // save another one
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "400");
-
-            let start_after = "200".to_string();
-            let page2 = query_mixnode_delegations_paged(
-                deps.as_ref(),
-                node_identity,
-                Option::from(start_after),
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            // now we have 2 pages, with 2 results on the second page
-            assert_eq!(2, page2.delegations.len());
-        }
-    }
-
-    #[cfg(test)]
-    mod querying_for_all_mixnode_delegations_paged {
-        use super::*;
-        use crate::support::tests::test_helpers;
-        use mixnet_contract::IdentityKey;
-
-        #[test]
-        fn retrieval_obeys_limits() {
-            let mut deps = test_helpers::init_contract();
-            let limit = 2;
-            let node_identity: IdentityKey = "foo".into();
-            store_n_mix_delegations(100, &mut deps.storage, &node_identity);
-
-            let page1 =
-                query_all_network_delegations_paged(deps.as_ref(), None, Option::from(limit))
-                    .unwrap();
-            assert_eq!(limit, page1.delegations.len() as u32);
-        }
-
-        #[test]
-        fn retrieval_has_default_limit() {
-            let mut deps = test_helpers::init_contract();
-            let node_identity: IdentityKey = "foo".into();
-            store_n_mix_delegations(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-                &mut deps.storage,
-                &node_identity,
-            );
-
-            // query without explicitly setting a limit
-            let page1 = query_all_network_delegations_paged(deps.as_ref(), None, None).unwrap();
-            assert_eq!(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT,
-                page1.delegations.len() as u32
-            );
-        }
-
-        #[test]
-        fn retrieval_has_max_limit() {
-            let mut deps = test_helpers::init_contract();
-            let node_identity: IdentityKey = "foo".into();
-            store_n_mix_delegations(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-                &mut deps.storage,
-                &node_identity,
-            );
-
-            // query with a crazily high limit in an attempt to use too many resources
-            let crazy_limit = 1000 * storage::DELEGATION_PAGE_DEFAULT_LIMIT;
-            let page1 =
-                query_all_network_delegations_paged(deps.as_ref(), None, Option::from(crazy_limit))
-                    .unwrap();
-
-            // we default to a decent sized upper bound instead
-            let expected_limit = storage::DELEGATION_PAGE_MAX_LIMIT;
-            assert_eq!(expected_limit, page1.delegations.len() as u32);
-        }
-
-        #[test]
-        fn pagination_works() {
-            let mut deps = test_helpers::init_contract();
-            let node_identity: IdentityKey = "foo".into();
-
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "100");
-
-            let per_page = 2;
-            let page1 =
-                query_all_network_delegations_paged(deps.as_ref(), None, Option::from(per_page))
-                    .unwrap();
-
-            // page should have 1 result on it
-            assert_eq!(1, page1.delegations.len());
-
-            // save another
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "200");
-
-            // page1 should have 2 results on it
-            let page1 =
-                query_all_network_delegations_paged(deps.as_ref(), None, Option::from(per_page))
-                    .unwrap();
-            assert_eq!(2, page1.delegations.len());
-
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "300");
-
-            // page1 still has 2 results
-            let page1 =
-                query_all_network_delegations_paged(deps.as_ref(), None, Option::from(per_page))
-                    .unwrap();
-            assert_eq!(2, page1.delegations.len());
-
-            // retrieving the next page should start after the last key on this page
-            let start_after = page1.start_next_after.unwrap();
-            let page2 = query_all_network_delegations_paged(
-                deps.as_ref(),
-                Option::from(start_after.clone()),
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            assert_eq!(1, page2.delegations.len());
-
-            // save another one
-            test_helpers::save_dummy_delegation(&mut deps.storage, &node_identity, "400");
-
-            let page2 = query_all_network_delegations_paged(
-                deps.as_ref(),
-                Option::from(start_after),
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            // now we have 2 pages, with 2 results on the second page
-            assert_eq!(2, page2.delegations.len());
-        }
-    }
-
-    #[test]
-    fn mix_deletion_query_returns_current_delegation_value() {
-        let mut deps = test_helpers::init_contract();
-        let node_identity: IdentityKey = "foo".into();
-        let delegation_owner = Addr::unchecked("bar");
-
-        let delegation = Delegation::new(
-            delegation_owner.clone(),
-            node_identity.clone(),
-            coin(1234, DENOM),
-            1234,
-            None,
-        );
-
-        storage::delegations()
-            .save(
-                deps.as_mut().storage,
-                delegation.storage_key().joined_key(),
-                &delegation,
-            )
-            .unwrap();
-
-        assert_eq!(
-            Ok(delegation),
-            query_mixnode_delegation(deps.as_ref(), node_identity, delegation_owner.to_string())
-        )
-    }
-
-    #[test]
-    fn mix_deletion_query_returns_error_if_delegation_doesnt_exist() {
-        let mut deps = test_helpers::init_contract();
-
-        let node_identity1: IdentityKey = "foo1".into();
-        let node_identity2: IdentityKey = "foo2".into();
-        let delegation_owner1 = Addr::unchecked("bar");
-        let delegation_owner2 = Addr::unchecked("bar2");
-
-        assert_eq!(
-            Err(ContractError::NoMixnodeDelegationFound {
-                identity: node_identity1.clone(),
-                address: delegation_owner1.clone(),
-            }),
-            query_mixnode_delegation(
-                deps.as_ref(),
-                node_identity1.clone(),
-                delegation_owner1.to_string()
-            )
-        );
-
-        // add delegation from a different address
-        let delegation = Delegation::new(
-            delegation_owner2.clone(),
-            node_identity1.clone(),
-            coin(1234, DENOM),
-            1234,
-            None,
-        );
-
-        storage::delegations()
-            .save(
-                deps.as_mut().storage,
-                delegation.storage_key().joined_key(),
-                &delegation,
-            )
-            .unwrap();
-
-        assert_eq!(
-            Err(ContractError::NoMixnodeDelegationFound {
-                identity: node_identity1.clone(),
-                address: delegation_owner1.clone(),
-            }),
-            query_mixnode_delegation(
-                deps.as_ref(),
-                node_identity1.clone(),
-                delegation_owner1.to_string()
-            )
-        );
-
-        // add delegation for a different node
-        let delegation = Delegation::new(
-            delegation_owner1.clone(),
-            node_identity2.clone(),
-            coin(1234, DENOM),
-            1234,
-            None,
-        );
-
-        storage::delegations()
-            .save(
-                deps.as_mut().storage,
-                delegation.storage_key().joined_key(),
-                &delegation,
-            )
-            .unwrap();
-
-        assert_eq!(
-            Err(ContractError::NoMixnodeDelegationFound {
-                identity: node_identity1.clone(),
-                address: Addr::unchecked(delegation_owner1.clone())
-            }),
-            query_mixnode_delegation(
-                deps.as_ref(),
-                node_identity1.clone(),
-                delegation_owner1.to_string()
-            )
-        )
-    }
-
-    #[cfg(test)]
-    mod querying_for_reverse_mixnode_delegations_paged {
-        use super::*;
-
-        fn store_n_reverse_delegations(n: u32, storage: &mut dyn Storage, delegation_owner: &str) {
-            for i in 0..n {
-                let node_identity = format!("node{}", i);
-                test_helpers::save_dummy_delegation(storage, node_identity, delegation_owner);
-            }
-        }
-
-        #[test]
-        fn retrieval_obeys_limits() {
-            let mut deps = test_helpers::init_contract();
-            let limit = 2;
-            let delegation_owner = "foo".to_string();
-            store_n_reverse_delegations(100, &mut deps.storage, &delegation_owner);
-
-            let page1 = query_delegator_delegations_paged(
-                deps.as_ref(),
-                delegation_owner,
-                None,
-                Option::from(limit),
-            )
-            .unwrap();
-            assert_eq!(limit, page1.delegations.len() as u32);
-        }
-
-        #[test]
-        fn retrieval_has_default_limit() {
-            let mut deps = test_helpers::init_contract();
-            let delegation_owner = "foo".to_string();
-            store_n_reverse_delegations(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-                &mut deps.storage,
-                &delegation_owner,
-            );
-
-            // query without explicitly setting a limit
-            let page1 =
-                query_delegator_delegations_paged(deps.as_ref(), delegation_owner, None, None)
-                    .unwrap();
-            assert_eq!(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT,
-                page1.delegations.len() as u32
-            );
-        }
-
-        #[test]
-        fn retrieval_has_max_limit() {
-            let mut deps = test_helpers::init_contract();
-            let delegation_owner = "foo".to_string();
-            store_n_reverse_delegations(
-                storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-                &mut deps.storage,
-                &delegation_owner,
-            );
-
-            // query with a crazy high limit in an attempt to use too many resources
-            let crazy_limit = 1000 * storage::DELEGATION_PAGE_DEFAULT_LIMIT;
-            let page1 = query_delegator_delegations_paged(
-                deps.as_ref(),
-                delegation_owner,
-                None,
-                Option::from(crazy_limit),
-            )
-            .unwrap();
-
-            // we default to a decent sized upper bound instead
-            let expected_limit = storage::DELEGATION_PAGE_MAX_LIMIT;
-            assert_eq!(expected_limit, page1.delegations.len() as u32);
-        }
-
-        #[test]
-        fn pagination_works() {
-            let mut deps = test_helpers::init_contract();
-            let delegation_owner = "bar".to_string();
-
-            test_helpers::save_dummy_delegation(&mut deps.storage, "100", &delegation_owner);
-
-            let per_page = 2;
-            let page1 = query_delegator_delegations_paged(
-                deps.as_ref(),
-                delegation_owner.clone(),
-                None,
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            // page should have 1 result on it
-            assert_eq!(1, page1.delegations.len());
-
-            // save another
-            test_helpers::save_dummy_delegation(&mut deps.storage, "200", &delegation_owner);
-
-            // page1 should have 2 results on it
-            let page1 = query_delegator_delegations_paged(
-                deps.as_ref(),
-                delegation_owner.clone(),
-                None,
-                Option::from(per_page),
-            )
-            .unwrap();
-            assert_eq!(2, page1.delegations.len());
-
-            test_helpers::save_dummy_delegation(&mut deps.storage, "300", &delegation_owner);
-
-            // page1 still has 2 results
-            let page1 = query_delegator_delegations_paged(
-                deps.as_ref(),
-                delegation_owner.clone(),
-                None,
-                Option::from(per_page),
-            )
-            .unwrap();
-            assert_eq!(2, page1.delegations.len());
-
-            // retrieving the next page should start after the last key on this page
-            let start_after: IdentityKey = page1.start_next_after.unwrap();
-            let page2 = query_delegator_delegations_paged(
-                deps.as_ref(),
-                delegation_owner.clone(),
-                Option::from(start_after),
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            assert_eq!(1, page2.delegations.len());
-
-            // save another one
-            test_helpers::save_dummy_delegation(&mut deps.storage, "400", &delegation_owner);
-
-            let start_after = String::from("2");
-            let page2 = query_delegator_delegations_paged(
-                deps.as_ref(),
-                delegation_owner,
-                Option::from(start_after),
-                Option::from(per_page),
-            )
-            .unwrap();
-
-            // now we have 2 pages, with 2 results on the second page
-            assert_eq!(2, page2.delegations.len());
-        }
-    }
-}
@@ -1,180 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cw_storage_plus::{Index, IndexList, IndexedMap, MultiIndex};
-use mixnet_contract::{Addr, Delegation, IdentityKey};
-
-// storage prefixes
-const DELEGATION_PK_NAMESPACE: &str = "dl";
-const DELEGATION_OWNER_IDX_NAMESPACE: &str = "dlo";
-const DELEGATION_MIXNODE_IDX_NAMESPACE: &str = "dlm";
-
-// paged retrieval limits for all queries and transactions
-pub(crate) const DELEGATION_PAGE_MAX_LIMIT: u32 = 500;
-pub(crate) const DELEGATION_PAGE_DEFAULT_LIMIT: u32 = 250;
-
-// It's a composite key on node's identity and delegator address
-type PrimaryKey = Vec<u8>;
-
-pub(crate) struct DelegationIndex<'a> {
-    pub(crate) owner: MultiIndex<'a, (Addr, PrimaryKey), Delegation>,
-
-    pub(crate) mixnode: MultiIndex<'a, (IdentityKey, PrimaryKey), Delegation>,
-}
-
-impl<'a> IndexList<Delegation> for DelegationIndex<'a> {
-    fn get_indexes(&'_ self) -> Box<dyn Iterator<Item = &'_ dyn Index<Delegation>> + '_> {
-        let v: Vec<&dyn Index<Delegation>> = vec![&self.owner, &self.mixnode];
-        Box::new(v.into_iter())
-    }
-}
-
-// I was really going back and forth about the data stored on the disk vs primary key duplication.
-// It was basically between convenience and bloat, but in the end I decided the convenience wins.
-//
-// Basically I had 2 approaches. a) store delegator address and mixnode identity only as primary key of delegation or
-// b) store it both as primary key AND inside delegation data.
-// For the longest time I was in favour of a), since that removed any data duplication. However...,
-// that also required that during index creation I recovered delegator address and mixnode identity
-// from the Vec<u8>. That doesn't sound that terrible. However, even though I'm 99.99% certain that
-// conversion would be impossible to fail, I'd still have to call an `unwrap` here due to required
-// type signature and I didn't feel super comfortable doing that in our smart contract...
-// So to get rid of this uncertainty I went with the b) approach. Even though each stored delegation
-// takes over ~250B (since the key has to be duplicated), in the grand blockchain scheme of things
-// it's not that terrible. Say we had 100_000_000 delegations -> that's still only 25GB of data
-// and as a nice by-product it cleans up code a little bit by only having a single Delegation type.
-pub(crate) fn delegations<'a>() -> IndexedMap<'a, PrimaryKey, Delegation, DelegationIndex<'a>> {
-    let indexes = DelegationIndex {
-        owner: MultiIndex::new(
-            |d, pk| (d.owner.clone(), pk),
-            DELEGATION_PK_NAMESPACE,
-            DELEGATION_OWNER_IDX_NAMESPACE,
-        ),
-        mixnode: MultiIndex::new(
-            |d, pk| (d.node_identity.clone(), pk),
-            DELEGATION_PK_NAMESPACE,
-            DELEGATION_MIXNODE_IDX_NAMESPACE,
-        ),
-    };
-
-    IndexedMap::new(DELEGATION_PK_NAMESPACE, indexes)
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::delegations::storage;
-    use cosmwasm_std::Addr;
-    use mixnet_contract::IdentityKey;
-
-    #[cfg(test)]
-    mod reverse_mix_delegations {
-        use super::*;
-        use crate::support::tests::test_helpers;
-        use config::defaults::DENOM;
-        use cosmwasm_std::testing::mock_env;
-        use cosmwasm_std::{coin, Order};
-        use cw_storage_plus::PrimaryKey;
-        use mixnet_contract::Delegation;
-
-        #[test]
-        fn reverse_mix_delegation_exists() {
-            let mut deps = test_helpers::init_contract();
-            let node_identity: IdentityKey = "foo".into();
-            let delegation_owner = Addr::unchecked("bar");
-            let delegation = coin(12345, DENOM);
-
-            let dummy_data = Delegation::new(
-                delegation_owner.clone(),
-                node_identity.clone(),
-                delegation,
-                mock_env().block.height,
-                None,
-            );
-
-            storage::delegations()
-                .save(
-                    &mut deps.storage,
-                    (node_identity.clone(), delegation_owner.clone()).joined_key(),
-                    &dummy_data,
-                )
-                .unwrap();
-
-            let read = storage::delegations()
-                .idx
-                .owner
-                .prefix(delegation_owner)
-                .range(&deps.storage, None, None, Order::Ascending)
-                .map(|record| record.unwrap().1)
-                .collect::<Vec<_>>();
-
-            assert_eq!(1, read.len());
-            assert_eq!(dummy_data, read[0]);
-        }
-
-        #[test]
-        fn reverse_mix_delegation_returns_none_if_delegation_doesnt_exist() {
-            let mut deps = test_helpers::init_contract();
-
-            let node_identity1: IdentityKey = "foo1".into();
-            let node_identity2: IdentityKey = "foo2".into();
-            let delegation_owner1 = Addr::unchecked("bar");
-            let delegation_owner2 = Addr::unchecked("bar2");
-            let delegation = coin(12345, DENOM);
-
-            assert!(test_helpers::read_delegation(
-                deps.as_ref().storage,
-                &node_identity1,
-                &delegation_owner1
-            )
-            .is_none());
-
-            // add delegation for a different node
-            let dummy_data = Delegation::new(
-                delegation_owner1.clone(),
-                node_identity2.clone(),
-                delegation.clone(),
-                mock_env().block.height,
-                None,
-            );
-            storage::delegations()
-                .save(
-                    &mut deps.storage,
-                    (node_identity1.clone(), delegation_owner1.clone()).joined_key(),
-                    &dummy_data,
-                )
-                .unwrap();
-
-            storage::delegations()
-                .idx
-                .owner
-                .prefix(delegation_owner1.clone())
-                .range(&deps.storage, None, None, Order::Ascending)
-                .map(|record| record.unwrap().1)
-                .for_each(|delegation| assert_ne!(delegation.node_identity, node_identity1));
-
-            // add delegation from a different owner
-            let dummy_data = Delegation::new(
-                delegation_owner2.clone(),
-                node_identity1.clone(),
-                delegation.clone(),
-                mock_env().block.height,
-                None,
-            );
-            storage::delegations()
-                .save(
-                    &mut deps.storage,
-                    (node_identity1.clone(), delegation_owner2.clone()).joined_key(),
-                    &dummy_data,
-                )
-                .unwrap();
-
-            storage::delegations()
-                .idx
-                .owner
-                .prefix(delegation_owner1.clone())
-                .range(&deps.storage, None, None, Order::Ascending)
-                .map(|record| record.unwrap().1)
-                .for_each(|delegation| assert_ne!(delegation.node_identity, node_identity1));
-        }
-    }
-}
@@ -1,855 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-use super::storage;
-use crate::error::ContractError;
-use crate::mixnodes::storage as mixnodes_storage;
-use crate::support::helpers::generate_storage_key;
-use config::defaults::DENOM;
-use cosmwasm_std::{coins, wasm_execute, Addr, BankMsg, Coin, DepsMut, Env, MessageInfo, Response};
-use cw_storage_plus::PrimaryKey;
-use mixnet_contract::Delegation;
-use mixnet_contract::IdentityKey;
-use vesting_contract::messages::ExecuteMsg as VestingContractExecuteMsg;
-
-fn validate_delegation_stake(mut delegation: Vec<Coin>) -> Result<Coin, ContractError> {
-    // check if anything was put as delegation
-    if delegation.is_empty() {
-        return Err(ContractError::EmptyDelegation);
-    }
-
-    if delegation.len() > 1 {
-        return Err(ContractError::MultipleDenoms);
-    }
-
-    // check that the denomination is correct
-    if delegation[0].denom != DENOM {
-        return Err(ContractError::WrongDenom {});
-    }
-
-    // check that we have provided a non-zero amount in the delegation
-    if delegation[0].amount.is_zero() {
-        return Err(ContractError::EmptyDelegation);
-    }
-
-    Ok(delegation.pop().unwrap())
-}
-
-pub(crate) fn try_delegate_to_mixnode(
-    deps: DepsMut,
-    env: Env,
-    info: MessageInfo,
-    mix_identity: IdentityKey,
-) -> Result<Response, ContractError> {
-    // check if the delegation contains any funds of the appropriate denomination
-    let amount = validate_delegation_stake(info.funds)?;
-
-    _try_delegate_to_mixnode(deps, env, mix_identity, info.sender.as_str(), amount, None)
-}
-
-pub(crate) fn try_delegate_to_mixnode_on_behalf(
-    deps: DepsMut,
-    env: Env,
-    info: MessageInfo,
-    mix_identity: IdentityKey,
-    delegate: String,
-) -> Result<Response, ContractError> {
-    // check if the delegation contains any funds of the appropriate denomination
-    let amount = validate_delegation_stake(info.funds)?;
-
-    _try_delegate_to_mixnode(deps, env, mix_identity, &delegate, amount, None)
-}
-
-pub(crate) fn _try_delegate_to_mixnode(
-    deps: DepsMut,
-    env: Env,
-    mix_identity: IdentityKey,
-    delegate: &str,
-    amount: Coin,
-    proxy: Option<Addr>,
-) -> Result<Response, ContractError> {
-    let delegate = deps.api.addr_validate(delegate)?;
-
-    // check if the target node actually exists
-    if mixnodes_storage::mixnodes()
-        .may_load(deps.storage, &mix_identity)?
-        .is_none()
-    {
-        return Err(ContractError::MixNodeBondNotFound {
-            identity: mix_identity,
-        });
-    }
-
-    let maybe_proxy_storage = generate_storage_key(&delegate, proxy.as_ref());
-    let storage_key = (mix_identity.clone(), maybe_proxy_storage).joined_key();
-
-    // update total_delegation of this node
-    mixnodes_storage::TOTAL_DELEGATION.update::<_, ContractError>(
-        deps.storage,
-        &mix_identity,
-        |total_delegation| {
-            // since we know that the target node exists and because the total_delegation bucket
-            // entry is created whenever the node itself is added, the unwrap here is fine
-            // as the entry MUST exist
-            Ok(total_delegation.unwrap() + amount.amount)
-        },
-    )?;
-
-    // update [or create new] delegation of this delegator
-    storage::delegations().update::<_, ContractError>(
-        deps.storage,
-        storage_key,
-        |existing_delegation| {
-            Ok(match existing_delegation {
-                Some(mut existing_delegation) => {
-                    existing_delegation.increment_amount(amount.amount, Some(env.block.height));
-                    existing_delegation
-                }
-                None => Delegation::new(
-                    delegate.to_owned(),
-                    mix_identity,
-                    amount,
-                    env.block.height,
-                    proxy,
-                ),
-            })
-        },
-    )?;
-
-    Ok(Response::default())
-}
-
-pub(crate) fn try_remove_delegation_from_mixnode(
-    deps: DepsMut,
-    info: MessageInfo,
-    mix_identity: IdentityKey,
-) -> Result<Response, ContractError> {
-    _try_remove_delegation_from_mixnode(deps, mix_identity, info.sender.as_str(), None)
-}
-
-pub(crate) fn try_remove_delegation_from_mixnode_on_behalf(
-    deps: DepsMut,
-    info: MessageInfo,
-    mix_identity: IdentityKey,
-    delegate: String,
-) -> Result<Response, ContractError> {
-    _try_remove_delegation_from_mixnode(deps, mix_identity, &delegate, Some(info.sender))
-}
-
-pub(crate) fn _try_remove_delegation_from_mixnode(
-    deps: DepsMut,
-    mix_identity: IdentityKey,
-    delegate: &str,
-    proxy: Option<Addr>,
-) -> Result<Response, ContractError> {
-    let delegate = deps.api.addr_validate(delegate)?;
-    let delegation_map = storage::delegations();
-    let maybe_proxy_storage = generate_storage_key(&delegate, proxy.as_ref());
-    let storage_key = (mix_identity.clone(), maybe_proxy_storage).joined_key();
-
-    match delegation_map.may_load(deps.storage, storage_key.clone())? {
-        None => Err(ContractError::NoMixnodeDelegationFound {
-            identity: mix_identity,
-            address: delegate,
-        }),
-        Some(old_delegation) => {
-            // remove all delegation associated with this delegator
-            if proxy != old_delegation.proxy {
-                return Err(ContractError::ProxyMismatch {
-                    existing: old_delegation
-                        .proxy
-                        .map_or_else(|| "None".to_string(), |a| a.to_string()),
-                    incoming: proxy.map_or_else(|| "None".to_string(), |a| a.to_string()),
-                });
-            }
-            // remove old delegation data from the store
-            // note for reviewers: I'm using `replace` as `remove` is just `may_load` followed by `replace`
-            // and we've already performed `may_load` and have access to pre-existing data
-            delegation_map.replace(deps.storage, storage_key, None, Some(&old_delegation))?;
-
-            // send delegated funds back to the delegation owner
-            let return_tokens = BankMsg::Send {
-                to_address: proxy.as_ref().unwrap_or(&delegate).to_string(),
-                amount: coins(
-                    old_delegation.amount.amount.u128(),
-                    old_delegation.amount.denom.clone(),
-                ),
-            };
-
-            // update total_delegation of this node
-            mixnodes_storage::TOTAL_DELEGATION.update::<_, ContractError>(
-                deps.storage,
-                &mix_identity,
-                |total_delegation| {
-                    // the first unwrap is fine because the delegation information MUST exist, otherwise we would
-                    // have never gotten here in the first place
-                    // the second unwrap is also fine because we should NEVER underflow here,
-                    // if we do, it means we have some serious error in our logic
-                    Ok(total_delegation
-                        .unwrap()
-                        .checked_sub(old_delegation.amount.amount)
-                        .unwrap())
-                },
-            )?;
-
-            let mut response = Response::new().add_message(return_tokens);
-
-            if let Some(proxy) = &proxy {
-                let msg = Some(VestingContractExecuteMsg::TrackUndelegation {
-                    owner: delegate.as_str().to_string(),
-                    mix_identity: mix_identity.clone(),
-                    amount: old_delegation.amount,
-                });
-
-                let track_undelegation_msg = wasm_execute(proxy, &msg, coins(0, DENOM))?;
-
-                response = response.add_message(track_undelegation_msg);
-            }
-            Ok(response)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use cosmwasm_std::coins;
-
-    use crate::support::tests::test_helpers;
-
-    use super::storage;
-    use super::*;
-
-    #[cfg(test)]
-    mod delegation_stake_validation {
-        use cosmwasm_std::coin;
-
-        use super::*;
-
-        #[test]
-        fn stake_cant_be_empty() {
-            assert_eq!(
-                Err(ContractError::EmptyDelegation),
-                validate_delegation_stake(vec![])
-            )
-        }
-
-        #[test]
-        fn stake_must_have_single_coin_type() {
-            assert_eq!(
-                Err(ContractError::MultipleDenoms),
-                validate_delegation_stake(vec![
-                    coin(123, DENOM),
-                    coin(123, "BTC"),
-                    coin(123, "DOGE")
-                ])
-            )
-        }
-
-        #[test]
-        fn stake_coin_must_be_of_correct_type() {
-            assert_eq!(
-                Err(ContractError::WrongDenom {}),
-                validate_delegation_stake(coins(123, "DOGE"))
-            )
-        }
-
-        #[test]
-        fn stake_coin_must_have_value_greater_than_zero() {
-            assert_eq!(
-                Err(ContractError::EmptyDelegation),
-                validate_delegation_stake(coins(0, DENOM))
-            )
-        }
-
-        #[test]
-        fn stake_can_have_any_positive_value() {
-            // this might change in the future, but right now an arbitrary (positive) value can be delegated
-            assert!(validate_delegation_stake(coins(1, DENOM)).is_ok());
-            assert!(validate_delegation_stake(coins(123, DENOM)).is_ok());
-            assert!(validate_delegation_stake(coins(10000000000, DENOM)).is_ok());
-        }
-    }
-
-    #[cfg(test)]
-    mod mix_stake_delegation {
-        use super::*;
-        use crate::mixnodes::transactions::try_remove_mixnode;
-        use crate::support::tests::test_helpers::good_mixnode_bond;
-        use cosmwasm_std::coin;
-        use cosmwasm_std::testing::mock_env;
-        use cosmwasm_std::testing::mock_info;
-        use cosmwasm_std::Addr;
-
-        #[test]
-        fn fails_if_node_doesnt_exist() {
-            let mut deps = test_helpers::init_contract();
-            assert_eq!(
-                Err(ContractError::MixNodeBondNotFound {
-                    identity: "non-existent-mix-identity".into()
-                }),
-                try_delegate_to_mixnode(
-                    deps.as_mut(),
-                    mock_env(),
-                    mock_info("sender", &coins(123, DENOM)),
-                    "non-existent-mix-identity".into(),
-                )
-            );
-        }
-
-        #[test]
-        fn succeeds_for_existing_node() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            let delegation = coin(123, DENOM);
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &[delegation.clone()]),
-                identity.clone(),
-            )
-            .is_ok());
-
-            let expected = Delegation::new(
-                delegation_owner.clone(),
-                identity.clone(),
-                delegation.clone(),
-                mock_env().block.height,
-                None,
-            );
-
-            assert_eq!(
-                expected,
-                test_helpers::read_delegation(&deps.storage, &identity, delegation_owner).unwrap()
-            );
-
-            // node's "total_delegation" is increased
-            assert_eq!(
-                delegation.amount,
-                mixnodes_storage::TOTAL_DELEGATION
-                    .load(&deps.storage, &identity)
-                    .unwrap()
-            )
-        }
-
-        #[test]
-        fn fails_if_node_unbonded() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            try_remove_mixnode(deps.as_mut(), mock_info(mixnode_owner, &[])).unwrap();
-            assert_eq!(
-                Err(ContractError::MixNodeBondNotFound {
-                    identity: identity.clone()
-                }),
-                try_delegate_to_mixnode(
-                    deps.as_mut(),
-                    mock_env(),
-                    mock_info(delegation_owner.as_str(), &coins(123, DENOM)),
-                    identity,
-                )
-            );
-        }
-
-        #[test]
-        fn succeeds_if_node_rebonded() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            try_remove_mixnode(deps.as_mut(), mock_info(mixnode_owner, &[])).unwrap();
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation = coin(123, DENOM);
-            let delegation_owner = Addr::unchecked("sender");
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &[delegation.clone()]),
-                identity.clone(),
-            )
-            .is_ok());
-
-            let expected = Delegation::new(
-                delegation_owner.clone(),
-                identity.clone(),
-                delegation.clone(),
-                mock_env().block.height,
-                None,
-            );
-
-            assert_eq!(
-                expected,
-                test_helpers::read_delegation(&deps.storage, &identity, delegation_owner).unwrap()
-            );
-
-            // node's "total_delegation" is increased
-            assert_eq!(
-                delegation.amount,
-                mixnodes_storage::TOTAL_DELEGATION
-                    .load(&deps.storage, &identity)
-                    .unwrap()
-            )
-        }
-
-        #[test]
-        fn is_possible_for_an_already_delegated_node() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            let delegation1 = coin(100, DENOM);
-            let delegation2 = coin(50, DENOM);
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &[delegation1.clone()]),
-                identity.clone(),
-            )
-            .unwrap();
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &[delegation2.clone()]),
-                identity.clone(),
-            )
-            .unwrap();
-
-            let expected = Delegation::new(
-                delegation_owner.clone(),
-                identity.clone(),
-                coin(delegation1.amount.u128() + delegation2.amount.u128(), DENOM),
-                mock_env().block.height,
-                None,
-            );
-
-            assert_eq!(
-                expected,
-                test_helpers::read_delegation(&deps.storage, &identity, delegation_owner).unwrap()
-            );
-
-            // node's "total_delegation" is sum of both
-            assert_eq!(
-                delegation1.amount + delegation2.amount,
-                mixnodes_storage::TOTAL_DELEGATION
-                    .load(&deps.storage, &identity)
-                    .unwrap()
-            )
-        }
-
-        #[test]
-        fn block_height_is_updated_on_new_delegation() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            let delegation = coin(100, DENOM);
-            let env1 = mock_env();
-            let mut env2 = mock_env();
-            let initial_height = env1.block.height;
-            let updated_height = initial_height + 42;
-            // second env has grown in block height
-            env2.block.height = updated_height;
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                env1,
-                mock_info(delegation_owner.as_str(), &[delegation.clone()]),
-                identity.clone(),
-            )
-            .unwrap();
-            assert_eq!(
-                initial_height,
-                test_helpers::read_delegation(&deps.storage, &identity, &delegation_owner)
-                    .unwrap()
-                    .block_height
-            );
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                env2,
-                mock_info(delegation_owner.as_str(), &[delegation.clone()]),
-                identity.clone(),
-            )
-            .unwrap();
-
-            let updated =
-                test_helpers::read_delegation(&deps.storage, &identity, &delegation_owner).unwrap();
-
-            assert_eq!(delegation.amount + delegation.amount, updated.amount.amount);
-            assert_eq!(updated_height, updated.block_height);
-        }
-
-        #[test]
-        fn block_height_is_not_updated_on_different_delegator() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner1 = Addr::unchecked("sender1");
-            let delegation_owner2 = Addr::unchecked("sender2");
-            let delegation1 = coin(100, DENOM);
-            let delegation2 = coin(120, DENOM);
-            let env1 = mock_env();
-            let mut env2 = mock_env();
-            let initial_height = env1.block.height;
-            let second_height = initial_height + 42;
-            // second env has grown in block height
-            env2.block.height = second_height;
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                env1,
-                mock_info(delegation_owner1.as_str(), &[delegation1.clone()]),
-                identity.clone(),
-            )
-            .unwrap();
-
-            assert_eq!(
-                initial_height,
-                test_helpers::read_delegation(&deps.storage, &identity, &delegation_owner1)
-                    .unwrap()
-                    .block_height
-            );
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                env2,
-                mock_info(delegation_owner2.as_str(), &[delegation2.clone()]),
-                identity.clone(),
-            )
-            .unwrap();
-
-            assert_eq!(
-                initial_height,
-                test_helpers::read_delegation(&deps.storage, &identity, &delegation_owner1)
-                    .unwrap()
-                    .block_height
-            );
-            assert_eq!(
-                second_height,
-                test_helpers::read_delegation(&deps.storage, identity, &delegation_owner2)
-                    .unwrap()
-                    .block_height
-            );
-        }
-
-        #[test]
-        fn is_disallowed_for_already_delegated_node_if_it_unbonded() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(100, DENOM)),
-                identity.clone(),
-            )
-            .unwrap();
-            try_remove_mixnode(deps.as_mut(), mock_info(mixnode_owner, &[])).unwrap();
-            assert_eq!(
-                Err(ContractError::MixNodeBondNotFound {
-                    identity: identity.clone()
-                }),
-                try_delegate_to_mixnode(
-                    deps.as_mut(),
-                    mock_env(),
-                    mock_info(delegation_owner.as_str(), &coins(50, DENOM)),
-                    identity,
-                )
-            );
-        }
-
-        #[test]
-        fn is_allowed_for_multiple_nodes() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner1 = "bob";
-            let mixnode_owner2 = "fred";
-            let identity1 =
-                test_helpers::add_mixnode(mixnode_owner1, good_mixnode_bond(), deps.as_mut());
-            let identity2 =
-                test_helpers::add_mixnode(mixnode_owner2, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(123, DENOM)),
-                identity1.clone(),
-            )
-            .is_ok());
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(42, DENOM)),
-                identity2.clone(),
-            )
-            .is_ok());
-
-            let expected1 = Delegation::new(
-                delegation_owner.clone(),
-                identity1.clone(),
-                coin(123, DENOM),
-                mock_env().block.height,
-                None,
-            );
-
-            let expected2 = Delegation::new(
-                delegation_owner.clone(),
-                identity2.clone(),
-                coin(42, DENOM),
-                mock_env().block.height,
-                None,
-            );
-
-            assert_eq!(
-                expected1,
-                test_helpers::read_delegation(&deps.storage, identity1, &delegation_owner).unwrap()
-            );
-            assert_eq!(
-                expected2,
-                test_helpers::read_delegation(&deps.storage, identity2, &delegation_owner).unwrap()
-            );
-        }
-
-        #[test]
-        fn is_allowed_by_multiple_users() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation1 = coin(123, DENOM);
-            let delegation2 = coin(234, DENOM);
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info("sender1", &[delegation1.clone()]),
-                identity.clone(),
-            )
-            .is_ok());
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info("sender2", &[delegation2.clone()]),
-                identity.clone(),
-            )
-            .is_ok());
-            // node's "total_delegation" is sum of both
-            assert_eq!(
-                delegation1.amount + delegation2.amount,
-                mixnodes_storage::TOTAL_DELEGATION
-                    .load(&deps.storage, &identity)
-                    .unwrap()
-            )
-        }
-
-        #[test]
-        fn delegation_is_not_removed_if_node_unbonded() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            let delegation_amount = coin(100, DENOM);
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &vec![delegation_amount.clone()]),
-                identity.clone(),
-            )
-            .unwrap();
-            try_remove_mixnode(deps.as_mut(), mock_info(mixnode_owner, &[])).unwrap();
-
-            let expected = Delegation::new(
-                delegation_owner.clone(),
-                identity.clone(),
-                delegation_amount,
-                mock_env().block.height,
-                None,
-            );
-
-            assert_eq!(
-                expected,
-                test_helpers::read_delegation(&deps.storage, identity, delegation_owner).unwrap()
-            )
-        }
-    }
-
-    #[cfg(test)]
-    mod removing_mix_stake_delegation {
-        use cosmwasm_std::coin;
-        use cosmwasm_std::testing::mock_env;
-        use cosmwasm_std::testing::mock_info;
-        use cosmwasm_std::Addr;
-        use cosmwasm_std::Uint128;
-
-        use crate::mixnodes::transactions::try_remove_mixnode;
-        use crate::support::tests::test_helpers::good_mixnode_bond;
-
-        use super::storage;
-        use super::*;
-
-        #[test]
-        fn fails_if_delegation_never_existed() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            assert_eq!(
-                Err(ContractError::NoMixnodeDelegationFound {
-                    identity: identity.clone(),
-                    address: delegation_owner.clone(),
-                }),
-                try_remove_delegation_from_mixnode(
-                    deps.as_mut(),
-                    mock_info(delegation_owner.as_str(), &[]),
-                    identity,
-                )
-            );
-        }
-
-        #[test]
-        fn succeeds_if_delegation_existed() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(100, DENOM)),
-                identity.clone(),
-            )
-            .unwrap();
-            assert_eq!(
-                Ok(Response::new().add_message(BankMsg::Send {
-                    to_address: delegation_owner.clone().into(),
-                    amount: coins(100, DENOM),
-                })),
-                try_remove_delegation_from_mixnode(
-                    deps.as_mut(),
-                    mock_info(delegation_owner.as_str(), &[]),
-                    identity.clone(),
-                )
-            );
-            assert!(storage::delegations()
-                .may_load(
-                    &deps.storage,
-                    (identity.clone(), delegation_owner).joined_key(),
-                )
-                .unwrap()
-                .is_none());
-
-            // and total delegation is cleared
-            assert_eq!(
-                Uint128::zero(),
-                mixnodes_storage::TOTAL_DELEGATION
-                    .load(&deps.storage, &identity)
-                    .unwrap()
-            )
-        }
-
-        #[test]
-        fn succeeds_if_delegation_existed_even_if_node_unbonded() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner = Addr::unchecked("sender");
-            try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner.as_str(), &coins(100, DENOM)),
-                identity.clone(),
-            )
-            .unwrap();
-            try_remove_mixnode(deps.as_mut(), mock_info(mixnode_owner, &[])).unwrap();
-            assert_eq!(
-                Ok(Response::new().add_message(BankMsg::Send {
-                    to_address: delegation_owner.clone().into(),
-                    amount: coins(100, DENOM),
-                })),
-                try_remove_delegation_from_mixnode(
-                    deps.as_mut(),
-                    mock_info(delegation_owner.as_str(), &[]),
-                    identity.clone(),
-                )
-            );
-
-            assert!(
-                test_helpers::read_delegation(&deps.storage, identity, delegation_owner).is_none()
-            );
-        }
-
-        #[test]
-        fn total_delegation_is_preserved_if_only_some_undelegate() {
-            let mut deps = test_helpers::init_contract();
-            let mixnode_owner = "bob";
-            let identity =
-                test_helpers::add_mixnode(mixnode_owner, good_mixnode_bond(), deps.as_mut());
-            let delegation_owner1 = Addr::unchecked("sender1");
-            let delegation_owner2 = Addr::unchecked("sender2");
-            let delegation1 = coin(123, DENOM);
-            let delegation2 = coin(234, DENOM);
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner1.as_str(), &[delegation1.clone()]),
-                identity.clone(),
-            )
-            .is_ok());
-            assert!(try_delegate_to_mixnode(
-                deps.as_mut(),
-                mock_env(),
-                mock_info(delegation_owner2.as_str(), &[delegation2.clone()]),
-                identity.clone(),
-            )
-            .is_ok());
-            // sender1 undelegates
-            try_remove_delegation_from_mixnode(
-                deps.as_mut(),
-                mock_info(delegation_owner1.as_str(), &[]),
-                identity.clone(),
-            )
-            .unwrap();
-            // but total delegation should still equal to what sender2 sent
-            // node's "total_delegation" is sum of both
-            assert_eq!(
-                delegation2.amount,
-                mixnodes_storage::TOTAL_DELEGATION
-                    .load(&deps.storage, &identity)
-                    .unwrap()
-            )
-        }
-    }
-
-    // #[cfg(test)]
-    // mod multi_delegations {
-    //     use super::*;
-    //     use crate::delegations::helpers;
-    //     use crate::delegations::queries::tests::store_n_mix_delegations;
-    //     use crate::support::tests::test_helpers;
-    //     use mixnet_contract::IdentityKey;
-    //     use mixnet_contract::RawDelegationData;
-    //
-    //     #[test]
-    //     fn multiple_page_delegations() {
-    //         let mut deps = test_helpers::init_contract();
-    //         let node_identity: IdentityKey = "foo".into();
-    //         store_n_mix_delegations(
-    //             storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-    //             &mut deps.storage,
-    //             &node_identity,
-    //         );
-    //         let mix_bucket = storage::all_mix_delegations_read::<RawDelegationData>(&deps.storage);
-    //         let mix_delegations = helpers::Delegations::new(mix_bucket);
-    //         assert_eq!(
-    //             storage::DELEGATION_PAGE_DEFAULT_LIMIT * 10,
-    //             mix_delegations.count() as u32
-    //         );
-    //     }
-    // }
-}
@@ -24,6 +24,9 @@ pub enum ContractError {
    #[error("Not enough funds sent for gateway bond. (received {received}, minimum {minimum})")]
    InsufficientGatewayBond { received: u128, minimum: u128 },

+    #[error("Gateway ({identity}) does not exist")]
+    GatewayBondNotFound { identity: IdentityKey },
+
    #[error("{owner} does not seem to own any mixnodes")]
    NoAssociatedMixNodeBond { owner: Addr },

@@ -51,6 +54,9 @@ pub enum ContractError {
    #[error("Provided rewarded set size is zero")]
    ZeroRewardedSet,

+    #[error("The node had uptime larger than 100%")]
+    UnexpectedUptime,
+
    #[error("This address has already bonded a mixnode")]
    AlreadyOwnsMixnode,

@@ -66,6 +72,9 @@ pub enum ContractError {
    #[error("No funds were provided for the delegation")]
    EmptyDelegation,

+    #[error("Request did not come from the node owner ({owner})")]
+    InvalidSender { owner: Addr },
+
    #[error("Could not find any delegation information associated with mixnode {identity} for {address}")]
    NoMixnodeDelegationFound {
        identity: IdentityKey,
@@ -92,19 +101,4 @@ pub enum ContractError {

    #[error("Mixnode's {identity} operator has not been rewarded yet - cannot perform delegator rewarding until that happens")]
    MixnodeOperatorNotRewarded { identity: IdentityKey },
-
-    #[error("Proxy address mismatch, expected {existing}, got {incoming}")]
-    ProxyMismatch { existing: String, incoming: String },
-
-    #[error("Failed to recover ed25519 public key from its base58 representation - {0}")]
-    MalformedEd25519IdentityKey(String),
-
-    #[error("Failed to recover ed25519 signature from its base58 representation - {0}")]
-    MalformedEd25519Signature(String),
-
-    #[error("Provided ed25519 signature did not verify correctly")]
-    InvalidEd25519Signature,
-
-    #[error("Profit margin percent needs to be an integer in range [0, 100], recieved {0}")]
-    InvalidProfitMarginPercent(u8),
 }
@@ -1,6 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod queries;
-pub mod storage;
-pub mod transactions;
@@ -1,212 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::storage;
-use crate::mixnodes::storage::{BOND_PAGE_DEFAULT_LIMIT, BOND_PAGE_MAX_LIMIT}; // Keeps gateway and mixnode retrieval in sync by re-using the constant. Could be split into its own constant.
-use cosmwasm_std::{Deps, Order, StdResult};
-use cw_storage_plus::Bound;
-use mixnet_contract::{GatewayBond, GatewayOwnershipResponse, IdentityKey, PagedGatewayResponse};
-
-pub(crate) fn query_gateways_paged(
-    deps: Deps,
-    start_after: Option<IdentityKey>,
-    limit: Option<u32>,
-) -> StdResult<PagedGatewayResponse> {
-    let limit = limit
-        .unwrap_or(BOND_PAGE_DEFAULT_LIMIT)
-        .min(BOND_PAGE_MAX_LIMIT) as usize;
-    let start = start_after.map(Bound::exclusive);
-
-    let nodes = storage::gateways()
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|res| res.map(|item| item.1))
-        .collect::<StdResult<Vec<GatewayBond>>>()?;
-
-    let start_next_after = nodes.last().map(|node| node.identity().clone());
-
-    Ok(PagedGatewayResponse::new(nodes, limit, start_next_after))
-}
-
-pub(crate) fn query_owns_gateway(
-    deps: Deps,
-    address: String,
-) -> StdResult<GatewayOwnershipResponse> {
-    let validated_addr = deps.api.addr_validate(&address)?;
-
-    let gateway = storage::gateways()
-        .idx
-        .owner
-        .item(deps.storage, validated_addr.clone())?
-        .map(|record| record.1);
-
-    Ok(GatewayOwnershipResponse {
-        address: validated_addr,
-        gateway,
-    })
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::*;
-    use crate::contract::execute;
-    use crate::support::tests::test_helpers;
-    use cosmwasm_std::testing::{mock_env, mock_info};
-
-    #[test]
-    fn gateways_empty_on_init() {
-        let deps = test_helpers::init_contract();
-        let response = query_gateways_paged(deps.as_ref(), None, Option::from(2)).unwrap();
-        assert_eq!(0, response.nodes.len());
-    }
-
-    #[test]
-    fn gateways_paged_retrieval_obeys_limits() {
-        let mut deps = test_helpers::init_contract();
-        let limit = 2;
-        for n in 0..1000 {
-            let key = format!("bond{}", n);
-            test_helpers::add_gateway(&key, test_helpers::good_gateway_bond(), deps.as_mut());
-        }
-
-        let page1 = query_gateways_paged(deps.as_ref(), None, Option::from(limit)).unwrap();
-        assert_eq!(limit, page1.nodes.len() as u32);
-    }
-
-    #[test]
-    fn gateways_paged_retrieval_has_default_limit() {
-        let mut deps = test_helpers::init_contract();
-        for n in 0..1000 {
-            let key = format!("bond{}", n);
-            test_helpers::add_gateway(&key, test_helpers::good_gateway_bond(), deps.as_mut());
-        }
-
-        // query without explicitly setting a limit
-        let page1 = query_gateways_paged(deps.as_ref(), None, None).unwrap();
-
-        assert_eq!(BOND_PAGE_DEFAULT_LIMIT, page1.nodes.len() as u32);
-    }
-
-    #[test]
-    fn gateways_paged_retrieval_has_max_limit() {
-        let mut deps = test_helpers::init_contract();
-        for n in 0..1000 {
-            let key = format!("bond{}", n);
-            test_helpers::add_gateway(&key, test_helpers::good_gateway_bond(), deps.as_mut());
-        }
-
-        // query with a crazily high limit in an attempt to use too many resources
-        let crazy_limit = 1000 * BOND_PAGE_DEFAULT_LIMIT;
-        let page1 = query_gateways_paged(deps.as_ref(), None, Option::from(crazy_limit)).unwrap();
-
-        // we default to a decent sized upper bound instead
-        let expected_limit = BOND_PAGE_MAX_LIMIT;
-        assert_eq!(expected_limit, page1.nodes.len() as u32);
-    }
-
-    #[test]
-    fn gateway_pagination_works() {
-        // prepare 4 messages and identities that are sorted by the generated identities
-        // (because we query them in an ascended manner)
-        let mut exec_data = (0..4)
-            .map(|i| {
-                let sender = format!("nym-addr{}", i);
-                let (msg, identity) = test_helpers::valid_bond_gateway_msg(&sender);
-                (msg, (sender, identity))
-            })
-            .collect::<Vec<_>>();
-        exec_data.sort_by(|(_, (_, id1)), (_, (_, id2))| id1.cmp(id2));
-        let (messages, sender_identities): (Vec<_>, Vec<_>) = exec_data.into_iter().unzip();
-
-        let mut deps = test_helpers::init_contract();
-
-        let info = mock_info(
-            &sender_identities[0].0.clone(),
-            &test_helpers::good_gateway_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[0].clone()).unwrap();
-
-        let per_page = 2;
-        let page1 = query_gateways_paged(deps.as_ref(), None, Option::from(per_page)).unwrap();
-
-        // page should have 1 result on it
-        assert_eq!(1, page1.nodes.len());
-
-        // save another
-        let info = mock_info(
-            &sender_identities[1].0.clone(),
-            &test_helpers::good_gateway_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[1].clone()).unwrap();
-
-        // page1 should have 2 results on it
-        let page1 = query_gateways_paged(deps.as_ref(), None, Option::from(per_page)).unwrap();
-        assert_eq!(2, page1.nodes.len());
-
-        let info = mock_info(
-            &sender_identities[2].0.clone(),
-            &test_helpers::good_gateway_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[2].clone()).unwrap();
-
-        // page1 still has 2 results
-        let page1 = query_gateways_paged(deps.as_ref(), None, Option::from(per_page)).unwrap();
-        assert_eq!(2, page1.nodes.len());
-
-        // retrieving the next page should start after the last key on this page
-        let start_after = page1.start_next_after.unwrap();
-        let page2 = query_gateways_paged(
-            deps.as_ref(),
-            Option::from(start_after.clone()),
-            Option::from(per_page),
-        )
-        .unwrap();
-
-        assert_eq!(1, page2.nodes.len());
-
-        // save another one
-        let info = mock_info(
-            &sender_identities[3].0.clone(),
-            &test_helpers::good_gateway_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[3].clone()).unwrap();
-
-        let page2 = query_gateways_paged(
-            deps.as_ref(),
-            Option::from(start_after),
-            Option::from(per_page),
-        )
-        .unwrap();
-
-        // now we have 2 pages, with 2 results on the second page
-        assert_eq!(2, page2.nodes.len());
-    }
-
-    #[test]
-    fn query_for_gateway_owner_works() {
-        let mut deps = test_helpers::init_contract();
-
-        // "fred" does not own a mixnode if there are no mixnodes
-        let res = query_owns_gateway(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.gateway.is_none());
-
-        // mixnode was added to "bob", "fred" still does not own one
-        test_helpers::add_gateway("bob", test_helpers::good_gateway_bond(), deps.as_mut());
-
-        let res = query_owns_gateway(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.gateway.is_none());
-
-        // "fred" now owns a gateway!
-        test_helpers::add_gateway("fred", test_helpers::good_gateway_bond(), deps.as_mut());
-
-        let res = query_owns_gateway(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.gateway.is_some());
-
-        // but after unbonding it, he doesn't own one anymore
-        crate::gateways::transactions::try_remove_gateway(deps.as_mut(), mock_info("fred", &[]))
-            .unwrap();
-
-        let res = query_owns_gateway(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.gateway.is_none());
-    }
-}
@@ -1,108 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_std::Addr;
-use cw_storage_plus::{Index, IndexList, IndexedMap, UniqueIndex};
-use mixnet_contract::{GatewayBond, IdentityKeyRef};
-
-// storage prefixes
-const GATEWAYS_PK_NAMESPACE: &str = "gt";
-const GATEWAYS_OWNER_IDX_NAMESPACE: &str = "gto";
-
-pub(crate) struct GatewayBondIndex<'a> {
-    pub(crate) owner: UniqueIndex<'a, Addr, GatewayBond>,
-}
-
-// IndexList is just boilerplate code for fetching a struct's indexes
-// note that from my understanding this will be converted into a macro at some point in the future
-impl<'a> IndexList<GatewayBond> for GatewayBondIndex<'a> {
-    fn get_indexes(&'_ self) -> Box<dyn Iterator<Item = &'_ dyn Index<GatewayBond>> + '_> {
-        let v: Vec<&dyn Index<GatewayBond>> = vec![&self.owner];
-        Box::new(v.into_iter())
-    }
-}
-
-// gateways() is the storage access function.
-pub(crate) fn gateways<'a>() -> IndexedMap<'a, IdentityKeyRef<'a>, GatewayBond, GatewayBondIndex<'a>>
-{
-    let indexes = GatewayBondIndex {
-        owner: UniqueIndex::new(|d| d.owner.clone(), GATEWAYS_OWNER_IDX_NAMESPACE),
-    };
-    IndexedMap::new(GATEWAYS_PK_NAMESPACE, indexes)
-}
-
-// currently not used outside tests
-#[cfg(test)]
-mod tests {
-    use super::super::storage;
-    use crate::support::tests::test_helpers;
-    use config::defaults::DENOM;
-    use cosmwasm_std::testing::MockStorage;
-    use cosmwasm_std::StdResult;
-    use cosmwasm_std::Storage;
-    use cosmwasm_std::{coin, Addr, Uint128};
-    use mixnet_contract::GatewayBond;
-    use mixnet_contract::IdentityKey;
-    use mixnet_contract::{Gateway, IdentityKeyRef};
-
-    // currently this is only used in tests but may become useful later on
-    pub(crate) fn read_gateway_pledge_amount(
-        storage: &dyn Storage,
-        identity: IdentityKeyRef,
-    ) -> StdResult<cosmwasm_std::Uint128> {
-        let node = storage::gateways().load(storage, identity)?;
-        Ok(node.pledge_amount.amount)
-    }
-
-    #[test]
-    fn gateway_single_read_retrieval() {
-        let mut storage = MockStorage::new();
-        let bond1 = test_helpers::gateway_bond_fixture("owner1");
-        let bond2 = test_helpers::gateway_bond_fixture("owner2");
-        storage::gateways()
-            .save(&mut storage, "bond1", &bond1)
-            .unwrap();
-        storage::gateways()
-            .save(&mut storage, "bond2", &bond2)
-            .unwrap();
-
-        let res1 = storage::gateways().load(&storage, "bond1").unwrap();
-        let res2 = storage::gateways().load(&storage, "bond2").unwrap();
-        assert_eq!(bond1, res1);
-        assert_eq!(bond2, res2);
-    }
-
-    #[test]
-    fn reading_gateway_bond() {
-        let mut mock_storage = MockStorage::new();
-        let node_owner: Addr = Addr::unchecked("node-owner");
-        let node_identity: IdentityKey = "nodeidentity".into();
-
-        // produces an error if target gateway doesn't exist
-        let res = read_gateway_pledge_amount(&mock_storage, &node_identity);
-        assert!(res.is_err());
-
-        // returns appropriate value otherwise
-        let pledge_amount = 1000;
-
-        let gateway_bond = GatewayBond {
-            pledge_amount: coin(pledge_amount, DENOM),
-            owner: node_owner.clone(),
-            block_height: 12_345,
-            gateway: Gateway {
-                identity_key: node_identity.clone(),
-                ..test_helpers::gateway_fixture()
-            },
-            proxy: None,
-        };
-
-        storage::gateways()
-            .save(&mut mock_storage, &node_identity, &gateway_bond)
-            .unwrap();
-
-        assert_eq!(
-            Uint128::new(pledge_amount),
-            read_gateway_pledge_amount(&mock_storage, &node_identity).unwrap()
-        );
-    }
-}
@@ -1,561 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::storage;
-use crate::error::ContractError;
-use crate::mixnet_contract_settings::storage as mixnet_params_storage;
-use crate::support::helpers::{ensure_no_existing_bond, validate_node_identity_signature};
-use config::defaults::DENOM;
-use cosmwasm_std::{
-    coins, wasm_execute, Addr, BankMsg, Coin, DepsMut, Env, MessageInfo, Response, Uint128,
-};
-use mixnet_contract::{Gateway, GatewayBond, Layer};
-use vesting_contract::messages::ExecuteMsg as VestingContractExecuteMsg;
-
-pub fn try_add_gateway(
-    deps: DepsMut,
-    env: Env,
-    info: MessageInfo,
-    gateway: Gateway,
-    owner_signature: String,
-) -> Result<Response, ContractError> {
-    // check if the pledge contains any funds of the appropriate denomination
-    let minimum_pledge = mixnet_params_storage::CONTRACT_STATE
-        .load(deps.storage)?
-        .params
-        .minimum_mixnode_pledge;
-    let pledge = validate_gateway_pledge(info.funds, minimum_pledge)?;
-
-    _try_add_gateway(
-        deps,
-        env,
-        gateway,
-        pledge,
-        info.sender.as_str(),
-        owner_signature,
-        None,
-    )
-}
-
-pub fn try_add_gateway_on_behalf(
-    deps: DepsMut,
-    env: Env,
-    info: MessageInfo,
-    gateway: Gateway,
-    owner: String,
-    owner_signature: String,
-) -> Result<Response, ContractError> {
-    // check if the pledge contains any funds of the appropriate denomination
-    let minimum_pledge = mixnet_params_storage::CONTRACT_STATE
-        .load(deps.storage)?
-        .params
-        .minimum_mixnode_pledge;
-    let pledge = validate_gateway_pledge(info.funds, minimum_pledge)?;
-
-    let _proxy = info.sender;
-    _try_add_gateway(deps, env, gateway, pledge, &owner, owner_signature, None)
-}
-
-pub(crate) fn _try_add_gateway(
-    deps: DepsMut,
-    env: Env,
-    gateway: Gateway,
-    pledge: Coin,
-    owner: &str,
-    owner_signature: String,
-    proxy: Option<Addr>,
-) -> Result<Response, ContractError> {
-    let owner = deps.api.addr_validate(owner)?;
-
-    // if the client has an active bonded mixnode or gateway, don't allow bonding
-    ensure_no_existing_bond(deps.storage, &owner)?;
-
-    // check if somebody else has already bonded a gateway with this identity
-    if let Some(existing_bond) =
-        storage::gateways().may_load(deps.storage, &gateway.identity_key)?
-    {
-        if existing_bond.owner != owner {
-            return Err(ContractError::DuplicateGateway {
-                owner: existing_bond.owner,
-            });
-        }
-    }
-
-    // check if this sender actually owns the gateway by checking the signature
-    validate_node_identity_signature(
-        deps.as_ref(),
-        &owner,
-        owner_signature,
-        &gateway.identity_key,
-    )?;
-
-    let bond = GatewayBond::new(pledge, owner, env.block.height, gateway, proxy);
-
-    storage::gateways().save(deps.storage, bond.identity(), &bond)?;
-    mixnet_params_storage::increment_layer_count(deps.storage, Layer::Gateway)?;
-
-    Ok(Response::new())
-}
-
-pub fn try_remove_gateway_on_behalf(
-    deps: DepsMut,
-    info: MessageInfo,
-    owner: String,
-) -> Result<Response, ContractError> {
-    let proxy = info.sender;
-    _try_remove_gateway(deps, &owner, Some(proxy))
-}
-
-pub fn try_remove_gateway(deps: DepsMut, info: MessageInfo) -> Result<Response, ContractError> {
-    _try_remove_gateway(deps, info.sender.as_ref(), None)
-}
-
-pub(crate) fn _try_remove_gateway(
-    deps: DepsMut,
-    owner: &str,
-    proxy: Option<Addr>,
-) -> Result<Response, ContractError> {
-    let owner = deps.api.addr_validate(owner)?;
-    // try to find the node of the sender
-    let gateway_bond = match storage::gateways()
-        .idx
-        .owner
-        .item(deps.storage, owner.clone())?
-    {
-        Some(record) => record.1,
-        None => return Err(ContractError::NoAssociatedGatewayBond { owner }),
-    };
-
-    if proxy != gateway_bond.proxy {
-        return Err(ContractError::ProxyMismatch {
-            existing: gateway_bond
-                .proxy
-                .map_or_else(|| "None".to_string(), |a| a.as_str().to_string()),
-            incoming: proxy.map_or_else(|| "None".to_string(), |a| a.as_str().to_string()),
-        });
-    }
-
-    // send bonded funds back to the bond owner
-    let return_tokens = BankMsg::Send {
-        to_address: proxy.as_ref().unwrap_or(&owner).to_string(),
-        amount: vec![gateway_bond.pledge_amount()],
-    };
-
-    // remove the bond
-    storage::gateways().remove(deps.storage, gateway_bond.identity())?;
-
-    // decrement layer count
-    mixnet_params_storage::decrement_layer_count(deps.storage, Layer::Gateway)?;
-
-    let mut response = Response::new()
-        .add_message(return_tokens)
-        .add_attribute("action", "unbond")
-        .add_attribute("address", owner.clone())
-        .add_attribute("gateway_bond", gateway_bond.to_string());
-
-    if let Some(proxy) = &proxy {
-        let msg = VestingContractExecuteMsg::TrackUnbondGateway {
-            owner: owner.as_str().to_string(),
-            amount: gateway_bond.pledge_amount,
-        };
-
-        let track_unbond_message = wasm_execute(proxy, &msg, coins(0, DENOM))?;
-        response = response.add_message(track_unbond_message);
-    }
-
-    Ok(response)
-}
-
-fn validate_gateway_pledge(
-    mut pledge: Vec<Coin>,
-    minimum_pledge: Uint128,
-) -> Result<Coin, ContractError> {
-    // check if anything was put as bond
-    if pledge.is_empty() {
-        return Err(ContractError::NoBondFound);
-    }
-
-    if pledge.len() > 1 {
-        return Err(ContractError::MultipleDenoms);
-    }
-
-    // check that the denomination is correct
-    if pledge[0].denom != DENOM {
-        return Err(ContractError::WrongDenom {});
-    }
-
-    // check that we have at least 100 coins in our pledge
-    if pledge[0].amount < minimum_pledge {
-        return Err(ContractError::InsufficientGatewayBond {
-            received: pledge[0].amount.into(),
-            minimum: minimum_pledge.into(),
-        });
-    }
-
-    Ok(pledge.pop().unwrap())
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-    use crate::contract::{execute, query, INITIAL_GATEWAY_PLEDGE};
-    use crate::error::ContractError;
-    use crate::gateways::transactions::validate_gateway_pledge;
-    use crate::support::tests::test_helpers;
-    use config::defaults::DENOM;
-    use cosmwasm_std::attr;
-    use cosmwasm_std::testing::{mock_env, mock_info};
-    use cosmwasm_std::{coins, BankMsg, Response};
-    use cosmwasm_std::{from_binary, Addr, Uint128};
-    use mixnet_contract::Gateway;
-    use mixnet_contract::{ExecuteMsg, PagedGatewayResponse, QueryMsg};
-
-    #[test]
-    fn gateway_add() {
-        let mut deps = test_helpers::init_contract();
-
-        // if we fail validation (by say not sending enough funds
-        let insufficient_bond = Into::<u128>::into(INITIAL_GATEWAY_PLEDGE) - 1;
-        let info = mock_info("anyone", &coins(insufficient_bond, DENOM));
-        let (msg, _) = test_helpers::valid_bond_gateway_msg("anyone");
-
-        // we are informed that we didn't send enough funds
-        let result = execute(deps.as_mut(), mock_env(), info, msg);
-        assert_eq!(
-            result,
-            Err(ContractError::InsufficientGatewayBond {
-                received: insufficient_bond,
-                minimum: INITIAL_GATEWAY_PLEDGE.into(),
-            })
-        );
-
-        // make sure no gateway was inserted into the topology
-        let res = query(
-            deps.as_ref(),
-            mock_env(),
-            QueryMsg::GetGateways {
-                start_after: None,
-                limit: Option::from(2),
-            },
-        )
-        .unwrap();
-        let page: PagedGatewayResponse = from_binary(&res).unwrap();
-        assert_eq!(0, page.nodes.len());
-
-        // if we send enough funds
-        let info = mock_info("anyone", &test_helpers::good_gateway_bond());
-        let (msg, identity) = test_helpers::valid_bond_gateway_msg("anyone");
-
-        // we get back a message telling us everything was OK
-        let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
-        assert!(execute_response.is_ok());
-
-        // we can query topology and the new node is there
-        let query_response = query(
-            deps.as_ref(),
-            mock_env(),
-            QueryMsg::GetGateways {
-                start_after: None,
-                limit: Option::from(2),
-            },
-        )
-        .unwrap();
-        let page: PagedGatewayResponse = from_binary(&query_response).unwrap();
-        assert_eq!(1, page.nodes.len());
-        assert_eq!(
-            &Gateway {
-                identity_key: identity,
-                ..test_helpers::gateway_fixture()
-            },
-            page.nodes[0].gateway()
-        );
-
-        // if there was already a gateway bonded by particular user
-        let info = mock_info("foomper", &test_helpers::good_gateway_bond());
-        let (msg, _) = test_helpers::valid_bond_gateway_msg("foomper");
-        execute(deps.as_mut(), mock_env(), info, msg).unwrap();
-
-        let info = mock_info("foomper", &test_helpers::good_gateway_bond());
-        let (msg, _) = test_helpers::valid_bond_gateway_msg("foomper");
-
-        // it fails
-        let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
-        assert_eq!(Err(ContractError::AlreadyOwnsGateway), execute_response);
-
-        // bonding fails if the user already owns a mixnode
-        test_helpers::add_mixnode(
-            "mixnode-owner",
-            test_helpers::good_mixnode_bond(),
-            deps.as_mut(),
-        );
-
-        let info = mock_info("mixnode-owner", &test_helpers::good_gateway_bond());
-        let (msg, _) = test_helpers::valid_bond_gateway_msg("mixnode-owner");
-
-        let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
-        assert_eq!(execute_response, Err(ContractError::AlreadyOwnsMixnode));
-
-        // but after he unbonds it, it's all fine again
-        let info = mock_info("mixnode-owner", &[]);
-        let msg = ExecuteMsg::UnbondMixnode {};
-        execute(deps.as_mut(), mock_env(), info, msg).unwrap();
-
-        let info = mock_info("mixnode-owner", &test_helpers::good_gateway_bond());
-        let (msg, _) = test_helpers::valid_bond_gateway_msg("mixnode-owner");
-
-        let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
-        assert!(execute_response.is_ok());
-
-        // adding another node from another account, but with the same IP, should fail (or we would have a weird state).
-        // Is that right? Think about this, not sure yet.
-    }
-
-    #[test]
-    fn adding_gateway_without_existing_owner() {
-        let mut deps = test_helpers::init_contract();
-
-        let info = mock_info("gateway-owner", &test_helpers::good_gateway_bond());
-
-        // before the execution the node had no associated owner
-        assert!(storage::gateways()
-            .idx
-            .owner
-            .item(deps.as_ref().storage, Addr::unchecked("gateway-owner"))
-            .unwrap()
-            .is_none());
-
-        let (msg, identity) = test_helpers::valid_bond_gateway_msg("gateway-owner");
-
-        // it's all fine, owner is saved
-        let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
-        assert!(execute_response.is_ok());
-
-        assert_eq!(
-            &identity,
-            storage::gateways()
-                .idx
-                .owner
-                .item(deps.as_ref().storage, Addr::unchecked("gateway-owner"))
-                .unwrap()
-                .unwrap()
-                .1
-                .identity()
-        );
-    }
-
-    #[test]
-    fn adding_gateway_with_existing_owner() {
-        let mut deps = test_helpers::init_contract();
-
-        let identity = test_helpers::add_gateway(
-            "gateway-owner",
-            test_helpers::good_gateway_bond(),
-            deps.as_mut(),
-        );
-
-        // request fails giving the existing owner address in the message
-        let info = mock_info(
-            "gateway-owner-pretender",
-            &test_helpers::good_gateway_bond(),
-        );
-        let msg = ExecuteMsg::BondGateway {
-            gateway: Gateway {
-                identity_key: identity,
-                ..test_helpers::gateway_fixture()
-            },
-            owner_signature: "foomp".to_string(),
-        };
-
-        let execute_response = execute(deps.as_mut(), mock_env(), info, msg);
-        assert_eq!(
-            Err(ContractError::DuplicateGateway {
-                owner: Addr::unchecked("gateway-owner")
-            }),
-            execute_response
-        );
-    }
-
-    #[test]
-    fn adding_gateway_with_existing_unchanged_owner() {
-        let mut deps = test_helpers::init_contract();
-
-        test_helpers::add_gateway(
-            "gateway-owner",
-            test_helpers::good_gateway_bond(),
-            deps.as_mut(),
-        );
-
-        let info = mock_info("gateway-owner", &test_helpers::good_gateway_bond());
-        let (msg, _) = test_helpers::valid_bond_gateway_msg("gateway-owner");
-
-        let res = execute(deps.as_mut(), mock_env(), info, msg);
-        assert_eq!(Err(ContractError::AlreadyOwnsGateway), res);
-    }
-
-    #[test]
-    fn gateway_remove() {
-        let mut deps = test_helpers::init_contract();
-
-        // try unbond when no nodes exist yet
-        let info = mock_info("anyone", &[]);
-        let msg = ExecuteMsg::UnbondGateway {};
-        let result = execute(deps.as_mut(), mock_env(), info, msg);
-
-        // we're told that there is no node for our address
-        assert_eq!(
-            result,
-            Err(ContractError::NoAssociatedGatewayBond {
-                owner: Addr::unchecked("anyone")
-            })
-        );
-
-        // let's add a node owned by bob
-        test_helpers::add_gateway("bob", test_helpers::good_gateway_bond(), deps.as_mut());
-
-        // attempt to unbond fred's node, which doesn't exist
-        let info = mock_info("fred", &[]);
-        let msg = ExecuteMsg::UnbondGateway {};
-        let result = execute(deps.as_mut(), mock_env(), info, msg);
-        assert_eq!(
-            result,
-            Err(ContractError::NoAssociatedGatewayBond {
-                owner: Addr::unchecked("fred")
-            })
-        );
-
-        // bob's node is still there
-        let nodes = test_helpers::get_gateways(&mut deps);
-        assert_eq!(1, nodes.len());
-
-        let first_node = &nodes[0];
-        assert_eq!(&Addr::unchecked("bob"), first_node.owner());
-
-        // add a node owned by fred
-        let fred_identity =
-            test_helpers::add_gateway("fred", test_helpers::good_gateway_bond(), deps.as_mut());
-
-        // let's make sure we now have 2 nodes:
-        assert_eq!(2, test_helpers::get_gateways(&mut deps).len());
-
-        // unbond fred's node
-        let info = mock_info("fred", &[]);
-        let msg = ExecuteMsg::UnbondGateway {};
-        let remove_fred = execute(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
-
-        // we should see log messages come back showing an unbond message
-        let expected_attributes = vec![
-            attr("action", "unbond"),
-            attr("address", "fred"),
-            attr(
-                "gateway_bond",
-                format!(
-                    "amount: {} {}, owner: fred, identity: {}",
-                    INITIAL_GATEWAY_PLEDGE, DENOM, fred_identity
-                ),
-            ),
-        ];
-
-        // we should see a funds transfer from the contract back to fred
-        let expected_message = BankMsg::Send {
-            to_address: String::from(info.sender),
-            amount: test_helpers::good_gateway_bond(),
-        };
-
-        // run the executor and check that we got back the correct results
-        let expected = Response::new()
-            .add_attributes(expected_attributes)
-            .add_message(expected_message);
-
-        assert_eq!(remove_fred, expected);
-
-        // only 1 node now exists, owned by bob:
-        let gateway_bonds = test_helpers::get_gateways(&mut deps);
-        assert_eq!(1, gateway_bonds.len());
-        assert_eq!(&Addr::unchecked("bob"), gateway_bonds[0].owner());
-    }
-
-    #[test]
-    fn removing_gateway_clears_ownership() {
-        let mut deps = test_helpers::init_contract();
-
-        let info = mock_info("gateway-owner", &test_helpers::good_gateway_bond());
-        let (bond_msg, identity) = test_helpers::valid_bond_gateway_msg("gateway-owner");
-        execute(deps.as_mut(), mock_env(), info, bond_msg.clone()).unwrap();
-
-        assert_eq!(
-            &identity,
-            storage::gateways()
-                .idx
-                .owner
-                .item(deps.as_ref().storage, Addr::unchecked("gateway-owner"))
-                .unwrap()
-                .unwrap()
-                .1
-                .identity()
-        );
-
-        let info = mock_info("gateway-owner", &[]);
-        let msg = ExecuteMsg::UnbondGateway {};
-
-        assert!(execute(deps.as_mut(), mock_env(), info, msg).is_ok());
-
-        assert!(storage::gateways()
-            .idx
-            .owner
-            .item(deps.as_ref().storage, Addr::unchecked("gateway-owner"))
-            .unwrap()
-            .is_none());
-
-        // and since it's removed, it can be reclaimed
-        let info = mock_info("gateway-owner", &test_helpers::good_gateway_bond());
-
-        assert!(execute(deps.as_mut(), mock_env(), info, bond_msg).is_ok());
-        assert_eq!(
-            &identity,
-            storage::gateways()
-                .idx
-                .owner
-                .item(deps.as_ref().storage, Addr::unchecked("gateway-owner"))
-                .unwrap()
-                .unwrap()
-                .1
-                .identity()
-        );
-    }
-
-    #[test]
-    fn validating_gateway_bond() {
-        // you must send SOME funds
-        let result = validate_gateway_pledge(Vec::new(), INITIAL_GATEWAY_PLEDGE);
-        assert_eq!(result, Err(ContractError::NoBondFound));
-
-        // you must send at least 100 coins...
-        let mut bond = test_helpers::good_gateway_bond();
-        bond[0].amount = INITIAL_GATEWAY_PLEDGE.checked_sub(Uint128::new(1)).unwrap();
-        let result = validate_gateway_pledge(bond.clone(), INITIAL_GATEWAY_PLEDGE);
-        assert_eq!(
-            result,
-            Err(ContractError::InsufficientGatewayBond {
-                received: Into::<u128>::into(INITIAL_GATEWAY_PLEDGE) - 1,
-                minimum: INITIAL_GATEWAY_PLEDGE.into(),
-            })
-        );
-
-        // more than that is still fine
-        let mut bond = test_helpers::good_gateway_bond();
-        bond[0].amount = INITIAL_GATEWAY_PLEDGE + Uint128::new(1);
-        let result = validate_gateway_pledge(bond.clone(), INITIAL_GATEWAY_PLEDGE);
-        assert!(result.is_ok());
-
-        // it must be sent in the defined denom!
-        let mut bond = test_helpers::good_gateway_bond();
-        bond[0].denom = "baddenom".to_string();
-        let result = validate_gateway_pledge(bond.clone(), INITIAL_GATEWAY_PLEDGE);
-        assert_eq!(result, Err(ContractError::WrongDenom {}));
-
-        let mut bond = test_helpers::good_gateway_bond();
-        bond[0].denom = "foomp".to_string();
-        let result = validate_gateway_pledge(bond.clone(), INITIAL_GATEWAY_PLEDGE);
-        assert_eq!(result, Err(ContractError::WrongDenom {}));
-    }
-}
@@ -0,0 +1,272 @@
+// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::transactions::OLD_DELEGATIONS_CHUNK_SIZE;
+use cosmwasm_std::{Order, StdError, StdResult};
+use cosmwasm_storage::ReadonlyBucket;
+use mixnet_contract::{Addr, IdentityKey, PagedAllDelegationsResponse, UnpackedDelegation};
+use serde::de::DeserializeOwned;
+use serde::Serialize;
+
+// cosmwasm bucket internal value
+const NAMESPACE_LENGTH: usize = 2;
+
+// Extracts the node identity and owner of a delegation from the bytes used as
+// key in the delegation buckets.
+fn extract_identity_and_owner(bytes: Vec<u8>) -> StdResult<(Addr, IdentityKey)> {
+    if bytes.len() < NAMESPACE_LENGTH {
+        return Err(StdError::parse_err(
+            "mixnet_contract::types::IdentityKey",
+            "Invalid type",
+        ));
+    }
+    let identity_size = u16::from_be_bytes([bytes[0], bytes[1]]) as usize;
+    let identity_bytes: Vec<u8> = bytes
+        .iter()
+        .skip(NAMESPACE_LENGTH)
+        .take(identity_size)
+        .copied()
+        .collect();
+    let identity = IdentityKey::from_utf8(identity_bytes)
+        .map_err(|_| StdError::parse_err("mixnet_contract::types::IdentityKey", "Invalid type"))?;
+    let owner_bytes: Vec<u8> = bytes
+        .iter()
+        .skip(NAMESPACE_LENGTH + identity_size)
+        .copied()
+        .collect();
+    let owner = Addr::unchecked(
+        String::from_utf8(owner_bytes)
+            .map_err(|_| StdError::parse_err("cosmwasm_std::addresses::Addr", "Invalid type"))?,
+    );
+
+    Ok((owner, identity))
+}
+
+// currently not used outside tests
+#[cfg(test)]
+// Converts the node identity and owner of a delegation into the bytes used as
+// key in the delegation buckets.
+pub(crate) fn identity_and_owner_to_bytes(identity: &IdentityKey, owner: &Addr) -> Vec<u8> {
+    let mut bytes = u16::to_be_bytes(identity.len() as u16).to_vec();
+    bytes.append(&mut identity.as_bytes().to_vec());
+    bytes.append(&mut owner.as_bytes().to_vec());
+
+    bytes
+}
+
+pub(crate) fn get_all_delegations_paged<T>(
+    bucket: &ReadonlyBucket<T>,
+    start_after: &Option<Vec<u8>>,
+    limit: usize,
+) -> StdResult<PagedAllDelegationsResponse<T>>
+where
+    T: Serialize + DeserializeOwned,
+{
+    let delegations = bucket
+        .range(start_after.as_deref(), None, Order::Ascending)
+        .filter(|res| res.is_ok())
+        .take(limit)
+        .map(|res| {
+            res.map(|entry| {
+                let (owner, identity) = extract_identity_and_owner(entry.0).expect("Invalid node identity or address used as key in bucket. The storage is corrupted!");
+                UnpackedDelegation::new(owner, identity, entry.1)
+            })
+        })
+        .collect::<StdResult<Vec<UnpackedDelegation<T>>>>()?;
+
+    let start_next_after = if let Some(Ok(last)) = bucket
+        .range(start_after.as_deref(), None, Order::Ascending)
+        .filter(|res| res.is_ok())
+        .take(limit)
+        .last()
+    {
+        Some(last.0)
+    } else {
+        None
+    };
+
+    Ok(PagedAllDelegationsResponse::new(
+        delegations,
+        start_next_after,
+    ))
+}
+
+pub struct Delegations<'a, T: Clone + Serialize + DeserializeOwned> {
+    delegations_bucket: ReadonlyBucket<'a, T>,
+    curr_delegations: Vec<UnpackedDelegation<T>>,
+    curr_index: usize,
+    start_after: Option<Vec<u8>>,
+    last_page: bool,
+}
+
+#[cfg(test)]
+impl<'a, T: Clone + Serialize + DeserializeOwned> Delegations<'a, T> {
+    pub fn new(delegations_bucket: ReadonlyBucket<'a, T>) -> Self {
+        Delegations {
+            delegations_bucket,
+            curr_delegations: vec![],
+            curr_index: OLD_DELEGATIONS_CHUNK_SIZE,
+            start_after: None,
+            last_page: false,
+        }
+    }
+}
+
+impl<'a, T: Clone + Serialize + DeserializeOwned> Iterator for Delegations<'a, T> {
+    type Item = UnpackedDelegation<T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.curr_index == OLD_DELEGATIONS_CHUNK_SIZE && !self.last_page {
+            self.start_after = self.start_after.clone().map(|mut v: Vec<u8>| {
+                v.push(0);
+                v
+            });
+            let delegations_paged = get_all_delegations_paged(
+                &self.delegations_bucket,
+                &self.start_after,
+                OLD_DELEGATIONS_CHUNK_SIZE,
+            )
+            .ok()?;
+            self.curr_delegations = delegations_paged.delegations;
+            self.curr_index = 0;
+            self.start_after = delegations_paged.start_next_after;
+            if self.start_after.is_none() {
+                self.last_page = true;
+            }
+        }
+        if self.curr_index < self.curr_delegations.len() {
+            let ret = self.curr_delegations[self.curr_index].clone();
+            self.curr_index += 1;
+            Some(ret)
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::queries::tests::store_n_mix_delegations;
+    use crate::storage::{all_mix_delegations_read, mix_delegations};
+    use crate::support::tests::helpers;
+    use cosmwasm_std::testing::mock_dependencies;
+    use mixnet_contract::RawDelegationData;
+
+    #[test]
+    fn delegations_iterator() {
+        let mut deps = helpers::init_contract();
+        let node_identity: IdentityKey = "foo".into();
+
+        store_n_mix_delegations(
+            2 * OLD_DELEGATIONS_CHUNK_SIZE as u32,
+            &mut deps.storage,
+            &node_identity,
+        );
+        let mix_bucket = all_mix_delegations_read::<RawDelegationData>(&deps.storage);
+        let mut delegations = Delegations::new(mix_bucket);
+        assert!(delegations.curr_delegations.is_empty());
+        assert_eq!(delegations.curr_index, OLD_DELEGATIONS_CHUNK_SIZE);
+        delegations.next().unwrap();
+        assert_eq!(
+            delegations.curr_delegations.len(),
+            OLD_DELEGATIONS_CHUNK_SIZE
+        );
+        assert_eq!(delegations.curr_index, 1);
+        for _ in 0..OLD_DELEGATIONS_CHUNK_SIZE {
+            delegations.next().unwrap();
+        }
+        assert_eq!(
+            delegations.curr_delegations.len(),
+            OLD_DELEGATIONS_CHUNK_SIZE
+        );
+        assert_eq!(delegations.curr_index, 1);
+        for _ in 0..OLD_DELEGATIONS_CHUNK_SIZE - 1 {
+            delegations.next().unwrap();
+        }
+        assert!(delegations.next().is_none());
+    }
+
+    #[test]
+    fn identity_and_owner_deserialization() {
+        assert!(extract_identity_and_owner(vec![]).is_err());
+        assert!(extract_identity_and_owner(vec![0]).is_err());
+        let (owner, identity) = extract_identity_and_owner(vec![
+            0, 7, 109, 105, 120, 110, 111, 100, 101, 97, 108, 105, 99, 101,
+        ])
+        .unwrap();
+        assert_eq!(owner, "alice");
+        assert_eq!(identity, "mixnode");
+    }
+
+    #[test]
+    fn identity_and_owner_serialization() {
+        let identity: IdentityKey = "gateway".into();
+        let owner = Addr::unchecked("bob");
+        assert_eq!(
+            vec![0, 7, 103, 97, 116, 101, 119, 97, 121, 98, 111, 98],
+            identity_and_owner_to_bytes(&identity, &owner)
+        );
+    }
+
+    #[test]
+    fn all_mix_delegations() {
+        let mut deps = mock_dependencies(&[]);
+        let node_identity1: IdentityKey = "foo1".into();
+        let delegation_owner1 = Addr::unchecked("bar1");
+        let node_identity2: IdentityKey = "foo2".into();
+        let delegation_owner2 = Addr::unchecked("bar2");
+        let raw_delegation = RawDelegationData::new(1000u128.into(), 42);
+        let mut start_after = None;
+
+        mix_delegations(&mut deps.storage, &node_identity1)
+            .save(delegation_owner1.as_bytes(), &raw_delegation)
+            .unwrap();
+
+        let bucket = all_mix_delegations_read::<RawDelegationData>(&deps.storage);
+        let response =
+            get_all_delegations_paged::<RawDelegationData>(&bucket, &start_after, 10).unwrap();
+        start_after = response.start_next_after;
+        let delegations = response.delegations;
+        assert_eq!(delegations.len(), 1);
+        assert_eq!(
+            delegations[0],
+            UnpackedDelegation::new(
+                delegation_owner1.clone(),
+                node_identity1.clone(),
+                raw_delegation.clone()
+            )
+        );
+
+        mix_delegations(&mut deps.storage, &node_identity2)
+            .save(delegation_owner2.as_bytes(), &raw_delegation)
+            .unwrap();
+
+        let bucket = all_mix_delegations_read::<RawDelegationData>(&deps.storage);
+        let response =
+            get_all_delegations_paged::<RawDelegationData>(&bucket, &start_after, 10).unwrap();
+        start_after = response.start_next_after;
+        let delegations = response.delegations;
+        assert_eq!(delegations.len(), 2);
+        assert_eq!(
+            delegations[1],
+            UnpackedDelegation::new(
+                delegation_owner2.clone(),
+                node_identity2.clone(),
+                raw_delegation.clone()
+            )
+        );
+
+        mix_delegations(&mut deps.storage, &node_identity1).remove(delegation_owner1.as_bytes());
+
+        let bucket = all_mix_delegations_read::<RawDelegationData>(&deps.storage);
+        let response =
+            get_all_delegations_paged::<RawDelegationData>(&bucket, &start_after, 10).unwrap();
+        let delegations = response.delegations;
+        assert_eq!(delegations.len(), 1);
+        assert_eq!(
+            delegations[0],
+            UnpackedDelegation::new(delegation_owner2, node_identity2, raw_delegation.clone()),
+        );
+    }
+}
@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 pub mod contract;
-mod delegations;
-mod error;
-mod gateways;
-mod mixnet_contract_settings;
-mod mixnodes;
-mod rewards;
-mod support;
+pub mod error;
+pub(crate) mod helpers;
+pub mod queries;
+pub mod state;
+pub(crate) mod storage;
+pub mod support;
+pub mod transactions;
@@ -1,7 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub mod models;
-pub mod queries;
-pub mod storage;
-pub mod transactions;
@@ -1,86 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::storage;
-use cosmwasm_std::{Deps, StdResult};
-use mixnet_contract::{ContractStateParams, MixnetContractVersion, RewardingIntervalResponse};
-
-pub(crate) fn query_contract_settings_params(deps: Deps) -> StdResult<ContractStateParams> {
-    storage::CONTRACT_STATE
-        .load(deps.storage)
-        .map(|settings| settings.params)
-}
-
-pub(crate) fn query_rewarding_interval(deps: Deps) -> StdResult<RewardingIntervalResponse> {
-    let state = storage::CONTRACT_STATE.load(deps.storage)?;
-
-    Ok(RewardingIntervalResponse {
-        current_rewarding_interval_starting_block: state.rewarding_interval_starting_block,
-        current_rewarding_interval_nonce: state.latest_rewarding_interval_nonce,
-        rewarding_in_progress: state.rewarding_in_progress,
-    })
-}
-
-pub(crate) fn query_contract_version() -> MixnetContractVersion {
-    // as per docs
-    // env! macro will expand to the value of the named environment variable at
-    // compile time, yielding an expression of type `&'static str`
-    MixnetContractVersion {
-        build_timestamp: env!("VERGEN_BUILD_TIMESTAMP").to_string(),
-        build_version: env!("VERGEN_BUILD_SEMVER").to_string(),
-        commit_sha: env!("VERGEN_GIT_SHA").to_string(),
-        commit_timestamp: env!("VERGEN_GIT_COMMIT_TIMESTAMP").to_string(),
-        commit_branch: env!("VERGEN_GIT_BRANCH").to_string(),
-        rustc_version: env!("VERGEN_RUSTC_SEMVER").to_string(),
-    }
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::*;
-    use crate::mixnet_contract_settings::models::ContractState;
-    use crate::support::tests::test_helpers;
-
-    use cosmwasm_std::Addr;
-
-    #[test]
-    fn query_for_contract_settings_works() {
-        let mut deps = test_helpers::init_contract();
-
-        let dummy_state = ContractState {
-            owner: Addr::unchecked("someowner"),
-            rewarding_validator_address: Addr::unchecked("monitor"),
-            params: ContractStateParams {
-                minimum_mixnode_pledge: 123u128.into(),
-                minimum_gateway_pledge: 456u128.into(),
-                mixnode_rewarded_set_size: 1000,
-                mixnode_active_set_size: 500,
-                active_set_work_factor: 10,
-            },
-            rewarding_interval_starting_block: 123,
-            latest_rewarding_interval_nonce: 0,
-            rewarding_in_progress: false,
-        };
-
-        storage::CONTRACT_STATE
-            .save(deps.as_mut().storage, &dummy_state)
-            .unwrap();
-
-        assert_eq!(
-            dummy_state.params,
-            query_contract_settings_params(deps.as_ref()).unwrap()
-        )
-    }
-
-    #[test]
-    fn query_for_contract_version_works() {
-        // this basically means _something_ was grabbed from the environment at compilation time
-        let version = query_contract_version();
-        assert!(!version.build_timestamp.is_empty());
-        assert!(!version.build_version.is_empty());
-        assert!(!version.commit_sha.is_empty());
-        assert!(!version.commit_timestamp.is_empty());
-        assert!(!version.commit_branch.is_empty());
-        assert!(!version.rustc_version.is_empty());
-    }
-}
@@ -1,60 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::mixnet_contract_settings::models::ContractState;
-use cosmwasm_std::StdResult;
-use cosmwasm_std::Storage;
-use cw_storage_plus::Item;
-use mixnet_contract::Layer;
-use mixnet_contract::LayerDistribution;
-
-pub(crate) const CONTRACT_STATE: Item<ContractState> = Item::new("config");
-pub(crate) const LAYERS: Item<LayerDistribution> = Item::new("layers");
-
-pub fn increment_layer_count(storage: &mut dyn Storage, layer: Layer) -> StdResult<()> {
-    LAYERS
-        .update(storage, |mut distribution| {
-            match layer {
-                Layer::Gateway => distribution.gateways += 1,
-                Layer::One => distribution.layer1 += 1,
-                Layer::Two => distribution.layer2 += 1,
-                Layer::Three => distribution.layer3 += 1,
-            }
-            Ok(distribution)
-        })
-        .map(|_| ())
-}
-
-pub fn decrement_layer_count(storage: &mut dyn Storage, layer: Layer) -> StdResult<()> {
-    LAYERS
-        .update(storage, |mut distribution| {
-            match layer {
-                Layer::Gateway => {
-                    distribution.gateways = distribution
-                        .gateways
-                        .checked_sub(1)
-                        .expect("tried to subtract from unsigned zero!")
-                }
-                Layer::One => {
-                    distribution.layer1 = distribution
-                        .layer1
-                        .checked_sub(1)
-                        .expect("tried to subtract from unsigned zero!")
-                }
-                Layer::Two => {
-                    distribution.layer2 = distribution
-                        .layer2
-                        .checked_sub(1)
-                        .expect("tried to subtract from unsigned zero!")
-                }
-                Layer::Three => {
-                    distribution.layer3 = distribution
-                        .layer3
-                        .checked_sub(1)
-                        .expect("tried to subtract from unsigned zero!")
-                }
-            }
-            Ok(distribution)
-        })
-        .map(|_| ())
-}
@@ -1,110 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::storage;
-use crate::error::ContractError;
-use cosmwasm_std::DepsMut;
-use cosmwasm_std::MessageInfo;
-use cosmwasm_std::Response;
-use mixnet_contract::ContractStateParams;
-
-pub(crate) fn try_update_contract_settings(
-    deps: DepsMut,
-    info: MessageInfo,
-    params: ContractStateParams,
-) -> Result<Response, ContractError> {
-    let mut state = storage::CONTRACT_STATE.load(deps.storage)?;
-
-    // check if this is executed by the owner, if not reject the transaction
-    if info.sender != state.owner {
-        return Err(ContractError::Unauthorized);
-    }
-
-    if params.mixnode_rewarded_set_size == 0 {
-        return Err(ContractError::ZeroRewardedSet);
-    }
-
-    if params.mixnode_active_set_size == 0 {
-        return Err(ContractError::ZeroActiveSet);
-    }
-
-    // note: rewarded_set = active_set + idle_set
-    // hence rewarded set must always be bigger than (or equal to) the active set
-    if params.mixnode_rewarded_set_size < params.mixnode_active_set_size {
-        return Err(ContractError::InvalidActiveSetSize);
-    }
-
-    state.params = params;
-    storage::CONTRACT_STATE.save(deps.storage, &state)?;
-
-    Ok(Response::default())
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-    use crate::contract::{INITIAL_GATEWAY_PLEDGE, INITIAL_MIXNODE_PLEDGE};
-    use crate::error::ContractError;
-    use crate::mixnet_contract_settings::transactions::try_update_contract_settings;
-    use crate::support::tests::test_helpers;
-    use cosmwasm_std::testing::mock_info;
-    use cosmwasm_std::Response;
-    use mixnet_contract::ContractStateParams;
-
-    #[test]
-    fn updating_contract_settings() {
-        let mut deps = test_helpers::init_contract();
-
-        let new_params = ContractStateParams {
-            minimum_mixnode_pledge: INITIAL_MIXNODE_PLEDGE,
-            minimum_gateway_pledge: INITIAL_GATEWAY_PLEDGE,
-            mixnode_rewarded_set_size: 100,
-            mixnode_active_set_size: 50,
-            active_set_work_factor: 10,
-        };
-
-        // sanity check to ensure new_params are different than the default ones
-        assert_ne!(
-            new_params,
-            storage::CONTRACT_STATE
-                .load(deps.as_ref().storage)
-                .unwrap()
-                .params
-        );
-
-        // cannot be updated from non-owner account
-        let info = mock_info("not-the-creator", &[]);
-        let res = try_update_contract_settings(deps.as_mut(), info, new_params.clone());
-        assert_eq!(res, Err(ContractError::Unauthorized));
-
-        // but works fine from the creator account
-        let info = mock_info("creator", &[]);
-        let res = try_update_contract_settings(deps.as_mut(), info, new_params.clone());
-        assert_eq!(res, Ok(Response::default()));
-
-        // and the state is actually updated
-        let current_state = storage::CONTRACT_STATE.load(deps.as_ref().storage).unwrap();
-        assert_eq!(current_state.params, new_params);
-
-        // error is thrown if rewarded set is smaller than the active set
-        let info = mock_info("creator", &[]);
-        let mut new_params = current_state.params.clone();
-        new_params.mixnode_rewarded_set_size = new_params.mixnode_active_set_size - 1;
-        let res = try_update_contract_settings(deps.as_mut(), info, new_params.clone());
-        assert_eq!(Err(ContractError::InvalidActiveSetSize), res);
-
-        // error is thrown for 0 size rewarded set
-        let info = mock_info("creator", &[]);
-        let mut new_params = current_state.params.clone();
-        new_params.mixnode_rewarded_set_size = 0;
-        let res = try_update_contract_settings(deps.as_mut(), info, new_params.clone());
-        assert_eq!(Err(ContractError::ZeroRewardedSet), res);
-
-        // error is thrown for 0 size active set
-        let info = mock_info("creator", &[]);
-        let mut new_params = current_state.params.clone();
-        new_params.mixnode_active_set_size = 0;
-        let res = try_update_contract_settings(deps.as_mut(), info, new_params.clone());
-        assert_eq!(Err(ContractError::ZeroActiveSet), res);
-    }
-}
@@ -1,228 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use super::storage;
-use cosmwasm_std::{Deps, Order, StdResult};
-use cw_storage_plus::Bound;
-use mixnet_contract::{IdentityKey, MixNodeBond, MixOwnershipResponse, PagedMixnodeResponse};
-
-pub fn query_mixnodes_paged(
-    deps: Deps,
-    start_after: Option<IdentityKey>,
-    limit: Option<u32>,
-) -> StdResult<PagedMixnodeResponse> {
-    let limit = limit
-        .unwrap_or(storage::BOND_PAGE_DEFAULT_LIMIT)
-        .min(storage::BOND_PAGE_MAX_LIMIT) as usize;
-
-    let start = start_after.map(Bound::exclusive);
-
-    let nodes = storage::mixnodes()
-        .range(deps.storage, start, None, Order::Ascending)
-        .take(limit)
-        .map(|res| res.map(|item| item.1))
-        .map(|stored_bond| {
-            // I really don't like this additional read per entry, but I don't see an obvious way to remove it
-            stored_bond.map(|stored_bond| {
-                let total_delegation =
-                    storage::TOTAL_DELEGATION.load(deps.storage, stored_bond.identity());
-                total_delegation
-                    .map(|total_delegation| stored_bond.attach_delegation(total_delegation))
-            })
-        })
-        .collect::<StdResult<StdResult<Vec<MixNodeBond>>>>()??;
-
-    let start_next_after = nodes.last().map(|node| node.identity().clone());
-
-    Ok(PagedMixnodeResponse::new(nodes, limit, start_next_after))
-}
-
-pub fn query_owns_mixnode(deps: Deps, address: String) -> StdResult<MixOwnershipResponse> {
-    let validated_addr = deps.api.addr_validate(&address)?;
-    let stored_bond = storage::mixnodes()
-        .idx
-        .owner
-        .item(deps.storage, validated_addr.clone())?
-        .map(|record| record.1);
-
-    let mixnode = match stored_bond {
-        None => None,
-        Some(bond) => {
-            let total_delegation =
-                storage::TOTAL_DELEGATION.may_load(deps.storage, bond.identity())?;
-            Some(bond.attach_delegation(total_delegation.unwrap_or_default()))
-        }
-    };
-
-    Ok(MixOwnershipResponse {
-        address: validated_addr,
-        mixnode,
-    })
-}
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::storage;
-    use super::*;
-    use crate::contract::execute;
-    use crate::mixnodes::storage::BOND_PAGE_DEFAULT_LIMIT;
-    use crate::support::tests::test_helpers;
-    use cosmwasm_std::testing::{mock_env, mock_info};
-
-    #[test]
-    fn mixnodes_empty_on_init() {
-        let deps = test_helpers::init_contract();
-        let response = query_mixnodes_paged(deps.as_ref(), None, Option::from(2)).unwrap();
-        assert_eq!(0, response.nodes.len());
-    }
-
-    #[test]
-    fn mixnodes_paged_retrieval_obeys_limits() {
-        let mut deps = test_helpers::init_contract();
-        let limit = 2;
-        for n in 0..1000 {
-            let key = format!("bond{}", n);
-            test_helpers::add_mixnode(&key, test_helpers::good_mixnode_bond(), deps.as_mut());
-        }
-
-        let page1 = query_mixnodes_paged(deps.as_ref(), None, Option::from(limit)).unwrap();
-        assert_eq!(limit, page1.nodes.len() as u32);
-    }
-
-    #[test]
-    fn mixnodes_paged_retrieval_has_default_limit() {
-        let mut deps = test_helpers::init_contract();
-        for n in 0..1000 {
-            let key = format!("bond{}", n);
-            test_helpers::add_mixnode(&key, test_helpers::good_mixnode_bond(), deps.as_mut());
-        }
-
-        // query without explicitly setting a limit
-        let page1 = query_mixnodes_paged(deps.as_ref(), None, None).unwrap();
-
-        assert_eq!(BOND_PAGE_DEFAULT_LIMIT, page1.nodes.len() as u32);
-    }
-
-    #[test]
-    fn mixnodes_paged_retrieval_has_max_limit() {
-        let mut deps = test_helpers::init_contract();
-        for n in 0..1000 {
-            let key = format!("bond{}", n);
-            test_helpers::add_mixnode(&key, test_helpers::good_mixnode_bond(), deps.as_mut());
-        }
-
-        // query with a crazily high limit in an attempt to use too many resources
-        let crazy_limit = 1000;
-        let page1 = query_mixnodes_paged(deps.as_ref(), None, Option::from(crazy_limit)).unwrap();
-
-        // we default to a decent sized upper bound instead
-        let expected_limit = storage::BOND_PAGE_MAX_LIMIT;
-        assert_eq!(expected_limit, page1.nodes.len() as u32);
-    }
-
-    #[test]
-    fn pagination_works() {
-        // prepare 4 messages and identities that are sorted by the generated identities
-        // (because we query them in an ascended manner)
-        let mut exec_data = (0..4)
-            .map(|i| {
-                let sender = format!("nym-addr{}", i);
-                let (msg, identity) = test_helpers::valid_bond_mixnode_msg(&sender);
-                (msg, (sender, identity))
-            })
-            .collect::<Vec<_>>();
-        exec_data.sort_by(|(_, (_, id1)), (_, (_, id2))| id1.cmp(id2));
-        let (messages, sender_identities): (Vec<_>, Vec<_>) = exec_data.into_iter().unzip();
-
-        let mut deps = test_helpers::init_contract();
-
-        let info = mock_info(
-            &sender_identities[0].0.clone(),
-            &test_helpers::good_mixnode_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[0].clone()).unwrap();
-
-        let per_page = 2;
-        let page1 = query_mixnodes_paged(deps.as_ref(), None, Option::from(per_page)).unwrap();
-
-        // page should have 1 result on it
-        assert_eq!(1, page1.nodes.len());
-
-        // save another
-        let info = mock_info(
-            &sender_identities[1].0.clone(),
-            &test_helpers::good_mixnode_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[1].clone()).unwrap();
-
-        // page1 should have 2 results on it
-        let page1 = query_mixnodes_paged(deps.as_ref(), None, Option::from(per_page)).unwrap();
-        assert_eq!(2, page1.nodes.len());
-
-        let info = mock_info(
-            &sender_identities[2].0.clone(),
-            &test_helpers::good_mixnode_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[2].clone()).unwrap();
-
-        // page1 still has 2 results
-        let page1 = query_mixnodes_paged(deps.as_ref(), None, Option::from(per_page)).unwrap();
-        assert_eq!(2, page1.nodes.len());
-
-        // retrieving the next page should start after the last key on this page
-        let start_after = page1.start_next_after.unwrap();
-        let page2 = query_mixnodes_paged(
-            deps.as_ref(),
-            Option::from(start_after.clone()),
-            Option::from(per_page),
-        )
-        .unwrap();
-
-        assert_eq!(1, page2.nodes.len());
-
-        // save another one
-        let info = mock_info(
-            &sender_identities[3].0.clone(),
-            &test_helpers::good_mixnode_bond(),
-        );
-        execute(deps.as_mut(), mock_env(), info, messages[3].clone()).unwrap();
-
-        let page2 = query_mixnodes_paged(
-            deps.as_ref(),
-            Option::from(start_after),
-            Option::from(per_page),
-        )
-        .unwrap();
-
-        // now we have 2 pages, with 2 results on the second page
-        assert_eq!(2, page2.nodes.len());
-    }
-
-    #[test]
-    fn query_for_mixnode_owner_works() {
-        let mut deps = test_helpers::init_contract();
-
-        // "fred" does not own a mixnode if there are no mixnodes
-        let res = query_owns_mixnode(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.mixnode.is_none());
-
-        // mixnode was added to "bob", "fred" still does not own one
-        test_helpers::add_mixnode("bob", test_helpers::good_mixnode_bond(), deps.as_mut());
-
-        let res = query_owns_mixnode(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.mixnode.is_none());
-
-        // "fred" now owns a mixnode!
-        test_helpers::add_mixnode("fred", test_helpers::good_mixnode_bond(), deps.as_mut());
-
-        let res = query_owns_mixnode(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.mixnode.is_some());
-
-        // but after unbonding it, he doesn't own one anymore
-        crate::mixnodes::transactions::try_remove_mixnode(deps.as_mut(), mock_info("fred", &[]))
-            .unwrap();
-
-        let res = query_owns_mixnode(deps.as_ref(), "fred".to_string()).unwrap();
-        assert!(res.mixnode.is_none());
-    }
-}
--- a/Show More
+++ b/Show More