signpost - unfinished just parking changes

1st commit
2021-11-22 15:08:46 +00:00 · 2021-11-17 11:55:06 +00:00
389 changed files with 30743 additions and 37787 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:
@@ -24,7 +24,6 @@ v6-topology.json
 /explorer/downloads/topology.json
 /explorer/public/downloads/mixmining.json
 /explorer/public/downloads/topology.json
-/nym-wallet/dist/*
 /clients/validator/examples/nym-driver-example/current-contract.txt
 validator-api/v4.json
 validator-api/v6.json
@@ -34,5 +33,4 @@ contracts/mixnet/code_id
 contracts/mixnet/Justfile
 contracts/mixnet/Makefile
 validator-config
-*.patch
-validator-api-config.toml
+*.patch
@@ -420,10 +420,7 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba3569f383e8f1598449f1a423e72e99569137b47740b1da11ef19af3d5c3223"
 dependencies = [
- "lazy_static",
 "memchr",
- "regex-automata",
- "serde",
 ]

 [[package]]
@@ -507,15 +504,6 @@ dependencies = [
 "system-deps 3.2.0",
 ]

-[[package]]
-name = "cast"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c24dab4283a142afa2fdca129b80ad2c6284e073930f964c3a1293c225ee39a"
-dependencies = [
- "rustc_version 0.4.0",
-]
-
 [[package]]
 name = "cc"
 version = "1.0.70"
@@ -679,11 +667,30 @@ dependencies = [
 name = "coconut-interface"
 version = "0.1.0"
 dependencies = [
+ "coconut-rs",
 "getset",
- "nymcoconut",
 "serde",
 ]

+[[package]]
+name = "coconut-rs"
+version = "0.5.0"
+source = "git+https://github.com/nymtech/coconut.git?branch=0.5.0#a1b72d51aa2a67b73b9f58d707030ae6dc70af7f"
+dependencies = [
+ "bls12_381",
+ "bs58",
+ "digest 0.9.0",
+ "ff",
+ "getrandom 0.2.3",
+ "group",
+ "itertools",
+ "rand 0.8.4",
+ "serde",
+ "serde_derive",
+ "sha2",
+ "thiserror",
+]
+
 [[package]]
 name = "colored"
 version = "2.0.0"
@@ -868,7 +875,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 +886,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 +908,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 +920,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",
@@ -980,42 +986,6 @@ dependencies = [
 "validator-client",
 ]

-[[package]]
-name = "criterion"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1604dafd25fba2fe2d5895a9da139f8dc9b319a5fe5354ca137cbbce4e178d10"
-dependencies = [
- "atty",
- "cast",
- "clap",
- "criterion-plot",
- "csv",
- "itertools",
- "lazy_static",
- "num-traits",
- "oorandom",
- "plotters",
- "rayon",
- "regex",
- "serde",
- "serde_cbor",
- "serde_derive",
- "serde_json",
- "tinytemplate",
- "walkdir",
-]
-
-[[package]]
-name = "criterion-plot"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d00996de9f2f7559f7f4dc286073197f83e92256a59ed395f9aac01fe717da57"
-dependencies = [
- "cast",
- "itertools",
-]
-
 [[package]]
 name = "crossbeam-channel"
 version = "0.5.1"
@@ -1155,28 +1125,6 @@ dependencies = [
 "syn",
 ]

-[[package]]
-name = "csv"
-version = "1.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1"
-dependencies = [
- "bstr",
- "csv-core",
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "csv-core"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
-dependencies = [
- "memchr",
-]
-
 [[package]]
 name = "ct-logs"
 version = "0.8.0"
@@ -1208,17 +1156,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 +1551,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"
@@ -1823,7 +1740,6 @@ dependencies = [
 "az",
 "bytemuck",
 "half",
- "serde",
 "typenum",
 ]

@@ -2305,19 +2221,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 +2993,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 +3010,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"
@@ -3585,7 +3464,6 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
- "network-defaults",
 "nymsphinx",
 "pemstore",
 "pretty_env_logger",
@@ -3598,7 +3476,6 @@ dependencies = [
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 "websocket-requests",
 ]
@@ -3632,10 +3509,8 @@ name = "nym-gateway"
 version = "0.11.0"
 dependencies = [
 "bip39",
- "bs58",
 "clap",
 "coconut-interface",
- "colored",
 "config",
 "credentials",
 "crypto",
@@ -3657,7 +3532,6 @@ dependencies = [
 "rand 0.7.3",
 "serde",
 "sqlx",
- "subtle-encoding",
 "thiserror",
 "tokio",
 "tokio-stream",
@@ -3665,7 +3539,6 @@ dependencies = [
 "tokio-util",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 "web3",
 ]
@@ -3694,14 +3567,12 @@ dependencies = [
 "rocket",
 "serde",
 "serial_test",
- "subtle-encoding",
 "tokio",
 "tokio-util",
 "toml",
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 ]

@@ -3742,7 +3613,6 @@ dependencies = [
 "gateway-client",
 "gateway-requests",
 "log",
- "network-defaults",
 "nymsphinx",
 "ordered-buffer",
 "pemstore",
@@ -3757,7 +3627,6 @@ dependencies = [
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 ]

@@ -3798,31 +3667,9 @@ dependencies = [
 "topology",
 "url",
 "validator-client",
- "vergen",
 "version-checker",
 ]

-[[package]]
-name = "nymcoconut"
-version = "0.5.0"
-dependencies = [
- "bincode",
- "bls12_381",
- "bs58",
- "criterion",
- "digest 0.9.0",
- "doc-comment",
- "ff",
- "getrandom 0.2.3",
- "group",
- "itertools",
- "rand 0.8.4",
- "serde",
- "serde_derive",
- "sha2",
- "thiserror",
-]
-
 [[package]]
 name = "nymsphinx"
 version = "0.1.0"
@@ -3972,11 +3819,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",
@@ -3988,12 +3834,6 @@ version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"

-[[package]]
-name = "oorandom"
-version = "11.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
-
 [[package]]
 name = "opaque-debug"
 version = "0.2.3"
@@ -4424,34 +4264,6 @@ version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7c9b1041b4387893b91ee6746cddfc28516aff326a3519fb2adf820932c5e6cb"

-[[package]]
-name = "plotters"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a3fd9ec30b9749ce28cd91f255d569591cdf937fe280c312143e3c4bad6f2a"
-dependencies = [
- "num-traits",
- "plotters-backend",
- "plotters-svg",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "plotters-backend"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d88417318da0eaf0fdcdb51a0ee6c3bed624333bff8f946733049380be67ac1c"
-
-[[package]]
-name = "plotters-svg"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521fa9638fa597e1dc53e9412a4f9cefb01187ee1f7413076f9e6749e2885ba9"
-dependencies = [
- "plotters-backend",
-]
-
 [[package]]
 name = "pmutil"
 version = "0.5.3"
@@ -4998,12 +4810,6 @@ dependencies = [
 "regex-syntax",
 ]

-[[package]]
-name = "regex-automata"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-
 [[package]]
 name = "regex-syntax"
 version = "0.6.25"
@@ -5213,12 +5019,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 +5033,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",
@@ -5287,15 +5091,6 @@ dependencies = [
 "semver 0.11.0",
 ]

-[[package]]
-name = "rustc_version"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
-dependencies = [
- "semver 1.0.4",
-]
-
 [[package]]
 name = "rustls"
 version = "0.19.1"
@@ -5535,16 +5330,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "serde_cbor"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
-dependencies = [
- "half",
- "serde",
-]
-
 [[package]]
 name = "serde_derive"
 version = "1.0.130"
@@ -6823,16 +6608,6 @@ dependencies = [
 "crunchy",
 ]

-[[package]]
-name = "tinytemplate"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
-dependencies = [
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "tokio"
 version = "1.12.0"
@@ -7210,7 +6985,6 @@ dependencies = [
 "thiserror",
 "ts-rs",
 "url",
- "vesting-contract",
 ]

 [[package]]
@@ -7225,23 +6999,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 +7024,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"
@@ -30,7 +30,6 @@ members = [
    "common/mixnode-common",
    "common/network-defaults",
    "common/nonexhaustive-delayqueue",
-    "common/nymcoconut",
    "common/nymsphinx",
    "common/nymsphinx/acknowledgements",
    "common/nymsphinx/addressing",
@@ -62,7 +61,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)
@@ -24,7 +24,7 @@ dirs = "3.0" # for determining default store directories in config
 dotenv = "0.15.0" # for obtaining environmental variables (only used for RUST_LOG for time being)
 log = "0.4" # self explanatory
 pretty_env_logger = "0.4" # for formatting log messages
-rand = { version = "0.7.3", features = ["wasm-bindgen"] } # rng-related traits + some rng implementation to use
+rand = {version = "0.7.3", features = ["wasm-bindgen"]} # rng-related traits + some rng implementation to use
 serde = { version = "1.0.104", features = ["derive"] } # for config serialization/deserialization
 sled = "0.34" # for storage of replySURB decryption keys
 tokio = { version = "1.4", features = ["rt-multi-thread", "net", "signal"] } # async runtime
@@ -44,13 +44,9 @@ topology = { path = "../../common/topology" }
 websocket-requests = { path = "websocket-requests" }
 validator-client = { path = "../../common/client-libs/validator-client" }
 version-checker = { path = "../../common/version-checker" }
-network-defaults = { path = "../../common/network-defaults" }

 [features]
 coconut = ["coconut-interface", "credentials", "gateway-requests/coconut", "gateway-client/coconut"]

 [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,6 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::client::config::{Config, SocketType};
+use crate::websocket;
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
@@ -22,7 +24,6 @@ use client_core::client::topology_control::{
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
    MixnetMessageSender,
@@ -34,8 +35,7 @@ use nymsphinx::anonymous_replies::ReplySurb;
 use nymsphinx::receiver::ReconstructedMessage;
 use tokio::runtime::Runtime;

-use crate::client::config::{Config, SocketType};
-use crate::websocket;
+use gateway_client::bandwidth::BandwidthController;

 pub(crate) mod config;

@@ -1,23 +1,15 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::client::config::Config;
+use crate::commands::override_config;
 use clap::{App, Arg, ArgMatches};
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-#[cfg(feature = "coconut")]
-use coconut_interface::{hash_to_scalar, Credential, Parameters};
 use config::NymConfig;
-#[cfg(feature = "coconut")]
-use credentials::coconut::bandwidth::{
-    obtain_signature, prepare_for_spending, BandwidthVoucherAttributes, TOTAL_ATTRIBUTES,
-};
-#[cfg(feature = "coconut")]
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
-#[cfg(feature = "coconut")]
-use network_defaults::BANDWIDTH_VALUE;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::rngs::OsRng;
@@ -29,9 +21,6 @@ use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;

-use crate::client::config::Config;
-use crate::commands::override_config;
-
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    let app = App::new("init")
        .about("Initialise a Nym client. Do this first!")
@@ -47,9 +36,9 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .takes_value(true)
        )
        .arg(Arg::with_name("validators")
-                 .long("validators")
-                 .help("Comma separated list of rest endpoints of the validators")
-                 .takes_value(true),
+                .long("validators")
+                .help("Comma separated list of rest endpoints of the validators")
+                .takes_value(true),
        )
        .arg(Arg::with_name("disable-socket")
            .long("disable-socket")
@@ -82,36 +71,6 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    app
 }

-// this behaviour should definitely be changed, we shouldn't
-// need to get bandwidth credential for registration
-#[cfg(feature = "coconut")]
-async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
-    let verification_key = obtain_aggregate_verification_key(validators)
-        .await
-        .expect("could not obtain aggregate verification key of validators");
-
-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-    let bandwidth_credential_attributes = BandwidthVoucherAttributes {
-        serial_number: params.random_scalar(),
-        binding_number: params.random_scalar(),
-        voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
-        voucher_info: hash_to_scalar(String::from("BandwidthVoucher").as_bytes()),
-    };
-
-    let bandwidth_credential =
-        obtain_signature(&params, &bandwidth_credential_attributes, validators)
-            .await
-            .expect("could not obtain bandwidth credential");
-
-    prepare_for_spending(
-        raw_identity,
-        &bandwidth_credential,
-        &bandwidth_credential_attributes,
-        &verification_key,
-    )
-    .expect("could not prepare out bandwidth credential for spending")
-}
-
 async fn register_with_gateway(
    gateway: &gateway::Node,
    our_identity: Arc<identity::KeyPair>,
@@ -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")
    )
 }

@@ -1,8 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-pub(crate) use handler::Handler;
-pub(crate) use listener::Listener;
-
 pub(crate) mod handler;
 pub(crate) mod listener;
+
+pub(crate) use handler::Handler;
+pub(crate) use listener::Listener;
@@ -32,17 +32,13 @@ crypto = { path = "../../common/crypto" }
 gateway-client = { path = "../../common/client-libs/gateway-client" }
 gateway-requests = { path = "../../gateway/gateway-requests" }
 nymsphinx = { path = "../../common/nymsphinx" }
-ordered-buffer = { path = "../../common/socks5/ordered-buffer" }
+ordered-buffer = {path = "../../common/socks5/ordered-buffer"}
 socks5-requests = { path = "../../common/socks5/requests" }
 topology = { path = "../../common/topology" }
 pemstore = { path = "../../common/pemstore" }
 proxy-helpers = { path = "../../common/socks5/proxy-helpers" }
 validator-client = { path = "../../common/client-libs/validator-client" }
 version-checker = { path = "../../common/version-checker" }
-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,6 +1,11 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::client::config::Config;
+use crate::socks::{
+    authentication::{AuthenticationMethods, Authenticator, User},
+    server::SphinxSocksServer,
+};
 use client_core::client::cover_traffic_stream::LoopCoverTrafficStream;
 use client_core::client::inbound_messages::{
    InputMessage, InputMessageReceiver, InputMessageSender,
@@ -20,7 +25,6 @@ use client_core::client::topology_control::{
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
 use crypto::asymmetric::identity;
 use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
 use gateway_client::{
    AcknowledgementReceiver, AcknowledgementSender, GatewayClient, MixnetMessageReceiver,
    MixnetMessageSender,
@@ -30,11 +34,7 @@ use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use tokio::runtime::Runtime;

-use crate::client::config::Config;
-use crate::socks::{
-    authentication::{AuthenticationMethods, Authenticator, User},
-    server::SphinxSocksServer,
-};
+use gateway_client::bandwidth::BandwidthController;

 pub(crate) mod config;

@@ -1,23 +1,15 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::client::config::Config;
+use crate::commands::override_config;
 use clap::{App, Arg, ArgMatches};
 use client_core::client::key_manager::KeyManager;
 use client_core::config::persistence::key_pathfinder::ClientKeyPathfinder;
-#[cfg(feature = "coconut")]
-use coconut_interface::{hash_to_scalar, Credential, Parameters};
 use config::NymConfig;
-#[cfg(feature = "coconut")]
-use credentials::coconut::bandwidth::{
-    obtain_signature, prepare_for_spending, BandwidthVoucherAttributes, TOTAL_ATTRIBUTES,
-};
-#[cfg(feature = "coconut")]
-use credentials::obtain_aggregate_verification_key;
 use crypto::asymmetric::{encryption, identity};
 use gateway_client::GatewayClient;
 use gateway_requests::registration::handshake::SharedKeys;
-#[cfg(feature = "coconut")]
-use network_defaults::BANDWIDTH_VALUE;
 use nymsphinx::addressing::clients::Recipient;
 use nymsphinx::addressing::nodes::NodeIdentity;
 use rand::{prelude::SliceRandom, rngs::OsRng, thread_rng};
@@ -27,9 +19,6 @@ use std::time::Duration;
 use topology::{filter::VersionFilterable, gateway};
 use url::Url;

-use crate::client::config::Config;
-use crate::commands::override_config;
-
 pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    let app = App::new("init")
        .about("Initialise a Nym client. Do this first!")
@@ -51,9 +40,9 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
            .takes_value(true)
        )
        .arg(Arg::with_name("validators")
-                 .long("validators")
-                 .help("Comma separated list of rest endpoints of the validators")
-                 .takes_value(true),
+                .long("validators")
+                .help("Comma separated list of rest endpoints of the validators")
+                .takes_value(true),
        )
        .arg(Arg::with_name("port")
            .short("p")
@@ -82,36 +71,6 @@ pub fn command_args<'a, 'b>() -> clap::App<'a, 'b> {
    app
 }

-// this behaviour should definitely be changed, we shouldn't
-// need to get bandwidth credential for registration
-#[cfg(feature = "coconut")]
-async fn _prepare_temporary_credential(validators: &[Url], raw_identity: &[u8]) -> Credential {
-    let verification_key = obtain_aggregate_verification_key(validators)
-        .await
-        .expect("could not obtain aggregate verification key of validators");
-
-    let params = Parameters::new(TOTAL_ATTRIBUTES).unwrap();
-    let bandwidth_credential_attributes = BandwidthVoucherAttributes {
-        serial_number: params.random_scalar(),
-        binding_number: params.random_scalar(),
-        voucher_value: hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
-        voucher_info: hash_to_scalar("BandwidthVoucher"),
-    };
-
-    let bandwidth_credential =
-        obtain_signature(&params, &bandwidth_credential_attributes, validators)
-            .await
-            .expect("could not obtain bandwidth credential");
-
-    prepare_for_spending(
-        raw_identity,
-        &bandwidth_credential,
-        &bandwidth_credential_attributes,
-        &verification_key,
-    )
-    .expect("could not prepare out bandwidth credential for spending")
-}
-
 async fn register_with_gateway(
    gateway: &gateway::Node,
    our_identity: Arc<identity::KeyPair>,
@@ -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")
    )
 }

@@ -3,24 +3,21 @@
  windows_subsystem = "windows"
 )]

-use std::sync::Arc;
-
-use tokio::sync::RwLock;
-use url::Url;
-
 use coconut_interface::{
  self, hash_to_scalar, Attribute, Credential, Parameters, Signature, Theta, VerificationKey,
 };
 use credentials::{obtain_aggregate_signature, obtain_aggregate_verification_key};
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use url::Url;

 struct State {
  signatures: Vec<Signature>,
  n_attributes: u32,
  params: Parameters,
-  serial_number: Attribute,
-  binding_number: Attribute,
-  voucher_value: Attribute,
-  voucher_info: Attribute,
+  public_attributes_bytes: Vec<Vec<u8>>,
+  public_attributes: Vec<Attribute>,
+  private_attributes: Vec<Attribute>,
  aggregated_verification_key: Option<VerificationKey>,
 }

@@ -40,10 +37,9 @@ impl State {
      signatures: Vec::new(),
      n_attributes,
      params,
-      serial_number: private_attributes[0],
-      binding_number: private_attributes[1],
-      voucher_value: public_attributes[0],
-      voucher_info: public_attributes[1],
+      public_attributes_bytes,
+      public_attributes,
+      private_attributes,
      aggregated_verification_key: None,
    }
  }
@@ -67,8 +63,8 @@ async fn randomise_credential(
 ) -> Result<Vec<Signature>, String> {
  let mut state = state.write().await;
  let signature = state.signatures.remove(idx);
-  let (new_signature, _) = signature.randomise(&state.params);
-  state.signatures.insert(idx, new_signature);
+  let new = signature.randomise(&state.params);
+  state.signatures.insert(idx, new);
  Ok(state.signatures.clone())
 }

@@ -121,15 +117,14 @@ async fn prove_credential(
  let state = state.read().await;

  if let Some(signature) = state.signatures.get(idx) {
-    match coconut_interface::prove_bandwidth_credential(
+    match coconut_interface::prove_credential(
      &state.params,
      &verification_key,
      signature,
-      state.serial_number,
-      state.binding_number,
+      &state.private_attributes,
    ) {
      Ok(theta) => Ok(theta),
-      Err(e) => Err(format!("{:?}", e)),
+      Err(e) => Err(format!("{}", e)),
    }
  } else {
    Err("Got invalid Signature idx".to_string())
@@ -149,15 +144,10 @@ async fn verify_credential(

  let state = state.read().await;

-  let public_attributes_bytes = vec![
-    state.voucher_value.to_bytes().to_vec(),
-    state.voucher_info.to_bytes().to_vec(),
-  ];
-
  let credential = Credential::new(
    state.n_attributes,
    theta,
-    public_attributes_bytes,
+    state.public_attributes_bytes.clone(),
    state
      .signatures
      .get(idx)
@@ -174,13 +164,11 @@ async fn get_credential(
 ) -> Result<Vec<Signature>, String> {
  let guard = state.read().await;
  let parsed_urls = parse_url_validators(&validator_urls)?;
-  let public_attributes = vec![guard.voucher_value, guard.voucher_info];
-  let private_attributes = vec![guard.serial_number, guard.binding_number];

  let signature = obtain_aggregate_signature(
    &guard.params,
-    &public_attributes,
-    &private_attributes,
+    &guard.public_attributes,
+    &guard.private_attributes,
    &parsed_urls,
  )
  .await
@@ -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,16 +1,16 @@
 {
  "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",
  "types": "dist/index.d.ts",
  "scripts": {
    "build": "tsc",
+    "run_cli": "clear && ts-node src/cli.ts",
    "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": [],
@@ -23,34 +23,25 @@
  "devDependencies": {
    "@types/chai": "^4.2.15",
    "@types/expect": "^24.3.0",
+    "@types/inquirer": "^8.1.3",
    "@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",
+    "@cosmjs/cosmwasm-stargate": "^0.25.5",
+    "@cosmjs/math": "^0.25.5",
+    "@cosmjs/proto-signing": "^0.25.5",
+    "@cosmjs/stargate": "^0.25.5",
    "axios": "^0.21.1",
-    "cosmjs-types": "^0.4.0"
+    "inquirer": "^8.2.0"
  }
 }
@@ -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,64 @@
+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");
+  }
+}
@@ -0,0 +1,317 @@
+import ValidatorClient from "./index";
+import inquirer from "inquirer";
+// This script runs a CLI to consume the Validator and provide mixnet information to the user
+
+const VALIDATOR_URLS: string[] = [
+  "https://testnet-milhon-validator1.nymtech.net",
+  // "https://testnet-milhon-validator2.nymtech.net", // <-- val 2 doesnt work apparently.
+];
+const DENOM = "punk";
+const MOCK_MNEMONIC =
+  "vault risk throw flat garlic pretty clay senior birth correct panic floor around pen horror mail entry arrest zoo devote message evoke street total";
+// ^^ addr: punk10dxwmqjy72s9nkm9x9pluyn6pyx0gkptjhs4k9
+// curr balance: 899999747
+
+// const MOCK_MNEMONIC =
+//   "oil once motion cute crawl patch happy wave donkey zoo retreat matrix emerge adult very universe aware error snap credit actress couple upset engine";
+// ^^ addr: punk1yzr7gtmtlfd0s7s9wpexhteeu05y4xlcvh65eh
+// curr balance: 5045 UPUNK
+
+// const MOCK_MNEMONIC =
+//   "sample menu edit midnight guard review call record horn antenna stairs awkward fringe document during amazing twelve wise wide escape matter betray staff someone";
+// ^^ addr: punk1wn8lwxe5hvdtx60c6p7ekskmu75agwfrslf0qs
+// curr balance:
+
+type AccountType = {
+  addr: string;
+  client: any;
+  mnemonic?: string;
+};
+function validatorCli() {
+  // define funcs to be used in CLI switch-case
+
+  let state: AccountType = {
+    addr: "",
+    client: null,
+    mnemonic: "",
+  };
+
+  function restartApp() {
+    setTimeout(() => {
+      validatorCli();
+    }, 300);
+  }
+
+  function generateNewAccount() {
+    const mnemonic = ValidatorClient.randomMnemonic();
+    ValidatorClient.mnemonicToAddress(mnemonic, "punk")
+      .then((address) => {
+        console.log("Your address is: ", address);
+        console.log("Your mnemonic is: ", mnemonic);
+        return address;
+      })
+      .catch((err) => {
+        console.log("err", err);
+      });
+    restartApp();
+  }
+
+  function sendFundsMenu() {
+    inquirer
+      .prompt([
+        {
+          name: "recipient",
+          type: "input",
+          message: "please enter the receipient:",
+        },
+        {
+          name: "amount",
+          type: "input",
+          message: "please enter the amount (UPUNK):",
+        },
+      ])
+      .then(async ({ recipient, amount }) => {
+        const { addr, client } = state;
+        console.log(
+          `🔥 Hold Tight - Sending ${amount}UPUNK to ${recipient} 🚀`
+        );
+
+        const res = await client.send(addr, recipient, [
+          {
+            denom: "upunk",
+            amount: amount,
+          },
+        ]);
+        console.log("Funds Transfer Response:", res);
+        restartApp();
+      });
+  }
+
+  async function delegateGateway() {
+    console.log(
+      "unfortunately - gateway delegation is switched off at the moment."
+    );
+    startTransactionMenu();
+    // const id = "punk1yzr7gtmtlfd0s7s9wpexhteeu05y4xlcvh65eh";
+    // const gatewayID = "EQhjPpUuy4i1u87nfQMW21WiBT5mJk4dcq4ju7Vct7cB";
+    // const coin = {
+    //   denom: "upunk",
+    //   amount: "101",
+    // };
+    // const res = await state.client.delegateToMixnode(gatewayID, coin);
+    // console.log("delegateMixnode ==> ", res);
+  }
+
+  async function delegateMixnode() {
+    const mixNodeID = "2cFpCe7yP79CcuRpf6JBRdJaSp7JF5YcA5SHi8JVm1d2";
+    // const mixNodeID = "2Vrr7s2peGiWsPh6xY3ZFEMDRmMNv8xLBUtV5XMyQLSB";
+    const coin = {
+      denom: "upunk",
+      amount: "1001",
+    };
+    const res = await state.client.delegateToMixnode(mixNodeID, coin);
+    console.log("delegate to mixnode response: ", res);
+  }
+  async function findMinimumMixnodeBond() {
+    const res = await state.client.minimumMixnodeBond();
+    console.log("res is back ", res);
+  }
+
+  async function bondMixnode() {
+    state.client.bondMixnode();
+  }
+
+  async function checkOwnsMixnodes() {
+    const res = await state.client.ownsMixNode();
+    console.log("owns mixnode? ", res);
+  }
+  function startTransactionMenu() {
+    inquirer
+      .prompt([
+        {
+          type: "list",
+          name: "task",
+          message: "What now?",
+          choices: [
+            "send_funds",
+            "get_mixnodes",
+            "refresh_mixnodes",
+            "refresh_val_api_mixnodes",
+            "min_mixn_bond",
+            "bond_mixnode",
+            "delegate_mixnode",
+            "delegate_gateway",
+            "check_owns_mixnode",
+          ],
+        },
+      ])
+      .then(({ task }) => {
+        switch (task) {
+          case "send_funds":
+            sendFundsMenu();
+            break;
+          case "get_mixnodes":
+            getMixnodes();
+            break;
+          case "refresh_mixnodes":
+            refreshMixnodes();
+            break;
+          case "refresh_val_api_mixnodes":
+            refreshValApiMixnodes();
+            break;
+          case "min_mixn_bond":
+            findMinimumMixnodeBond();
+            break;
+          case "bond_mixnode":
+            bondMixnode();
+            break;
+          case "delegate_gateway":
+            delegateGateway();
+            break;
+          case "delegate_mixnode":
+            delegateMixnode();
+            break;
+          case "check_owns_mixnode":
+            checkOwnsMixnodes();
+            break;
+          default:
+            return null;
+        }
+      });
+  }
+
+  function queryUserAccount() {
+    inquirer
+      .prompt([
+        {
+          type: "input",
+          name: "query_user",
+          message: "Please enter the public address of user you wish to query",
+        },
+      ])
+      .then(async ({ query_user }) => {
+        let response = "";
+        try {
+          const client = await ValidatorClient.connectForQuery(
+            query_user,
+            VALIDATOR_URLS,
+            DENOM
+          );
+          const balance = await client.getBalance(query_user);
+          response = `User ${query_user} has a balance of ${balance?.amount}${balance?.denom}`;
+          console.log(response);
+          return validatorCli();
+        } catch (error) {
+          console.log("error back ", error);
+          return validatorCli();
+        }
+      });
+  }
+
+  async function refreshMixnodes() {
+    const res = await state.client.refreshMixNodes(
+      "punk1yksauczytk60x5cejaras8w6nwf7r772n3kwkp"
+    );
+    console.log("done:", res);
+  }
+  function connectAccount() {
+    inquirer
+      .prompt([
+        {
+          name: "user_mnemonic",
+          type: "input",
+          message: "please enter your mnemonic:",
+        },
+      ])
+      .then(async ({ user_mnemonic }) => {
+        console.log("Connecting...");
+        const addr = await ValidatorClient.mnemonicToAddress(
+          MOCK_MNEMONIC,
+          // user_mnemonic,
+          "punk"
+        );
+
+        const client = await ValidatorClient.connect(
+          addr,
+          MOCK_MNEMONIC,
+          VALIDATOR_URLS,
+          DENOM
+        );
+
+        state = {
+          addr,
+          mnemonic: MOCK_MNEMONIC,
+          client,
+        };
+
+        const balance = await client.getBalance(addr);
+        console.log(`connected to validator, our address is ${client.address}`);
+        console.log("connected to validator", client.urls[0]);
+        console.log(
+          `💰 Your balance is ${balance?.amount}${balance?.denom.toUpperCase()}`
+        );
+
+        startTransactionMenu();
+      })
+      .catch((err) => {
+        console.log("error: ", err);
+      });
+  }
+  function buildAWallet() {
+    inquirer
+      .prompt([
+        {
+          message: "enter your mnemonic to build wallet:",
+          type: "input",
+          name: "mnemonic",
+        },
+      ])
+      .then(async ({ mnemonic }) => {
+        const res = await ValidatorClient.buildWallet(mnemonic, DENOM);
+        console.log("Build_Wallet Response: ", res);
+      });
+  }
+  async function refreshValApiMixnodes() {
+    const res = await state.client.refreshValidatorAPIMixNodes();
+    console.log("res is back: ", res);
+  }
+  function getMixnodes() {
+    const res = state.client.mixNodesCache;
+    console.log("Mixnodes", res);
+  }
+  // app provides a list of possible tasks
+  inquirer
+    .prompt([
+      {
+        type: "list",
+        name: "task",
+        message: "Yo, What would you like to do today?",
+        choices: [
+          "create_account",
+          "connect_account",
+          "build_wallet",
+          "query_user",
+        ],
+      },
+    ])
+    .then(({ task }) => {
+      switch (task) {
+        case "create_account":
+          generateNewAccount();
+          break;
+        case "connect_account":
+          connectAccount();
+          break;
+        case "build_wallet":
+          buildAWallet();
+          break;
+        case "query_user":
+          queryUserAccount();
+          break;
+        default:
+          return null;
+      }
+    });
+}
+
+validatorCli();
@@ -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: "",
+            }
+        }
+    }
+}
@@ -3,7 +3,6 @@

 use crypto::asymmetric::{encryption, identity};
 use futures::channel::mpsc;
-use gateway_client::bandwidth::BandwidthController;
 use gateway_client::GatewayClient;
 use nymsphinx::acknowledgements::AckKey;
 use nymsphinx::addressing::clients::Recipient;
@@ -18,6 +17,8 @@ use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::spawn_local;
 use wasm_utils::{console_log, console_warn};

+use gateway_client::bandwidth::BandwidthController;
+
 pub(crate) mod received_processor;

 const DEFAULT_AVERAGE_PACKET_DELAY: Duration = Duration::from_millis(200);
@@ -249,7 +250,7 @@ impl NymClient {
        let validator_client = validator_client::ApiClient::new(self.validator_server.clone());

        let mixnodes = match validator_client.get_cached_active_mixnodes().await {
-            Err(err) => panic!("{:?}", err),
+            Err(err) => panic!("{}", err),
            Ok(mixes) => mixes,
        };

@@ -1,11 +1,10 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::error::GatewayClientError;
 #[cfg(feature = "coconut")]
 use credentials::coconut::{
-    bandwidth::{
-        obtain_signature, prepare_for_spending, BandwidthVoucherAttributes, TOTAL_ATTRIBUTES,
-    },
+    bandwidth::{obtain_signature, prepare_for_spending},
    utils::obtain_aggregate_verification_key,
 };
 #[cfg(not(feature = "coconut"))]
@@ -13,11 +12,10 @@ use credentials::token::bandwidth::TokenCredential;
 #[cfg(not(feature = "coconut"))]
 use crypto::asymmetric::identity;
 use crypto::asymmetric::identity::PublicKey;
-use network_defaults::BANDWIDTH_VALUE;
 #[cfg(not(feature = "coconut"))]
 use network_defaults::{
-    eth_contract::ETH_JSON_ABI, ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS, ETH_MIN_BLOCK_DEPTH,
-    TOKENS_TO_BURN,
+    eth_contract::ETH_JSON_ABI, BANDWIDTH_VALUE, ETH_BURN_FUNCTION_NAME, ETH_CONTRACT_ADDRESS,
+    ETH_MIN_BLOCK_DEPTH, TOKENS_TO_BURN,
 };
 #[cfg(not(feature = "coconut"))]
 use rand::rngs::OsRng;
@@ -35,8 +33,6 @@ use web3::{
    Web3,
 };

-use crate::error::GatewayClientError;
-
 #[cfg(not(feature = "coconut"))]
 pub fn eth_contract(web3: Web3<Http>) -> Contract<Http> {
    Contract::from_json(
@@ -112,31 +108,15 @@ impl BandwidthController {
        &self,
    ) -> Result<coconut_interface::Credential, GatewayClientError> {
        let verification_key = obtain_aggregate_verification_key(&self.validator_endpoints).await?;
-        let params = coconut_interface::Parameters::new(TOTAL_ATTRIBUTES).unwrap();

-        // TODO: Decide what is the value and additional info associated with the bandwidth voucher
-        let bandwidth_credential_attributes = BandwidthVoucherAttributes {
-            serial_number: params.random_scalar(),
-            binding_number: params.random_scalar(),
-            voucher_value: coconut_interface::hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes()),
-            voucher_info: coconut_interface::hash_to_scalar(
-                String::from("BandwidthVoucher").as_bytes(),
-            ),
-        };
-
-        let bandwidth_credential = obtain_signature(
-            &params,
-            &bandwidth_credential_attributes,
-            &self.validator_endpoints,
-        )
-        .await?;
+        let bandwidth_credential =
+            obtain_signature(&self.identity.to_bytes(), &self.validator_endpoints).await?;
        // the above would presumably be loaded from a file

        // the below would only be executed once we know where we want to spend it (i.e. which gateway and stuff)
        Ok(prepare_for_spending(
            &self.identity.to_bytes(),
            &bandwidth_credential,
-            &bandwidth_credential_attributes,
            &verification_key,
        )?)
    }
@@ -223,9 +203,8 @@ impl BandwidthController {
 #[cfg(not(feature = "coconut"))]
 #[cfg(test)]
 mod tests {
-    use network_defaults::ETH_EVENT_NAME;
-
    use super::*;
+    use network_defaults::ETH_EVENT_NAME;

    #[test]
    fn parse_contract() {
@@ -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};
-#[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(
@@ -206,20 +181,6 @@ impl<C> Client<C> {
        Ok(self.nymd.get_current_rewarding_interval().await?)
    }

-    pub async fn get_rewarding_status(
-        &self,
-        mix_identity: mixnet_contract::IdentityKey,
-        rewarding_interval_nonce: u32,
-    ) -> Result<MixnodeRewardingStatusResponse, ValidatorClientError>
-    where
-        C: CosmWasmClient + Sync,
-    {
-        Ok(self
-            .nymd
-            .get_rewarding_status(mix_identity, rewarding_interval_nonce)
-            .await?)
-    }
-
    pub async fn get_reward_pool(&self) -> Result<u128, ValidatorClientError>
    where
        C: CosmWasmClient + Sync,
@@ -325,7 +286,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 +297,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 +314,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 +326,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 +344,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
-
-
@@ -8,4 +8,4 @@ description = "Crutch library until there is proper SerDe support for coconut st
 serde = { version = "1.0", features = ["derive"] }
 getset = "0.1.1"

-nymcoconut = {path = "../nymcoconut" }
+coconut-rs = { git = "https://github.com/nymtech/coconut.git", branch = "0.5.0" }
@@ -4,7 +4,7 @@
 use getset::{CopyGetters, Getters};
 use serde::{Deserialize, Serialize};

-pub use nymcoconut::*;
+pub use coconut_rs::*;

 #[derive(Serialize, Deserialize, Getters, CopyGetters, Clone)]
 pub struct Credential {
@@ -42,7 +42,7 @@ impl Credential {
            .iter()
            .map(hash_to_scalar)
            .collect::<Vec<Attribute>>();
-        nymcoconut::verify_credential(&params, verification_key, &self.theta, &public_attributes)
+        coconut_rs::verify_credential(&params, verification_key, &self.theta, &public_attributes)
    }
 }

@@ -84,7 +84,7 @@ pub struct BlindSignRequestBody {
    #[getset(get = "pub")]
    blind_sign_request: BlindSignRequest,
    #[getset(get = "pub")]
-    public_key: nymcoconut::PublicKey,
+    public_key: coconut_rs::PublicKey,
    public_attributes: Vec<String>,
    #[getset(get = "pub")]
    total_params: u32,
@@ -92,13 +92,13 @@ pub struct BlindSignRequestBody {

 impl BlindSignRequestBody {
    pub fn new(
-        blind_sign_request: &BlindSignRequest,
-        public_key: &nymcoconut::PublicKey,
+        blind_sign_request: BlindSignRequest,
+        public_key: &coconut_rs::PublicKey,
        public_attributes: &[Attribute],
        total_params: u32,
    ) -> BlindSignRequestBody {
        BlindSignRequestBody {
-            blind_sign_request: blind_sign_request.clone(),
+            blind_sign_request,
            public_key: public_key.clone(),
            public_attributes: public_attributes
                .iter()
@@ -6,71 +6,41 @@
 // right now this has no double-spending protection, spender binding, etc
 // it's the simplest possible case

-use coconut_interface::{
-    Credential, Parameters, PrivateAttribute, PublicAttribute, Signature, VerificationKey,
-};
-use network_defaults::BANDWIDTH_VALUE;
 use url::Url;

-use crate::error::Error;
-
 use super::utils::{obtain_aggregate_signature, prepare_credential_for_spending};
+use crate::error::Error;
+use coconut_interface::{hash_to_scalar, Credential, Parameters, Signature, VerificationKey};
+use network_defaults::BANDWIDTH_VALUE;

-pub const PUBLIC_ATTRIBUTES: u32 = 2;
-pub const PRIVATE_ATTRIBUTES: u32 = 2;
+pub const PUBLIC_ATTRIBUTES: u32 = 1;
+pub const PRIVATE_ATTRIBUTES: u32 = 1;
 pub const TOTAL_ATTRIBUTES: u32 = PUBLIC_ATTRIBUTES + PRIVATE_ATTRIBUTES;

-pub struct BandwidthVoucherAttributes {
-    // a random secret value generated by the client used for double-spending detection
-    pub serial_number: PrivateAttribute,
-    // a random secret value generated by the client used to bind multiple credentials together
-    pub binding_number: PrivateAttribute,
-    // the value (e.g., bandwidth) encoded in this voucher
-    pub voucher_value: PublicAttribute,
-    // a field with public information, e.g., type of voucher, epoch etc.
-    pub voucher_info: PublicAttribute,
-}
-
-impl BandwidthVoucherAttributes {
-    pub fn get_public_attributes(&self) -> Vec<PublicAttribute> {
-        vec![self.voucher_value, self.voucher_info]
-    }
-
-    pub fn get_private_attributes(&self) -> Vec<PrivateAttribute> {
-        vec![self.serial_number, self.binding_number]
-    }
-}
-
 // TODO: this definitely has to be moved somewhere else. It's just a temporary solution
-pub async fn obtain_signature(
-    params: &Parameters,
-    attributes: &BandwidthVoucherAttributes,
-    validators: &[Url],
-) -> Result<Signature, Error> {
-    let public_attributes = attributes.get_public_attributes();
-    let private_attributes = attributes.get_private_attributes();
+pub async fn obtain_signature(raw_identity: &[u8], validators: &[Url]) -> Result<Signature, Error> {
+    let public_attributes = vec![hash_to_scalar(BANDWIDTH_VALUE.to_be_bytes())];
+    let private_attributes = vec![hash_to_scalar(raw_identity)];

-    obtain_aggregate_signature(params, &public_attributes, &private_attributes, validators).await
+    let params = Parameters::new(TOTAL_ATTRIBUTES)?;
+
+    obtain_aggregate_signature(&params, &public_attributes, &private_attributes, validators).await
 }

 pub fn prepare_for_spending(
    raw_identity: &[u8],
    signature: &Signature,
-    attributes: &BandwidthVoucherAttributes,
    verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
-    let public_attributes = vec![
-        raw_identity.to_vec(),
-        BANDWIDTH_VALUE.to_be_bytes().to_vec(),
-    ];
+    let public_attributes = vec![BANDWIDTH_VALUE.to_be_bytes().to_vec()];
+    let private_attributes = vec![raw_identity.to_vec()];

    let params = Parameters::new(TOTAL_ATTRIBUTES)?;

    prepare_credential_for_spending(
        &params,
        public_attributes,
-        attributes.serial_number,
-        attributes.binding_number,
+        private_attributes,
        signature,
        verification_key,
    )
@@ -1,16 +1,14 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

+use crate::error::Error;
 use coconut_interface::{
-    aggregate_signature_shares, aggregate_verification_keys, prepare_blind_sign,
-    prove_bandwidth_credential, Attribute, BlindSignRequestBody, Credential, Parameters, Signature,
+    aggregate_signature_shares, aggregate_verification_keys, hash_to_scalar, prepare_blind_sign,
+    prove_credential, Attribute, BlindSignRequestBody, Credential, Parameters, Signature,
    SignatureShare, VerificationKey,
 };
 use url::Url;

-use crate::coconut::bandwidth::PRIVATE_ATTRIBUTES;
-use crate::error::Error;
-
 /// Contacts all provided validators and then aggregate their verification keys.
 ///
 /// # Arguments
@@ -65,18 +63,17 @@ async fn obtain_partial_credential(
    public_attributes: &[Attribute],
    private_attributes: &[Attribute],
    client: &validator_client::ApiClient,
-    validator_vk: &VerificationKey,
 ) -> Result<Signature, Error> {
    let elgamal_keypair = coconut_interface::elgamal_keygen(params);
    let blind_sign_request = prepare_blind_sign(
        params,
-        &elgamal_keypair,
+        elgamal_keypair.public_key(),
        private_attributes,
        public_attributes,
    )?;

    let blind_sign_request_body = BlindSignRequestBody::new(
-        &blind_sign_request,
+        blind_sign_request,
        elgamal_keypair.public_key(),
        public_attributes,
        (public_attributes.len() + private_attributes.len()) as u32,
@@ -86,17 +83,7 @@ async fn obtain_partial_credential(
        .blind_sign(&blind_sign_request_body)
        .await?
        .blinded_signature;
-
-    let unblinded_signature = blinded_signature.unblind(
-        params,
-        elgamal_keypair.private_key(),
-        validator_vk,
-        private_attributes,
-        public_attributes,
-        &blind_sign_request.get_commitment_hash(),
-    )?;
-
-    Ok(unblinded_signature)
+    Ok(blinded_signature.unblind(elgamal_keypair.private_key()))
 }

 pub async fn obtain_aggregate_signature(
@@ -110,76 +97,40 @@ pub async fn obtain_aggregate_signature(
    }

    let mut shares = Vec::with_capacity(validators.len());
-    let mut validators_partial_vks: Vec<VerificationKey> = Vec::with_capacity(validators.len());

    let mut client = validator_client::ApiClient::new(validators[0].clone());
-    let validator_partial_vk = client.get_coconut_verification_key().await?;
-    validators_partial_vks.push(validator_partial_vk.key.clone());
-
-    let first = obtain_partial_credential(
-        params,
-        public_attributes,
-        private_attributes,
-        &client,
-        &validator_partial_vk.key,
-    )
-    .await?;
+    let first =
+        obtain_partial_credential(params, public_attributes, private_attributes, &client).await?;
    shares.push(SignatureShare::new(first, 0));

    for (id, validator_url) in validators.iter().enumerate().skip(1) {
        client.change_validator_api(validator_url.clone());
-        let validator_partial_vk = client.get_coconut_verification_key().await?;
-        validators_partial_vks.push(validator_partial_vk.key.clone());
-        let signature = obtain_partial_credential(
-            params,
-            public_attributes,
-            private_attributes,
-            &client,
-            &validator_partial_vk.key,
-        )
-        .await?;
+        let signature =
+            obtain_partial_credential(params, public_attributes, private_attributes, &client)
+                .await?;
        let share = SignatureShare::new(signature, id as u64);
        shares.push(share)
    }

-    let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
-    attributes.extend_from_slice(private_attributes);
-    attributes.extend_from_slice(public_attributes);
-
-    let mut indices: Vec<u64> = Vec::with_capacity(validators_partial_vks.len());
-    for i in 1..validators_partial_vks.len() {
-        indices.push(i as u64);
-    }
-    let verification_key =
-        aggregate_verification_keys(&validators_partial_vks, Some(indices.as_ref()))?;
-
-    Ok(aggregate_signature_shares(
-        params,
-        &verification_key,
-        &attributes,
-        &shares,
-    )?)
+    Ok(aggregate_signature_shares(&shares)?)
 }

 // TODO: better type flow
 pub fn prepare_credential_for_spending(
    params: &Parameters,
    public_attributes: Vec<Vec<u8>>,
-    serial_number: Attribute,
-    binding_number: Attribute,
+    private_attributes: Vec<Vec<u8>>,
    signature: &Signature,
    verification_key: &VerificationKey,
 ) -> Result<Credential, Error> {
-    let theta = prove_bandwidth_credential(
-        params,
-        verification_key,
-        signature,
-        serial_number,
-        binding_number,
-    )?;
+    let private_attributes = private_attributes
+        .iter()
+        .map(hash_to_scalar)
+        .collect::<Vec<Attribute>>();
+    let theta = prove_credential(params, verification_key, signature, &private_attributes)?;

    Ok(Credential::new(
-        (public_attributes.len() + PRIVATE_ATTRIBUTES as usize) as u32,
+        (public_attributes.len() + private_attributes.len()) as u32,
        theta,
        public_attributes,
        signature,
@@ -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"
@@ -15,7 +17,7 @@ schemars = "0.8"
 ts-rs = { version = "5.1", optional = true }
 thiserror = "1.0"
 network-defaults = { path = "../network-defaults" }
-fixed = { version = "1.1", features = ["serde"] }
+fixed = "1.1"
 az = "1.1"
 log = "0.4.14"

@@ -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:
@@ -8,14 +8,15 @@ pub mod mixnode;
 mod msg;
 mod types;

-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 types::*;
+pub use msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg};
+pub use types::{
+    IdentityKey, IdentityKeyRef, LayerDistribution, RewardingIntervalResponse, SphinxKey,
+    StateParams,
+};
@@ -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};
@@ -14,10 +14,6 @@ use std::fmt::Display;

 type U128 = fixed::types::U75F53; // u128 with 18 significant digits

-fixed::const_fixed_from_int! {
-    const ONE: U128 = 1;
-}
-
 #[cfg_attr(feature = "ts-rs", derive(ts_rs::TS))]
 #[derive(Clone, Debug, Deserialize, PartialEq, PartialOrd, Serialize, JsonSchema)]
 pub struct MixNode {
@@ -29,7 +25,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 +51,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 +93,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 +110,7 @@ impl NodeRewardParams {
    }

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

    pub fn alpha(&self) -> U128 {
@@ -159,90 +118,6 @@ impl NodeRewardParams {
    }
 }

-// cosmwasm's limited serde doesn't work with U128 directly
-#[allow(non_snake_case)]
-pub mod fixed_U128_as_string {
-    use super::U128;
-    use serde::de::Error;
-    use serde::Deserialize;
-    use std::str::FromStr;
-
-    pub fn serialize<S>(val: &U128, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let s = (*val).to_string();
-        serializer.serialize_str(&s)
-    }
-
-    pub fn deserialize<'de, D>(deserializer: D) -> Result<U128, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let s = String::deserialize(deserializer)?;
-        U128::from_str(&s).map_err(|err| {
-            D::Error::custom(format!(
-                "failed to deserialize U128 with its string representation - {}",
-                err
-            ))
-        })
-    }
-}
-
-// everything required to reward delegator of given mixnode
-#[derive(Debug, Clone, Copy, Serialize, Deserialize, JsonSchema)]
-pub struct DelegatorRewardParams {
-    node_reward_params: NodeRewardParams,
-
-    // to be completely honest I don't understand all consequences of using `#[schemars(with = "String")]`
-    // for U128 here, but it seems that CosmWasm is using the same attribute for their Uint128
-    #[schemars(with = "String")]
-    #[serde(with = "fixed_U128_as_string")]
-    sigma: U128,
-    #[schemars(with = "String")]
-    #[serde(with = "fixed_U128_as_string")]
-    profit_margin: U128,
-    #[schemars(with = "String")]
-    #[serde(with = "fixed_U128_as_string")]
-    node_profit: U128,
-}
-
-impl DelegatorRewardParams {
-    pub fn new(mixnode_bond: &MixNodeBond, node_reward_params: NodeRewardParams) -> Self {
-        DelegatorRewardParams {
-            sigma: mixnode_bond.sigma(&node_reward_params),
-            profit_margin: mixnode_bond.profit_margin(),
-            node_profit: mixnode_bond.node_profit(&node_reward_params),
-            node_reward_params,
-        }
-    }
-
-    pub fn determine_delegation_reward(&self, delegation_amount: Uint128) -> u128 {
-        // change all values into their fixed representations
-        let delegation_amount = U128::from_num(delegation_amount.u128());
-        let circulating_supply = U128::from_num(self.node_reward_params.circulating_supply());
-
-        let scaled_delegation_amount = delegation_amount / circulating_supply;
-        let delegator_reward =
-            (ONE - self.profit_margin) * scaled_delegation_amount / self.sigma * self.node_profit;
-
-        let reward = delegator_reward.max(U128::ZERO);
-        if let Some(int_reward) = reward.checked_cast() {
-            int_reward
-        } else {
-            error!(
-                "Could not cast delegator reward ({}) to u128, returning 0",
-                reward,
-            );
-            0u128
-        }
-    }
-
-    pub fn node_reward_params(&self) -> &NodeRewardParams {
-        &self.node_reward_params
-    }
-}
-
 #[derive(Debug)]
 pub struct NodeRewardResult {
    reward: U128,
@@ -266,45 +141,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 +192,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,38 +203,39 @@ 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 = U128::from_num(1u128);
        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())
-            / (ONE + params.alpha());
+            * (sigma * omega_k + params.alpha() * lambda * sigma * params.k())
+            / (U128::from_num(1) + params.alpha());

        NodeRewardResult {
            reward,
@@ -384,7 +261,7 @@ impl MixNodeBond {
        };
        let operator_base_reward = reward.reward.min(params.operator_cost());
        let operator_reward = (self.profit_margin()
-            + (ONE - self.profit_margin()) * reward.lambda / reward.sigma)
+            + (U128::from_num(1) - self.profit_margin()) * reward.lambda / reward.sigma)
            * profit;

        let reward = (operator_reward + operator_base_reward).max(U128::from_num(0));
@@ -402,50 +279,67 @@ 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()
        }
    }

    pub fn reward_delegation(&self, delegation_amount: Uint128, params: &NodeRewardParams) -> u128 {
-        let reward_params = DelegatorRewardParams::new(self, *params);
-        reward_params.determine_delegation_reward(delegation_amount)
+        let scaled_delegation_amount =
+            U128::from_num(delegation_amount.u128()) / U128::from_num(params.circulating_supply());
+
+        let delegator_reward = (U128::from_num(1) - self.profit_margin())
+            * scaled_delegation_amount
+            / self.sigma(params)
+            * self.node_profit(params);
+
+        let reward = delegator_reward.max(U128::from_num(0));
+        if let Some(int_reward) = reward.checked_cast() {
+            int_reward
+        } else {
+            error!(
+                "Could not cast delegator reward ({}) to u128, returning 0 - mixnode {}",
+                reward,
+                self.identity()
+            );
+            0u128
+        }
    }
 }

 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 +378,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 +407,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 +423,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 +433,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,
@@ -40,12 +37,21 @@ pub enum ExecuteMsg {
        rewarding_interval_nonce: u32,
    },

+    RewardMixnode {
+        identity: IdentityKey,
+        // percentage value in range 0-100
+        uptime: u32,
+
+        // nonce of the current rewarding interval
+        rewarding_interval_nonce: u32,
+    },
+
    FinishMixnodeRewarding {
        // nonce of the current rewarding interval
        rewarding_interval_nonce: u32,
    },

-    RewardMixnode {
+    RewardMixnodeV2 {
        identity: IdentityKey,
        // percentage value in range 0-100
        params: NodeRewardParams,
@@ -53,41 +59,11 @@ 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,49 +73,36 @@ 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 {},
    GetCirculatingSupply {},
    GetEpochRewardPercent {},
    GetSybilResistancePercent {},
-    GetRewardingStatus {
-        mix_identity: IdentityKey,
-        rewarding_interval_nonce: u32,
-    },
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
@@ -1,9 +1,8 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

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

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
-pub struct ContractStateParams {
-    // 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 struct StateParams {
+    pub epoch_length: u32, // length of a rewarding epoch/interval, expressed in hours
+
+    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
+
+    pub mixnode_bond_reward_rate: Decimal, // annual reward rate, expressed as a decimal like 1.25
+    pub mixnode_delegation_reward_rate: Decimal, // annual reward rate, expressed as a decimal like 1.25

    // number of mixnode that are going to get rewarded during current rewarding interval (k_m)
    // based on overall demand for private bandwidth-
@@ -50,21 +50,23 @@ 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, "epoch length: {}; ", self.epoch_length)?;
+        write!(f, "minimum mixnode bond: {}; ", self.minimum_mixnode_bond)?;
+        write!(f, "minimum gateway bond: {}; ", self.minimum_gateway_bond)?;
        write!(
            f,
-            "minimum mixnode pledge: {}; ",
-            self.minimum_mixnode_pledge
+            "mixnode bond reward rate: {}; ",
+            self.mixnode_bond_reward_rate
        )?;
        write!(
            f,
-            "minimum gateway pledge: {}; ",
-            self.minimum_gateway_pledge
+            "mixnode delegation reward rate: {}; ",
+            self.mixnode_delegation_reward_rate
        )?;
        write!(
            f,
@@ -75,63 +77,10 @@ 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
        )
    }
 }

-#[derive(Default, Debug, Serialize, Deserialize, PartialEq)]
-pub struct RewardingResult {
-    pub operator_reward: Uint128,
-    pub total_delegator_reward: Uint128,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-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 rewarding_params: DelegatorRewardParams,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub enum RewardingStatus {
-    Complete(RewardingResult),
-    PendingNextDelegatorPage(PendingDelegatorRewarding),
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-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";
@@ -1,43 +0,0 @@
-[package]
-name = "nymcoconut"
-version = "0.5.0"
-authors = ["Jedrzej Stuczynski <andrew@nymtech.net>", "Ania Piotrowska <ania@nymtech.net>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-bls12_381 = { version = "0.5", default-features = false, features = ["pairings", "alloc", "experimental"] }
-itertools = "0.10"
-digest = "0.9"
-rand = "0.8"
-thiserror = "1.0"
-serde = "1.0"
-serde_derive = "1.0"
-bs58 = "0.4.0"
-sha2 = "0.9"
-
-[dependencies.ff]
-version = "0.10"
-default-features = false
-
-[dependencies.group]
-version = "0.10"
-default-features = false
-
-[dev-dependencies]
-criterion = { version="0.3", features=["html_reports"] }
-doc-comment = "0.3"
-
-[dev-dependencies.bincode]
-version = "1"
-
-#[[bench]]
-#name = "benchmarks"
-#harness = false
-
-[features]
-default = []
-
-[target.'cfg(target_env = "wasm32-unknown-unknown")'.dependencies]
-getrandom = { version="0.2", features=["js"] }
@@ -1,322 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use core::ops::{Deref, Mul};
-use std::convert::TryFrom;
-use std::convert::TryInto;
-
-use bls12_381::{G1Projective, Scalar};
-use group::Curve;
-use serde_derive::{Deserialize, Serialize};
-
-use crate::error::{CoconutError, Result};
-use crate::scheme::setup::Parameters;
-use crate::traits::{Base58, Bytable};
-use crate::utils::{try_deserialize_g1_projective, try_deserialize_scalar};
-
-/// Type alias for the ephemeral key generated during ElGamal encryption
-pub type EphemeralKey = Scalar;
-
-/// Two G1 points representing ElGamal ciphertext
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct Ciphertext(pub(crate) G1Projective, pub(crate) G1Projective);
-
-impl TryFrom<&[u8]> for Ciphertext {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<Ciphertext> {
-        if bytes.len() != 96 {
-            return Err(CoconutError::Deserialization(format!(
-                "Ciphertext must be exactly 96 bytes, got {}",
-                bytes.len()
-            )));
-        }
-
-        let c1_bytes: &[u8; 48] = &bytes[..48].try_into().unwrap();
-        let c2_bytes: &[u8; 48] = &bytes[48..].try_into().unwrap();
-
-        let c1 = try_deserialize_g1_projective(
-            c1_bytes,
-            CoconutError::Deserialization("Failed to deserialize compressed c1".to_string()),
-        )?;
-        let c2 = try_deserialize_g1_projective(
-            c2_bytes,
-            CoconutError::Deserialization("Failed to deserialize compressed c2".to_string()),
-        )?;
-
-        Ok(Ciphertext(c1, c2))
-    }
-}
-
-impl Ciphertext {
-    pub fn c1(&self) -> &G1Projective {
-        &self.0
-    }
-
-    pub fn c2(&self) -> &G1Projective {
-        &self.1
-    }
-
-    pub fn to_bytes(&self) -> [u8; 96] {
-        let mut bytes = [0u8; 96];
-        bytes[..48].copy_from_slice(&self.0.to_affine().to_compressed());
-        bytes[48..].copy_from_slice(&self.1.to_affine().to_compressed());
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<Ciphertext> {
-        Ciphertext::try_from(bytes)
-    }
-}
-
-/// PrivateKey used in the ElGamal encryption scheme to recover the plaintext
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct PrivateKey(pub(crate) Scalar);
-
-impl PrivateKey {
-    /// Decrypt takes the ElGamal encryption of a message and returns a point on the G1 curve
-    /// that represents original h^m.
-    pub fn decrypt(&self, ciphertext: &Ciphertext) -> G1Projective {
-        let (c1, c2) = &(ciphertext.0, ciphertext.1);
-
-        // (gamma^k * h^m) / (g1^{d * k})   |   note: gamma = g1^d
-        c2 - c1 * self.0
-    }
-
-    pub fn public_key(&self, params: &Parameters) -> PublicKey {
-        PublicKey(params.gen1() * self.0)
-    }
-
-    pub fn to_bytes(&self) -> [u8; 32] {
-        self.0.to_bytes()
-    }
-
-    pub fn from_bytes(bytes: &[u8; 32]) -> Result<PrivateKey> {
-        try_deserialize_scalar(
-            bytes,
-            CoconutError::Deserialization(
-                "Failed to deserialize ElGamal private key - it was not in the canonical form"
-                    .to_string(),
-            ),
-        )
-        .map(PrivateKey)
-    }
-}
-
-impl Bytable for PrivateKey {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes().to_vec()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        PrivateKey::from_bytes(slice.try_into().unwrap())
-    }
-}
-
-impl Base58 for PrivateKey {}
-
-// TODO: perhaps be more explicit and apart from gamma also store generator and group order?
-/// PublicKey used in the ElGamal encryption scheme to produce the ciphertext
-#[derive(Debug, Clone)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct PublicKey(G1Projective);
-
-impl PublicKey {
-    /// Encrypt encrypts the given message in the form of h^m,
-    /// where h is a point on the G1 curve using the given public key.
-    /// The random k is returned alongside the encryption
-    /// as it is required by the Coconut Scheme to create proofs of knowledge.
-    pub fn encrypt(
-        &self,
-        params: &Parameters,
-        h: &G1Projective,
-        msg: &Scalar,
-    ) -> (Ciphertext, EphemeralKey) {
-        let k = params.random_scalar();
-        // c1 = g1^k
-        let c1 = params.gen1() * k;
-        // c2 = gamma^k * h^m
-        let c2 = self.0 * k + h * msg;
-
-        (Ciphertext(c1, c2), k)
-    }
-
-    pub fn to_bytes(&self) -> [u8; 48] {
-        self.to_byte_vec().try_into().unwrap()
-    }
-
-    pub fn from_bytes(bytes: &[u8; 48]) -> Result<PublicKey> {
-        Ok(PublicKey::try_from(bytes.to_vec().as_slice()).unwrap())
-    }
-}
-
-impl Bytable for PublicKey {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.0.to_affine().to_compressed().into()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        Ok(PublicKey::from_bytes(slice.try_into().unwrap()).unwrap())
-    }
-}
-
-impl TryFrom<&[u8]> for PublicKey {
-    type Error = CoconutError;
-
-    fn try_from(slice: &[u8]) -> Result<PublicKey> {
-        try_deserialize_g1_projective(
-            slice.try_into().unwrap(),
-            CoconutError::Deserialization(
-                "Failed to deserialize compressed ElGamal public key".to_string(),
-            ),
-        )
-        .map(PublicKey)
-    }
-}
-
-impl Base58 for PublicKey {}
-
-impl Deref for PublicKey {
-    type Target = G1Projective;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl<'a, 'b> Mul<&'b Scalar> for &'a PublicKey {
-    type Output = G1Projective;
-
-    fn mul(self, rhs: &'b Scalar) -> Self::Output {
-        self.0 * rhs
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-/// A convenient wrapper for both keys of the ElGamal keypair
-pub struct ElGamalKeyPair {
-    private_key: PrivateKey,
-    public_key: PublicKey,
-}
-
-impl ElGamalKeyPair {
-    pub fn public_key(&self) -> &PublicKey {
-        &self.public_key
-    }
-
-    pub fn private_key(&self) -> &PrivateKey {
-        &self.private_key
-    }
-}
-
-/// Generate a fresh ElGamal keypair using the group generator specified by the provided [Parameters]
-pub fn elgamal_keygen(params: &Parameters) -> ElGamalKeyPair {
-    let private_key = params.random_scalar();
-    let gamma = params.gen1() * private_key;
-
-    ElGamalKeyPair {
-        private_key: PrivateKey(private_key),
-        public_key: PublicKey(gamma),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn keygen() {
-        let params = Parameters::default();
-        let keypair = super::elgamal_keygen(&params);
-
-        let expected = params.gen1() * keypair.private_key.0;
-        let gamma = keypair.public_key.0;
-        assert_eq!(
-            expected, gamma,
-            "Public key, gamma, should be equal to g1^d, where d is the private key"
-        );
-    }
-
-    #[test]
-    fn encryption() {
-        let params = Parameters::default();
-        let keypair = super::elgamal_keygen(&params);
-
-        let r = params.random_scalar();
-        let h = params.gen1() * r;
-        let m = params.random_scalar();
-
-        let (ciphertext, ephemeral_key) = keypair.public_key.encrypt(&params, &h, &m);
-
-        let expected_c1 = params.gen1() * ephemeral_key;
-        assert_eq!(expected_c1, ciphertext.0, "c1 should be equal to g1^k");
-
-        let expected_c2 = keypair.public_key.0 * ephemeral_key + h * m;
-        assert_eq!(
-            expected_c2, ciphertext.1,
-            "c2 should be equal to gamma^k * h^m"
-        );
-    }
-
-    #[test]
-    fn decryption() {
-        let params = Parameters::default();
-        let keypair = super::elgamal_keygen(&params);
-
-        let r = params.random_scalar();
-        let h = params.gen1() * r;
-        let m = params.random_scalar();
-
-        let (ciphertext, _) = keypair.public_key.encrypt(&params, &h, &m);
-        let dec = keypair.private_key.decrypt(&ciphertext);
-
-        let expected = h * m;
-        assert_eq!(
-            expected, dec,
-            "after ElGamal decryption, original h^m should be obtained"
-        );
-    }
-
-    #[test]
-    fn private_key_bytes_roundtrip() {
-        let params = Parameters::default();
-        let private_key = PrivateKey(params.random_scalar());
-        let bytes = private_key.to_bytes();
-
-        // also make sure it is equivalent to the internal scalar's bytes
-        assert_eq!(private_key.0.to_bytes(), bytes);
-        assert_eq!(private_key, PrivateKey::from_bytes(&bytes).unwrap())
-    }
-
-    #[test]
-    fn public_key_bytes_roundtrip() {
-        let params = Parameters::default();
-        let r = params.random_scalar();
-        let public_key = PublicKey(params.gen1() * r);
-        let bytes = public_key.to_bytes();
-
-        // also make sure it is equivalent to the internal g1 compressed bytes
-        assert_eq!(public_key.0.to_affine().to_compressed(), bytes);
-        assert_eq!(public_key, PublicKey::from_bytes(&bytes).unwrap())
-    }
-
-    #[test]
-    fn ciphertext_bytes_roundtrip() {
-        let params = Parameters::default();
-        let r = params.random_scalar();
-        let s = params.random_scalar();
-        let ciphertext = Ciphertext(params.gen1() * r, params.gen1() * s);
-        let bytes = ciphertext.to_bytes();
-
-        // also make sure it is equivalent to the internal g1 compressed bytes concatenated
-        let expected_bytes = [
-            ciphertext.0.to_affine().to_compressed(),
-            ciphertext.1.to_affine().to_compressed(),
-        ]
-        .concat();
-        assert_eq!(expected_bytes, bytes);
-        assert_eq!(ciphertext, Ciphertext::try_from(&bytes[..]).unwrap())
-    }
-}
@@ -1,53 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use thiserror::Error;
-
-/// A `Result` alias where the `Err` case is `coconut_rs::Error`.
-pub type Result<T> = std::result::Result<T, CoconutError>;
-
-#[derive(Error, Debug)]
-pub enum CoconutError {
-    #[error("Setup error: {0}")]
-    Setup(String),
-
-    #[error("encountered error during keygen")]
-    Keygen,
-
-    #[error("Issuance related error: {0}")]
-    Issuance(String),
-
-    #[error("Tried to prepare blind sign request for higher than specified number of attributes (max: {}, requested: {})", max, requested)]
-    IssuanceMaxAttributes { max: usize, requested: usize },
-
-    #[error("Interpolation error: {0}")]
-    Interpolation(String),
-
-    #[error("Aggregation error: {0}")]
-    Aggregation(String),
-
-    #[error("Unblind error: {0}")]
-    Unblind(String),
-
-    #[error("Verification error: {0}")]
-    Verification(String),
-
-    #[error("Deserialization error: {0}")]
-    Deserialization(String),
-
-    #[error(
-        "Deserailization error, expected at least {} bytes, got {}",
-        min,
-        actual
-    )]
-    DeserializationMinLength { min: usize, actual: usize },
-
-    #[error("Tried to deserialize {object} with bytes of invalid length. Expected {actual} < {} or {modulus_target} % {modulus} == 0")]
-    DeserializationInvalidLength {
-        actual: usize,
-        target: usize,
-        modulus_target: usize,
-        modulus: usize,
-        object: String,
-    },
-}
@@ -1,15 +0,0 @@
-use crate::{BlindSignRequest, BlindedSignature, Bytable, Theta};
-
-macro_rules! impl_clone {
-    ($struct:ident) => {
-        impl Clone for $struct {
-            fn clone(&self) -> Self {
-                Self::try_from_byte_slice(&self.to_byte_vec()).unwrap()
-            }
-        }
-    };
-}
-
-impl_clone!(BlindSignRequest);
-impl_clone!(BlindedSignature);
-impl_clone!(Theta);
@@ -1,2 +0,0 @@
-mod clone;
-mod serde;
@@ -1,56 +0,0 @@
-use crate::elgamal::PrivateKey;
-use crate::scheme::SecretKey;
-use crate::{
-    Base58, BlindSignRequest, BlindedSignature, PublicKey, Signature, Theta, VerificationKey,
-};
-use serde::de::Unexpected;
-use serde::{de::Error, de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
-use std::fmt;
-
-macro_rules! impl_serde {
-    ($struct:ident, $visitor:ident) => {
-        pub struct $visitor {}
-
-        impl Serialize for $struct {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                serializer.serialize_str(&self.to_bs58())
-            }
-        }
-
-        impl<'de> Visitor<'de> for $visitor {
-            type Value = $struct;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                write!(formatter, "A base58 encoded struct")
-            }
-
-            fn visit_str<E: Error>(self, s: &str) -> Result<Self::Value, E> {
-                match $struct::try_from_bs58(s) {
-                    Ok(x) => Ok(x),
-                    Err(_) => Err(Error::invalid_value(Unexpected::Str(s), &self)),
-                }
-            }
-        }
-
-        impl<'de> Deserialize<'de> for $struct {
-            fn deserialize<D>(deserializer: D) -> Result<$struct, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                deserializer.deserialize_str($visitor {})
-            }
-        }
-    };
-}
-
-impl_serde!(SecretKey, V1);
-impl_serde!(VerificationKey, V2);
-impl_serde!(PublicKey, V3);
-impl_serde!(PrivateKey, V4);
-impl_serde!(BlindSignRequest, V5);
-impl_serde!(BlindedSignature, V6);
-impl_serde!(Signature, V7);
-impl_serde!(Theta, V8);
@@ -1,57 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::convert::TryInto;
-
-use bls12_381::Scalar;
-
-pub use elgamal::elgamal_keygen;
-pub use elgamal::ElGamalKeyPair;
-pub use elgamal::PublicKey;
-pub use error::CoconutError;
-pub use scheme::aggregation::aggregate_signature_shares;
-pub use scheme::aggregation::aggregate_verification_keys;
-pub use scheme::issuance::blind_sign;
-pub use scheme::issuance::prepare_blind_sign;
-pub use scheme::issuance::BlindSignRequest;
-pub use scheme::keygen::ttp_keygen;
-pub use scheme::keygen::KeyPair;
-pub use scheme::keygen::VerificationKey;
-pub use scheme::setup::setup;
-pub use scheme::setup::Parameters;
-pub use scheme::verification::prove_bandwidth_credential;
-pub use scheme::verification::verify_credential;
-pub use scheme::verification::Theta;
-pub use scheme::BlindedSignature;
-pub use scheme::Signature;
-pub use scheme::SignatureShare;
-pub use traits::Base58;
-pub use utils::hash_to_scalar;
-
-use crate::traits::Bytable;
-
-pub mod elgamal;
-mod error;
-mod impls;
-mod proofs;
-mod scheme;
-#[cfg(test)]
-mod tests;
-mod traits;
-mod utils;
-
-pub type Attribute = Scalar;
-pub type PrivateAttribute = Attribute;
-pub type PublicAttribute = Attribute;
-
-impl Bytable for Attribute {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes().to_vec()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CoconutError> {
-        Ok(Attribute::from_bytes(slice.try_into().unwrap()).unwrap())
-    }
-}
-
-impl Base58 for Attribute {}
@@ -1,663 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// TODO: look at https://crates.io/crates/merlin to perhaps use it instead?
-
-use std::borrow::Borrow;
-use std::convert::TryInto;
-
-use bls12_381::{G1Projective, G2Projective, Scalar};
-use digest::generic_array::typenum::Unsigned;
-use digest::Digest;
-use group::GroupEncoding;
-use itertools::izip;
-use sha2::Sha256;
-
-use crate::elgamal::Ciphertext;
-use crate::error::{CoconutError, Result};
-use crate::scheme::setup::Parameters;
-use crate::scheme::VerificationKey;
-use crate::utils::{hash_g1, try_deserialize_scalar, try_deserialize_scalar_vec};
-use crate::{elgamal, Attribute, ElGamalKeyPair};
-
-// as per the reference python implementation
-type ChallengeDigest = Sha256;
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct ProofCmCs {
-    challenge: Scalar,
-    response_opening: Scalar,
-    response_private_elgamal_key: Scalar,
-    response_keys: Vec<Scalar>,
-    response_attributes: Vec<Scalar>,
-}
-
-// note: this is slightly different from the reference python implementation
-// as we omit the unnecessary string conversion. Instead we concatenate byte
-// representations together and hash that.
-// note2: G1 and G2 elements are using their compressed representations
-// and as per the bls12-381 library all elements are using big-endian form
-/// Generates a Scalar [or Fp] challenge by hashing a number of elliptic curve points.  
-fn compute_challenge<D, I, B>(iter: I) -> Scalar
-where
-    D: Digest,
-    I: Iterator<Item = B>,
-    B: AsRef<[u8]>,
-{
-    let mut h = D::new();
-    for point_representation in iter {
-        h.update(point_representation);
-    }
-    let digest = h.finalize();
-
-    // TODO: I don't like the 0 padding here (though it's what we've been using before,
-    // but we never had a security audit anyway...)
-    // instead we could maybe use the `from_bytes` variant and adding some suffix
-    // when computing the digest until we produce a valid scalar.
-    let mut bytes = [0u8; 64];
-    let pad_size = 64usize
-        .checked_sub(D::OutputSize::to_usize())
-        .unwrap_or_default();
-
-    bytes[pad_size..].copy_from_slice(&digest);
-
-    Scalar::from_bytes_wide(&bytes)
-}
-
-fn produce_response(witness: &Scalar, challenge: &Scalar, secret: &Scalar) -> Scalar {
-    witness - challenge * secret
-}
-
-// note: it's caller's responsibility to ensure witnesses.len() = secrets.len()
-fn produce_responses<S>(witnesses: &[Scalar], challenge: &Scalar, secrets: &[S]) -> Vec<Scalar>
-where
-    S: Borrow<Scalar>,
-{
-    debug_assert_eq!(witnesses.len(), secrets.len());
-
-    witnesses
-        .iter()
-        .zip(secrets.iter())
-        .map(|(w, x)| produce_response(w, challenge, x.borrow()))
-        .collect()
-}
-
-impl ProofCmCs {
-    /// Construct non-interactive zero-knowledge proof of correctness of the ciphertexts and the commitment
-    /// using the Fiat-Shamir heuristic.
-    pub(crate) fn construct(
-        params: &Parameters,
-        elgamal_keypair: &ElGamalKeyPair,
-        ephemeral_keys: &[elgamal::EphemeralKey],
-        commitment: &G1Projective,
-        commitment_opening: &Scalar,
-        private_attributes: &[Attribute],
-        priv_attributes_ciphertexts: &[Ciphertext],
-    ) -> Self {
-        // note: this is only called from `prepare_blind_sign` that already checks
-        // whether private attributes are non-empty and whether we don't have too many
-        // attributes in total to sign.
-        // we also know, due to the single call place, that ephemeral_keys.len() == private_attributes.len()
-
-        // witness creation
-
-        let witness_commitment_opening = params.random_scalar();
-        let witness_private_elgamal_key = params.random_scalar();
-        let witness_keys = params.n_random_scalars(ephemeral_keys.len());
-        let witness_attributes = params.n_random_scalars(private_attributes.len());
-
-        // recompute h
-        let h = hash_g1(commitment.to_bytes());
-        let hs_bytes = params
-            .gen_hs()
-            .iter()
-            .map(|h| h.to_bytes())
-            .collect::<Vec<_>>();
-
-        let g1 = params.gen1();
-
-        // compute commitments
-        let commitment_private_key_elgamal = g1 * witness_private_elgamal_key;
-
-        // Aw[i] = (wk[i] * g1)
-        let commitment_keys1_bytes = witness_keys
-            .iter()
-            .map(|wk_i| g1 * wk_i)
-            .map(|witness| witness.to_bytes())
-            .collect::<Vec<_>>();
-
-        // Bw[i] = (wm[i] * h) + (wk[i] * gamma)
-        let commitment_keys2_bytes = witness_keys
-            .iter()
-            .zip(witness_attributes.iter())
-            .map(|(wk_i, wm_i)| elgamal_keypair.public_key() * wk_i + h * wm_i)
-            .map(|witness| witness.to_bytes())
-            .collect::<Vec<_>>();
-
-        // zkp commitment for the attributes commitment cm
-        // Ccm = (wr * g1) + (wm[0] * hs[0]) + ... + (wm[i] * hs[i])
-        let commitment_attributes = g1 * witness_commitment_opening
-            + witness_attributes
-                .iter()
-                .zip(params.gen_hs().iter())
-                .map(|(wm_i, hs_i)| hs_i * wm_i)
-                .sum::<G1Projective>();
-
-        let ciphertexts_bytes = priv_attributes_ciphertexts
-            .iter()
-            .map(|c| c.to_bytes())
-            .collect::<Vec<_>>();
-
-        // compute challenge
-        let challenge = compute_challenge::<ChallengeDigest, _, _>(
-            std::iter::once(params.gen1().to_bytes().as_ref())
-                .chain(hs_bytes.iter().map(|hs| hs.as_ref()))
-                .chain(std::iter::once(h.to_bytes().as_ref()))
-                .chain(std::iter::once(
-                    elgamal_keypair.public_key().to_bytes().as_ref(),
-                ))
-                .chain(std::iter::once(commitment.to_bytes().as_ref()))
-                .chain(std::iter::once(commitment_attributes.to_bytes().as_ref()))
-                .chain(std::iter::once(
-                    commitment_private_key_elgamal.to_bytes().as_ref(),
-                ))
-                .chain(commitment_keys1_bytes.iter().map(|aw| aw.as_ref()))
-                .chain(commitment_keys2_bytes.iter().map(|bw| bw.as_ref()))
-                .chain(ciphertexts_bytes.iter().map(|c| c.as_ref())),
-        );
-
-        // Responses
-        let response_opening =
-            produce_response(&witness_commitment_opening, &challenge, commitment_opening);
-        let response_private_elgamal_key = produce_response(
-            &witness_private_elgamal_key,
-            &challenge,
-            &elgamal_keypair.private_key().0,
-        );
-        let response_keys = produce_responses(&witness_keys, &challenge, ephemeral_keys);
-        let response_attributes = produce_responses(
-            &witness_attributes,
-            &challenge,
-            &private_attributes.iter().collect::<Vec<_>>(),
-        );
-
-        ProofCmCs {
-            challenge,
-            response_opening,
-            response_private_elgamal_key,
-            response_keys,
-            response_attributes,
-        }
-    }
-
-    pub(crate) fn verify(
-        &self,
-        params: &Parameters,
-        pub_key: &elgamal::PublicKey,
-        commitment: &G1Projective,
-        attributes_ciphertexts: &[elgamal::Ciphertext],
-    ) -> bool {
-        if self.response_keys.len() != attributes_ciphertexts.len() {
-            return false;
-        }
-
-        // recompute h
-        let h = hash_g1(commitment.to_bytes());
-        let g1 = params.gen1();
-
-        let hs_bytes = params
-            .gen_hs()
-            .iter()
-            .map(|h| h.to_bytes())
-            .collect::<Vec<_>>();
-
-        // recompute witnesses commitments
-        let commitment_private_key_elgamal =
-            pub_key * &self.challenge + g1 * self.response_private_elgamal_key;
-
-        // Aw[i] = (c * c1[i]) + (rk[i] * g1)
-        let commitment_keys1_bytes = attributes_ciphertexts
-            .iter()
-            .map(|ciphertext| ciphertext.c1())
-            .zip(self.response_keys.iter())
-            .map(|(c1, res_k)| c1 * self.challenge + g1 * res_k)
-            .map(|witness| witness.to_bytes())
-            .collect::<Vec<_>>();
-
-        // Bw[i] = (c * c2[i]) + (rk[i] * gamma) + (rm[i] * h)
-        let commitment_keys2_bytes = izip!(
-            attributes_ciphertexts
-                .iter()
-                .map(|ciphertext| ciphertext.c2()),
-            self.response_keys.iter(),
-            self.response_attributes.iter()
-        )
-        .map(|(c2, res_key, res_attr)| c2 * self.challenge + pub_key * res_key + h * res_attr)
-        .map(|witness| witness.to_bytes())
-        .collect::<Vec<_>>();
-
-        // Cw = (cm * c) + (rr * g1) + (rm[0] * hs[0]) + ... + (rm[n] * hs[n])
-        let commitment_attributes = commitment * self.challenge
-            + g1 * self.response_opening
-            + self
-                .response_attributes
-                .iter()
-                .zip(params.gen_hs().iter())
-                .map(|(res_attr, hs)| hs * res_attr)
-                .sum::<G1Projective>();
-
-        let ciphertexts_bytes = attributes_ciphertexts
-            .iter()
-            .map(|c| c.to_bytes())
-            .collect::<Vec<_>>();
-
-        // re-compute the challenge
-        let challenge = compute_challenge::<ChallengeDigest, _, _>(
-            std::iter::once(params.gen1().to_bytes().as_ref())
-                .chain(hs_bytes.iter().map(|hs| hs.as_ref()))
-                .chain(std::iter::once(h.to_bytes().as_ref()))
-                .chain(std::iter::once(pub_key.to_bytes().as_ref()))
-                .chain(std::iter::once(commitment.to_bytes().as_ref()))
-                .chain(std::iter::once(commitment_attributes.to_bytes().as_ref()))
-                .chain(std::iter::once(
-                    commitment_private_key_elgamal.to_bytes().as_ref(),
-                ))
-                .chain(commitment_keys1_bytes.iter().map(|aw| aw.as_ref()))
-                .chain(commitment_keys2_bytes.iter().map(|bw| bw.as_ref()))
-                .chain(ciphertexts_bytes.iter().map(|c| c.as_ref())),
-        );
-
-        challenge == self.challenge
-    }
-
-    // challenge || response opening || response private elgamal key || keys len || response keys || attributes len || response attributes
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        let keys_len = self.response_keys.len() as u64;
-        let attributes_len = self.response_attributes.len() as u64;
-
-        let mut bytes = Vec::with_capacity(16 + (keys_len + attributes_len + 3) as usize * 32);
-
-        bytes.extend_from_slice(&self.challenge.to_bytes());
-        bytes.extend_from_slice(&self.response_opening.to_bytes());
-        bytes.extend_from_slice(&self.response_private_elgamal_key.to_bytes());
-        bytes.extend_from_slice(&keys_len.to_le_bytes());
-
-        for rk in &self.response_keys {
-            bytes.extend_from_slice(&rk.to_bytes());
-        }
-
-        bytes.extend_from_slice(&attributes_len.to_le_bytes());
-
-        for rm in &self.response_attributes {
-            bytes.extend_from_slice(&rm.to_bytes());
-        }
-
-        bytes
-    }
-
-    pub(crate) fn from_bytes(bytes: &[u8]) -> Result<Self> {
-        // at the very minimum there must be a single attribute being proven
-        if bytes.len() < 32 * 5 + 16 || (bytes.len() - 16) % 32 != 0 {
-            return Err(
-                CoconutError::Deserialization(
-                    "tried to deserialize proof of ciphertexts and commitment with bytes of invalid length".to_string())
-            );
-        }
-
-        let mut idx = 0;
-        let challenge_bytes = bytes[idx..idx + 32].try_into().unwrap();
-        idx += 32;
-        let response_opening_bytes = bytes[idx..idx + 32].try_into().unwrap();
-        idx += 32;
-        let response_private_elgamal_key_bytes = bytes[idx..idx + 32].try_into().unwrap();
-        idx += 32;
-
-        let challenge = try_deserialize_scalar(
-            &challenge_bytes,
-            CoconutError::Deserialization("Failed to deserialize challenge".to_string()),
-        )?;
-        let response_opening = try_deserialize_scalar(
-            &response_opening_bytes,
-            CoconutError::Deserialization(
-                "Failed to deserialize the response to the random".to_string(),
-            ),
-        )?;
-        let response_private_elgamal_key = try_deserialize_scalar(
-            &response_private_elgamal_key_bytes,
-            CoconutError::Deserialization(
-                "Failed to deserialize the response to the private ElGamal key".to_string(),
-            ),
-        )?;
-
-        let rk_len = u64::from_le_bytes(bytes[idx..idx + 8].try_into().unwrap());
-        idx += 8;
-        if bytes[idx..].len() < rk_len as usize * 32 + 8 {
-            return Err(
-                CoconutError::Deserialization(
-                    "tried to deserialize proof of ciphertexts and commitment with insufficient number of bytes provided".to_string()),
-            );
-        }
-
-        let rk_end = idx + rk_len as usize * 32;
-        let response_keys = try_deserialize_scalar_vec(
-            rk_len,
-            &bytes[idx..rk_end],
-            CoconutError::Deserialization("Failed to deserialize keys response".to_string()),
-        )?;
-
-        let rm_len = u64::from_le_bytes(bytes[rk_end..rk_end + 8].try_into().unwrap());
-        let response_attributes = try_deserialize_scalar_vec(
-            rm_len,
-            &bytes[rk_end + 8..],
-            CoconutError::Deserialization("Failed to deserialize attributes response".to_string()),
-        )?;
-
-        Ok(ProofCmCs {
-            challenge,
-            response_opening,
-            response_private_elgamal_key,
-            response_keys,
-            response_attributes,
-        })
-    }
-}
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct ProofKappaZeta {
-    // c
-    challenge: Scalar,
-
-    // responses
-    response_serial_number: Scalar,
-    response_binding_number: Scalar,
-    response_blinder: Scalar,
-}
-
-impl ProofKappaZeta {
-    pub(crate) fn construct(
-        params: &Parameters,
-        verification_key: &VerificationKey,
-        serial_number: &Attribute,
-        binding_number: &Attribute,
-        blinding_factor: &Scalar,
-        blinded_message: &G2Projective,
-        blinded_serial_number: &G2Projective,
-    ) -> Self {
-        // create the witnesses
-        let witness_blinder = params.random_scalar();
-        let witness_serial_number = params.random_scalar();
-        let witness_binding_number = params.random_scalar();
-        let witness_attributes = vec![witness_serial_number, witness_binding_number];
-
-        let beta_bytes = verification_key
-            .beta
-            .iter()
-            .map(|beta_i| beta_i.to_bytes())
-            .collect::<Vec<_>>();
-
-        // witnesses commitments
-        // Aw = g2 * wt + alpha + beta[0] * wm[0] + ... + beta[i] * wm[i]
-        let commitment_kappa = params.gen2() * witness_blinder
-            + verification_key.alpha
-            + witness_attributes
-                .iter()
-                .zip(verification_key.beta.iter())
-                .map(|(wm_i, beta_i)| beta_i * wm_i)
-                .sum::<G2Projective>();
-
-        // zeta is the public value associated with the serial number
-        let commitment_zeta = params.gen2() * witness_serial_number;
-
-        let challenge = compute_challenge::<ChallengeDigest, _, _>(
-            std::iter::once(params.gen2().to_bytes().as_ref())
-                .chain(std::iter::once(blinded_message.to_bytes().as_ref()))
-                .chain(std::iter::once(blinded_serial_number.to_bytes().as_ref()))
-                .chain(std::iter::once(verification_key.alpha.to_bytes().as_ref()))
-                .chain(beta_bytes.iter().map(|b| b.as_ref()))
-                .chain(std::iter::once(commitment_kappa.to_bytes().as_ref()))
-                .chain(std::iter::once(commitment_zeta.to_bytes().as_ref())),
-        );
-
-        // responses
-        let response_blinder = produce_response(&witness_blinder, &challenge, blinding_factor);
-        let response_serial_number =
-            produce_response(&witness_serial_number, &challenge, serial_number);
-        let response_binding_number =
-            produce_response(&witness_binding_number, &challenge, binding_number);
-
-        ProofKappaZeta {
-            challenge,
-            response_serial_number,
-            response_binding_number,
-            response_blinder,
-        }
-    }
-
-    pub(crate) fn private_attributes_len(&self) -> usize {
-        2
-    }
-
-    pub(crate) fn verify(
-        &self,
-        params: &Parameters,
-        verification_key: &VerificationKey,
-        kappa: &G2Projective,
-        zeta: &G2Projective,
-    ) -> bool {
-        let beta_bytes = verification_key
-            .beta
-            .iter()
-            .map(|beta_i| beta_i.to_bytes())
-            .collect::<Vec<_>>();
-
-        let response_attributes = vec![self.response_serial_number, self.response_binding_number];
-        // re-compute witnesses commitments
-        // Aw = (c * kappa) + (rt * g2) + ((1 - c) * alpha) + (rm[0] * beta[0]) + ... + (rm[i] * beta[i])
-        let commitment_kappa = kappa * self.challenge
-            + params.gen2() * self.response_blinder
-            + verification_key.alpha * (Scalar::one() - self.challenge)
-            + response_attributes
-                .iter()
-                .zip(verification_key.beta.iter())
-                .map(|(priv_attr, beta_i)| beta_i * priv_attr)
-                .sum::<G2Projective>();
-
-        // zeta is the public value associated with the serial number
-        let commitment_zeta = zeta * self.challenge + params.gen2() * self.response_serial_number;
-
-        // compute the challenge
-        let challenge = compute_challenge::<ChallengeDigest, _, _>(
-            std::iter::once(params.gen2().to_bytes().as_ref())
-                .chain(std::iter::once(kappa.to_bytes().as_ref()))
-                .chain(std::iter::once(zeta.to_bytes().as_ref()))
-                .chain(std::iter::once(verification_key.alpha.to_bytes().as_ref()))
-                .chain(beta_bytes.iter().map(|b| b.as_ref()))
-                .chain(std::iter::once(commitment_kappa.to_bytes().as_ref()))
-                .chain(std::iter::once(commitment_zeta.to_bytes().as_ref())),
-        );
-
-        challenge == self.challenge
-    }
-
-    // challenge || response serial number || response binding number || repose blinder
-    pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        let attributes_len = 2; // because we have serial number and the binding number
-        let mut bytes = Vec::with_capacity((1 + attributes_len + 1) as usize * 32);
-
-        bytes.extend_from_slice(&self.challenge.to_bytes());
-        bytes.extend_from_slice(&self.response_serial_number.to_bytes());
-        bytes.extend_from_slice(&self.response_binding_number.to_bytes());
-
-        bytes.extend_from_slice(&self.response_blinder.to_bytes());
-
-        bytes
-    }
-
-    pub(crate) fn from_bytes(bytes: &[u8]) -> Result<Self> {
-        // at the very minimum there must be a single attribute being proven
-        if bytes.len() < 32 * 4 || (bytes.len()) % 32 != 0 {
-            return Err(CoconutError::DeserializationInvalidLength {
-                actual: bytes.len(),
-                modulus_target: bytes.len(),
-                modulus: 32,
-                object: "kappa and zeta".to_string(),
-                target: 32 * 4,
-            });
-        }
-
-        let challenge_bytes = bytes[..32].try_into().unwrap();
-        let challenge = try_deserialize_scalar(
-            &challenge_bytes,
-            CoconutError::Deserialization("Failed to deserialize challenge".to_string()),
-        )?;
-
-        let serial_number_bytes = &bytes[32..64].try_into().unwrap();
-        let response_serial_number = try_deserialize_scalar(
-            serial_number_bytes,
-            CoconutError::Deserialization("failed to deserialize the serial number".to_string()),
-        )?;
-
-        let binding_number_bytes = &bytes[64..96].try_into().unwrap();
-        let response_binding_number = try_deserialize_scalar(
-            binding_number_bytes,
-            CoconutError::Deserialization("failed to deserialize the binding number".to_string()),
-        )?;
-
-        let blinder_bytes = bytes[96..].try_into().unwrap();
-        let response_blinder = try_deserialize_scalar(
-            &blinder_bytes,
-            CoconutError::Deserialization("failed to deserialize the blinder".to_string()),
-        )?;
-
-        Ok(ProofKappaZeta {
-            challenge,
-            response_serial_number,
-            response_binding_number,
-            response_blinder,
-        })
-    }
-}
-
-// proof builder:
-// - commitment
-// - challenge
-// - responses
-
-#[cfg(test)]
-mod tests {
-    use group::Group;
-    use rand::thread_rng;
-
-    use crate::scheme::issuance::{compute_attribute_encryption, compute_commitment_hash};
-    use crate::scheme::keygen::keygen;
-    use crate::scheme::setup::setup;
-    use crate::scheme::verification::{compute_kappa, compute_zeta};
-
-    use super::*;
-
-    #[test]
-    fn proof_cm_cs_bytes_roundtrip() {
-        let mut rng = thread_rng();
-        let mut params = setup(1).unwrap();
-
-        let elgamal_keypair = elgamal::elgamal_keygen(&params);
-        let private_attributes = params.n_random_scalars(1);
-
-        // we don't care about 'correctness' of the proof. only whether we can correctly recover it from bytes
-        let cm = G1Projective::random(&mut rng);
-        let r = params.random_scalar();
-
-        let commitment_hash = compute_commitment_hash(cm);
-        let (attributes_ciphertexts, _): (Vec<_>, Vec<_>) = compute_attribute_encryption(
-            &params,
-            private_attributes.as_ref(),
-            elgamal_keypair.public_key(),
-            commitment_hash,
-        );
-        let ephemeral_keys = params.n_random_scalars(1);
-
-        // 0 public 1 private
-        let pi_s = ProofCmCs::construct(
-            &mut params,
-            &elgamal_keypair,
-            &ephemeral_keys,
-            &cm,
-            &r,
-            &private_attributes,
-            &*attributes_ciphertexts,
-        );
-
-        let bytes = pi_s.to_bytes();
-        assert_eq!(ProofCmCs::from_bytes(&bytes).unwrap(), pi_s);
-
-        // 2 private
-        let private_attributes = params.n_random_scalars(2);
-        let ephemeral_keys = params.n_random_scalars(2);
-
-        let pi_s = ProofCmCs::construct(
-            &mut params,
-            &elgamal_keypair,
-            &ephemeral_keys,
-            &cm,
-            &r,
-            &private_attributes,
-            &*attributes_ciphertexts,
-        );
-
-        let bytes = pi_s.to_bytes();
-        assert_eq!(ProofCmCs::from_bytes(&bytes).unwrap(), pi_s);
-    }
-
-    #[test]
-    fn proof_kappa_zeta_bytes_roundtrip() {
-        let mut params = setup(4).unwrap();
-
-        let keypair = keygen(&mut params);
-
-        // we don't care about 'correctness' of the proof. only whether we can correctly recover it from bytes
-        let serial_number = params.random_scalar();
-        let binding_number = params.random_scalar();
-        let private_attributes = vec![serial_number, binding_number];
-
-        let r = params.random_scalar();
-        let kappa = compute_kappa(&params, &keypair.verification_key(), &private_attributes, r);
-        let zeta = compute_zeta(&params, serial_number);
-
-        // 0 public 2 private
-        let pi_v = ProofKappaZeta::construct(
-            &mut params,
-            &keypair.verification_key(),
-            &serial_number,
-            &binding_number,
-            &r,
-            &kappa,
-            &zeta,
-        );
-
-        let proof_bytes = pi_v.to_bytes();
-
-        let proof_from_bytes = ProofKappaZeta::from_bytes(&proof_bytes).unwrap();
-        assert_eq!(proof_from_bytes, pi_v);
-
-        // 2 public 2 private
-        let mut params = setup(4).unwrap();
-        let keypair = keygen(&mut params);
-
-        let pi_v = ProofKappaZeta::construct(
-            &mut params,
-            &keypair.verification_key(),
-            &serial_number,
-            &binding_number,
-            &r,
-            &kappa,
-            &zeta,
-        );
-
-        let proof_bytes = pi_v.to_bytes();
-
-        let proof_from_bytes = ProofKappaZeta::from_bytes(&proof_bytes).unwrap();
-        assert_eq!(proof_from_bytes, pi_v);
-    }
-}
@@ -1,377 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use core::iter::Sum;
-use core::ops::Mul;
-
-use bls12_381::{G2Prepared, G2Projective, Scalar};
-use group::Curve;
-use itertools::Itertools;
-
-use crate::error::{CoconutError, Result};
-use crate::scheme::verification::check_bilinear_pairing;
-use crate::scheme::{PartialSignature, Signature, SignatureShare, SignerIndex, VerificationKey};
-use crate::utils::perform_lagrangian_interpolation_at_origin;
-use crate::{Attribute, Parameters};
-
-pub(crate) trait Aggregatable: Sized {
-    fn aggregate(aggregatable: &[Self], indices: Option<&[SignerIndex]>) -> Result<Self>;
-
-    fn check_unique_indices(indices: &[SignerIndex]) -> bool {
-        // if aggregation is a threshold one, all indices should be unique
-        indices.iter().unique_by(|&index| index).count() == indices.len()
-    }
-}
-
-// includes `VerificationKey`
-impl<T> Aggregatable for T
-where
-    T: Sum,
-    for<'a> T: Sum<&'a T>,
-    for<'a> &'a T: Mul<Scalar, Output = T>,
-{
-    fn aggregate(aggregatable: &[T], indices: Option<&[u64]>) -> Result<T> {
-        if aggregatable.is_empty() {
-            return Err(CoconutError::Aggregation("Empty set of values".to_string()));
-        }
-
-        if let Some(indices) = indices {
-            if !Self::check_unique_indices(indices) {
-                return Err(CoconutError::Aggregation("Non-unique indices".to_string()));
-            }
-            perform_lagrangian_interpolation_at_origin(indices, aggregatable)
-        } else {
-            // non-threshold
-            Ok(aggregatable.iter().sum())
-        }
-    }
-}
-
-impl Aggregatable for PartialSignature {
-    fn aggregate(sigs: &[PartialSignature], indices: Option<&[u64]>) -> Result<Signature> {
-        let h = sigs
-            .get(0)
-            .ok_or_else(|| CoconutError::Aggregation("Empty set of signatures".to_string()))?
-            .sig1();
-
-        // TODO: is it possible to avoid this allocation?
-        let sigmas = sigs.iter().map(|sig| *sig.sig2()).collect::<Vec<_>>();
-        let aggr_sigma = Aggregatable::aggregate(&sigmas, indices)?;
-
-        Ok(Signature(*h, aggr_sigma))
-    }
-}
-
-/// Ensures all provided verification keys were generated to verify the same number of attributes.
-fn check_same_key_size(keys: &[VerificationKey]) -> bool {
-    keys.iter().map(|vk| vk.beta.len()).all_equal()
-}
-
-pub fn aggregate_verification_keys(
-    keys: &[VerificationKey],
-    indices: Option<&[SignerIndex]>,
-) -> Result<VerificationKey> {
-    if !check_same_key_size(keys) {
-        return Err(CoconutError::Aggregation(
-            "Verification keys are of different sizes".to_string(),
-        ));
-    }
-    Aggregatable::aggregate(keys, indices)
-}
-
-pub fn aggregate_signatures(
-    params: &Parameters,
-    verification_key: &VerificationKey,
-    attributes: &[Attribute],
-    signatures: &[PartialSignature],
-    indices: Option<&[SignerIndex]>,
-) -> Result<Signature> {
-    // aggregate the signature
-
-    let signature = match Aggregatable::aggregate(signatures, indices) {
-        Ok(res) => res,
-        Err(err) => return Err(err),
-    };
-
-    // Verify the signature
-    let alpha = verification_key.alpha;
-
-    let tmp = attributes
-        .iter()
-        .zip(verification_key.beta.iter())
-        .map(|(attr, beta_i)| beta_i * attr)
-        .sum::<G2Projective>();
-
-    if !check_bilinear_pairing(
-        &signature.0.to_affine(),
-        &G2Prepared::from((alpha + tmp).to_affine()),
-        &signature.1.to_affine(),
-        params.prepared_miller_g2(),
-    ) {
-        return Err(CoconutError::Aggregation(
-            "Verification of the aggregated signature failed".to_string(),
-        ));
-    }
-    Ok(signature)
-}
-
-pub fn aggregate_signature_shares(
-    params: &Parameters,
-    verification_key: &VerificationKey,
-    attributes: &[Attribute],
-    shares: &[SignatureShare],
-) -> Result<Signature> {
-    let (signatures, indices): (Vec<_>, Vec<_>) = shares
-        .iter()
-        .map(|share| (*share.signature(), share.index()))
-        .unzip();
-
-    aggregate_signatures(
-        params,
-        verification_key,
-        attributes,
-        &signatures,
-        Some(&indices),
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use bls12_381::G1Projective;
-    use group::Group;
-
-    use crate::scheme::issuance::sign;
-    use crate::scheme::keygen::ttp_keygen;
-    use crate::scheme::setup::Parameters;
-    use crate::scheme::verification::verify;
-
-    use super::*;
-
-    #[test]
-    fn key_aggregation_works_for_any_subset_of_keys() {
-        let mut params = Parameters::new(2).unwrap();
-        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
-
-        let vks = keypairs
-            .into_iter()
-            .map(|keypair| keypair.verification_key())
-            .collect::<Vec<_>>();
-
-        let aggr_vk1 = aggregate_verification_keys(&vks[..3], Some(&[1, 2, 3])).unwrap();
-        let aggr_vk2 = aggregate_verification_keys(&vks[2..], Some(&[3, 4, 5])).unwrap();
-
-        assert_eq!(aggr_vk1, aggr_vk2);
-
-        // TODO: should those two actually work or not?
-        // aggregating threshold+1
-        let aggr_more = aggregate_verification_keys(&vks[1..], Some(&[2, 3, 4, 5])).unwrap();
-        assert_eq!(aggr_vk1, aggr_more);
-
-        // aggregating all
-        let aggr_all = aggregate_verification_keys(&vks, Some(&[1, 2, 3, 4, 5])).unwrap();
-        assert_eq!(aggr_all, aggr_vk1);
-
-        // not taking enough points (threshold was 3)
-        let aggr_not_enough = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
-        assert_ne!(aggr_not_enough, aggr_vk1);
-
-        // taking wrong index
-        let aggr_bad = aggregate_verification_keys(&vks[2..], Some(&[42, 123, 100])).unwrap();
-        assert_ne!(aggr_vk1, aggr_bad);
-    }
-
-    #[test]
-    fn key_aggregation_doesnt_work_for_empty_set_of_keys() {
-        let keys: Vec<VerificationKey> = vec![];
-        assert!(aggregate_verification_keys(&keys, None).is_err());
-    }
-
-    #[test]
-    fn key_aggregation_doesnt_work_if_indices_have_invalid_length() {
-        let keys = vec![VerificationKey::identity(3)];
-
-        assert!(aggregate_verification_keys(&keys, Some(&[])).is_err());
-        assert!(aggregate_verification_keys(&keys, Some(&[1, 2])).is_err());
-    }
-
-    #[test]
-    fn key_aggregation_doesnt_work_for_non_unique_indices() {
-        let keys = vec![VerificationKey::identity(3), VerificationKey::identity(3)];
-
-        assert!(aggregate_verification_keys(&keys, Some(&[1, 1])).is_err());
-    }
-
-    #[test]
-    fn key_aggregation_doesnt_work_for_keys_of_different_size() {
-        let keys = vec![VerificationKey::identity(3), VerificationKey::identity(1)];
-
-        assert!(aggregate_verification_keys(&keys, None).is_err())
-    }
-
-    #[test]
-    fn signature_aggregation_works_for_any_subset_of_signatures() {
-        let mut params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
-
-        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
-
-        let (sks, vks): (Vec<_>, Vec<_>) = keypairs
-            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
-            .unzip();
-
-        let sigs = sks
-            .iter()
-            .map(|sk| sign(&mut params, sk, &attributes).unwrap())
-            .collect::<Vec<_>>();
-
-        // aggregating (any) threshold works
-        let aggr_vk_1 = aggregate_verification_keys(&vks[..3], Some(&[1, 2, 3])).unwrap();
-        let aggr_sig1 = aggregate_signatures(
-            &params,
-            &aggr_vk_1,
-            &attributes,
-            &sigs[..3],
-            Some(&[1, 2, 3]),
-        )
-        .unwrap();
-
-        let aggr_vk_2 = aggregate_verification_keys(&vks[2..], Some(&[3, 4, 5])).unwrap();
-        let aggr_sig2 = aggregate_signatures(
-            &params,
-            &aggr_vk_1,
-            &attributes,
-            &sigs[2..],
-            Some(&[3, 4, 5]),
-        )
-        .unwrap();
-        assert_eq!(aggr_sig1, aggr_sig2);
-
-        // verify credential for good measure
-        assert!(verify(&params, &aggr_vk_1, &attributes, &aggr_sig1));
-        assert!(verify(&params, &aggr_vk_2, &attributes, &aggr_sig2));
-
-        // aggregating threshold+1 works
-        let aggr_vk_more = aggregate_verification_keys(&vks[1..], Some(&[2, 3, 4, 5])).unwrap();
-        let aggr_more = aggregate_signatures(
-            &params,
-            &aggr_vk_more,
-            &attributes,
-            &sigs[1..],
-            Some(&[2, 3, 4, 5]),
-        )
-        .unwrap();
-        assert_eq!(aggr_sig1, aggr_more);
-
-        // aggregating all
-        let aggr_vk_all = aggregate_verification_keys(&vks, Some(&[1, 2, 3, 4, 5])).unwrap();
-        let aggr_all = aggregate_signatures(
-            &params,
-            &aggr_vk_all,
-            &attributes,
-            &sigs,
-            Some(&[1, 2, 3, 4, 5]),
-        )
-        .unwrap();
-        assert_eq!(aggr_all, aggr_sig1);
-
-        // not taking enough points (threshold was 3) should fail
-        let aggr_vk_not_enough = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
-        let aggr_not_enough = aggregate_signatures(
-            &params,
-            &aggr_vk_not_enough,
-            &attributes,
-            &sigs[..2],
-            Some(&[1, 2]),
-        )
-        .unwrap();
-        assert_ne!(aggr_not_enough, aggr_sig1);
-
-        // taking wrong index should fail
-        let aggr_vk_bad = aggregate_verification_keys(&vks[2..], Some(&[1, 2, 3])).unwrap();
-        assert!(aggregate_signatures(
-            &params,
-            &aggr_vk_bad,
-            &attributes,
-            &sigs[2..],
-            Some(&[42, 123, 100]),
-        )
-        .is_err());
-    }
-
-    fn random_signature() -> Signature {
-        let mut rng = rand::thread_rng();
-        Signature(
-            G1Projective::random(&mut rng),
-            G1Projective::random(&mut rng),
-        )
-    }
-
-    #[test]
-    fn signature_aggregation_doesnt_work_for_empty_set_of_signatures() {
-        let signatures: Vec<Signature> = vec![];
-        let mut params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
-        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
-
-        let (_, vks): (Vec<_>, Vec<_>) = keypairs
-            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
-            .unzip();
-
-        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
-        assert!(
-            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, None).is_err()
-        );
-    }
-
-    #[test]
-    fn signature_aggregation_doesnt_work_if_indices_have_invalid_length() {
-        let signatures = vec![random_signature()];
-        let mut params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
-        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
-        let (_, vks): (Vec<_>, Vec<_>) = keypairs
-            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
-            .unzip();
-        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
-
-        assert!(
-            aggregate_signatures(&params, &aggr_vk_all, &attributes, &signatures, Some(&[]))
-                .is_err()
-        );
-        assert!(aggregate_signatures(
-            &params,
-            &aggr_vk_all,
-            &attributes,
-            &signatures,
-            Some(&[1, 2]),
-        )
-        .is_err());
-    }
-
-    #[test]
-    fn signature_aggregation_doesnt_work_for_non_unique_indices() {
-        let signatures = vec![random_signature(), random_signature()];
-        let mut params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
-        let keypairs = ttp_keygen(&mut params, 3, 5).unwrap();
-        let (_, vks): (Vec<_>, Vec<_>) = keypairs
-            .into_iter()
-            .map(|keypair| (keypair.secret_key(), keypair.verification_key()))
-            .unzip();
-        let aggr_vk_all = aggregate_verification_keys(&vks, None).unwrap();
-
-        assert!(aggregate_signatures(
-            &params,
-            &aggr_vk_all,
-            &attributes,
-            &signatures,
-            Some(&[1, 1]),
-        )
-        .is_err());
-    }
-
-    // TODO: test for aggregating non-threshold keys
-}
@@ -1,382 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use std::convert::TryFrom;
-use std::convert::TryInto;
-
-use bls12_381::{G1Affine, G1Projective, Scalar};
-use group::{Curve, GroupEncoding};
-
-use crate::elgamal::{Ciphertext, EphemeralKey};
-use crate::error::{CoconutError, Result};
-use crate::proofs::ProofCmCs;
-use crate::scheme::setup::Parameters;
-use crate::scheme::BlindedSignature;
-use crate::scheme::SecretKey;
-/// Creates a Coconut Signature under a given secret key on a set of public attributes only.
-#[cfg(test)]
-use crate::Signature;
-use crate::{elgamal, Attribute, ElGamalKeyPair};
-// TODO: possibly completely remove those two functions.
-// They only exist to have a simpler and smaller code snippets to test
-// basic functionalities.
-use crate::traits::{Base58, Bytable};
-use crate::utils::{hash_g1, try_deserialize_g1_projective};
-
-// TODO NAMING: double check this one
-// Lambda
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct BlindSignRequest {
-    // cm
-    commitment: G1Projective,
-    // h
-    commitment_hash: G1Projective,
-    // c
-    private_attributes_ciphertexts: Vec<elgamal::Ciphertext>,
-    // pi_s
-    pi_s: ProofCmCs,
-}
-
-impl TryFrom<&[u8]> for BlindSignRequest {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<BlindSignRequest> {
-        if bytes.len() < 48 + 48 + 8 + 96 {
-            return Err(CoconutError::DeserializationMinLength {
-                min: 48 + 48 + 8 + 96,
-                actual: bytes.len(),
-            });
-        }
-
-        let mut j = 0;
-        let commitment_bytes_len = 48;
-        let commitment_hash_bytes_len = 48;
-
-        let cm_bytes = bytes[..j + commitment_bytes_len].try_into().unwrap();
-        let commitment = try_deserialize_g1_projective(
-            &cm_bytes,
-            CoconutError::Deserialization(
-                "Failed to deserialize compressed commitment".to_string(),
-            ),
-        )?;
-        j += commitment_bytes_len;
-
-        let cm_hash_bytes = bytes[j..j + commitment_hash_bytes_len].try_into().unwrap();
-        let commitment_hash = try_deserialize_g1_projective(
-            &cm_hash_bytes,
-            CoconutError::Deserialization(
-                "Failed to deserialize compressed commitment hash".to_string(),
-            ),
-        )?;
-        j += commitment_hash_bytes_len;
-
-        let c_len = u64::from_le_bytes(bytes[j..j + 8].try_into().unwrap());
-        j += 8;
-        if bytes[j..].len() < c_len as usize * 96 {
-            return Err(CoconutError::DeserializationMinLength {
-                min: c_len as usize * 96,
-                actual: bytes[56..].len(),
-            });
-        }
-
-        let mut private_attributes_ciphertexts = Vec::with_capacity(c_len as usize);
-        for i in 0..c_len as usize {
-            let start = j + i * 96;
-            let end = start + 96;
-            private_attributes_ciphertexts.push(Ciphertext::try_from(&bytes[start..end])?)
-        }
-
-        let pi_s = ProofCmCs::from_bytes(&bytes[j + c_len as usize * 96..])?;
-
-        Ok(BlindSignRequest {
-            commitment,
-            commitment_hash,
-            private_attributes_ciphertexts,
-            pi_s,
-        })
-    }
-}
-
-impl Bytable for BlindSignRequest {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        let cm_bytes = self.commitment.to_affine().to_compressed();
-        let cm_hash_bytes = self.commitment_hash.to_affine().to_compressed();
-        let c_len = self.private_attributes_ciphertexts.len() as u64;
-        let proof_bytes = self.pi_s.to_bytes();
-
-        let mut bytes = Vec::with_capacity(48 + 48 + 8 + c_len as usize * 96 + proof_bytes.len());
-
-        bytes.extend_from_slice(&cm_bytes);
-        bytes.extend_from_slice(&cm_hash_bytes);
-        bytes.extend_from_slice(&c_len.to_le_bytes());
-        for c in &self.private_attributes_ciphertexts {
-            bytes.extend_from_slice(&c.to_bytes());
-        }
-
-        bytes.extend_from_slice(&proof_bytes);
-
-        bytes
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        BlindSignRequest::from_bytes(slice)
-    }
-}
-
-impl Base58 for BlindSignRequest {}
-
-impl BlindSignRequest {
-    fn verify_proof(&self, params: &Parameters, pub_key: &elgamal::PublicKey) -> bool {
-        self.pi_s.verify(
-            params,
-            pub_key,
-            &self.commitment,
-            &self.private_attributes_ciphertexts,
-        )
-    }
-
-    pub fn get_commitment_hash(&self) -> G1Projective {
-        self.commitment_hash
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        self.to_byte_vec()
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<BlindSignRequest> {
-        BlindSignRequest::try_from(bytes)
-    }
-}
-
-pub fn compute_private_attributes_commitment(
-    params: &Parameters,
-    private_attributes: &[Attribute],
-    hs: &[G1Affine],
-) -> (Scalar, G1Projective) {
-    let commitment_opening = params.random_scalar();
-
-    // Produces h0 ^ m0 * h1^m1 * .... * hn^mn
-    // where m0, m1, ...., mn are private attributes
-    let attr_cm = private_attributes
-        .iter()
-        .zip(hs)
-        .map(|(&m, h)| h * m)
-        .sum::<G1Projective>();
-
-    // Produces g1^r * h0 ^ m0 * h1^m1 * .... * hn^mn
-    let commitment = params.gen1() * commitment_opening + attr_cm;
-    (commitment_opening, commitment)
-}
-
-pub fn compute_commitment_hash(commitment: G1Projective) -> G1Projective {
-    hash_g1(commitment.to_bytes())
-}
-
-pub fn compute_attribute_encryption(
-    params: &Parameters,
-    private_attributes: &[Attribute],
-    pub_key: &elgamal::PublicKey,
-    commitment_hash: G1Projective,
-) -> (Vec<Ciphertext>, Vec<EphemeralKey>) {
-    private_attributes
-        .iter()
-        .map(|m| pub_key.encrypt(params, &commitment_hash, m))
-        .unzip()
-}
-
-/// Builds cryptographic material required for blind sign.
-pub fn prepare_blind_sign(
-    params: &Parameters,
-    elgamal_keypair: &ElGamalKeyPair,
-    private_attributes: &[Attribute],
-    public_attributes: &[Attribute],
-) -> Result<BlindSignRequest> {
-    if private_attributes.is_empty() {
-        return Err(CoconutError::Issuance(
-            "Tried to prepare blind sign request for an empty set of private attributes"
-                .to_string(),
-        ));
-    }
-
-    let hs = params.gen_hs();
-    if private_attributes.len() + public_attributes.len() > hs.len() {
-        return Err(CoconutError::IssuanceMaxAttributes {
-            max: hs.len(),
-            requested: private_attributes.len() + public_attributes.len(),
-        });
-    }
-
-    let (commitment_opening, commitment) =
-        compute_private_attributes_commitment(params, private_attributes, hs);
-
-    // Compute the challenge as the commitment hash
-    let commitment_hash = compute_commitment_hash(commitment);
-    // build ElGamal encryption
-    let (private_attributes_ciphertexts, ephemeral_keys): (Vec<_>, Vec<_>) =
-        compute_attribute_encryption(
-            params,
-            private_attributes,
-            elgamal_keypair.public_key(),
-            commitment_hash,
-        );
-
-    let pi_s = ProofCmCs::construct(
-        params,
-        elgamal_keypair,
-        &ephemeral_keys,
-        &commitment,
-        &commitment_opening,
-        private_attributes,
-        &*private_attributes_ciphertexts,
-    );
-
-    Ok(BlindSignRequest {
-        commitment,
-        commitment_hash,
-        private_attributes_ciphertexts,
-        pi_s,
-    })
-}
-
-pub fn blind_sign(
-    params: &Parameters,
-    signing_secret_key: &SecretKey,
-    prover_pub_key: &elgamal::PublicKey,
-    blind_sign_request: &BlindSignRequest,
-    public_attributes: &[Attribute],
-) -> Result<BlindedSignature> {
-    let num_private = blind_sign_request.private_attributes_ciphertexts.len();
-    let hs = params.gen_hs();
-
-    if num_private + public_attributes.len() > hs.len() {
-        return Err(CoconutError::IssuanceMaxAttributes {
-            max: hs.len(),
-            requested: num_private + public_attributes.len(),
-        });
-    }
-
-    // Verify the commitment hash
-    let h = hash_g1(blind_sign_request.commitment.to_bytes());
-    if !(h == blind_sign_request.commitment_hash) {
-        return Err(CoconutError::Issuance(
-            "Failed to verify the commitment hash".to_string(),
-        ));
-    }
-
-    // Verify the ZK proof
-    if !blind_sign_request.verify_proof(params, prover_pub_key) {
-        return Err(CoconutError::Issuance(
-            "Failed to verify the proof of knowledge".to_string(),
-        ));
-    }
-
-    // in python implementation there are n^2 G1 multiplications, let's do it with a single one instead.
-    // i.e. compute h ^ (pub_m[0] * y[m + 1] + ... + pub_m[n] * y[m + n]) directly (where m is number of PRIVATE attributes)
-    // rather than ((h ^ pub_m[0]) ^ y[m + 1] , (h ^ pub_m[1]) ^ y[m + 2] , ...).sum() separately
-    let signed_public = h * public_attributes
-        .iter()
-        .zip(signing_secret_key.ys.iter().skip(num_private))
-        .map(|(attr, yi)| attr * yi)
-        .sum::<Scalar>();
-
-    // c1[0] ^ y[0] * ... * c1[m] ^ y[m]
-    let sig_1 = blind_sign_request
-        .private_attributes_ciphertexts
-        .iter()
-        .map(|ciphertext| ciphertext.c1())
-        .zip(signing_secret_key.ys.iter())
-        .map(|(c1, yi)| c1 * yi)
-        .sum();
-
-    // h ^ x + c2[0] ^ y[0] + ... c2[m] ^ y[m] + h ^ (pub_m[0] * y[m + 1] + ... + pub_m[n] * y[m + n])
-    let sig_2 = blind_sign_request
-        .private_attributes_ciphertexts
-        .iter()
-        .map(|ciphertext| ciphertext.c2())
-        .zip(signing_secret_key.ys.iter())
-        .map(|(c2, yi)| c2 * yi)
-        .chain(std::iter::once(h * signing_secret_key.x))
-        .chain(std::iter::once(signed_public))
-        .sum();
-
-    Ok(BlindedSignature(h, elgamal::Ciphertext(sig_1, sig_2)))
-}
-
-#[cfg(test)]
-pub fn sign(
-    params: &mut Parameters,
-    secret_key: &SecretKey,
-    public_attributes: &[Attribute],
-) -> Result<Signature> {
-    if public_attributes.len() > secret_key.ys.len() {
-        return Err(CoconutError::IssuanceMaxAttributes {
-            max: secret_key.ys.len(),
-            requested: public_attributes.len(),
-        });
-    }
-
-    // TODO: why in the python implementation this hash onto the curve is present
-    // while it's not used in the paper? the paper uses random exponent instead.
-    // (the python implementation hashes string representation of all attributes onto the curve,
-    // but I think the same can be achieved by just summing the attributes thus avoiding the unnecessary
-    // transformation. If I'm wrong, please correct me.)
-    let attributes_sum = public_attributes.iter().sum::<Scalar>();
-    let h = hash_g1((params.gen1() * attributes_sum).to_bytes());
-
-    // x + m0 * y0 + m1 * y1 + ... mn * yn
-    let exponent = secret_key.x
-        + public_attributes
-            .iter()
-            .zip(secret_key.ys.iter())
-            .map(|(m_i, y_i)| m_i * y_i)
-            .sum::<Scalar>();
-
-    let sig2 = h * exponent;
-    Ok(Signature(h, sig2))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn blind_sign_request_bytes_roundtrip() {
-        let mut params = Parameters::new(1).unwrap();
-        let public_attributes = params.n_random_scalars(0);
-        let private_attributes = params.n_random_scalars(1);
-        let elgamal_keypair = elgamal::elgamal_keygen(&params);
-
-        let lambda = prepare_blind_sign(
-            &mut params,
-            &elgamal_keypair,
-            &private_attributes,
-            &public_attributes,
-        )
-        .unwrap();
-
-        let bytes = lambda.to_bytes();
-        println!("{:?}", bytes.len());
-        assert_eq!(
-            BlindSignRequest::try_from(bytes.as_slice()).unwrap(),
-            lambda
-        );
-
-        let mut params = Parameters::new(4).unwrap();
-        let public_attributes = params.n_random_scalars(2);
-        let private_attributes = params.n_random_scalars(2);
-        let lambda = prepare_blind_sign(
-            &mut params,
-            &elgamal_keypair,
-            &private_attributes,
-            &public_attributes,
-        )
-        .unwrap();
-
-        let bytes = lambda.to_bytes();
-        assert_eq!(
-            BlindSignRequest::try_from(bytes.as_slice()).unwrap(),
-            lambda
-        );
-    }
-}
@@ -1,539 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use core::borrow::Borrow;
-use core::iter::Sum;
-use core::ops::{Add, Mul};
-use std::convert::TryFrom;
-use std::convert::TryInto;
-
-use bls12_381::{G2Projective, Scalar};
-use group::Curve;
-use serde_derive::{Deserialize, Serialize};
-
-use crate::error::{CoconutError, Result};
-use crate::scheme::aggregation::aggregate_verification_keys;
-use crate::scheme::setup::Parameters;
-use crate::scheme::SignerIndex;
-use crate::traits::Bytable;
-use crate::utils::{
-    try_deserialize_g2_projective, try_deserialize_scalar, try_deserialize_scalar_vec, Polynomial,
-};
-use crate::Base58;
-
-#[derive(Debug, Clone)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct SecretKey {
-    pub(crate) x: Scalar,
-    pub(crate) ys: Vec<Scalar>,
-}
-
-impl TryFrom<&[u8]> for SecretKey {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<SecretKey> {
-        if bytes.len() < 32 * 2 + 8 || (bytes.len() - 8) % 32 != 0 {
-            return Err(CoconutError::DeserializationInvalidLength {
-                actual: bytes.len(),
-                modulus_target: bytes.len() - 8,
-                target: 32 * 2 + 8,
-                modulus: 32,
-                object: "secret key".to_string(),
-            });
-        }
-
-        // this conversion will not fail as we are taking the same length of data
-        let x_bytes: [u8; 32] = bytes[..32].try_into().unwrap();
-        let ys_len = u64::from_le_bytes(bytes[32..40].try_into().unwrap());
-        let actual_ys_len = (bytes.len() - 40) / 32;
-
-        if ys_len as usize != actual_ys_len {
-            return Err(CoconutError::Deserialization(format!(
-                "Tried to deserialize secret key with inconsistent ys len (expected {}, got {})",
-                ys_len, actual_ys_len
-            )));
-        }
-
-        let x = try_deserialize_scalar(
-            &x_bytes,
-            CoconutError::Deserialization("Failed to deserialize secret key scalar".to_string()),
-        )?;
-        let ys = try_deserialize_scalar_vec(
-            ys_len,
-            &bytes[40..],
-            CoconutError::Deserialization("Failed to deserialize secret key scalars".to_string()),
-        )?;
-
-        Ok(SecretKey { x, ys })
-    }
-}
-
-impl SecretKey {
-    /// Derive verification key using this secret key.
-    pub fn verification_key(&self, params: &Parameters) -> VerificationKey {
-        let g2 = params.gen2();
-        VerificationKey {
-            alpha: g2 * self.x,
-            beta: self.ys.iter().map(|y| g2 * y).collect(),
-        }
-    }
-
-    // x || ys.len() || ys
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let ys_len = self.ys.len() as u64;
-        let mut bytes = Vec::with_capacity(8 + (ys_len + 1) as usize * 32);
-
-        bytes.extend_from_slice(&self.x.to_bytes());
-        bytes.extend_from_slice(&ys_len.to_le_bytes());
-        for y in self.ys.iter() {
-            bytes.extend_from_slice(&y.to_bytes())
-        }
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<SecretKey> {
-        SecretKey::try_from(bytes)
-    }
-}
-
-impl Bytable for SecretKey {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        SecretKey::try_from(slice)
-    }
-}
-
-impl Base58 for SecretKey {}
-
-// TODO: perhaps change points to affine representation
-// to make verification slightly more efficient?
-#[derive(Debug, PartialEq, Clone)]
-pub struct VerificationKey {
-    // TODO add gen2 as per the paper or imply it from the fact library is using bls381?
-    pub(crate) alpha: G2Projective,
-    pub(crate) beta: Vec<G2Projective>,
-}
-
-impl TryFrom<&[u8]> for VerificationKey {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<VerificationKey> {
-        if bytes.len() < 96 * 2 + 8 || (bytes.len() - 8) % 96 != 0 {
-            return Err(CoconutError::DeserializationInvalidLength {
-                actual: bytes.len(),
-                modulus_target: bytes.len() - 8,
-                target: 96 * 2 + 8,
-                modulus: 96,
-                object: "secret key".to_string(),
-            });
-        }
-
-        // this conversion will not fail as we are taking the same length of data
-        let alpha_bytes: [u8; 96] = bytes[..96].try_into().unwrap();
-        let beta_len = u64::from_le_bytes(bytes[96..104].try_into().unwrap());
-        let actual_beta_len = (bytes.len() - 104) / 96;
-
-        if beta_len as usize != actual_beta_len {
-            return Err(
-                CoconutError::Deserialization(
-                    format!("Tried to deserialize verification key with inconsistent beta len (expected {}, got {})",
-                            beta_len, actual_beta_len
-                    )));
-        }
-
-        let alpha = try_deserialize_g2_projective(
-            &alpha_bytes,
-            CoconutError::Deserialization(
-                "Failed to deserialize verification key G2 point (alpha)".to_string(),
-            ),
-        )?;
-
-        let mut beta = Vec::with_capacity(actual_beta_len);
-        for i in 0..actual_beta_len {
-            let start = 104 + i * 96;
-            let end = start + 96;
-            let beta_i_bytes = bytes[start..end].try_into().unwrap();
-            let beta_i = try_deserialize_g2_projective(
-                &beta_i_bytes,
-                CoconutError::Deserialization(
-                    "Failed to deserialize verification key G2 point (beta)".to_string(),
-                ),
-            )?;
-
-            beta.push(beta_i)
-        }
-
-        Ok(VerificationKey { alpha, beta })
-    }
-}
-
-impl<'b> Add<&'b VerificationKey> for VerificationKey {
-    type Output = VerificationKey;
-
-    #[inline]
-    fn add(self, rhs: &'b VerificationKey) -> VerificationKey {
-        // If you're trying to add two keys together that were created
-        // for different number of attributes, just panic as it's a
-        // nonsense operation.
-        assert_eq!(
-            self.beta.len(),
-            rhs.beta.len(),
-            "trying to add verification keys generated for different number of attributes"
-        );
-
-        VerificationKey {
-            alpha: self.alpha + rhs.alpha,
-            beta: self
-                .beta
-                .iter()
-                .zip(rhs.beta.iter())
-                .map(|(self_beta, rhs_beta)| self_beta + rhs_beta)
-                .collect(),
-        }
-    }
-}
-
-impl<'a> Mul<Scalar> for &'a VerificationKey {
-    type Output = VerificationKey;
-
-    #[inline]
-    fn mul(self, rhs: Scalar) -> Self::Output {
-        VerificationKey {
-            alpha: self.alpha * rhs,
-            beta: self.beta.iter().map(|b_i| b_i * rhs).collect(),
-        }
-    }
-}
-
-impl<T> Sum<T> for VerificationKey
-where
-    T: Borrow<VerificationKey>,
-{
-    #[inline]
-    fn sum<I>(iter: I) -> Self
-    where
-        I: Iterator<Item = T>,
-    {
-        let mut peekable = iter.peekable();
-        let head_attributes = match peekable.peek() {
-            Some(head) => head.borrow().beta.len(),
-            None => {
-                // TODO: this is a really weird edge case. You're trying to sum an EMPTY iterator
-                // of VerificationKey. So should it panic here or just return some nonsense value?
-                return VerificationKey::identity(0);
-            }
-        };
-
-        peekable.fold(VerificationKey::identity(head_attributes), |acc, item| {
-            acc + item.borrow()
-        })
-    }
-}
-
-impl VerificationKey {
-    /// Create a (kinda) identity verification key using specified
-    /// number of 'beta' elements
-    pub(crate) fn identity(beta_size: usize) -> Self {
-        VerificationKey {
-            alpha: G2Projective::identity(),
-            beta: vec![G2Projective::identity(); beta_size],
-        }
-    }
-
-    pub fn aggregate(sigs: &[Self], indices: Option<&[SignerIndex]>) -> Result<Self> {
-        aggregate_verification_keys(sigs, indices)
-    }
-
-    pub fn alpha(&self) -> &G2Projective {
-        &self.alpha
-    }
-
-    pub fn beta(&self) -> &Vec<G2Projective> {
-        &self.beta
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let beta_len = self.beta.len() as u64;
-        let mut bytes = Vec::with_capacity(8 + (beta_len + 1) as usize * 96);
-
-        bytes.extend_from_slice(&self.alpha.to_affine().to_compressed());
-        bytes.extend_from_slice(&beta_len.to_le_bytes());
-        for beta in self.beta.iter() {
-            bytes.extend_from_slice(&beta.to_affine().to_compressed())
-        }
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<VerificationKey> {
-        VerificationKey::try_from(bytes)
-    }
-}
-
-impl Bytable for VerificationKey {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        VerificationKey::try_from(slice)
-    }
-}
-
-impl Base58 for VerificationKey {}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct KeyPair {
-    secret_key: SecretKey,
-    verification_key: VerificationKey,
-
-    /// Optional index value specifying polynomial point used during threshold key generation.
-    pub index: Option<SignerIndex>,
-}
-
-impl KeyPair {
-    const MARKER_BYTES: &'static [u8] = b"coconutkeypair";
-
-    pub fn secret_key(&self) -> SecretKey {
-        self.secret_key.clone()
-    }
-
-    pub fn verification_key(&self) -> VerificationKey {
-        self.verification_key.clone()
-    }
-
-    pub fn to_bytes(&self) -> Vec<u8> {
-        // Schema is coconutkeypair[14]|secret_key_len[8]|secret_key[secret_key_len]|verification_key_len[8]|verification_key[verification_key_len]|signer_index[8] - optional
-        self.to_byte_vec()
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
-        KeyPair::try_from_byte_slice(bytes)
-    }
-}
-
-impl Bytable for KeyPair {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        // Schema is coconutkeypair[14]|secret_key_len[8]|secret_key[secret_key_len]|verification_key_len[8]|verification_key[verification_key_len]|signer_index[8] - optional
-        let mut byts = vec![];
-        let secret_key_bytes = self.secret_key.to_bytes();
-        let secret_key_len = (secret_key_bytes.len() as u64).to_le_bytes();
-        let verification_key_bytes = self.verification_key.to_bytes();
-        let verification_key_len = (verification_key_bytes.len() as u64).to_le_bytes();
-        byts.extend_from_slice(Self::MARKER_BYTES);
-        byts.extend_from_slice(&secret_key_len);
-        byts.extend_from_slice(&secret_key_bytes);
-        byts.extend_from_slice(&verification_key_len);
-        byts.extend_from_slice(&verification_key_bytes);
-        if let Some(index) = self.index {
-            byts.extend_from_slice(&index.to_le_bytes())
-        }
-        byts
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        KeyPair::try_from(slice)
-    }
-}
-
-impl Base58 for KeyPair {}
-
-impl TryFrom<&[u8]> for KeyPair {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<KeyPair> {
-        let header_len = Self::MARKER_BYTES.len();
-
-        // we must be able to at the very least read the length of secret key which is past the header
-        // and is 8 bytes long
-        if bytes.len() < header_len + 8 {
-            return Err(CoconutError::DeserializationMinLength {
-                min: header_len + 8,
-                actual: bytes.len(),
-            });
-        }
-
-        let secret_key_len =
-            u64::from_le_bytes(bytes[header_len..header_len + 8].try_into().unwrap()) as usize;
-        let secret_key_start = header_len + 8;
-
-        let secret_key =
-            SecretKey::try_from(&bytes[secret_key_start..secret_key_start + secret_key_len])?;
-
-        // we must be able to read the length of verification key
-        if bytes.len() < secret_key_start + secret_key_len + 8 {
-            return Err(CoconutError::DeserializationMinLength {
-                min: secret_key_start + secret_key_len + 8,
-                actual: bytes.len(),
-            });
-        }
-
-        let verification_key_len = u64::from_le_bytes(
-            bytes[secret_key_start + secret_key_len..secret_key_start + secret_key_len + 8]
-                .try_into()
-                .unwrap(),
-        ) as usize;
-        let verification_key_start = secret_key_start + secret_key_len + 8;
-
-        let verification_key = VerificationKey::try_from(
-            &bytes[verification_key_start..verification_key_start + verification_key_len],
-        )?;
-        let consumed_bytes = verification_key_start + verification_key_len;
-        let index = if consumed_bytes < bytes.len() && [consumed_bytes..].len() == 8 {
-            Some(u64::from_le_bytes(
-                bytes[consumed_bytes..consumed_bytes + 8]
-                    .try_into()
-                    .unwrap(),
-            ))
-        } else {
-            None
-        };
-        Ok(KeyPair {
-            secret_key,
-            verification_key,
-            index,
-        })
-    }
-}
-
-/// Generate a single Coconut keypair ((x, y0, y1...), (g2^x, g2^y0, ...)).
-/// It is not suitable for threshold credentials as all subsequent calls to `keygen` generate keys
-/// that are independent of each other.
-#[cfg(test)]
-pub fn keygen(params: &Parameters) -> KeyPair {
-    let attributes = params.gen_hs().len();
-
-    let x = params.random_scalar();
-    let ys = params.n_random_scalars(attributes);
-
-    let secret_key = SecretKey { x, ys };
-    let verification_key = secret_key.verification_key(params);
-
-    KeyPair {
-        secret_key,
-        verification_key,
-        index: None,
-    }
-}
-
-/// Generate a set of n Coconut keypairs [((x, y0, y1...), (g2^x, g2^y0, ...)), ...],
-/// such that they support threshold aggregation by `threshold` number of parties.
-/// It is expected that this procedure is executed by a Trusted Third Party.
-pub fn ttp_keygen(
-    params: &Parameters,
-    threshold: u64,
-    num_authorities: u64,
-) -> Result<Vec<KeyPair>> {
-    if threshold == 0 {
-        return Err(CoconutError::Setup(
-            "Tried to generate threshold keys with a 0 threshold value".to_string(),
-        ));
-    }
-
-    if threshold > num_authorities {
-        return Err(
-            CoconutError::Setup(
-                "Tried to generate threshold keys for threshold value being higher than number of the signing authorities".to_string(),
-            ));
-    }
-
-    let attributes = params.gen_hs().len();
-
-    // generate polynomials
-    let v = Polynomial::new_random(params, threshold - 1);
-    let ws = (0..attributes)
-        .map(|_| Polynomial::new_random(params, threshold - 1))
-        .collect::<Vec<_>>();
-
-    // TODO: potentially if we had some known authority identifier we could use that instead
-    // of the increasing (1,2,3,...) sequence
-    let polynomial_indices = (1..=num_authorities).collect::<Vec<_>>();
-
-    // generate polynomial shares
-    let x = polynomial_indices
-        .iter()
-        .map(|&id| v.evaluate(&Scalar::from(id)));
-    let ys = polynomial_indices.iter().map(|&id| {
-        ws.iter()
-            .map(|w| w.evaluate(&Scalar::from(id)))
-            .collect::<Vec<_>>()
-    });
-
-    // finally set the keys
-    let secret_keys = x.zip(ys).map(|(x, ys)| SecretKey { x, ys });
-
-    let keypairs = secret_keys
-        .zip(polynomial_indices.iter())
-        .map(|(secret_key, index)| {
-            let verification_key = secret_key.verification_key(params);
-            KeyPair {
-                secret_key,
-                verification_key,
-                index: Some(*index),
-            }
-        })
-        .collect();
-
-    Ok(keypairs)
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::scheme::setup::setup;
-
-    use super::*;
-
-    #[test]
-    fn keypair_bytes_roundtrip() {
-        let mut params1 = setup(1).unwrap();
-        let mut params5 = setup(5).unwrap();
-
-        let keypair1 = keygen(&mut params1);
-        let keypair5 = keygen(&mut params5);
-
-        let bytes1 = keypair1.to_bytes();
-        let bytes5 = keypair5.to_bytes();
-
-        assert_eq!(KeyPair::from_bytes(&bytes1).unwrap(), keypair1);
-        assert_eq!(KeyPair::from_bytes(&bytes5).unwrap(), keypair5);
-    }
-
-    #[test]
-    fn secret_key_bytes_roundtrip() {
-        let mut params1 = setup(1).unwrap();
-        let mut params5 = setup(5).unwrap();
-
-        let keypair1 = keygen(&mut params1);
-        let keypair5 = keygen(&mut params5);
-
-        let bytes1 = keypair1.secret_key.to_bytes();
-        let bytes5 = keypair5.secret_key.to_bytes();
-
-        assert_eq!(SecretKey::from_bytes(&bytes1).unwrap(), keypair1.secret_key);
-        assert_eq!(SecretKey::from_bytes(&bytes5).unwrap(), keypair5.secret_key);
-    }
-
-    #[test]
-    fn verification_key_bytes_roundtrip() {
-        let mut params1 = setup(1).unwrap();
-        let mut params5 = setup(5).unwrap();
-
-        let keypair1 = &keygen(&mut params1);
-        let keypair5 = &keygen(&mut params5);
-
-        let bytes1: Vec<u8> = keypair1.verification_key.to_bytes();
-        let bytes5: Vec<u8> = keypair5.verification_key.to_bytes();
-
-        assert_eq!(
-            VerificationKey::try_from(bytes1.as_slice()).unwrap(),
-            keypair1.verification_key
-        );
-        assert_eq!(
-            VerificationKey::try_from(bytes5.as_slice()).unwrap(),
-            keypair5.verification_key
-        );
-    }
-}
@@ -1,661 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-// TODO: implement https://crates.io/crates/signature traits?
-
-use std::convert::TryFrom;
-use std::convert::TryInto;
-
-use bls12_381::{G1Projective, G2Prepared, G2Projective, Scalar};
-use group::Curve;
-
-pub use keygen::{SecretKey, VerificationKey};
-
-use crate::elgamal::Ciphertext;
-use crate::error::{CoconutError, Result};
-use crate::scheme::setup::Parameters;
-use crate::scheme::verification::check_bilinear_pairing;
-use crate::traits::{Base58, Bytable};
-use crate::utils::try_deserialize_g1_projective;
-use crate::{elgamal, Attribute};
-
-pub mod aggregation;
-pub mod issuance;
-pub mod keygen;
-pub mod setup;
-pub mod verification;
-
-pub type SignerIndex = u64;
-
-// (h, s)
-#[derive(Debug, Clone, Copy)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct Signature(pub(crate) G1Projective, pub(crate) G1Projective);
-
-pub type PartialSignature = Signature;
-
-impl TryFrom<&[u8]> for Signature {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<Signature> {
-        if bytes.len() != 96 {
-            return Err(CoconutError::Deserialization(format!(
-                "Signature must be exactly 96 bytes, got {}",
-                bytes.len()
-            )));
-        }
-
-        let sig1_bytes: &[u8; 48] = &bytes[..48].try_into().expect("Slice size != 48");
-        let sig2_bytes: &[u8; 48] = &bytes[48..].try_into().expect("Slice size != 48");
-
-        let sig1 = try_deserialize_g1_projective(
-            sig1_bytes,
-            CoconutError::Deserialization("Failed to deserialize compressed sig1".to_string()),
-        )?;
-
-        let sig2 = try_deserialize_g1_projective(
-            sig2_bytes,
-            CoconutError::Deserialization("Failed to deserialize compressed sig2".to_string()),
-        )?;
-
-        Ok(Signature(sig1, sig2))
-    }
-}
-
-impl Signature {
-    pub(crate) fn sig1(&self) -> &G1Projective {
-        &self.0
-    }
-
-    pub(crate) fn sig2(&self) -> &G1Projective {
-        &self.1
-    }
-
-    pub fn randomise(&self, params: &Parameters) -> (Signature, Scalar) {
-        let r = params.random_scalar();
-        let r_prime = params.random_scalar();
-        let h_prime = self.0 * r_prime;
-        let s_prime = (self.1 * r_prime) + (h_prime * r);
-        (Signature(h_prime, s_prime), r)
-    }
-
-    pub fn to_bytes(self) -> [u8; 96] {
-        let mut bytes = [0u8; 96];
-        bytes[..48].copy_from_slice(&self.0.to_affine().to_compressed());
-        bytes[48..].copy_from_slice(&self.1.to_affine().to_compressed());
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<Signature> {
-        Signature::try_from(bytes)
-    }
-}
-
-impl Bytable for Signature {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes().to_vec()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        Signature::from_bytes(slice)
-    }
-}
-
-impl Base58 for Signature {}
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct BlindedSignature(G1Projective, elgamal::Ciphertext);
-
-impl Bytable for BlindedSignature {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes().to_vec()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        Self::from_bytes(slice)
-    }
-}
-
-impl Base58 for BlindedSignature {}
-
-impl TryFrom<&[u8]> for BlindedSignature {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<BlindedSignature> {
-        if bytes.len() != 144 {
-            return Err(CoconutError::Deserialization(format!(
-                "BlindedSignature must be exactly 144 bytes, got {}",
-                bytes.len()
-            )));
-        }
-
-        let h_bytes: &[u8; 48] = &bytes[..48].try_into().expect("Slice size != 48");
-
-        let h = try_deserialize_g1_projective(
-            h_bytes,
-            CoconutError::Deserialization("Failed to deserialize compressed h".to_string()),
-        )?;
-        let c_tilde = Ciphertext::try_from(&bytes[48..])?;
-
-        Ok(BlindedSignature(h, c_tilde))
-    }
-}
-
-impl BlindedSignature {
-    pub fn unblind(
-        &self,
-        params: &Parameters,
-        private_key: &elgamal::PrivateKey,
-        partial_verification_key: &VerificationKey,
-        private_attributes: &[Attribute],
-        public_attributes: &[Attribute],
-        commitment_hash: &G1Projective,
-    ) -> Result<Signature> {
-        // parse the signature
-        let h = &self.0;
-        let c = &self.1;
-        let sig2 = private_key.decrypt(c);
-
-        // Verify the commitment hash
-        if !(commitment_hash == h) {
-            return Err(CoconutError::Unblind(
-                "Verification of commitment hash from signature failed".to_string(),
-            ));
-        }
-
-        let alpha = partial_verification_key.alpha;
-
-        let tmp = private_attributes
-            .iter()
-            .chain(public_attributes.iter())
-            .zip(partial_verification_key.beta.iter())
-            .map(|(attr, beta_i)| beta_i * attr)
-            .sum::<G2Projective>();
-
-        // Verify the signature share
-        if !check_bilinear_pairing(
-            &h.to_affine(),
-            &G2Prepared::from((alpha + tmp).to_affine()),
-            &sig2.to_affine(),
-            params.prepared_miller_g2(),
-        ) {
-            return Err(CoconutError::Unblind(
-                "Verification of signature share failed".to_string(),
-            ));
-        }
-
-        Ok(Signature(self.0, sig2))
-    }
-
-    pub fn to_bytes(&self) -> [u8; 144] {
-        let mut bytes = [0u8; 144];
-        bytes[..48].copy_from_slice(&self.0.to_affine().to_compressed());
-        bytes[48..].copy_from_slice(&self.1.to_bytes());
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<BlindedSignature> {
-        BlindedSignature::try_from(bytes)
-    }
-}
-
-// perhaps this should take signature by reference? we'll see how it goes
-pub struct SignatureShare {
-    signature: Signature,
-    index: SignerIndex,
-}
-
-impl SignatureShare {
-    pub fn new(signature: Signature, index: SignerIndex) -> Self {
-        SignatureShare { signature, index }
-    }
-
-    pub fn signature(&self) -> &Signature {
-        &self.signature
-    }
-
-    pub fn index(&self) -> SignerIndex {
-        self.index
-    }
-
-    // pub fn aggregate(shares: &[Self]) -> Result<Signature> {
-    //     aggregate_signature_shares(shares)
-    // }
-}
-
-#[cfg(test)]
-mod tests {
-    use group::GroupEncoding;
-
-    use crate::hash_to_scalar;
-    use crate::scheme::aggregation::{aggregate_signatures, aggregate_verification_keys};
-    use crate::scheme::issuance::{blind_sign, prepare_blind_sign, sign};
-    use crate::scheme::keygen::{keygen, ttp_keygen};
-    use crate::scheme::verification::{prove_bandwidth_credential, verify, verify_credential};
-    use crate::utils::hash_g1;
-
-    use super::*;
-
-    #[test]
-    fn unblind_returns_error_if_integrity_check_on_commitment_hash_fails() {
-        let mut params = Parameters::new(2).unwrap();
-        let private_attributes = params.n_random_scalars(2 as usize);
-        let elgamal_keypair = elgamal::elgamal_keygen(&mut params);
-
-        let lambda =
-            prepare_blind_sign(&mut params, &elgamal_keypair, &private_attributes, &[]).unwrap();
-
-        let keypair1 = keygen(&mut params);
-
-        let sig1 = blind_sign(
-            &mut params,
-            &keypair1.secret_key(),
-            elgamal_keypair.public_key(),
-            &lambda,
-            &[],
-        )
-        .unwrap();
-
-        let wrong_commitment_opening = params.random_scalar();
-        let wrong_commitment = params.gen1() * wrong_commitment_opening;
-        let fake_commitment_hash = hash_g1(wrong_commitment.to_bytes());
-        assert!(sig1
-            .unblind(
-                &params,
-                elgamal_keypair.private_key(),
-                &keypair1.verification_key(),
-                &private_attributes,
-                &[],
-                &fake_commitment_hash,
-            )
-            .is_err());
-    }
-
-    #[test]
-    fn unblind_returns_error_if_signature_verification_fails() {
-        let mut params = Parameters::new(2).unwrap();
-        let private_attributes = vec![hash_to_scalar("Attribute1"), hash_to_scalar("Attribute2")];
-        let private_attributes2 = vec![hash_to_scalar("Attribute3"), hash_to_scalar("Attribute4")];
-        let elgamal_keypair = elgamal::elgamal_keygen(&mut params);
-
-        let lambda =
-            prepare_blind_sign(&mut params, &elgamal_keypair, &private_attributes, &[]).unwrap();
-
-        let keypair1 = keygen(&mut params);
-
-        let sig1 = blind_sign(
-            &mut params,
-            &keypair1.secret_key(),
-            elgamal_keypair.public_key(),
-            &lambda,
-            &[],
-        )
-        .unwrap();
-
-        assert!(sig1
-            .unblind(
-                &params,
-                elgamal_keypair.private_key(),
-                &keypair1.verification_key(),
-                &private_attributes2,
-                &[],
-                &lambda.get_commitment_hash(),
-            )
-            .is_err());
-    }
-
-    #[test]
-    fn verification_on_two_private_attributes() {
-        let mut params = Parameters::new(2).unwrap();
-        let serial_number = params.random_scalar();
-        let binding_number = params.random_scalar();
-        let private_attributes = vec![serial_number, binding_number];
-        let elgamal_keypair = elgamal::elgamal_keygen(&mut params);
-
-        let keypair1 = keygen(&mut params);
-        let keypair2 = keygen(&mut params);
-
-        let lambda =
-            prepare_blind_sign(&mut params, &elgamal_keypair, &private_attributes, &[]).unwrap();
-
-        let sig1 = blind_sign(
-            &mut params,
-            &keypair1.secret_key(),
-            elgamal_keypair.public_key(),
-            &lambda,
-            &[],
-        )
-        .unwrap()
-        .unblind(
-            &params,
-            elgamal_keypair.private_key(),
-            &keypair1.verification_key(),
-            &private_attributes,
-            &[],
-            &lambda.get_commitment_hash(),
-        )
-        .unwrap();
-
-        let sig2 = blind_sign(
-            &mut params,
-            &keypair2.secret_key(),
-            elgamal_keypair.public_key(),
-            &lambda,
-            &[],
-        )
-        .unwrap()
-        .unblind(
-            &params,
-            elgamal_keypair.private_key(),
-            &keypair2.verification_key(),
-            &private_attributes,
-            &[],
-            &lambda.get_commitment_hash(),
-        )
-        .unwrap();
-
-        let theta1 = prove_bandwidth_credential(
-            &mut params,
-            &keypair1.verification_key(),
-            &sig1,
-            serial_number,
-            binding_number,
-        )
-        .unwrap();
-
-        let theta2 = prove_bandwidth_credential(
-            &mut params,
-            &keypair2.verification_key(),
-            &sig2,
-            serial_number,
-            binding_number,
-        )
-        .unwrap();
-
-        assert!(verify_credential(
-            &params,
-            &keypair1.verification_key(),
-            &theta1,
-            &[],
-        ));
-
-        assert!(verify_credential(
-            &params,
-            &keypair2.verification_key(),
-            &theta2,
-            &[],
-        ));
-
-        assert!(!verify_credential(
-            &params,
-            &keypair1.verification_key(),
-            &theta2,
-            &[],
-        ));
-    }
-
-    #[test]
-    fn verification_on_two_public_attributes() {
-        let mut params = Parameters::new(2).unwrap();
-        let attributes = params.n_random_scalars(2);
-
-        let keypair1 = keygen(&mut params);
-        let keypair2 = keygen(&mut params);
-        let sig1 = sign(&mut params, &keypair1.secret_key(), &attributes).unwrap();
-        let sig2 = sign(&mut params, &keypair2.secret_key(), &attributes).unwrap();
-
-        assert!(verify(
-            &params,
-            &keypair1.verification_key(),
-            &attributes,
-            &sig1,
-        ));
-
-        assert!(!verify(
-            &params,
-            &keypair2.verification_key(),
-            &attributes,
-            &sig1,
-        ));
-
-        assert!(!verify(
-            &params,
-            &keypair1.verification_key(),
-            &attributes,
-            &sig2,
-        ));
-    }
-
-    #[test]
-    fn verification_on_two_public_and_two_private_attributes() {
-        let mut params = Parameters::new(4).unwrap();
-        let public_attributes = params.n_random_scalars(2);
-        let serial_number = params.random_scalar();
-        let binding_number = params.random_scalar();
-        let private_attributes = vec![serial_number, binding_number];
-        let elgamal_keypair = elgamal::elgamal_keygen(&mut params);
-
-        let keypair1 = keygen(&mut params);
-        let keypair2 = keygen(&mut params);
-
-        let lambda = prepare_blind_sign(
-            &mut params,
-            &elgamal_keypair,
-            &private_attributes,
-            &public_attributes,
-        )
-        .unwrap();
-
-        let sig1 = blind_sign(
-            &mut params,
-            &keypair1.secret_key(),
-            elgamal_keypair.public_key(),
-            &lambda,
-            &public_attributes,
-        )
-        .unwrap()
-        .unblind(
-            &params,
-            elgamal_keypair.private_key(),
-            &keypair1.verification_key(),
-            &private_attributes,
-            &public_attributes,
-            &lambda.get_commitment_hash(),
-        )
-        .unwrap();
-
-        let sig2 = blind_sign(
-            &mut params,
-            &keypair2.secret_key(),
-            elgamal_keypair.public_key(),
-            &lambda,
-            &public_attributes,
-        )
-        .unwrap()
-        .unblind(
-            &params,
-            elgamal_keypair.private_key(),
-            &keypair2.verification_key(),
-            &private_attributes,
-            &public_attributes,
-            &lambda.get_commitment_hash(),
-        )
-        .unwrap();
-
-        let theta1 = prove_bandwidth_credential(
-            &mut params,
-            &keypair1.verification_key(),
-            &sig1,
-            serial_number,
-            binding_number,
-        )
-        .unwrap();
-
-        let theta2 = prove_bandwidth_credential(
-            &mut params,
-            &keypair2.verification_key(),
-            &sig2,
-            serial_number,
-            binding_number,
-        )
-        .unwrap();
-
-        assert!(verify_credential(
-            &params,
-            &keypair1.verification_key(),
-            &theta1,
-            &public_attributes,
-        ));
-
-        assert!(verify_credential(
-            &params,
-            &keypair2.verification_key(),
-            &theta2,
-            &public_attributes,
-        ));
-
-        assert!(!verify_credential(
-            &params,
-            &keypair1.verification_key(),
-            &theta2,
-            &public_attributes,
-        ));
-    }
-
-    #[test]
-    fn verification_on_two_public_and_two_private_attributes_from_two_signers() {
-        let mut params = Parameters::new(4).unwrap();
-        let public_attributes = params.n_random_scalars(2);
-        let serial_number = params.random_scalar();
-        let binding_number = params.random_scalar();
-        let private_attributes = vec![serial_number, binding_number];
-        let elgamal_keypair = elgamal::elgamal_keygen(&params);
-
-        let keypairs = ttp_keygen(&mut params, 2, 3).unwrap();
-
-        let lambda = prepare_blind_sign(
-            &mut params,
-            &elgamal_keypair,
-            &private_attributes,
-            &public_attributes,
-        )
-        .unwrap();
-
-        let sigs = keypairs
-            .iter()
-            .map(|keypair| {
-                blind_sign(
-                    &mut params,
-                    &keypair.secret_key(),
-                    elgamal_keypair.public_key(),
-                    &lambda,
-                    &public_attributes,
-                )
-                .unwrap()
-                .unblind(
-                    &params,
-                    elgamal_keypair.private_key(),
-                    &keypair.verification_key(),
-                    &private_attributes,
-                    &public_attributes,
-                    &lambda.get_commitment_hash(),
-                )
-                .unwrap()
-            })
-            .collect::<Vec<_>>();
-
-        let vks = keypairs
-            .into_iter()
-            .map(|keypair| keypair.verification_key())
-            .collect::<Vec<_>>();
-
-        let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
-        attributes.extend_from_slice(&private_attributes);
-        attributes.extend_from_slice(&public_attributes);
-
-        let aggr_vk = aggregate_verification_keys(&vks[..2], Some(&[1, 2])).unwrap();
-        let aggr_sig =
-            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[..2], Some(&[1, 2]))
-                .unwrap();
-
-        let theta = prove_bandwidth_credential(
-            &mut params,
-            &aggr_vk,
-            &aggr_sig,
-            serial_number,
-            binding_number,
-        )
-        .unwrap();
-
-        assert!(verify_credential(
-            &params,
-            &aggr_vk,
-            &theta,
-            &public_attributes,
-        ));
-
-        // taking different subset of keys and credentials
-        let aggr_vk = aggregate_verification_keys(&vks[1..], Some(&[2, 3])).unwrap();
-        let aggr_sig =
-            aggregate_signatures(&params, &aggr_vk, &attributes, &sigs[1..], Some(&[2, 3]))
-                .unwrap();
-
-        let theta = prove_bandwidth_credential(
-            &mut params,
-            &aggr_vk,
-            &aggr_sig,
-            serial_number,
-            binding_number,
-        )
-        .unwrap();
-
-        assert!(verify_credential(
-            &params,
-            &aggr_vk,
-            &theta,
-            &public_attributes,
-        ));
-    }
-
-    #[test]
-    fn signature_bytes_roundtrip() {
-        let params = Parameters::default();
-        let r = params.random_scalar();
-        let s = params.random_scalar();
-        let signature = Signature(params.gen1() * r, params.gen1() * s);
-        let bytes = signature.to_bytes();
-
-        // also make sure it is equivalent to the internal g1 compressed bytes concatenated
-        let expected_bytes = [
-            signature.0.to_affine().to_compressed(),
-            signature.1.to_affine().to_compressed(),
-        ]
-        .concat();
-        assert_eq!(expected_bytes, bytes);
-        assert_eq!(signature, Signature::try_from(&bytes[..]).unwrap())
-    }
-
-    #[test]
-    fn blinded_signature_bytes_roundtrip() {
-        let params = Parameters::default();
-        let r = params.random_scalar();
-        let s = params.random_scalar();
-        let t = params.random_scalar();
-        let blinded_sig = BlindedSignature(
-            params.gen1() * t,
-            Ciphertext(params.gen1() * r, params.gen1() * s),
-        );
-        let bytes = blinded_sig.to_bytes();
-
-        // also make sure it is equivalent to the internal g1 compressed bytes concatenated
-        let expected_bytes = [
-            blinded_sig.0.to_affine().to_compressed(),
-            blinded_sig.1 .0.to_affine().to_compressed(),
-            blinded_sig.1 .1.to_affine().to_compressed(),
-        ]
-        .concat();
-        assert_eq!(expected_bytes, bytes);
-        assert_eq!(blinded_sig, BlindedSignature::try_from(&bytes[..]).unwrap())
-    }
-}
@@ -1,90 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use bls12_381::{G1Affine, G2Affine, G2Prepared, Scalar};
-use ff::Field;
-use group::Curve;
-use rand::thread_rng;
-
-use crate::error::{CoconutError, Result};
-use crate::utils::hash_g1;
-
-/// System-wide parameters used for the protocol
-pub struct Parameters {
-    /// Generator of the G1 group
-    g1: G1Affine,
-
-    /// Additional generators of the G1 group
-    hs: Vec<G1Affine>,
-
-    /// Generator of the G2 group
-    g2: G2Affine,
-
-    /// Precomputed G2 generator used for the miller loop
-    _g2_prepared_miller: G2Prepared,
-}
-
-impl Parameters {
-    pub fn new(num_attributes: u32) -> Result<Parameters> {
-        if num_attributes == 0 {
-            return Err(CoconutError::Setup(
-                "Tried to setup the scheme for 0 attributes".to_string(),
-            ));
-        }
-
-        let hs = (1..=num_attributes)
-            .map(|i| hash_g1(format!("h{}", i)).to_affine())
-            .collect();
-
-        Ok(Parameters {
-            g1: G1Affine::generator(),
-            hs,
-            g2: G2Affine::generator(),
-            _g2_prepared_miller: G2Prepared::from(G2Affine::generator()),
-        })
-    }
-
-    pub(crate) fn gen1(&self) -> &G1Affine {
-        &self.g1
-    }
-
-    pub(crate) fn gen2(&self) -> &G2Affine {
-        &self.g2
-    }
-
-    pub(crate) fn prepared_miller_g2(&self) -> &G2Prepared {
-        &self._g2_prepared_miller
-    }
-
-    pub(crate) fn gen_hs(&self) -> &[G1Affine] {
-        &self.hs
-    }
-
-    pub fn random_scalar(&self) -> Scalar {
-        // lazily-initialized thread-local random number generator, seeded by the system
-        let mut rng = thread_rng();
-        Scalar::random(&mut rng)
-    }
-
-    pub fn n_random_scalars(&self, n: usize) -> Vec<Scalar> {
-        (0..n).map(|_| self.random_scalar()).collect()
-    }
-}
-
-pub fn setup(num_attributes: u32) -> Result<Parameters> {
-    Parameters::new(num_attributes)
-}
-
-// for ease of use in tests requiring params
-// TODO: not sure if this will have to go away when tests require some specific number of generators
-#[cfg(test)]
-impl Default for Parameters {
-    fn default() -> Self {
-        Parameters {
-            g1: G1Affine::generator(),
-            hs: Vec::new(),
-            g2: G2Affine::generator(),
-            _g2_prepared_miller: G2Prepared::from(G2Affine::generator()),
-        }
-    }
-}
@@ -1,296 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use core::ops::Neg;
-use std::convert::TryFrom;
-use std::convert::TryInto;
-
-use bls12_381::{multi_miller_loop, G1Affine, G2Prepared, G2Projective, Scalar};
-use group::{Curve, Group};
-
-use crate::error::{CoconutError, Result};
-use crate::proofs::ProofKappaZeta;
-use crate::scheme::setup::Parameters;
-use crate::scheme::Signature;
-use crate::scheme::VerificationKey;
-use crate::traits::{Base58, Bytable};
-use crate::utils::try_deserialize_g2_projective;
-use crate::Attribute;
-
-// TODO NAMING: this whole thing
-// Theta
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct Theta {
-    // blinded_message (kappa)
-    pub blinded_message: G2Projective,
-    // blinded serial number (zeta)
-    pub blinded_serial_number: G2Projective,
-    // sigma
-    pub credential: Signature,
-    // pi_v
-    pub pi_v: ProofKappaZeta,
-}
-
-impl TryFrom<&[u8]> for Theta {
-    type Error = CoconutError;
-
-    fn try_from(bytes: &[u8]) -> Result<Theta> {
-        if bytes.len() < 288 {
-            return Err(
-                CoconutError::Deserialization(
-                    format!("Tried to deserialize theta with insufficient number of bytes, expected >= 288, got {}", bytes.len()),
-                ));
-        }
-
-        let blinded_message_bytes = bytes[..96].try_into().unwrap();
-        let blinded_message = try_deserialize_g2_projective(
-            &blinded_message_bytes,
-            CoconutError::Deserialization(
-                "failed to deserialize the blinded message (kappa)".to_string(),
-            ),
-        )?;
-
-        let blinded_serial_number_bytes = bytes[96..192].try_into().unwrap();
-        let blinded_serial_number = try_deserialize_g2_projective(
-            &blinded_serial_number_bytes,
-            CoconutError::Deserialization(
-                "failed to deserialize the blinded serial number (zeta)".to_string(),
-            ),
-        )?;
-        let credential = Signature::try_from(&bytes[192..288])?;
-
-        let pi_v = ProofKappaZeta::from_bytes(&bytes[288..])?;
-
-        Ok(Theta {
-            blinded_message,
-            blinded_serial_number,
-            credential,
-            pi_v,
-        })
-    }
-}
-
-impl Theta {
-    fn verify_proof(&self, params: &Parameters, verification_key: &VerificationKey) -> bool {
-        self.pi_v.verify(
-            params,
-            verification_key,
-            &self.blinded_message,
-            &self.blinded_serial_number,
-        )
-    }
-
-    // blinded message (kappa)  || blinded serial number (zeta) || credential || pi_v
-    pub fn to_bytes(&self) -> Vec<u8> {
-        let blinded_message_bytes = self.blinded_message.to_affine().to_compressed();
-        let blinded_serial_number_bytes = self.blinded_serial_number.to_affine().to_compressed();
-        let credential_bytes = self.credential.to_bytes();
-        let proof_bytes = self.pi_v.to_bytes();
-
-        let mut bytes = Vec::with_capacity(288 + proof_bytes.len());
-        bytes.extend_from_slice(&blinded_message_bytes);
-        bytes.extend_from_slice(&blinded_serial_number_bytes);
-        bytes.extend_from_slice(&credential_bytes);
-        bytes.extend_from_slice(&proof_bytes);
-
-        bytes
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<Theta> {
-        Theta::try_from(bytes)
-    }
-}
-
-impl Bytable for Theta {
-    fn to_byte_vec(&self) -> Vec<u8> {
-        self.to_bytes()
-    }
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self> {
-        Theta::try_from(slice)
-    }
-}
-
-impl Base58 for Theta {}
-
-pub fn compute_kappa(
-    params: &Parameters,
-    verification_key: &VerificationKey,
-    private_attributes: &[Attribute],
-    blinding_factor: Scalar,
-) -> G2Projective {
-    params.gen2() * blinding_factor
-        + verification_key.alpha
-        + private_attributes
-            .iter()
-            .zip(verification_key.beta.iter())
-            .map(|(priv_attr, beta_i)| beta_i * priv_attr)
-            .sum::<G2Projective>()
-}
-
-pub fn compute_zeta(params: &Parameters, serial_number: Attribute) -> G2Projective {
-    params.gen2() * serial_number
-}
-
-pub fn prove_bandwidth_credential(
-    params: &Parameters,
-    verification_key: &VerificationKey,
-    signature: &Signature,
-    serial_number: Attribute,
-    binding_number: Attribute,
-) -> Result<Theta> {
-    if verification_key.beta.len() < 2 {
-        return Err(
-            CoconutError::Verification(
-                format!("Tried to prove a credential for higher than supported by the provided verification key number of attributes (max: {}, requested: 2)",
-                        verification_key.beta.len()
-                )));
-    }
-
-    // Randomize the signature
-    let (signature_prime, sign_blinding_factor) = signature.randomise(params);
-
-    // blinded_message : kappa in the paper.
-    // Value kappa is needed since we want to show a signature sigma'.
-    // In order to verify sigma' we need both the verification key vk and the message m.
-    // However, we do not want to reveal m to whomever we are showing the signature.
-    // Thus, we need kappa which allows us to verify sigma'. In particular,
-    // kappa is computed on m as input, but thanks to the use or random value r,
-    // it does not reveal any information about m.
-    let private_attributes = vec![serial_number, binding_number];
-    let blinded_message = compute_kappa(
-        params,
-        verification_key,
-        &private_attributes,
-        sign_blinding_factor,
-    );
-
-    // zeta is a commitment to the serial number (i.e., a public value associated with the serial number)
-    let blinded_serial_number = compute_zeta(params, serial_number);
-
-    let pi_v = ProofKappaZeta::construct(
-        params,
-        verification_key,
-        &serial_number,
-        &binding_number,
-        &sign_blinding_factor,
-        &blinded_message,
-        &blinded_serial_number,
-    );
-
-    Ok(Theta {
-        blinded_message,
-        blinded_serial_number,
-        credential: signature_prime,
-        pi_v,
-    })
-}
-
-/// Checks whether e(P, Q) * e(-R, S) == id
-pub fn check_bilinear_pairing(p: &G1Affine, q: &G2Prepared, r: &G1Affine, s: &G2Prepared) -> bool {
-    // checking e(P, Q) * e(-R, S) == id
-    // is equivalent to checking e(P, Q) == e(R, S)
-    // but requires only a single final exponentiation rather than two of them
-    // and therefore, as seen via benchmarks.rs, is almost 50% faster
-    // (1.47ms vs 2.45ms, tested on R9 5900X)
-
-    let multi_miller = multi_miller_loop(&[(p, q), (&r.neg(), s)]);
-    multi_miller.final_exponentiation().is_identity().into()
-}
-
-pub fn verify_credential(
-    params: &Parameters,
-    verification_key: &VerificationKey,
-    theta: &Theta,
-    public_attributes: &[Attribute],
-) -> bool {
-    if public_attributes.len() + theta.pi_v.private_attributes_len() > verification_key.beta.len() {
-        return false;
-    }
-
-    if !theta.verify_proof(params, verification_key) {
-        return false;
-    }
-
-    let kappa = if public_attributes.is_empty() {
-        theta.blinded_message
-    } else {
-        let signed_public_attributes = public_attributes
-            .iter()
-            .zip(
-                verification_key
-                    .beta
-                    .iter()
-                    .skip(theta.pi_v.private_attributes_len()),
-            )
-            .map(|(pub_attr, beta_i)| beta_i * pub_attr)
-            .sum::<G2Projective>();
-
-        theta.blinded_message + signed_public_attributes
-    };
-
-    check_bilinear_pairing(
-        &theta.credential.0.to_affine(),
-        &G2Prepared::from(kappa.to_affine()),
-        &(theta.credential.1).to_affine(),
-        params.prepared_miller_g2(),
-    ) && !bool::from(theta.credential.0.is_identity())
-}
-
-// Used in tests only
-#[cfg(test)]
-pub fn verify(
-    params: &Parameters,
-    verification_key: &VerificationKey,
-    public_attributes: &[Attribute],
-    sig: &Signature,
-) -> bool {
-    let kappa = (verification_key.alpha
-        + public_attributes
-            .iter()
-            .zip(verification_key.beta.iter())
-            .map(|(m_i, b_i)| b_i * m_i)
-            .sum::<G2Projective>())
-    .to_affine();
-
-    check_bilinear_pairing(
-        &sig.0.to_affine(),
-        &G2Prepared::from(kappa),
-        &sig.1.to_affine(),
-        params.prepared_miller_g2(),
-    ) && !bool::from(sig.0.is_identity())
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::scheme::keygen::keygen;
-    use crate::scheme::setup::setup;
-
-    use super::*;
-
-    #[test]
-    fn theta_bytes_roundtrip() {
-        let mut params = setup(2).unwrap();
-
-        let keypair = keygen(&mut params);
-        let r = params.random_scalar();
-        let s = params.random_scalar();
-
-        let signature = Signature(params.gen1() * r, params.gen1() * s);
-        let serial_number = params.random_scalar();
-        let binding_number = params.random_scalar();
-
-        let theta = prove_bandwidth_credential(
-            &mut params,
-            &keypair.verification_key(),
-            &signature,
-            serial_number,
-            binding_number,
-        )
-        .unwrap();
-
-        let bytes = theta.to_bytes();
-        assert_eq!(Theta::try_from(bytes.as_slice()).unwrap(), theta);
-    }
-}
@@ -1,106 +0,0 @@
-use crate::{
-    aggregate_signature_shares, aggregate_verification_keys, blind_sign, elgamal_keygen,
-    prepare_blind_sign, prove_bandwidth_credential, setup, ttp_keygen, verify_credential,
-    CoconutError, Signature, SignatureShare, VerificationKey,
-};
-
-#[test]
-fn main() -> Result<(), CoconutError> {
-    let params = setup(5)?;
-
-    let public_attributes = params.n_random_scalars(2);
-    let serial_number = params.random_scalar();
-    let binding_number = params.random_scalar();
-    let private_attributes = vec![serial_number, binding_number];
-
-    let elgamal_keypair = elgamal_keygen(&params);
-
-    // generate commitment and encryption
-    let blind_sign_request = prepare_blind_sign(
-        &params,
-        &elgamal_keypair,
-        &private_attributes,
-        &public_attributes,
-    )?;
-
-    // generate_keys
-    let coconut_keypairs = ttp_keygen(&params, 2, 3)?;
-
-    let verification_keys: Vec<VerificationKey> = coconut_keypairs
-        .iter()
-        .map(|keypair| keypair.verification_key())
-        .collect();
-
-    // aggregate verification keys
-    let verification_key = aggregate_verification_keys(&verification_keys, Some(&[1, 2, 3]))?;
-
-    // generate blinded signatures
-    let mut blinded_signatures = Vec::new();
-
-    for keypair in coconut_keypairs {
-        let blinded_signature = blind_sign(
-            &params,
-            &keypair.secret_key(),
-            &elgamal_keypair.public_key(),
-            &blind_sign_request,
-            &public_attributes,
-        )?;
-        blinded_signatures.push(blinded_signature)
-    }
-
-    // Unblind
-
-    let unblinded_signatures: Vec<Signature> = blinded_signatures
-        .into_iter()
-        .zip(verification_keys.iter())
-        .map(|(signature, verification_key)| {
-            signature
-                .unblind(
-                    &params,
-                    &elgamal_keypair.private_key(),
-                    &verification_key,
-                    &private_attributes,
-                    &public_attributes,
-                    &blind_sign_request.get_commitment_hash(),
-                )
-                .unwrap()
-        })
-        .collect();
-
-    // Aggregate signatures
-
-    let signature_shares: Vec<SignatureShare> = unblinded_signatures
-        .iter()
-        .enumerate()
-        .map(|(idx, signature)| SignatureShare::new(*signature, (idx + 1) as u64))
-        .collect();
-
-    let mut attributes = Vec::with_capacity(private_attributes.len() + public_attributes.len());
-    attributes.extend_from_slice(&private_attributes);
-    attributes.extend_from_slice(&public_attributes);
-
-    // Randomize credentials and generate any cryptographic material to verify them
-    let signature =
-        aggregate_signature_shares(&params, &verification_key, &attributes, &signature_shares)?;
-
-    // Generate cryptographic material to verify them
-
-    let theta = prove_bandwidth_credential(
-        &params,
-        &verification_key,
-        &signature,
-        serial_number,
-        binding_number,
-    )?;
-
-    // Verify credentials
-
-    assert!(verify_credential(
-        &params,
-        &verification_key,
-        &theta,
-        &public_attributes,
-    ));
-
-    Ok(())
-}
@@ -1 +0,0 @@
-mod e2e;
@@ -1,22 +0,0 @@
-use crate::CoconutError;
-
-pub trait Bytable
-where
-    Self: Sized,
-{
-    fn to_byte_vec(&self) -> Vec<u8>;
-
-    fn try_from_byte_slice(slice: &[u8]) -> Result<Self, CoconutError>;
-}
-
-pub trait Base58
-where
-    Self: Bytable,
-{
-    fn try_from_bs58<S: AsRef<str>>(x: S) -> Result<Self, CoconutError> {
-        Self::try_from_byte_slice(&bs58::decode(x.as_ref()).into_vec().unwrap())
-    }
-    fn to_bs58(&self) -> String {
-        bs58::encode(self.to_byte_vec()).into_string()
-    }
-}
@@ -1,386 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use core::iter::Sum;
-use core::ops::Mul;
-use std::convert::TryInto;
-
-use bls12_381::hash_to_curve::{ExpandMsgXmd, HashToCurve, HashToField};
-use bls12_381::{G1Affine, G1Projective, G2Affine, G2Projective, Scalar};
-use ff::Field;
-
-use crate::error::{CoconutError, Result};
-use crate::scheme::setup::Parameters;
-use crate::scheme::SignerIndex;
-
-pub struct Polynomial {
-    coefficients: Vec<Scalar>,
-}
-
-impl Polynomial {
-    // for polynomial of degree n, we generate n+1 values
-    // (for example for degree 1, like y = x + 2, we need [2,1])
-    pub fn new_random(params: &Parameters, degree: u64) -> Self {
-        Polynomial {
-            coefficients: params.n_random_scalars((degree + 1) as usize),
-        }
-    }
-
-    /// Evaluates the polynomial at point x.
-    pub fn evaluate(&self, x: &Scalar) -> Scalar {
-        if self.coefficients.is_empty() {
-            Scalar::zero()
-            // if x is zero then we can ignore most of the expensive computation and
-            // just return the last term of the polynomial
-        } else if x.is_zero() {
-            // we checked that coefficients are not empty so unwrap here is fine
-            *self.coefficients.first().unwrap()
-        } else {
-            self.coefficients
-                .iter()
-                .enumerate()
-                // coefficient[n] * x ^ n
-                .map(|(i, coefficient)| coefficient * x.pow(&[i as u64, 0, 0, 0]))
-                .sum()
-        }
-    }
-}
-
-#[inline]
-fn generate_lagrangian_coefficients_at_origin(points: &[u64]) -> Vec<Scalar> {
-    let x = Scalar::zero();
-
-    points
-        .iter()
-        .enumerate()
-        .map(|(i, point_i)| {
-            let mut numerator = Scalar::one();
-            let mut denominator = Scalar::one();
-            let xi = Scalar::from(*point_i);
-
-            for (j, point_j) in points.iter().enumerate() {
-                if j != i {
-                    let xj = Scalar::from(*point_j);
-
-                    // numerator = (x - xs[0]) * ... * (x - xs[j]), j != i
-                    numerator *= x - xj;
-
-                    // denominator = (xs[i] - x[0]) * ... * (xs[i] - x[j]), j != i
-                    denominator *= xi - xj;
-                }
-            }
-            // numerator / denominator
-            numerator * denominator.invert().unwrap()
-        })
-        .collect()
-}
-
-/// Performs a Lagrange interpolation at the origin for a polynomial defined by `points` and `values`.
-/// It can be used for Scalars, G1 and G2 points.
-pub(crate) fn perform_lagrangian_interpolation_at_origin<T>(
-    points: &[SignerIndex],
-    values: &[T],
-) -> Result<T>
-where
-    T: Sum,
-    for<'a> &'a T: Mul<Scalar, Output = T>,
-{
-    if points.is_empty() || values.is_empty() {
-        return Err(CoconutError::Interpolation(
-            "Tried to perform lagrangian interpolation for an empty set of coordinates".to_string(),
-        ));
-    }
-
-    if points.len() != values.len() {
-        return Err(CoconutError::Interpolation(
-            "Tried to perform lagrangian interpolation for an incomplete set of coordinates"
-                .to_string(),
-        ));
-    }
-
-    let coefficients = generate_lagrangian_coefficients_at_origin(points);
-
-    Ok(coefficients
-        .into_iter()
-        .zip(values.iter())
-        .map(|(coeff, val)| val * coeff)
-        .sum())
-}
-
-// A temporary way of hashing particular message into G1.
-// Implementation idea was taken from `threshold_crypto`:
-// https://github.com/poanetwork/threshold_crypto/blob/7709462f2df487ada3bb3243060504b5881f2628/src/lib.rs#L691
-// Eventually it should get replaced by, most likely, the osswu map
-// method once ideally it's implemented inside the pairing crate.
-
-// note: I have absolutely no idea what are the correct domains for those. I just used whatever
-// was given in the test vectors of `Hashing to Elliptic Curves draft-irtf-cfrg-hash-to-curve-11`
-
-// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#appendix-J.9.1
-const G1_HASH_DOMAIN: &[u8] = b"QUUX-V01-CS02-with-BLS12381G1_XMD:SHA-256_SSWU_RO_";
-
-// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#appendix-K.1
-const SCALAR_HASH_DOMAIN: &[u8] = b"QUUX-V01-CS02-with-expander";
-
-pub(crate) fn hash_g1<M: AsRef<[u8]>>(msg: M) -> G1Projective {
-    <G1Projective as HashToCurve<ExpandMsgXmd<sha2::Sha256>>>::hash_to_curve(msg, G1_HASH_DOMAIN)
-}
-
-pub fn hash_to_scalar<M: AsRef<[u8]>>(msg: M) -> Scalar {
-    let mut output = vec![Scalar::zero()];
-
-    Scalar::hash_to_field::<ExpandMsgXmd<sha2::Sha256>>(
-        msg.as_ref(),
-        SCALAR_HASH_DOMAIN,
-        &mut output,
-    );
-    output[0]
-}
-
-pub(crate) fn try_deserialize_scalar_vec(
-    expected_len: u64,
-    bytes: &[u8],
-    err: CoconutError,
-) -> Result<Vec<Scalar>> {
-    if bytes.len() != expected_len as usize * 32 {
-        return Err(err);
-    }
-
-    let mut out = Vec::with_capacity(expected_len as usize);
-    for i in 0..expected_len as usize {
-        let s_bytes = bytes[i * 32..(i + 1) * 32].try_into().unwrap();
-        let s = match Into::<Option<Scalar>>::into(Scalar::from_bytes(&s_bytes)) {
-            None => return Err(err),
-            Some(scalar) => scalar,
-        };
-        out.push(s)
-    }
-
-    Ok(out)
-}
-
-pub(crate) fn try_deserialize_scalar(bytes: &[u8; 32], err: CoconutError) -> Result<Scalar> {
-    Into::<Option<Scalar>>::into(Scalar::from_bytes(bytes)).ok_or(err)
-}
-
-pub(crate) fn try_deserialize_g1_projective(
-    bytes: &[u8; 48],
-    err: CoconutError,
-) -> Result<G1Projective> {
-    Into::<Option<G1Affine>>::into(G1Affine::from_compressed(bytes))
-        .ok_or(err)
-        .map(G1Projective::from)
-}
-
-pub(crate) fn try_deserialize_g2_projective(
-    bytes: &[u8; 96],
-    err: CoconutError,
-) -> Result<G2Projective> {
-    Into::<Option<G2Affine>>::into(G2Affine::from_compressed(bytes))
-        .ok_or(err)
-        .map(G2Projective::from)
-}
-
-// use core::fmt;
-// #[cfg(feature = "serde")]
-// use serde::de::Visitor;
-// #[cfg(feature = "serde")]
-// use serde::{self, Deserialize, Deserializer, Serialize, Serializer};
-//
-// // #[cfg(feature = "serde")]
-// #[serde(remote = "Scalar")]
-// pub(crate) struct ScalarDef(pub Scalar);
-//
-// // #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-//
-// impl Serialize for ScalarDef {
-//     fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
-//     where
-//         S: Serializer,
-//     {
-//         use serde::ser::SerializeTuple;
-//         let mut tup = serializer.serialize_tuple(32)?;
-//         for byte in self.0.to_bytes().iter() {
-//             tup.serialize_element(byte)?;
-//         }
-//         tup.end()
-//     }
-// }
-//
-// impl<'de> Deserialize<'de> for ScalarDef {
-//     fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
-//     where
-//         D: Deserializer<'de>,
-//     {
-//         struct ScalarVisitor;
-//
-//         impl<'de> Visitor<'de> for ScalarVisitor {
-//             type Value = ScalarDef;
-//
-//             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-//                 formatter.write_str("a 32-byte canonical bls12_381 scalar")
-//             }
-//
-//             fn visit_seq<A>(self, mut seq: A) -> core::result::Result<ScalarDef, A::Error>
-//             where
-//                 A: serde::de::SeqAccess<'de>,
-//             {
-//                 let mut bytes = [0u8; 32];
-//                 for i in 0..32 {
-//                     bytes[i] = seq
-//                         .next_element()?
-//                         .ok_or_else(|| serde::de::Error::invalid_length(i, &"expected 32 bytes"))?;
-//                 }
-//
-//                 let res = Scalar::from_bytes(&bytes);
-//                 if res.is_some().into() {
-//                     Ok(ScalarDef(res.unwrap()))
-//                 } else {
-//                     Err(serde::de::Error::custom(
-//                         &"scalar was not canonically encoded",
-//                     ))
-//                 }
-//             }
-//         }
-//
-//         deserializer.deserialize_tuple(32, ScalarVisitor)
-//     }
-// }
-//
-// #[cfg(feature = "serde")]
-// pub(crate) struct G1ProjectiveSerdeHelper(Scalar);
-//
-// #[cfg(feature = "serde")]
-// pub(crate) struct G2ProjectiveSerdeHelper(Scalar);
-
-#[cfg(test)]
-mod tests {
-    use rand::RngCore;
-
-    use super::*;
-
-    #[test]
-    fn polynomial_evaluation() {
-        // y = 42 (it should be 42 regardless of x)
-        let poly = Polynomial {
-            coefficients: vec![Scalar::from(42)],
-        };
-
-        assert_eq!(Scalar::from(42), poly.evaluate(&Scalar::from(1)));
-        assert_eq!(Scalar::from(42), poly.evaluate(&Scalar::from(0)));
-        assert_eq!(Scalar::from(42), poly.evaluate(&Scalar::from(10)));
-
-        // y = x + 10, at x = 2 (exp: 12)
-        let poly = Polynomial {
-            coefficients: vec![Scalar::from(10), Scalar::from(1)],
-        };
-
-        assert_eq!(Scalar::from(12), poly.evaluate(&Scalar::from(2)));
-
-        // y = x^4 - 5x^2 + 2x - 3, at x = 3 (exp: 39)
-        let poly = Polynomial {
-            coefficients: vec![
-                (-Scalar::from(3)),
-                Scalar::from(2),
-                (-Scalar::from(5)),
-                Scalar::zero(),
-                Scalar::from(1),
-            ],
-        };
-
-        assert_eq!(Scalar::from(39), poly.evaluate(&Scalar::from(3)));
-
-        // empty polynomial
-        let poly = Polynomial {
-            coefficients: vec![],
-        };
-
-        // should always be 0
-        assert_eq!(Scalar::from(0), poly.evaluate(&Scalar::from(1)));
-        assert_eq!(Scalar::from(0), poly.evaluate(&Scalar::from(0)));
-        assert_eq!(Scalar::from(0), poly.evaluate(&Scalar::from(10)));
-    }
-
-    #[test]
-    fn performing_lagrangian_scalar_interpolation_at_origin() {
-        // x^2 + 3
-        // x, f(x):
-        // 1, 4,
-        // 2, 7,
-        // 3, 12,
-        let points = vec![1, 2, 3];
-        let values = vec![Scalar::from(4), Scalar::from(7), Scalar::from(12)];
-
-        assert_eq!(
-            Scalar::from(3),
-            perform_lagrangian_interpolation_at_origin(&points, &values).unwrap()
-        );
-
-        // x^3 + 3x^2 - 5x + 11
-        // x, f(x):
-        // 1, 10
-        // 2, 21
-        // 3, 50
-        // 4, 103
-        let points = vec![1, 2, 3, 4];
-        let values = vec![
-            Scalar::from(10),
-            Scalar::from(21),
-            Scalar::from(50),
-            Scalar::from(103),
-        ];
-
-        assert_eq!(
-            Scalar::from(11),
-            perform_lagrangian_interpolation_at_origin(&points, &values).unwrap()
-        );
-
-        // more points than it is required
-        // x^2 + x + 10
-        // x, f(x)
-        // 1, 12
-        // 2, 16
-        // 3, 22
-        // 4, 30
-        // 5, 40
-        let points = vec![1, 2, 3, 4, 5];
-        let values = vec![
-            Scalar::from(12),
-            Scalar::from(16),
-            Scalar::from(22),
-            Scalar::from(30),
-            Scalar::from(40),
-        ];
-
-        assert_eq!(
-            Scalar::from(10),
-            perform_lagrangian_interpolation_at_origin(&points, &values).unwrap()
-        );
-    }
-
-    #[test]
-    fn hash_g1_sanity_check() {
-        let mut rng = rand::thread_rng();
-        let mut msg1 = [0u8; 1024];
-        rng.fill_bytes(&mut msg1);
-        let mut msg2 = [0u8; 1024];
-        rng.fill_bytes(&mut msg2);
-
-        assert_eq!(hash_g1(msg1), hash_g1(msg1));
-        assert_eq!(hash_g1(msg2), hash_g1(msg2));
-        assert_ne!(hash_g1(msg1), hash_g1(msg2));
-    }
-
-    #[test]
-    fn hash_scalar_sanity_check() {
-        let mut rng = rand::thread_rng();
-        let mut msg1 = [0u8; 1024];
-        rng.fill_bytes(&mut msg1);
-        let mut msg2 = [0u8; 1024];
-        rng.fill_bytes(&mut msg2);
-
-        assert_eq!(hash_to_scalar(msg1), hash_to_scalar(msg1));
-        assert_eq!(hash_to_scalar(msg2), hash_to_scalar(msg2));
-        assert_ne!(hash_to_scalar(msg1), hash_to_scalar(msg2));
-    }
-}
@@ -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 {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Aid Thompson	b8494eb83a	signpost - unfinished just parking changes	2021-11-22 15:08:46 +00:00
Aid Thompson	cb549dfe25	1st commit	2021-11-17 11:55:06 +00:00