Tidy up

wip: work on tidy up
wip: simplify
2023-08-22 10:30:12 +02:00 · 2023-08-21 18:01:26 +02:00 · 2023-08-21 16:34:17 +02:00 · 2023-08-21 12:22:55 +02:00 · 2023-08-21 12:19:55 +02:00 · 2023-08-18 16:46:05 +02:00
419 changed files with 3197 additions and 31211 deletions
@@ -57,7 +57,7 @@ jobs:
          echo $OUTPUT_DIR

      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
        continue-on-error: true

      - name: Install Rust stable
@@ -98,6 +98,7 @@ jobs:
          cp target/release/nym-network-requester $OUTPUT_DIR
          cp target/release/nym-network-statistics $OUTPUT_DIR
          cp target/release/nym-cli $OUTPUT_DIR
+          cp target/release/nym-credential-client $OUTPUT_DIR
          cp target/release/explorer-api $OUTPUT_DIR
          
          cp contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm $OUTPUT_DIR
@@ -108,7 +109,6 @@ jobs:
          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/nym_service_provider_directory.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/nym_name_service.wasm $OUTPUT_DIR
-          cp contracts/target/wasm32-unknown-unknown/release/nym_ephemera.wasm $OUTPUT_DIR

      - name: Deploy branch to CI www
        continue-on-error: true
@@ -6,7 +6,6 @@ on:
      - 'clients/**'
      - 'common/**'
      - 'explorer-api/**'
-      - 'ephemera/**'
      - 'gateway/**'
      - 'integrations/**'
      - 'mixnode/**'
@@ -16,7 +15,6 @@ on:
      - 'nym-api/**'
      - 'nym-outfox/**'
      - 'tools/nym-cli/**'
-      - 'tools/nym-nr-query/**'
      - 'tools/ts-rs-cli/**'
      - 'Cargo.toml'
  pull_request:
@@ -24,7 +22,6 @@ on:
      - 'clients/**'
      - 'common/**'
      - 'explorer-api/**'
-      - 'ephemera/**'
      - 'gateway/**'
      - 'integrations/**'
      - 'mixnode/**'
@@ -34,7 +31,6 @@ on:
      - 'nym-api/**'
      - 'nym-outfox/**'
      - 'tools/nym-cli/**'
-      - 'tools/nym-nr-query/**'
      - 'tools/ts-rs-cli/**'
      - 'Cargo.toml'

@@ -46,7 +42,7 @@ jobs:
      RUSTC_WRAPPER: /home/ubuntu/.cargo/bin/sccache
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
+        run: sudo apt-get update && sudo apt-get -y install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
        continue-on-error: true

      - name: Check out repository code
@@ -0,0 +1,76 @@
+name: CD dev-portal
+
+on:
+  push:
+    branches: master
+    paths:
+      - 'documentation/dev-portal/**'
+
+jobs:
+  build:
+    runs-on: custom-runner-linux
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install rsync
+        run: sudo apt-get install rsync
+      - uses: rlespinasse/github-slug-action@v3.x
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install mdbook
+        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
+      - name: Install mdbook plugins
+        run: |
+          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
+            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
+            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
+            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck
+      - name: Clean website
+        run: cd documentation/dev-portal && mdbook clean
+      - name: Build website
+        run: cd documentation/dev-portal && mdbook build
+      - name: Deploy branch master to dev
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "documentation/dev-portal/book/html/"
+          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_DEV }}
+          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET_DEVP }}/
+          EXCLUDE: "/dist/, /node_modules/"
+      - name: Deploy branch master to prod
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "documentation/dev-portal/book/html/"
+          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_PROD }}
+          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET_DEVP }}/
+          EXCLUDE: "/dist/, /node_modules/"
+      - name: Matrix - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Matrix - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: cd-dev
+          NYM_PROJECT_NAME: "Dev portal CD"
+          NYM_CI_WWW_BASE: "${{ secrets.NYM_CD_WWW_BASE }}"
+          NYM_CI_WWW_LOCATION: "${{ env.GITHUB_REF_SLUG }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DEVP }}"
+          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+          IS_SUCCESS: "${{ job.status == 'success' }}"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -1,7 +1,6 @@
 name: CD docs

 on:
-  workflow_dispatch:
  push:
    branches: master
    paths:
@@ -28,38 +27,39 @@ jobs:
          command: build
          args: --workspace --release --all
      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.33" mdbook)
+        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
      - name: Install mdbook plugins
        run: |
-          cargo install --vers "=0.2.2" mdbook-variables && cargo install \
+          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
-            && cargo install --vers "^0.7.7" mdbook-linkcheck
-      - name: Build all projects in documentation/ & move to ~/dist/docs/
-        run: cd documentation && ./build_all_to_dist.sh
-        continue-on-error: false
+            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
+            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck && \
+            cargo install --vers "^0.5.0" mdbook-cmdrun
+      - name: Clean website
+        run: cd documentation/docs && mdbook clean
+      - name: Build website
+        run: cd documentation/docs && mdbook build
      - name: Deploy branch master to dev
        continue-on-error: true
        uses: easingthemes/ssh-deploy@main
        env:
          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "dist/docs/"
+          SOURCE: "documentation/docs/book/"
          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_DEV }}
          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
-          EXCLUDE: "/node_modules/"
+          EXCLUDE: "/dist/, /node_modules/"
      - name: Deploy branch master to prod
-        if: github.ref == 'refs/heads/master'
        uses: easingthemes/ssh-deploy@main
        env:
          SSH_PRIVATE_KEY: ${{ secrets.CD_WWW_SSH_PRIVATE_KEY }}
          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "dist/docs/"
+          SOURCE: "documentation/docs/book/"
          REMOTE_HOST: ${{ secrets.CD_WWW_REMOTE_HOST_PROD }}
          REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
          TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
-          EXCLUDE: "/node_modules/"
+          EXCLUDE: "/dist/, /node_modules/"
      - name: Matrix - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
@@ -0,0 +1,67 @@
+name: CI dev-portal
+
+on:
+  workflow_dispatch:
+  push:
+    branches-ignore: master
+    paths:
+      - 'documentation/dev-portal/**'
+
+jobs:
+  build:
+    runs-on: custom-runner-linux
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install rsync
+        run: sudo apt-get install rsync
+      - uses: rlespinasse/github-slug-action@v3.x
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+      - name: Install mdbook
+        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
+      - name: Install mdbook plugins
+        run: |
+          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
+            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
+            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
+            && cargo install --vers "^0.7.7" mdbook-linkcheck 
+      - name: Clean website
+        run: cd documentation/dev-portal && mdbook clean
+      - name: Build website
+        run: cd documentation/dev-portal && mdbook build
+      - name: Deploy branch to CI www
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "documentation/dev-portal/book/html/"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/dev-portal-${{ env.GITHUB_REF_SLUG }}
+          EXCLUDE: "/dist/, /node_modules/"
+      - name: Matrix - Node Install
+        run: npm install
+        working-directory: .github/workflows/support-files
+      - name: Matrix - Send Notification
+        env:
+          NYM_NOTIFICATION_KIND: ci-dev
+          NYM_PROJECT_NAME: "Dev portal CI"
+          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+          NYM_CI_WWW_LOCATION: "dev-portal-${{ env.GITHUB_REF_SLUG }}"
+          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+          GIT_BRANCH: "${GITHUB_REF##*/}"
+          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM_DEVP }}"
+          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+          IS_SUCCESS: "${{ job.status == 'success' }}"
+        uses: docker://keybaseio/client:stable-node
+        with:
+          args: .github/workflows/support-files/notifications/entry_point.sh
@@ -1,7 +1,6 @@
 name: CI docs

 on:
-  workflow_dispatch:
  push:
    branches-ignore: master
    paths:
@@ -28,27 +27,29 @@ jobs:
          command: build
          args: --workspace --release --all
      - name: Install mdbook
-        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4.33" mdbook)
+        run: (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.4" mdbook)
      - name: Install mdbook plugins
        run: |
-          cargo install --vers "=0.2.2" mdbook-variables && cargo install \
+          cargo install --vers "^0.2.0" mdbook-variables && cargo install \
            --vers "^1.8.0" mdbook-admonish && cargo install --vers \
-            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" mdbook-theme \
-            && cargo install --vers "^0.7.7" mdbook-linkcheck
-      - name: Build all projects in documentation/ & move to ~/dist/docs/
-        run: cd documentation && ./build_all_to_dist.sh
-        continue-on-error: false
+            "^0.1.2" mdbook-last-changed && cargo install --vers "^0.1.2" \
+            mdbook-theme && cargo install --vers "^0.7.7" mdbook-linkcheck && \
+            cargo install --vers "^0.5.0" mdbook-cmdrun
+      - name: Clean website
+        run: cd documentation/docs && mdbook clean
+      - name: Build website
+        run: cd documentation/docs && mdbook build
      - name: Deploy branch to CI www
        continue-on-error: true
        uses: easingthemes/ssh-deploy@main
        env:
          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "dist/docs/"
+          SOURCE: "documentation/docs/book/"
          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/docs-${{ env.GITHUB_REF_SLUG }}
-          EXCLUDE: "/node_modules/"
+          EXCLUDE: "/dist/, /node_modules/"
      - name: Matrix - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
@@ -24,7 +24,7 @@ jobs:
    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
        continue-on-error: true
        if: matrix.os == 'ubuntu-20.04'

@@ -37,7 +37,7 @@ jobs:
    continue-on-error: ${{ matrix.rust == 'nightly' || matrix.rust == 'beta' || matrix.rust == 'stable' }}
    steps:
      - name: Install Dependencies (Linux)
-        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools protobuf-compiler
+        run: sudo apt-get update && sudo apt-get install libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools
        continue-on-error: true
        if: matrix.os == 'ubuntu-20.04'

@@ -100,7 +100,6 @@ jobs:
            nym-connect/desktop/target/release/bundle/msi/*.msi.zip*
      - id: release-info
        name: Prepare release info
-        shell: bash
        run: |
          ref=${{ github.ref_name }}
          semver="${ref##nym-connect-}" && semver="${semver##v}"
@@ -32,5 +32,5 @@ jobs:
        run: yarn

      - name: Run tests
-        run: yarn test:sandbox
+        run: yarn test:qa
        working-directory: nym-api/tests
@@ -0,0 +1,79 @@
+name: Upload nyxd to CI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  publish-nyxd:
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [ubuntu-20.04]
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare build output directory
+        shell: bash
+        env:
+          OUTPUT_DIR: ci-builds/nyxd
+        run: |
+          rm -rf ci-builds || true
+          mkdir -p $OUTPUT_DIR
+          echo $OUTPUT_DIR
+
+      - name: Install Dependencies (Linux)
+        run: sudo apt-get update && sudo apt-get -y install build-essential curl wget libssl-dev libgtk-3-dev libudev-dev squashfs-tools git
+        continue-on-error: true
+      
+      - name: Update env variables to include go
+        run: | 
+          sudo rm -rf /usr/local/go
+          curl https://dl.google.com/go/go1.19.2.linux-amd64.tar.gz | sudo tar -C/usr/local -zxvf -
+          cat <<'EOF' >>$HOME/.profile
+          export GOROOT=/usr/local/go
+          export GOPATH=$HOME/go
+          export GO111MODULE=on
+          export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
+          EOF
+          source $HOME/.profile
+
+      - name: Verify Go is installed
+        run: go version
+
+      - name: Clone nyxd repo
+        run: | 
+          git clone https://github.com/tommyv1987/nyxd
+          cd nyxd
+          git checkout release/v0.30.2
+
+      - name: Run nyxd
+        run: |
+          pwd
+          cd nyxd && make build
+          sleep 10
+          ls /home/runner/work/nym/nym/nyxd/build
+
+      - name: Prepare build output
+        shell: bash
+        env:
+          OUTPUT_DIR: ci-builds/nyxd
+        run: |
+          cp /home/runner/work/nym/nym/nyxd/build/nyxd $OUTPUT_DIR
+          WASMVM_SO=$(ldd /home/runner/work/nym/nym/nyxd/build/nyxd | grep "libwasm*" | awk '{ print $3 }')
+          ls $WASMVM_SO
+          sleep 3
+          cp $(echo $WASMVM_SO) $OUTPUT_DIR
+
+      - name: Deploy nyxd to CI www
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-avzr"
+          SOURCE: "ci-builds/"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/
+          EXCLUDE: "/dist/, /node_modules/"
@@ -31,7 +31,7 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: 1.71.0
+          toolchain: stable
          override: true
          components: rustfmt, clippy

@@ -4,42 +4,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [v1.1.29-snickers] (2023-08-29)
-
- Add EXPLORER_API configurable url ([#3810])
- Bugfix/use correct tendermint dialect ([#3802])
- Explorer - look up gateways based on geo-location ([#3776])
- Speedy mode - select the mixnodes based on the location of the NR ([#3775])
- NR - reduce response time by removing poisson delay ([#3774])
- [demo] libp2p example with nym-sdk ([#3763])
- introduced /network/details endpoint to nym-api to return used network information ([#3758])
- Feature/issue credentials ([#3691])
-
-[#3810]: https://github.com/nymtech/nym/pull/3810
-[#3802]: https://github.com/nymtech/nym/pull/3802
-[#3776]: https://github.com/nymtech/nym/issues/3776
-[#3775]: https://github.com/nymtech/nym/issues/3775
-[#3774]: https://github.com/nymtech/nym/issues/3774
-[#3763]: https://github.com/nymtech/nym/pull/3763
-[#3758]: https://github.com/nymtech/nym/pull/3758
-[#3691]: https://github.com/nymtech/nym/pull/3691
-
-## [v1.1.28] (2023-08-22)
-
- [final step3]: add [rust] support to nyxd client in wasm ([#3743])
- Feature/ephemera upgrade ([#3791])
- [rust-sdk] feat: make it more convenient to send and receive messages in different tasks ([#3756])
- feat: validator client refactoring + wasm compatible nyxd client ([#3726])
- feat: retain connection between client init and run ([#3767])
-
-[#3743]: https://github.com/nymtech/nym/issues/3743
-[#3791]: https://github.com/nymtech/nym/pull/3791
-[#3756]: https://github.com/nymtech/nym/pull/3756
-[#3726]: https://github.com/nymtech/nym/pull/3726
-[#3767]: https://github.com/nymtech/nym/pull/3767
-
-
-## [v1.1.27] (2023-08-16)
+## [1.1.27] (2023-08-16)

 - fix serialisation of contract types ([#3752])
 - Investigate spending credentials from the main API (coconut enabled to a gateway) from feature/ephemera branch ([#3741])
@@ -17,6 +17,7 @@ opt-level = 3

 resolver = "2"
 members = [
+    "clients/credential",
    "clients/native",
    "clients/native/websocket-requests",
    "clients/socks5",
@@ -33,7 +34,6 @@ members = [
    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
    "common/cosmwasm-smart-contracts/coconut-dkg",
    "common/cosmwasm-smart-contracts/contracts-common",
-    "common/cosmwasm-smart-contracts/ephemera",
    "common/cosmwasm-smart-contracts/group-contract",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
@@ -42,7 +42,6 @@ members = [
    "common/cosmwasm-smart-contracts/vesting-contract",
    "common/credential-storage",
    "common/credentials",
-    "common/credential-utils",
    "common/crypto",
    "common/dkg",
    "common/execute",
@@ -150,7 +149,6 @@ tap = "1.0.1"
 tendermint-rpc = "0.32" # same version as used by cosmrs
 thiserror = "1.0.38"
 tokio = "1.24.1"
-ts-rs = "7.0.0"
 url = "2.4"
 zeroize = "1.6.0"

@@ -77,6 +77,9 @@ $(eval $(call add_cargo_workspace,contracts,contracts,--lib --target wasm32-unkn
 $(eval $(call add_cargo_workspace,wasm-client,clients/webassembly,--target wasm32-unknown-unknown))
 $(eval $(call add_cargo_workspace,wallet,nym-wallet,))
 $(eval $(call add_cargo_workspace,connect,nym-connect/desktop))
+ifdef NYM_MOBILE
+$(eval $(call add_cargo_workspace,connect-mobile,nym-connect/mobile/src-tauri))
+endif

 # -----------------------------------------------------------------------------
 # Convenience targets for crates that are already part of the main workspace
@@ -1,18 +1,25 @@
 [package]
-name = "nym-credential-utils"
+name = "nym-credential-client"
 version = "0.1.0"
 edition = "2021"

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

 [dependencies]
-log = { workspace = true }
-thiserror = { workspace = true }
-tokio = { workspace = true }
+clap = { version = "4.0", features = ["cargo", "derive"] }
+log = "0.4"
+serde = { workspace = true, features = ["derive"] }
+thiserror = "1.0"
+tokio = { version = "1.24.1", features = ["rt-multi-thread", "net", "signal", "macros"] } # async runtime
+

 nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
+nym-client-core = { path = "../../common/client-core" }
+nym-config = { path = "../../common/config" }
 nym-credentials = { path = "../../common/credentials" }
 nym-credential-storage = { path = "../../common/credential-storage" }
+nym-bin-common = { path = "../../common/bin-common"}
+nym-network-defaults = { path = "../../common/network-defaults" }
+nym-pemstore = { path = "../../common/pemstore" }
 nym-validator-client = { path = "../../common/client-libs/validator-client" }
-nym-config = { path = "../../common/config" }
-nym-client-core = { path = "../../common/client-core" }
+
@@ -0,0 +1,32 @@
+<!--
+Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+SPDX-License-Identifier: Apache-2.0
+-->
+
+## Credential binary
+
+The credential binary is used to acquire coconut bandwidth credentials in exchange for nym tokens. Those credentials are stored in the client's `data` directory, so that they can be used as the client sees fit.
+
+### Warning
+
+The credential binary is still experimental software. The infrastructure for using it is not yet deployed to mainnet and it's still in the process of being deployed to sandbox.
+
+### Building
+
+From the project's root directory, run:
+```
+cargo build -p nym-credential-client
+```
+which generates the `nym-credential-client` binary in `target/debug/nym-credential-client`.
+
+
+### Running
+
+For example, you can get a credential worth 3 nym (3000000 unym) in a socks5 client that was already initialized like so:
+
+```
+./target/debug/nym-credential-client --config-env-file envs/sandbox.env --client-home-directory  ~/.nym/socks5-clients/cred_client  --nyxd-url  https://sandbox-validator1.nymtech.net --mnemonic $MNEMONIC  --recovery-dir /tmp/recovery --amount 3000000
+```
+
+More information regarding how to run the binary can be found by running it with the `--help` argument.
+
@@ -0,0 +1,55 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use crate::error::Result;
+use bip39::Mnemonic;
+use nym_network_defaults::{NymNetworkDetails, VOUCHER_INFO};
+use nym_validator_client::nyxd::contract_traits::CoconutBandwidthSigningClient;
+use nym_validator_client::nyxd::{self, DirectSigningHttpRpcNyxdClient};
+use nym_validator_client::nyxd::{Coin, Fee, NyxdClient};
+use std::str::FromStr;
+use url::Url;
+
+pub(crate) struct Client {
+    nyxd_client: DirectSigningHttpRpcNyxdClient,
+    mix_denom_base: String,
+}
+
+impl Client {
+    pub fn new(nyxd_url: &str, mnemonic: &str) -> Self {
+        let nyxd_url = Url::from_str(nyxd_url).unwrap();
+        let mnemonic = Mnemonic::from_str(mnemonic).unwrap();
+        let network_details = NymNetworkDetails::new_from_env();
+        let config = nyxd::Config::try_from_nym_network_details(&network_details)
+            .expect("failed to construct valid validator client config with the provided network");
+        let nyxd_client =
+            NyxdClient::connect_with_mnemonic(config, nyxd_url.as_ref(), mnemonic, None).unwrap();
+
+        Client {
+            nyxd_client,
+            mix_denom_base: network_details.chain_details.mix_denom.base,
+        }
+    }
+
+    pub async fn deposit(
+        &self,
+        amount: u64,
+        verification_key: String,
+        encryption_key: String,
+        fee: Option<Fee>,
+    ) -> Result<String> {
+        let amount = Coin::new(amount as u128, self.mix_denom_base.clone());
+        Ok(self
+            .nyxd_client
+            .deposit(
+                amount,
+                String::from(VOUCHER_INFO),
+                verification_key,
+                encryption_key,
+                fee,
+            )
+            .await?
+            .transaction_hash
+            .to_string())
+    }
+}
@@ -0,0 +1,82 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use clap::{ArgGroup, Args, Subcommand};
+use log::*;
+use nym_bandwidth_controller::acquire::state::State;
+use nym_bin_common::completions::ArgShell;
+use nym_credential_storage::persistent_storage::PersistentStorage;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
+
+use crate::error::Result;
+use crate::recovery_storage::RecoveryStorage;
+
+#[derive(Subcommand)]
+pub(crate) enum Command {
+    /// Run the binary to obtain a credential
+    Run(Run),
+
+    /// Generate shell completions
+    Completions(ArgShell),
+
+    /// Generate Fig specification
+    GenerateFigSpec,
+}
+
+#[derive(Args)]
+#[clap(group(
+ArgGroup::new("recov")
+.required(true)
+.args(&["amount", "recovery_mode"]),
+))]
+pub(crate) struct Run {
+    /// Home directory of the client that is supposed to use the credential.
+    #[clap(long)]
+    pub(crate) client_home_directory: std::path::PathBuf,
+
+    /// A mnemonic for the account that buys the credential
+    #[clap(long)]
+    pub(crate) mnemonic: String,
+
+    /// The amount of utokens the credential will hold. If recovery mode is enabled, this value
+    /// is not needed
+    #[clap(long, default_value = "0")]
+    pub(crate) amount: u64,
+
+    /// Path to a directory used to store recovery files for unconsumed deposits
+    #[clap(long)]
+    pub(crate) recovery_dir: std::path::PathBuf,
+
+    /// Recovery mode, when enabled, tries to recover any deposit data dumped in recovery_dir
+    #[clap(long)]
+    pub(crate) recovery_mode: bool,
+}
+
+pub(crate) async fn recover_credentials<C: DkgQueryClient + Send + Sync>(
+    client: &C,
+    recovery_storage: &RecoveryStorage,
+    shared_storage: &PersistentStorage,
+) -> Result<()> {
+    for voucher in recovery_storage.unconsumed_vouchers()? {
+        let state = State::new(voucher);
+        if let Err(e) =
+            nym_bandwidth_controller::acquire::get_credential(&state, client, shared_storage).await
+        {
+            error!(
+                "Could not recover deposit {} due to {:?}, try again later",
+                state.voucher.tx_hash(),
+                e
+            )
+        } else {
+            info!(
+                "Converted deposit {} to a credential, removing recovery data for it",
+                state.voucher.tx_hash()
+            );
+            if let Err(e) = recovery_storage.remove_voucher(state.voucher.tx_hash().to_string()) {
+                warn!("Could not remove recovery data - {:?}", e);
+            }
+        }
+    }
+
+    Ok(())
+}
@@ -0,0 +1,36 @@
+// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use std::time::SystemTimeError;
+use thiserror::Error;
+
+use nym_credential_storage::error::StorageError;
+use nym_credentials::error::Error as CredentialError;
+use nym_validator_client::nyxd::error::NyxdError;
+use nym_validator_client::ValidatorClientError;
+
+pub type Result<T> = std::result::Result<T, CredentialClientError>;
+
+#[derive(Error, Debug)]
+pub enum CredentialClientError {
+    #[error("IO error: {0}")]
+    IOError(#[from] std::io::Error),
+
+    #[error("Bandwidth controller error: {0}")]
+    BandwidthControllerError(#[from] nym_bandwidth_controller::error::BandwidthControllerError),
+
+    #[error("Nyxd error: {0}")]
+    Nyxd(#[from] NyxdError),
+
+    #[error("Validator client error: {0}")]
+    ValidatorClientError(#[from] ValidatorClientError),
+
+    #[error("Credential error: {0}")]
+    Credential(#[from] CredentialError),
+
+    #[error("Could not use shared storage")]
+    SharedStorageError(#[from] StorageError),
+
+    #[error("Could not get system time")]
+    SysTimeError(#[from] SystemTimeError),
+}
@@ -0,0 +1,131 @@
+// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+mod commands;
+mod error;
+mod recovery_storage;
+
+use commands::*;
+use error::Result;
+use log::*;
+use nym_bin_common::completions::fig_generate;
+use nym_config::DEFAULT_DATA_DIR;
+use nym_network_defaults::{setup_env, NymNetworkDetails};
+use std::process::exit;
+use std::time::{Duration, SystemTime};
+
+use clap::{CommandFactory, Parser};
+use nym_bin_common::logging::setup_logging;
+use nym_client_core::config::disk_persistence::CommonClientPaths;
+use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
+use nym_validator_client::nyxd::{Coin, Config};
+use nym_validator_client::DirectSigningHttpRpcNyxdClient;
+
+const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute
+
+#[derive(Parser)]
+#[clap(author = "Nymtech", version, about)]
+struct Cli {
+    /// Path pointing to an env file that configures the client.
+    #[clap(short, long)]
+    pub(crate) config_env_file: Option<std::path::PathBuf>,
+
+    #[clap(subcommand)]
+    pub(crate) command: Command,
+}
+
+async fn block_until_coconut_is_available<C: DkgQueryClient + Send + Sync>(
+    client: &C,
+) -> Result<()> {
+    loop {
+        let epoch = client.get_current_epoch().await?;
+        let current_timestamp_secs = SystemTime::now()
+            .duration_since(SystemTime::UNIX_EPOCH)?
+            .as_secs();
+        if epoch.state.is_final() {
+            if current_timestamp_secs + SAFETY_BUFFER_SECS >= epoch.finish_timestamp.seconds() {
+                info!("In the next {} minute(s), a transition will take place in the coconut system. Deposits should be halted in this time for safety reasons.", SAFETY_BUFFER_SECS / 60);
+                exit(0);
+            }
+
+            break;
+        } else {
+            // Use 1 additional second to not start the next iteration immediately and spam get_current_epoch queries
+            let secs_until_final = epoch
+                .final_timestamp_secs()
+                .saturating_sub(current_timestamp_secs)
+                + 1;
+            info!("Approximately {} seconds until coconut is available. Sleeping until then. You can safely kill the process at any moment.", secs_until_final);
+            std::thread::sleep(Duration::from_secs(secs_until_final));
+        }
+    }
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let args = Cli::parse();
+    setup_logging();
+    setup_env(args.config_env_file.as_ref());
+    let bin_name = "nym-credential-client";
+
+    match args.command {
+        Command::Run(r) => {
+            // we assume the structure of <home-dir>/data
+            let data_dir = r.client_home_directory.join(DEFAULT_DATA_DIR);
+            let paths = CommonClientPaths::new_default(data_dir);
+            let db_path = paths.credentials_database;
+
+            let shared_storage =
+                nym_credential_storage::initialise_persistent_storage(db_path).await;
+            let recovery_storage = recovery_storage::RecoveryStorage::new(r.recovery_dir)?;
+
+            let network_details = NymNetworkDetails::new_from_env();
+            let config = Config::try_from_nym_network_details(&network_details).expect(
+                "failed to construct valid validator client config with the provided network",
+            );
+            let amount = Coin::new(
+                r.amount as u128,
+                network_details.chain_details.mix_denom.base,
+            );
+            let endpoint = network_details.endpoints[0].nyxd_url.as_str();
+            let client = DirectSigningHttpRpcNyxdClient::connect_with_mnemonic(
+                config,
+                endpoint,
+                r.mnemonic.parse().unwrap(),
+            )?;
+
+            block_until_coconut_is_available(&client).await?;
+            info!("Starting depositing funds, don't kill the process");
+
+            if !r.recovery_mode {
+                let state = nym_bandwidth_controller::acquire::deposit(&client, amount).await?;
+                if nym_bandwidth_controller::acquire::get_credential(
+                    &state,
+                    &client,
+                    &shared_storage,
+                )
+                .await
+                .is_err()
+                {
+                    warn!("Failed to obtain credential. Dumping recovery data.",);
+                    match recovery_storage.insert_voucher(&state.voucher) {
+                        Ok(file_path) => {
+                            warn!("Dumped recovery data to {:?}. Try using recovery mode to convert it to a credential", file_path);
+                        }
+                        Err(e) => {
+                            error!("Could not dump recovery data to file system due to {:?}, the deposit will be lost!", e)
+                        }
+                    }
+                }
+            } else {
+                recover_credentials(&client, &recovery_storage, &shared_storage).await?;
+            }
+        }
+        Command::Completions(c) => c.generate(&mut Cli::command(), bin_name),
+        Command::GenerateFigSpec => fig_generate(&mut Cli::command(), bin_name),
+    }
+
+    Ok(())
+}
@@ -0,0 +1,56 @@
+// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
+// SPDX-License-Identifier: Apache-2.0
+
+use nym_credentials::coconut::bandwidth::BandwidthVoucher;
+use std::fs::{create_dir_all, read_dir, File};
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+pub struct RecoveryStorage {
+    recovery_dir: PathBuf,
+}
+
+impl RecoveryStorage {
+    pub fn new(recovery_dir: PathBuf) -> std::io::Result<Self> {
+        create_dir_all(&recovery_dir)?;
+        Ok(Self { recovery_dir })
+    }
+
+    pub fn unconsumed_vouchers(&self) -> std::io::Result<impl Iterator<Item = BandwidthVoucher>> {
+        Ok(read_dir(&self.recovery_dir)?
+            .filter_map(|entry| entry.ok())
+            .filter_map(|entry| {
+                let path = entry.path();
+                if path.is_file() {
+                    Some(path)
+                } else {
+                    None
+                }
+            })
+            .filter_map(|path| File::open(path).ok())
+            .filter_map(|mut f| {
+                let mut buff = Vec::new();
+                if f.read_to_end(&mut buff).is_ok() {
+                    Some(buff)
+                } else {
+                    None
+                }
+            })
+            .filter_map(|buff| BandwidthVoucher::try_from_bytes(&buff).ok()))
+    }
+
+    pub fn insert_voucher(&self, voucher: &BandwidthVoucher) -> std::io::Result<PathBuf> {
+        let file_name = voucher.tx_hash().to_string();
+        let file_path = self.recovery_dir.join(file_name);
+        let mut file = File::create(&file_path)?;
+        let buff = voucher.to_bytes();
+        file.write_all(&buff)?;
+
+        Ok(file_path)
+    }
+
+    pub fn remove_voucher(&self, file_name: String) -> std::io::Result<()> {
+        let file_path = self.recovery_dir.join(file_name);
+        std::fs::remove_file(file_path)
+    }
+}
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.27"
+version = "1.1.25"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -164,6 +164,7 @@ pub(crate) async fn execute(args: &Init) -> Result<(), ClientError> {
        user_chosen_gateway_id.map(|id| id.to_base58_string()),
        Some(args.latency_based_selection),
    );
+    dbg!(&gateway_setup);

    // Load and potentially override config
    let config = override_config(Config::new(id), OverrideConfig::from(args.clone()));
@@ -105,10 +105,10 @@ impl ClientRequest {
        let conn_id_bytes = connection_id.unwrap_or(0).to_be_bytes();

        std::iter::once(ClientRequestTag::Send as u8)
-            .chain(recipient.to_bytes()) // will not be length prefixed because the length is constant
-            .chain(conn_id_bytes)
-            .chain(data_len_bytes)
-            .chain(data)
+            .chain(recipient.to_bytes().into_iter()) // will not be length prefixed because the length is constant
+            .chain(conn_id_bytes.into_iter())
+            .chain(data_len_bytes.into_iter())
+            .chain(data.into_iter())
            .collect()
    }

@@ -180,11 +180,11 @@ impl ClientRequest {
        let conn_id_bytes = connection_id.unwrap_or(0).to_be_bytes();

        std::iter::once(ClientRequestTag::SendAnonymous as u8)
-            .chain(reply_surbs.to_be_bytes())
-            .chain(recipient.to_bytes()) // will not be length prefixed because the length is constant
-            .chain(conn_id_bytes)
-            .chain(data_len_bytes)
-            .chain(data)
+            .chain(reply_surbs.to_be_bytes().into_iter())
+            .chain(recipient.to_bytes().into_iter()) // will not be length prefixed because the length is constant
+            .chain(conn_id_bytes.into_iter())
+            .chain(data_len_bytes.into_iter())
+            .chain(data.into_iter())
            .collect()
    }

@@ -258,10 +258,10 @@ impl ClientRequest {
        let conn_id_bytes = connection_id.unwrap_or(0).to_be_bytes();

        std::iter::once(ClientRequestTag::Reply as u8)
-            .chain(sender_tag.to_bytes())
-            .chain(conn_id_bytes)
-            .chain(message_len_bytes)
-            .chain(message)
+            .chain(sender_tag.to_bytes().into_iter())
+            .chain(conn_id_bytes.into_iter())
+            .chain(message_len_bytes.into_iter())
+            .chain(message.into_iter())
            .collect()
    }

@@ -332,7 +332,7 @@ impl ClientRequest {
    fn serialize_closed_connection(connection_id: u64) -> Vec<u8> {
        let conn_id_bytes = connection_id.to_be_bytes();
        std::iter::once(ClientRequestTag::ClosedConnection as u8)
-            .chain(conn_id_bytes)
+            .chain(conn_id_bytes.into_iter())
            .collect()
    }

@@ -359,7 +359,7 @@ impl ClientRequest {
    fn serialize_get_lane_queue_lengths(connection_id: u64) -> Vec<u8> {
        let conn_id_bytes = connection_id.to_be_bytes();
        std::iter::once(ClientRequestTag::GetLaneQueueLength as u8)
-            .chain(conn_id_bytes)
+            .chain(conn_id_bytes.into_iter())
            .collect()
    }

@@ -67,15 +67,15 @@ impl ServerResponse {
        if let Some(sender_tag) = reconstructed_message.sender_tag {
            std::iter::once(ServerResponseTag::Received as u8)
                .chain(std::iter::once(true as u8))
-                .chain(sender_tag.to_bytes())
+                .chain(sender_tag.to_bytes().into_iter())
                .chain(message_len_bytes.iter().cloned())
-                .chain(reconstructed_message.message)
+                .chain(reconstructed_message.message.into_iter())
                .collect()
        } else {
            std::iter::once(ServerResponseTag::Received as u8)
                .chain(std::iter::once(false as u8))
                .chain(message_len_bytes.iter().cloned())
-                .chain(reconstructed_message.message)
+                .chain(reconstructed_message.message.into_iter())
                .collect()
        }
    }
@@ -149,7 +149,7 @@ impl ServerResponse {
    // SELF_ADDRESS_RESPONSE_TAG || self_address
    fn serialize_self_address(address: Recipient) -> Vec<u8> {
        std::iter::once(ServerResponseTag::SelfAddress as u8)
-            .chain(address.to_bytes())
+            .chain(address.to_bytes().into_iter())
            .collect()
    }

@@ -211,8 +211,8 @@ impl ServerResponse {
        let message_len_bytes = (error.message.len() as u64).to_be_bytes();
        std::iter::once(ServerResponseTag::Error as u8)
            .chain(std::iter::once(error.kind as u8))
-            .chain(message_len_bytes)
-            .chain(error.message.into_bytes())
+            .chain(message_len_bytes.into_iter())
+            .chain(error.message.into_bytes().into_iter())
            .collect()
    }

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.27"
+version = "1.1.25"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>"]
 description = "A SOCKS5 localhost proxy that converts incoming messages to Sphinx and sends them to a Nym address"
 edition = "2021"
@@ -17,7 +17,7 @@ use nym_client_core::client::base_client::storage::gateway_details::{
 };
 use nym_client_core::client::key_manager::persistence::OnDiskKeys;
 use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
-use nym_client_core::config::{GatewayEndpointConfig, GroupBy, TopologyStructure};
+use nym_client_core::config::{GatewayEndpointConfig, TopologyStructure};
 use nym_client_core::error::ClientCoreError;
 use nym_config::OptionalSet;
 use nym_sphinx::params::{PacketSize, PacketType};
@@ -101,17 +101,9 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
    let secondary_packet_size = args.medium_toggle.then_some(PacketSize::ExtendedPacket16);
    let no_per_hop_delays = args.medium_toggle;

-    let topology_structure = if args.medium_toggle {
-        // Use the location of the network-requester
-        let address = config
-            .core
-            .socks5
-            .provider_mix_address
-            .parse()
-            .expect("failed to parse provider mix address");
-        TopologyStructure::GeoAware(GroupBy::NymAddress(address))
-    } else if let Some(code) = args.geo_routing {
-        TopologyStructure::GeoAware(GroupBy::CountryGroup(code))
+    let topology_structure = if args.medium_toggle || args.geo_routing.is_some() {
+        // TODO: rethink the default group. I just picked one for now.
+        TopologyStructure::GeoAware(args.geo_routing.unwrap_or(CountryGroup::Europe))
    } else {
        TopologyStructure::default()
    };
@@ -2503,7 +2503,6 @@ version = "1.1.15"
 dependencies = [
 "async-trait",
 "base64 0.21.2",
- "cfg-if 1.0.0",
 "dashmap",
 "dirs 4.0.0",
 "futures",
@@ -2677,7 +2676,6 @@ version = "0.1.0"
 dependencies = [
 "bls12_381 0.5.0",
 "cosmrs",
- "log",
 "nym-api-requests",
 "nym-coconut-interface",
 "nym-crypto",
@@ -2731,16 +2729,6 @@ dependencies = [
 "zeroize",
 ]

-[[package]]
-name = "nym-ephemera-common"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-utils",
- "nym-contracts-common",
-]
-
 [[package]]
 name = "nym-explorer-api-requests"
 version = "0.1.0"
@@ -3157,7 +3145,6 @@ dependencies = [
 "nym-coconut-interface",
 "nym-config",
 "nym-contracts-common",
- "nym-ephemera-common",
 "nym-group-contract-common",
 "nym-mixnet-contract-common",
 "nym-multisig-contract-common",
@@ -114,7 +114,7 @@ impl WasmTopologyExt for Arc<ClientState> {
        let this = Arc::clone(self);
        future_to_promise(async move {
            let Some(current_topology) = this.topology_accessor.current_topology().await else {
-                return Err(WasmClientError::UnavailableNetworkTopology.into());
+                return Err(WasmClientError::UnavailableNetworkTopology.into())
            };

            match current_topology.find_mix_by_identity(&mixnode_identity) {
@@ -135,7 +135,7 @@ impl WasmTopologyExt for Arc<ClientState> {
        let this = Arc::clone(self);
        future_to_promise(async move {
            let Some(current_topology) = this.topology_accessor.current_topology().await else {
-                return Err(WasmClientError::UnavailableNetworkTopology.into());
+                return Err(WasmClientError::UnavailableNetworkTopology.into())
            };

            let Some(mix) = current_topology.find_mix_by_identity(&mixnode_identity) else {
@@ -52,7 +52,7 @@ pub fn encode_payload_with_headers(
        Ok(metadata) => {
            let metadata = metadata.as_bytes().to_vec();
            let size = (metadata.len() as u64).to_be_bytes().to_vec();
-            Ok([size, metadata, payload].concat())
+            Ok(vec![size, metadata, payload].concat())
        }
        Err(e) => Err(JsValue::from(JsError::new(
            format!("Could not encode message: {}", e).as_str(),
@@ -1,8 +1,6 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use std::rc::Rc;
-
 use crate::client::config::Config;
 use crate::storage::error::ClientStorageError;
 use js_sys::Promise;
@@ -10,6 +8,7 @@ use nym_client_core::client::base_client::storage::gateway_details::PersistedGat
 use nym_crypto::asymmetric::{encryption, identity};
 use nym_gateway_client::SharedKeys;
 use nym_sphinx::acknowledgements::AckKey;
+use std::sync::Arc;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::future_to_promise;
 use wasm_utils::storage::{IdbVersionChangeEvent, WasmStorage};
@@ -44,7 +43,7 @@ mod v1 {
 pub struct ClientStorage {
    #[allow(dead_code)]
    pub(crate) name: String,
-    pub(crate) inner: Rc<WasmStorage>,
+    pub(crate) inner: Arc<WasmStorage>,
 }

 #[wasm_bindgen]
@@ -89,7 +88,7 @@ impl ClientStorage {
        .await?;

        Ok(ClientStorage {
-            inner: Rc::new(inner),
+            inner: Arc::new(inner),
            name,
        })
    }
@@ -58,7 +58,7 @@ impl<'a> EphemeralTestReceiver<'a> {
        let Some(received_packet) = packet else {
            // can't do anything more...
            console_error!("packet receiver has stopped processing results!");
-            return true;
+            return true
        };
        match received_packet {
            Received::Message(msg) => {
@@ -29,7 +29,6 @@ use nym_validator_client::client::IdentityKey;
 use nym_validator_client::QueryReqwestRpcNyxdClient;
 use rand::rngs::OsRng;
 use std::collections::HashSet;
-use std::rc::Rc;
 use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 use std::sync::{Arc, Mutex as SyncMutex};
 use std::time::Duration;
@@ -43,7 +42,7 @@ pub(crate) mod helpers;

 pub type NodeTestMessage = TestMessage<WasmTestMessageExt>;
 type LockedGatewayClient =
-    Rc<AsyncMutex<GatewayClient<QueryReqwestRpcNyxdClient, EphemeralStorage>>>;
+    Arc<AsyncMutex<GatewayClient<QueryReqwestRpcNyxdClient, EphemeralStorage>>>;

 pub(crate) const DEFAULT_TEST_TIMEOUT: Duration = Duration::from_secs(10);
 pub(crate) const DEFAULT_TEST_PACKETS: u32 = 20;
@@ -211,7 +210,7 @@ impl NymNodeTesterBuilder {
            test_in_progress: Arc::new(AtomicBool::new(false)),
            current_test_nonce: Default::default(),
            tester: Arc::new(SyncMutex::new(tester)),
-            gateway_client: Rc::new(AsyncMutex::new(gateway_client)),
+            gateway_client: Arc::new(AsyncMutex::new(gateway_client)),
            processed_receiver: ReceivedReceiverWrapper::new(processed_receiver),
            _task_manager: task_manager,
        })
@@ -344,7 +343,7 @@ impl NymNodeTester {
        ));

        let processed_receiver_clone = self.processed_receiver.clone();
-        let gateway_client_clone = Rc::clone(&self.gateway_client);
+        let gateway_client_clone = Arc::clone(&self.gateway_client);
        let tester_marker = TestMarker::new(Arc::clone(&self.test_in_progress));

        // start doing async things (send packets and watch for anything coming back)
@@ -10,7 +10,6 @@ rust-version = "1.66"
 [dependencies]
 async-trait = { workspace = true }
 base64 = "0.21.2"
-cfg-if = "1.0.0"
 dashmap = "5.4.0"
 dirs = "4.0"
 futures = { workspace = true }
@@ -46,6 +45,8 @@ nym-task = { path = "../task" }
 nym-credential-storage = { path = "../credential-storage" }
 nym-network-defaults = { path = "../network-defaults" }

+nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
+
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
 version = "0.1.11"
 features = ["time"]
@@ -354,13 +354,11 @@ where
                nym_api_urls,
                env!("CARGO_PKG_VERSION").to_string(),
            )),
-            config::TopologyStructure::GeoAware(group_by) => {
-                Box::new(GeoAwareTopologyProvider::new(
-                    nym_api_urls,
-                    env!("CARGO_PKG_VERSION").to_string(),
-                    group_by,
-                ))
-            }
+            config::TopologyStructure::GeoAware(group) => Box::new(GeoAwareTopologyProvider::new(
+                nym_api_urls,
+                env!("CARGO_PKG_VERSION").to_string(),
+                group,
+            )),
        })
    }

@@ -1,48 +1,23 @@
 use std::{collections::HashMap, fmt};

 use log::{debug, error, info};
-use nym_explorer_api_requests::{PrettyDetailedGatewayBond, PrettyDetailedMixNodeBond};
-use nym_network_defaults::var_names::EXPLORER_API;
+use nym_explorer_api_requests::PrettyDetailedMixNodeBond;
 use nym_topology::{
    nym_topology_from_detailed,
    provider_trait::{async_trait, TopologyProvider},
    NymTopology,
 };
-use nym_validator_client::client::{IdentityKey, MixId};
+use nym_validator_client::client::MixId;
 use rand::{prelude::SliceRandom, thread_rng};
 use serde::{Deserialize, Serialize};
-use tap::TapOptional;
 use url::Url;

-use crate::config::GroupBy;
-
 const MIN_NODES_PER_LAYER: usize = 1;
-
-#[cfg(target_arch = "wasm32")]
-fn reqwest_client() -> Option<reqwest::Client> {
-    reqwest::Client::builder().build().ok()
-}
-
-#[cfg(not(target_arch = "wasm32"))]
-fn reqwest_client() -> Option<reqwest::Client> {
-    reqwest::Client::builder()
-        .timeout(std::time::Duration::from_secs(5))
-        .build()
-        .ok()
-}
+const EXPLORER_API_MIXNODES_URL: &str = "https://explorer.nymtech.net/api/v1/mix-nodes";

 // TODO: create a explorer-api-client
 async fn fetch_mixnodes_from_explorer_api() -> Option<Vec<PrettyDetailedMixNodeBond>> {
-    let explorer_api_url = std::env::var(EXPLORER_API).ok()?;
-    let explorer_api_url = Url::parse(&explorer_api_url)
-        .ok()?
-        .join("v1/mix-nodes")
-        .ok()?;
-
-    debug!("Fetching: {}", explorer_api_url);
-    reqwest_client()?
-        .get(explorer_api_url)
-        .send()
+    reqwest::get(EXPLORER_API_MIXNODES_URL)
        .await
        .ok()?
        .json::<Vec<PrettyDetailedMixNodeBond>>()
@@ -50,25 +25,6 @@ async fn fetch_mixnodes_from_explorer_api() -> Option<Vec<PrettyDetailedMixNodeB
        .ok()
 }

-// TODO: create a explorer-api-client
-async fn fetch_gateways_from_explorer_api() -> Option<Vec<PrettyDetailedGatewayBond>> {
-    let explorer_api_url = std::env::var(EXPLORER_API).ok()?;
-    let explorer_api_url = Url::parse(&explorer_api_url)
-        .ok()?
-        .join("v1/gateways")
-        .ok()?;
-
-    debug!("Fetching: {}", explorer_api_url);
-    reqwest_client()?
-        .get(explorer_api_url)
-        .send()
-        .await
-        .ok()?
-        .json::<Vec<PrettyDetailedGatewayBond>>()
-        .await
-        .ok()
-}
-
 #[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
 pub enum CountryGroup {
    Europe,
@@ -235,23 +191,6 @@ fn group_mixnodes_by_country_code(
        })
 }

-fn group_gateways_by_country_code(
-    gateways: Vec<PrettyDetailedGatewayBond>,
-) -> HashMap<CountryGroup, Vec<IdentityKey>> {
-    gateways.into_iter().fold(
-        HashMap::<CountryGroup, Vec<IdentityKey>>::new(),
-        |mut acc, g| {
-            if let Some(ref location) = g.location {
-                let country_code = location.two_letter_iso_country_code.clone();
-                let group_code = CountryGroup::new(country_code.as_str());
-                let gateways = acc.entry(group_code).or_insert_with(Vec::new);
-                gateways.push(g.gateway.identity_key)
-            }
-            acc
-        },
-    )
-}
-
 fn log_mixnode_distribution(mixnodes: &HashMap<CountryGroup, Vec<MixId>>) {
    let mixnode_distribution = mixnodes
        .iter()
@@ -261,15 +200,6 @@ fn log_mixnode_distribution(mixnodes: &HashMap<CountryGroup, Vec<MixId>>) {
    debug!("Mixnode distribution - {}", mixnode_distribution);
 }

-fn log_gateway_distribution(gateways: &HashMap<CountryGroup, Vec<IdentityKey>>) {
-    let gateway_distribution = gateways
-        .iter()
-        .map(|(k, v)| format!("{}: {}", k, v.len()))
-        .collect::<Vec<_>>()
-        .join(", ");
-    debug!("Gateway distribution - {}", gateway_distribution);
-}
-
 fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {
    let mixes = topology.mixes();
    if mixes.keys().len() < 3 {
@@ -292,7 +222,7 @@ fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {

 pub struct GeoAwareTopologyProvider {
    validator_client: nym_validator_client::client::NymApiClient,
-    filter_on: GroupBy,
+    filter_on: CountryGroup,
    client_version: String,
 }

@@ -300,7 +230,7 @@ impl GeoAwareTopologyProvider {
    pub fn new(
        mut nym_api_urls: Vec<Url>,
        client_version: String,
-        filter_on: GroupBy,
+        filter_on: CountryGroup,
    ) -> GeoAwareTopologyProvider {
        log::info!(
            "Creating geo-aware topology provider with filter on {:?}",
@@ -342,38 +272,6 @@ impl GeoAwareTopologyProvider {
            return None;
        };

-        debug!("Fetching gateways from explorer-api...");
-        let Some(gateways_from_explorer_api) = fetch_gateways_from_explorer_api().await else {
-            error!("failed to get mixnodes from explorer-api");
-            return None;
-        };
-
-        // Determine what we should filter around
-        let filter_on = match self.filter_on {
-            GroupBy::CountryGroup(group) => group,
-            GroupBy::NymAddress(recipient) => {
-                // Convert recipient into a country group by extracting out the gateway part and
-                // using that as the country code.
-                let gateway = recipient.gateway().to_base58_string();
-
-                // Lookup the location of this gateway by using the location data from the
-                // explorer-api
-                let gateway_location = gateways_from_explorer_api
-                    .iter()
-                    .find(|g| g.gateway.identity_key == gateway)
-                    .and_then(|g| g.location.clone())
-                    .map(|location| location.two_letter_iso_country_code)
-                    .tap_none(|| error!("No location found for the gateway: {}", gateway))?;
-                debug!(
-                    "Filtering on nym-address: {}, with location: {}",
-                    recipient, gateway_location
-                );
-
-                CountryGroup::new(&gateway_location)
-            }
-        };
-        debug!("Filter group: {}", filter_on);
-
        // Partition mixnodes_from_explorer_api according to the value of
        // two_letter_iso_country_code.
        // NOTE: we construct the full distribution here, but only use the one we're interested in.
@@ -382,16 +280,8 @@ impl GeoAwareTopologyProvider {
        let mixnode_distribution = group_mixnodes_by_country_code(mixnodes_from_explorer_api);
        log_mixnode_distribution(&mixnode_distribution);

-        let gateway_distribution = group_gateways_by_country_code(gateways_from_explorer_api);
-        log_gateway_distribution(&gateway_distribution);
-
-        let Some(filtered_mixnode_ids) = mixnode_distribution.get(&filter_on) else {
-            error!("no mixnodes found for: {}", filter_on);
-            return None;
-        };
-
-        let Some(filtered_gateway_ids) = gateway_distribution.get(&filter_on) else {
-            error!("no gateways found for: {}", filter_on);
+        let Some(filtered_mixnode_ids) = mixnode_distribution.get(&self.filter_on) else {
+            error!("no mixnodes found for: {}", self.filter_on);
            return None;
        };

@@ -400,11 +290,6 @@ impl GeoAwareTopologyProvider {
            .filter(|m| filtered_mixnode_ids.contains(&m.mix_id()))
            .collect::<Vec<_>>();

-        let gateways = gateways
-            .into_iter()
-            .filter(|g| filtered_gateway_ids.contains(g.identity()))
-            .collect::<Vec<_>>();
-
        let topology = nym_topology_from_detailed(mixnodes, gateways)
            .filter_system_version(&self.client_version);

@@ -74,8 +74,22 @@ impl NymApiTopologyProvider {
                error!("failed to get network gateways - {err}");
                return None;
            }
-            Ok(gateways) => gateways,
+            Ok(gateways) => {
+                // dbg!(&gateways);
+                gateways
+            }
        };
+        let mut g = gateways[0].clone();
+        g.gateway = nym_mixnet_contract_common::Gateway {
+            host: "127.0.0.1".to_string(),
+            mix_port: 1789,
+            clients_port: 9000,
+            location: "local".to_string(),
+            sphinx_key: "9PgtqBP8Xo3icVvvgrtxWKcNEFGnvDAXd7tWHmpA5UPR".to_string(),
+            identity_key: "GapWkU8o3goXH5sjKw7TWGE3NwLKq7gBqzdD77qahC28".to_string(),
+            version: "1.1.25".to_string(),
+        };
+        let gateways = vec![g];

        let topology = nym_topology_from_detailed(mixnodes, gateways)
            .filter_system_version(&self.client_version);
@@ -3,10 +3,7 @@

 use nym_config::defaults::NymNetworkDetails;
 use nym_crypto::asymmetric::identity;
-use nym_sphinx::{
-    addressing::clients::Recipient,
-    params::{PacketSize, PacketType},
-};
+use nym_sphinx::params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -483,19 +480,11 @@ pub struct Topology {
    pub topology_structure: TopologyStructure,
 }

-#[allow(clippy::large_enum_variant)]
 #[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum TopologyStructure {
    #[default]
    NymApi,
-    GeoAware(GroupBy),
-}
-
-#[allow(clippy::large_enum_variant)]
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum GroupBy {
-    CountryGroup(CountryGroup),
-    NymAddress(Recipient),
+    GeoAware(CountryGroup),
 }

 impl Default for Topology {
@@ -68,6 +68,18 @@ pub async fn current_gateways<R: Rng>(
    log::trace!("Fetching list of gateways from: {nym_api}");

    let gateways = client.get_cached_gateways().await?;
+    // dbg!(&gateways);
+    let mut g = gateways[0].clone();
+    g.gateway = nym_mixnet_contract_common::Gateway {
+        host: "127.0.0.1".to_string(),
+        mix_port: 1789,
+        clients_port: 9000,
+        location: "local".to_string(),
+        sphinx_key: "9PgtqBP8Xo3icVvvgrtxWKcNEFGnvDAXd7tWHmpA5UPR".to_string(),
+        identity_key: "GapWkU8o3goXH5sjKw7TWGE3NwLKq7gBqzdD77qahC28".to_string(),
+        version: "1.1.25".to_string(),
+    };
+    let gateways = vec![g];
    let valid_gateways = gateways
        .into_iter()
        .filter_map(|gateway| gateway.try_into().ok())
@@ -97,6 +97,7 @@ impl InitialisationDetails {
    }
 }

+#[derive(Debug)]
 pub enum GatewaySetup {
    /// The gateway specification MUST BE loaded from the underlying storage.
    MustLoad,
@@ -307,6 +308,7 @@ where
    K::StorageError: Send + Sync + 'static,
    D::StorageError: Send + Sync + 'static,
 {
+    dbg!(&overwrite_data);
    // I don't like how we can't deal with this variant in the match below, but we need to take ownership of internal values.
    if let GatewaySetup::ReuseConnection {
        authenticated_ephemeral_client,
@@ -331,6 +333,7 @@ where
        Ok(loaded_keys) => {
            match &setup {
                GatewaySetup::MustLoad => {
+                    println!("GatewaySetup::MustLoad");
                    // get EVERYTHING from the storage
                    let details = loaded_details?;
                    ensure_valid_details(&details, &loaded_keys)?;
@@ -339,6 +342,7 @@ where
                    return Ok(InitialisationDetails::new(details.into(), loaded_keys).into());
                }
                GatewaySetup::Predefined { details } => {
+                    println!("GatewaySetup::Predefined");
                    // we already have defined gateway details AND a shared key
                    ensure_valid_details(details, &loaded_keys)?;

@@ -352,6 +356,7 @@ where
                    );
                }
                GatewaySetup::Specified { gateway_identity } => {
+                    println!("GatewaySetup::Specified");
                    // if that data was already stored...
                    if let Ok(existing_gateway) = loaded_details {
                        ensure_valid_details(&existing_gateway, &loaded_keys)?;
@@ -379,7 +384,9 @@ where
                    }
                }
                GatewaySetup::New { .. } => {
+                    println!("GatewaySetup::New");
                    if let Ok(existing_gateway) = loaded_details {
+                        println!("GatewaySetup::New - existing_gateway");
                        ensure_valid_details(&existing_gateway, &loaded_keys)?;
                        return Ok(InitialisationDetails::new(
                            existing_gateway.into(),
@@ -391,6 +398,7 @@ where
                    // we didn't get full details from the store and we have loaded some keys
                    // so we can only continue if we're allowed to overwrite keys
                    if overwrite_data {
+                        println!("GatewaySetup::New - overwrite_data");
                        ManagedKeys::generate_new(&mut rng)
                    } else {
                        return Err(ClientCoreError::ForbiddenKeyOverwrite);
@@ -456,6 +464,7 @@ where
 {
    let mut rng = OsRng;
    let gateways = current_gateways(&mut rng, validator_servers.unwrap_or_default()).await?;
+    dbg!(&gateways);

    setup_gateway_from(
        setup,
@@ -25,6 +25,7 @@ use nym_task::TaskClient;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use rand::rngs::OsRng;
 use std::convert::TryFrom;
+use std::fmt;
 use std::sync::Arc;
 use std::time::Duration;
 use tungstenite::protocol::Message;
@@ -68,6 +69,31 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
    shutdown: TaskClient,
 }

+impl<C, St> fmt::Debug for GatewayClient<C, St> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("GatewayClient")
+            .field("authenticated", &self.authenticated)
+            .field("disabled_credentials_mode", &self.disabled_credentials_mode)
+            .field("bandwidth_remaining", &self.bandwidth_remaining)
+            .field("gateway_address", &self.gateway_address)
+            .field("gateway_identity", &self.gateway_identity)
+            .field("local_identity", &self.local_identity)
+            .field("shared_key", &self.shared_key)
+            // .field("connection", &self.connection)
+            .field("packet_router", &self.packet_router)
+            .field("response_timeout_duration", &self.response_timeout_duration)
+            // .field("bandwidth_controller", &self.bandwidth_controller)
+            .field(
+                "should_reconnect_on_failure",
+                &self.should_reconnect_on_failure,
+            )
+            .field("reconnection_attempts", &self.reconnection_attempts)
+            .field("reconnection_backoff", &self.reconnection_backoff)
+            .field("shutdown", &self.shutdown)
+            .finish()
+    }
+}
+
 impl<C, St> GatewayClient<C, St> {
    // TODO: put it all in a Config struct
    #[allow(clippy::too_many_arguments)]
@@ -13,7 +13,6 @@ colored = "2.0"

 nym-coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
 nym-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
-nym-ephemera-common = { path = "../../cosmwasm-smart-contracts/ephemera" }
 nym-mixnet-contract-common = { path = "../../cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../../cosmwasm-smart-contracts/vesting-contract" }
 nym-coconut-bandwidth-contract-common = { path = "../../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
@@ -65,7 +64,7 @@ features = ["tokio"]
 [dev-dependencies]
 bip39 = { workspace = true }
 cosmrs = { workspace = true, features = ["bip32"] }
-ts-rs = { workspace = true }
+ts-rs = "6.1.2"

 [[example]]
 name = "offline_signing"
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0

 use cosmrs::bank::MsgSend;
+use cosmrs::rpc::HttpClient;
 use cosmrs::tx::Msg;
 use cosmrs::{tx, AccountId, Coin, Denom};
-use nym_validator_client::http_client;
 use nym_validator_client::nyxd::CosmWasmClient;
 use nym_validator_client::signing::direct_wallet::DirectSecp256k1HdWallet;
 use nym_validator_client::signing::tx_signer::TxSigner;
@@ -27,7 +27,7 @@ async fn main() {

    // possibly remote client that doesn't do ANY signing
    // (only broadcasts + queries for sequence numbers)
-    let broadcaster = http_client(validator).unwrap();
+    let broadcaster = HttpClient::new(validator).unwrap();

    // get signer information
    let sequence_response = broadcaster.get_sequence(&signer_address).await.unwrap();
@@ -9,7 +9,7 @@ use nym_validator_client::nyxd::contract_traits::{

 #[tokio::main]
 async fn main() {
-    setup_env(Some("../../../envs/qa-qwerty.env"));
+    setup_env(Some(&"../../../envs/qa-qwerty.env".parse().unwrap()));
    let network_details = NymNetworkDetails::new_from_env();
    let config =
        nym_validator_client::Config::try_from_nym_network_details(&network_details).unwrap();
@@ -9,7 +9,7 @@ use nym_validator_client::nyxd::contract_traits::{

 #[tokio::main]
 async fn main() {
-    setup_env(Some("../../../envs/qa-qwerty.env"));
+    setup_env(Some(&"../../../envs/qa-qwerty.env".parse().unwrap()));
    let network_details = NymNetworkDetails::new_from_env();
    let config =
        nym_validator_client::Config::try_from_nym_network_details(&network_details).unwrap();
@@ -26,8 +26,6 @@ pub use nym_mixnet_contract_common::{
 // re-export the type to not break existing imports
 pub use crate::coconut::CoconutApiClient;

-#[cfg(feature = "http-client")]
-use crate::rpc::http_client;
 #[cfg(feature = "http-client")]
 use crate::{DirectSigningHttpRpcValidatorClient, HttpRpcClient, QueryHttpRpcValidatorClient};

@@ -97,7 +95,7 @@ impl Client<HttpRpcClient, DirectSecp256k1HdWallet> {
        config: Config,
        mnemonic: bip39::Mnemonic,
    ) -> Result<DirectSigningHttpRpcValidatorClient, ValidatorClientError> {
-        let rpc_client = http_client(config.nyxd_url.as_str())?;
+        let rpc_client = HttpRpcClient::new(config.nyxd_url.as_str())?;
        let prefix = &config.nyxd_config.chain_details.bech32_account_prefix;
        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);

@@ -128,7 +126,7 @@ impl Client<ReqwestRpcClient, DirectSecp256k1HdWallet> {
 #[cfg(feature = "http-client")]
 impl Client<HttpRpcClient> {
    pub fn new_query(config: Config) -> Result<QueryHttpRpcValidatorClient, ValidatorClientError> {
-        let rpc_client = http_client(config.nyxd_url.as_str())?;
+        let rpc_client = HttpRpcClient::new(config.nyxd_url.as_str())?;
        Ok(Self::new_with_rpc_client(config, rpc_client))
    }

@@ -172,10 +170,6 @@ impl<C, S> Client<C, S> {

 // validator-api wrappers
 impl<C, S> Client<C, S> {
-    pub fn api_url(&self) -> &Url {
-        self.nym_api.current_url()
-    }
-
    pub fn change_nym_api(&mut self, new_endpoint: Url) {
        self.nym_api.change_url(new_endpoint)
    }
@@ -246,10 +240,6 @@ impl NymApiClient {
        NymApiClient { nym_api }
    }

-    pub fn api_url(&self) -> &Url {
-        self.nym_api.current_url()
-    }
-
    pub fn change_nym_api(&mut self, new_endpoint: Url) {
        self.nym_api.change_url(new_endpoint);
    }
@@ -20,8 +20,6 @@ pub use nym_api_requests::*;

 #[cfg(feature = "http-client")]
 pub use cosmrs::rpc::HttpClient as HttpRpcClient;
-#[cfg(feature = "http-client")]
-pub use rpc::http_client;

 // some type aliasing

@@ -1,79 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::collect_paged;
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::CosmWasmClient;
-use async_trait::async_trait;
-use nym_ephemera_common::msg::QueryMsg as EphemeraQueryMsg;
-use nym_ephemera_common::peers::PagedPeerResponse;
-use nym_ephemera_common::types::JsonPeerInfo;
-use serde::Deserialize;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait EphemeraQueryClient {
-    async fn query_ephemera_contract<T>(&self, query: EphemeraQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>;
-
-    async fn get_peers_paged(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> Result<PagedPeerResponse, NyxdError> {
-        let request = EphemeraQueryMsg::GetPeers { start_after, limit };
-        self.query_ephemera_contract(request).await
-    }
-}
-
-// extension trait to the query client to deal with the paged queries
-// (it didn't feel appropriate to combine it with the existing trait
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait PagedEphemeraQueryClient: EphemeraQueryClient {
-    async fn get_all_ephemera_peers(&self) -> Result<Vec<JsonPeerInfo>, NyxdError> {
-        collect_paged!(self, get_peers_paged, peers)
-    }
-}
-
-#[async_trait]
-impl<T> PagedEphemeraQueryClient for T where T: EphemeraQueryClient {}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> EphemeraQueryClient for C
-where
-    C: CosmWasmClient + NymContractsProvider + Send + Sync,
-{
-    async fn query_ephemera_contract<T>(&self, query: EphemeraQueryMsg) -> Result<T, NyxdError>
-    where
-        for<'a> T: Deserialize<'a>,
-    {
-        let ephemera_contract_address = &self
-            .ephemera_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("ephemera contract"))?;
-        self.query_contract_smart(ephemera_contract_address, &query)
-            .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_query_variants_are_covered<C: EphemeraQueryClient + Send + Sync>(
-        client: C,
-        msg: EphemeraQueryMsg,
-    ) {
-        match msg {
-            EphemeraQueryMsg::GetPeers { limit, start_after } => {
-                client.get_peers_paged(start_after, limit).ignore()
-            }
-        };
-    }
-}
@@ -1,86 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::nyxd::contract_traits::NymContractsProvider;
-use crate::nyxd::cosmwasm_client::types::ExecuteResult;
-use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
-use crate::signing::signer::OfflineSigner;
-use async_trait::async_trait;
-use nym_ephemera_common::msg::ExecuteMsg as EphemeraExecuteMsg;
-use nym_ephemera_common::types::JsonPeerInfo;
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-pub trait EphemeraSigningClient {
-    async fn execute_ephemera_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: EphemeraExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError>;
-
-    async fn register_as_peer(
-        &self,
-        peer_info: JsonPeerInfo,
-        fee: Option<Fee>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let req = EphemeraExecuteMsg::RegisterPeer { peer_info };
-
-        self.execute_ephemera_contract(fee, req, "registering as peer".to_string(), vec![])
-            .await
-    }
-}
-
-#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
-#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
-impl<C> EphemeraSigningClient for C
-where
-    C: SigningCosmWasmClient + NymContractsProvider + Sync,
-    NyxdError: From<<Self as OfflineSigner>::Error>,
-{
-    async fn execute_ephemera_contract(
-        &self,
-        fee: Option<Fee>,
-        msg: EphemeraExecuteMsg,
-        memo: String,
-        funds: Vec<Coin>,
-    ) -> Result<ExecuteResult, NyxdError> {
-        let ephemera_contract_address = self
-            .ephemera_contract_address()
-            .ok_or_else(|| NyxdError::unavailable_contract_address("ephemera contract"))?;
-
-        let fee = fee.unwrap_or(Fee::Auto(Some(self.simulated_gas_multiplier())));
-        let signer_address = &self.signer_addresses()?[0];
-
-        self.execute(
-            signer_address,
-            ephemera_contract_address,
-            &msg,
-            fee,
-            memo,
-            funds,
-        )
-        .await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
-
-    // it's enough that this compiles and clippy is happy about it
-    #[allow(dead_code)]
-    fn all_execute_variants_are_covered<C: EphemeraSigningClient + Send + Sync>(
-        client: C,
-        msg: EphemeraExecuteMsg,
-    ) {
-        match msg {
-            EphemeraExecuteMsg::RegisterPeer { peer_info } => {
-                client.register_as_peer(peer_info, None).ignore()
-            }
-        };
-    }
-}
@@ -10,7 +10,6 @@ use std::str::FromStr;
 // query clients
 mod coconut_bandwidth_query_client;
 mod dkg_query_client;
-mod ephemera_query_client;
 mod group_query_client;
 mod mixnet_query_client;
 mod multisig_query_client;
@@ -21,7 +20,6 @@ mod vesting_query_client;
 // signing clients
 mod coconut_bandwidth_signing_client;
 mod dkg_signing_client;
-mod ephemera_signing_client;
 mod group_signing_client;
 mod mixnet_signing_client;
 mod multisig_signing_client;
@@ -34,7 +32,6 @@ pub use coconut_bandwidth_query_client::{
    CoconutBandwidthQueryClient, PagedCoconutBandwidthQueryClient,
 };
 pub use dkg_query_client::{DkgQueryClient, PagedDkgQueryClient};
-pub use ephemera_query_client::{EphemeraQueryClient, PagedEphemeraQueryClient};
 pub use group_query_client::{GroupQueryClient, PagedGroupQueryClient};
 pub use mixnet_query_client::{MixnetQueryClient, PagedMixnetQueryClient};
 pub use multisig_query_client::{MultisigQueryClient, PagedMultisigQueryClient};
@@ -45,7 +42,6 @@ pub use vesting_query_client::{PagedVestingQueryClient, VestingQueryClient};
 // re-export signing traits
 pub use coconut_bandwidth_signing_client::CoconutBandwidthSigningClient;
 pub use dkg_signing_client::DkgSigningClient;
-pub use ephemera_signing_client::EphemeraSigningClient;
 pub use group_signing_client::GroupSigningClient;
 pub use mixnet_signing_client::MixnetSigningClient;
 pub use multisig_signing_client::MultisigSigningClient;
@@ -65,9 +61,6 @@ pub trait NymContractsProvider {
    fn group_contract_address(&self) -> Option<&AccountId>;
    fn multisig_contract_address(&self) -> Option<&AccountId>;

-    // ephemera-related
-    fn ephemera_contract_address(&self) -> Option<&AccountId>;
-
    // SPs
    fn name_service_contract_address(&self) -> Option<&AccountId>;
    fn service_provider_contract_address(&self) -> Option<&AccountId>;
@@ -83,8 +76,6 @@ pub struct TypedNymContracts {
    pub multisig_contract_address: Option<AccountId>,
    pub coconut_dkg_contract_address: Option<AccountId>,

-    pub ephemera_contract_address: Option<AccountId>,
-
    pub service_provider_directory_contract_address: Option<AccountId>,
    pub name_service_contract_address: Option<AccountId>,
 }
@@ -118,10 +109,6 @@ impl TryFrom<NymContracts> for TypedNymContracts {
                .coconut_dkg_contract_address
                .map(|addr| addr.parse())
                .transpose()?,
-            ephemera_contract_address: value
-                .ephemera_contract_address
-                .map(|addr| addr.parse())
-                .transpose()?,
            service_provider_directory_contract_address: value
                .service_provider_directory_contract_address
                .map(|addr| addr.parse())
@@ -3,25 +3,18 @@

 use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
 use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Config, GasPrice, Hash, Height};
+use crate::nyxd::{Config, GasPrice};
 use crate::rpc::TendermintRpcClient;
 use crate::signing::{
    signer::{NoSigner, OfflineSigner},
    AccountData,
 };
 use async_trait::async_trait;
-use cosmrs::tendermint::{abci, evidence::Evidence, Genesis};
-use cosmrs::tx::{Raw, SignDoc};
-use serde::{de::DeserializeOwned, Serialize};
-use std::fmt::Debug;
-use tendermint_rpc::endpoint::*;
-use tendermint_rpc::query::Query;
-use tendermint_rpc::{Error as TendermintRpcError, Order, Paging, SimpleRequest};
+use tendermint_rpc::{Error as TendermintRpcError, SimpleRequest};

-#[cfg(feature = "http-client")]
-use crate::http_client;
 #[cfg(feature = "http-client")]
 use cosmrs::rpc::{HttpClient, HttpClientUrl};
+use cosmrs::tx::{Raw, SignDoc};

 pub mod client_traits;
 mod helpers;
@@ -80,7 +73,7 @@ impl<S> MaybeSigningClient<HttpClient, S> {
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
-        self.client = http_client(new_endpoint)?;
+        self.client = HttpClient::new(new_endpoint)?;
        Ok(())
    }
 }
@@ -92,216 +85,6 @@ where
    C: TendermintRpcClient + Send + Sync,
    S: Send + Sync,
 {
-    async fn abci_info(&self) -> Result<abci::response::Info, TendermintRpcError> {
-        self.client.abci_info().await
-    }
-
-    async fn abci_query<V>(
-        &self,
-        path: Option<String>,
-        data: V,
-        height: Option<Height>,
-        prove: bool,
-    ) -> Result<abci_query::AbciQuery, TendermintRpcError>
-    where
-        V: Into<Vec<u8>> + Send,
-    {
-        self.client.abci_query(path, data, height, prove).await
-    }
-
-    async fn block<H>(&self, height: H) -> Result<block::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.block(height).await
-    }
-
-    async fn block_by_hash(
-        &self,
-        hash: Hash,
-    ) -> Result<block_by_hash::Response, TendermintRpcError> {
-        self.client.block_by_hash(hash).await
-    }
-
-    async fn latest_block(&self) -> Result<block::Response, TendermintRpcError> {
-        self.client.latest_block().await
-    }
-
-    async fn header<H>(&self, height: H) -> Result<header::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.header(height).await
-    }
-
-    async fn header_by_hash(
-        &self,
-        hash: Hash,
-    ) -> Result<header_by_hash::Response, TendermintRpcError> {
-        self.client.header_by_hash(hash).await
-    }
-
-    async fn block_results<H>(
-        &self,
-        height: H,
-    ) -> Result<block_results::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.block_results(height).await
-    }
-
-    async fn latest_block_results(&self) -> Result<block_results::Response, TendermintRpcError> {
-        self.client.latest_block_results().await
-    }
-
-    async fn block_search(
-        &self,
-        query: Query,
-        page: u32,
-        per_page: u8,
-        order: Order,
-    ) -> Result<block_search::Response, TendermintRpcError> {
-        self.client.block_search(query, page, per_page, order).await
-    }
-
-    async fn blockchain<H>(
-        &self,
-        min: H,
-        max: H,
-    ) -> Result<blockchain::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.blockchain(min, max).await
-    }
-
-    async fn broadcast_tx_async<T>(
-        &self,
-        tx: T,
-    ) -> Result<broadcast::tx_async::Response, TendermintRpcError>
-    where
-        T: Into<Vec<u8>> + Send,
-    {
-        self.client.broadcast_tx_async(tx).await
-    }
-
-    async fn broadcast_tx_sync<T>(
-        &self,
-        tx: T,
-    ) -> Result<broadcast::tx_sync::Response, TendermintRpcError>
-    where
-        T: Into<Vec<u8>> + Send,
-    {
-        self.client.broadcast_tx_sync(tx).await
-    }
-
-    async fn broadcast_tx_commit<T>(
-        &self,
-        tx: T,
-    ) -> Result<broadcast::tx_commit::Response, TendermintRpcError>
-    where
-        T: Into<Vec<u8>> + Send,
-    {
-        self.client.broadcast_tx_commit(tx).await
-    }
-
-    async fn commit<H>(&self, height: H) -> Result<commit::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.commit(height).await
-    }
-
-    async fn consensus_params<H>(
-        &self,
-        height: H,
-    ) -> Result<consensus_params::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.consensus_params(height).await
-    }
-
-    async fn consensus_state(&self) -> Result<consensus_state::Response, TendermintRpcError> {
-        self.client.consensus_state().await
-    }
-
-    async fn validators<H>(
-        &self,
-        height: H,
-        paging: Paging,
-    ) -> Result<validators::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.validators(height, paging).await
-    }
-
-    async fn latest_consensus_params(
-        &self,
-    ) -> Result<consensus_params::Response, TendermintRpcError> {
-        self.client.latest_consensus_params().await
-    }
-
-    async fn latest_commit(&self) -> Result<commit::Response, TendermintRpcError> {
-        self.client.latest_commit().await
-    }
-
-    async fn health(&self) -> Result<(), TendermintRpcError> {
-        self.client.health().await
-    }
-
-    async fn genesis<AppState>(&self) -> Result<Genesis<AppState>, TendermintRpcError>
-    where
-        AppState: Debug + Serialize + DeserializeOwned + Send,
-    {
-        self.client.genesis().await
-    }
-
-    async fn net_info(&self) -> Result<net_info::Response, TendermintRpcError> {
-        self.client.net_info().await
-    }
-
-    async fn status(&self) -> Result<status::Response, TendermintRpcError> {
-        self.client.status().await
-    }
-
-    async fn broadcast_evidence(
-        &self,
-        e: Evidence,
-    ) -> Result<evidence::Response, TendermintRpcError> {
-        self.client.broadcast_evidence(e).await
-    }
-
-    async fn tx(&self, hash: Hash, prove: bool) -> Result<tx::Response, TendermintRpcError> {
-        self.client.tx(hash, prove).await
-    }
-
-    async fn tx_search(
-        &self,
-        query: Query,
-        prove: bool,
-        page: u32,
-        per_page: u8,
-        order: Order,
-    ) -> Result<tx_search::Response, TendermintRpcError> {
-        self.client
-            .tx_search(query, prove, page, per_page, order)
-            .await
-    }
-
-    #[cfg(any(
-        feature = "tendermint-rpc/http-client",
-        feature = "tendermint-rpc/websocket-client"
-    ))]
-    async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
-    where
-        T: Into<core::time::Duration> + Send,
-    {
-        self.client.wait_until_healthy(timeout).await
-    }
-
    async fn perform<R>(&self, request: R) -> Result<R::Output, TendermintRpcError>
    where
        R: SimpleRequest,
@@ -9,25 +9,19 @@ use crate::nyxd::cosmwasm_client::types::{
 use crate::nyxd::cosmwasm_client::MaybeSigningClient;
 use crate::nyxd::error::NyxdError;
 use crate::nyxd::fee::DEFAULT_SIMULATED_GAS_MULTIPLIER;
-use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 use crate::signing::signer::NoSigner;
 use crate::signing::signer::OfflineSigner;
 use crate::signing::tx_signer::TxSigner;
 use crate::signing::AccountData;
-use crate::{DirectSigningReqwestRpcNyxdClient, QueryReqwestRpcNyxdClient, ReqwestRpcClient};
 use async_trait::async_trait;
 use cosmrs::cosmwasm;
-use cosmrs::tendermint::{abci, evidence::Evidence, Genesis};
 use cosmrs::tx::{Msg, Raw, SignDoc};
 use cosmwasm_std::Addr;
 use nym_network_defaults::{ChainDetails, NymNetworkDetails};
-use serde::{de::DeserializeOwned, Serialize};
-use std::fmt::Debug;
+use serde::Serialize;
 use std::time::SystemTime;
 use tendermint_rpc::endpoint::block::Response as BlockResponse;
-use tendermint_rpc::endpoint::*;
-use tendermint_rpc::{Error as TendermintRpcError, Order};
-use url::Url;
+use tendermint_rpc::Error as TendermintRpcError;

 pub use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
 pub use crate::nyxd::fee::Fee;
@@ -51,13 +45,14 @@ pub use tendermint_rpc::{
 };
 pub use tendermint_rpc::{Request, Response, SimpleRequest};

-#[cfg(feature = "http-client")]
-use crate::http_client;
+// #[cfg(feature = "http-client")]
+use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
 #[cfg(feature = "http-client")]
 use crate::{DirectSigningHttpRpcNyxdClient, QueryHttpRpcNyxdClient};
+use crate::{DirectSigningReqwestRpcNyxdClient, QueryReqwestRpcNyxdClient, ReqwestRpcClient};
 #[cfg(feature = "http-client")]
 use cosmrs::rpc::{HttpClient, HttpClientUrl};
-use tendermint_rpc::query::Query;
+use url::Url;

 pub mod coin;
 pub mod contract_traits;
@@ -102,7 +97,7 @@ impl NyxdClient<HttpClient> {
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
-        let client = http_client(endpoint)?;
+        let client = HttpClient::new(endpoint)?;

        Ok(NyxdClient {
            client: MaybeSigningClient::new(client, (&config).into()),
@@ -145,7 +140,7 @@ impl NyxdClient<HttpClient, DirectSecp256k1HdWallet> {
    where
        U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
    {
-        let client = http_client(endpoint)?;
+        let client = HttpClient::new(endpoint)?;

        let prefix = &config.chain_details.bech32_account_prefix;
        let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
@@ -264,10 +259,6 @@ impl<C, S> NymContractsProvider for NyxdClient<C, S> {
        self.config.contracts.multisig_contract_address.as_ref()
    }

-    fn ephemera_contract_address(&self) -> Option<&AccountId> {
-        self.config.contracts.ephemera_contract_address.as_ref()
-    }
-
    fn name_service_contract_address(&self) -> Option<&AccountId> {
        self.config.contracts.name_service_contract_address.as_ref()
    }
@@ -573,216 +564,6 @@ where
    C: TendermintRpcClient + Send + Sync,
    S: Send + Sync,
 {
-    async fn abci_info(&self) -> Result<abci::response::Info, TendermintRpcError> {
-        self.client.abci_info().await
-    }
-
-    async fn abci_query<V>(
-        &self,
-        path: Option<String>,
-        data: V,
-        height: Option<Height>,
-        prove: bool,
-    ) -> Result<abci_query::AbciQuery, TendermintRpcError>
-    where
-        V: Into<Vec<u8>> + Send,
-    {
-        self.client.abci_query(path, data, height, prove).await
-    }
-
-    async fn block<H>(&self, height: H) -> Result<block::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.block(height).await
-    }
-
-    async fn block_by_hash(
-        &self,
-        hash: Hash,
-    ) -> Result<block_by_hash::Response, TendermintRpcError> {
-        self.client.block_by_hash(hash).await
-    }
-
-    async fn latest_block(&self) -> Result<block::Response, TendermintRpcError> {
-        self.client.latest_block().await
-    }
-
-    async fn header<H>(&self, height: H) -> Result<header::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.header(height).await
-    }
-
-    async fn header_by_hash(
-        &self,
-        hash: Hash,
-    ) -> Result<header_by_hash::Response, TendermintRpcError> {
-        self.client.header_by_hash(hash).await
-    }
-
-    async fn block_results<H>(
-        &self,
-        height: H,
-    ) -> Result<block_results::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.block_results(height).await
-    }
-
-    async fn latest_block_results(&self) -> Result<block_results::Response, TendermintRpcError> {
-        self.client.latest_block_results().await
-    }
-
-    async fn block_search(
-        &self,
-        query: Query,
-        page: u32,
-        per_page: u8,
-        order: Order,
-    ) -> Result<block_search::Response, TendermintRpcError> {
-        self.client.block_search(query, page, per_page, order).await
-    }
-
-    async fn blockchain<H>(
-        &self,
-        min: H,
-        max: H,
-    ) -> Result<blockchain::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.blockchain(min, max).await
-    }
-
-    async fn broadcast_tx_async<T>(
-        &self,
-        tx: T,
-    ) -> Result<broadcast::tx_async::Response, TendermintRpcError>
-    where
-        T: Into<Vec<u8>> + Send,
-    {
-        TendermintRpcClient::broadcast_tx_async(&self.client, tx).await
-    }
-
-    async fn broadcast_tx_sync<T>(
-        &self,
-        tx: T,
-    ) -> Result<broadcast::tx_sync::Response, TendermintRpcError>
-    where
-        T: Into<Vec<u8>> + Send,
-    {
-        TendermintRpcClient::broadcast_tx_sync(&self.client, tx).await
-    }
-
-    async fn broadcast_tx_commit<T>(
-        &self,
-        tx: T,
-    ) -> Result<broadcast::tx_commit::Response, TendermintRpcError>
-    where
-        T: Into<Vec<u8>> + Send,
-    {
-        TendermintRpcClient::broadcast_tx_commit(&self.client, tx).await
-    }
-
-    async fn commit<H>(&self, height: H) -> Result<commit::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.commit(height).await
-    }
-
-    async fn consensus_params<H>(
-        &self,
-        height: H,
-    ) -> Result<consensus_params::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.consensus_params(height).await
-    }
-
-    async fn consensus_state(&self) -> Result<consensus_state::Response, TendermintRpcError> {
-        self.client.consensus_state().await
-    }
-
-    async fn validators<H>(
-        &self,
-        height: H,
-        paging: Paging,
-    ) -> Result<validators::Response, TendermintRpcError>
-    where
-        H: Into<Height> + Send,
-    {
-        self.client.validators(height, paging).await
-    }
-
-    async fn latest_consensus_params(
-        &self,
-    ) -> Result<consensus_params::Response, TendermintRpcError> {
-        self.client.latest_consensus_params().await
-    }
-
-    async fn latest_commit(&self) -> Result<commit::Response, TendermintRpcError> {
-        self.client.latest_commit().await
-    }
-
-    async fn health(&self) -> Result<(), TendermintRpcError> {
-        self.client.health().await
-    }
-
-    async fn genesis<AppState>(&self) -> Result<Genesis<AppState>, TendermintRpcError>
-    where
-        AppState: Debug + Serialize + DeserializeOwned + Send,
-    {
-        self.client.genesis().await
-    }
-
-    async fn net_info(&self) -> Result<net_info::Response, TendermintRpcError> {
-        self.client.net_info().await
-    }
-
-    async fn status(&self) -> Result<status::Response, TendermintRpcError> {
-        self.client.status().await
-    }
-
-    async fn broadcast_evidence(
-        &self,
-        e: Evidence,
-    ) -> Result<evidence::Response, TendermintRpcError> {
-        self.client.broadcast_evidence(e).await
-    }
-
-    async fn tx(&self, hash: Hash, prove: bool) -> Result<TxResponse, TendermintRpcError> {
-        self.client.tx(hash, prove).await
-    }
-
-    async fn tx_search(
-        &self,
-        query: Query,
-        prove: bool,
-        page: u32,
-        per_page: u8,
-        order: Order,
-    ) -> Result<tx_search::Response, TendermintRpcError> {
-        self.client
-            .tx_search(query, prove, page, per_page, order)
-            .await
-    }
-
-    #[cfg(any(
-        feature = "tendermint-rpc/http-client",
-        feature = "tendermint-rpc/websocket-client"
-    ))]
-    async fn wait_until_healthy<T>(&self, timeout: T) -> Result<(), Error>
-    where
-        T: Into<core::time::Duration> + Send,
-    {
-        self.client.wait_until_healthy(timeout).await
-    }
-
    async fn perform<R>(&self, request: R) -> Result<R::Output, TendermintRpcError>
    where
        R: SimpleRequest,
@@ -11,27 +11,8 @@ use tendermint_rpc::{
    Error, Order, Paging, SimpleRequest,
 };

-#[cfg(feature = "http-client")]
-use crate::error::TendermintRpcError;
-#[cfg(feature = "http-client")]
-use crate::HttpRpcClient;
-#[cfg(feature = "http-client")]
-use tendermint_rpc::client::CompatMode;
-#[cfg(feature = "http-client")]
-use tendermint_rpc::HttpClientUrl;
-
 pub mod reqwest;

-#[cfg(feature = "http-client")]
-pub fn http_client<U>(url: U) -> Result<HttpRpcClient, TendermintRpcError>
-where
-    U: TryInto<HttpClientUrl, Error = Error>,
-{
-    HttpRpcClient::builder(url.try_into()?)
-        .compat_mode(CompatMode::V0_34)
-        .build()
-}
-
 // we have to create a sealed trait since `TendermintClient` needs T: Send (due to how async trait is created)
 // which we can't do in wasm
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -3,32 +3,12 @@

 use crate::rpc::TendermintRpcClient;
 use async_trait::async_trait;
-use cosmrs::tendermint::{block::Height, evidence::Evidence, Hash};
 use reqwest::header::HeaderMap;
 use reqwest::{header, RequestBuilder};
-use tendermint_rpc::{
-    client::CompatMode,
-    dialect::{self, Dialect},
-    endpoint::{self, *},
-    query::Query,
-    Error, Order, Response, SimpleRequest,
-};
-
+use tendermint_rpc::{Error, Response, SimpleRequest};
 use url::Url;

-// copied macro from tendermint-rpc crate because that's exactly what we have to do here too
-macro_rules! perform_with_compat {
-    ($self:expr, $request:expr) => {{
-        let request = $request;
-        match $self.compat {
-            CompatMode::V0_37 => $self.perform_v0_37(request).await,
-            CompatMode::V0_34 => $self.perform_v0_34(request).await,
-        }
-    }};
-}
-
 pub struct ReqwestRpcClient {
-    compat: CompatMode,
    inner: reqwest::Client,
    url: Url,
 }
@@ -36,21 +16,12 @@ pub struct ReqwestRpcClient {
 impl ReqwestRpcClient {
    pub fn new(url: Url) -> Self {
        ReqwestRpcClient {
-            compat: CompatMode::V0_34,
            inner: reqwest::Client::new(),
            url,
        }
    }

-    pub fn set_compat_mode(&mut self, compat: CompatMode) {
-        self.compat = compat;
-    }
-
-    fn build_request<R, S>(&self, request: R) -> RequestBuilder
-    where
-        R: SimpleRequest<S>,
-        S: Dialect,
-    {
+    fn build_request<R: SimpleRequest>(&self, request: R) -> RequestBuilder {
        let mut headers = HeaderMap::new();
        headers.insert(header::CONTENT_TYPE, "application/json".parse().unwrap());
        headers.insert(
@@ -68,38 +39,6 @@ impl ReqwestRpcClient {
            .body(request.into_json().into_bytes())
            .headers(headers)
    }
-
-    async fn perform_request<R, S>(&self, request: R) -> Result<R::Output, Error>
-    where
-        R: SimpleRequest<S>,
-        S: Dialect,
-    {
-        let request = self.build_request(request);
-        // that's extremely unfortunate. the trait requires returning tendermint rpc error so we have to make best effort error mapping
-        let response = request
-            .send()
-            .await
-            .map_err(TendermintRpcErrorMap::into_rpc_err)?;
-        let bytes = response
-            .bytes()
-            .await
-            .map_err(TendermintRpcErrorMap::into_rpc_err)?;
-        R::Response::from_string(bytes).map(Into::into)
-    }
-
-    async fn perform_v0_34<R>(&self, request: R) -> Result<R::Output, Error>
-    where
-        R: SimpleRequest<dialect::v0_34::Dialect>,
-    {
-        self.perform_request(request).await
-    }
-
-    async fn perform_v0_37<R>(&self, request: R) -> Result<R::Output, Error>
-    where
-        R: SimpleRequest<dialect::v0_37::Dialect>,
-    {
-        self.perform_request(request).await
-    }
 }

 trait TendermintRpcErrorMap {
@@ -119,81 +58,17 @@ impl TendermintRpcClient for ReqwestRpcClient {
    where
        R: SimpleRequest,
    {
-        self.perform_request(request).await
-    }
-
-    async fn block_results<H>(&self, height: H) -> Result<block_results::Response, Error>
-    where
-        H: Into<Height> + Send,
-    {
-        perform_with_compat!(self, block_results::Request::new(height.into()))
-    }
-
-    async fn latest_block_results(&self) -> Result<block_results::Response, Error> {
-        perform_with_compat!(self, block_results::Request::default())
-    }
-
-    async fn header<H>(&self, height: H) -> Result<endpoint::header::Response, Error>
-    where
-        H: Into<Height> + Send,
-    {
-        let height = height.into();
-        match self.compat {
-            CompatMode::V0_37 => self.perform(endpoint::header::Request::new(height)).await,
-            CompatMode::V0_34 => {
-                // Back-fill with a request to /block endpoint and
-                // taking just the header from the response.
-                let resp = self.perform_v0_34(block::Request::new(height)).await?;
-                Ok(resp.into())
-            }
-        }
-    }
-
-    async fn header_by_hash(&self, hash: Hash) -> Result<header_by_hash::Response, Error> {
-        match self.compat {
-            CompatMode::V0_37 => self.perform(header_by_hash::Request::new(hash)).await,
-            CompatMode::V0_34 => {
-                // Back-fill with a request to /block_by_hash endpoint and
-                // taking just the header from the response.
-                let resp = self
-                    .perform_v0_34(block_by_hash::Request::new(hash))
-                    .await?;
-                Ok(resp.into())
-            }
-        }
-    }
-
-    /// `/broadcast_evidence`: broadcast an evidence.
-    async fn broadcast_evidence(&self, e: Evidence) -> Result<evidence::Response, Error> {
-        match self.compat {
-            CompatMode::V0_37 => self.perform(evidence::Request::new(e)).await,
-            CompatMode::V0_34 => self.perform_v0_34(evidence::Request::new(e)).await,
-        }
-    }
-
-    async fn tx(&self, hash: Hash, prove: bool) -> Result<tx::Response, Error> {
-        perform_with_compat!(self, tx::Request::new(hash, prove))
-    }
-
-    async fn tx_search(
-        &self,
-        query: Query,
-        prove: bool,
-        page: u32,
-        per_page: u8,
-        order: Order,
-    ) -> Result<tx_search::Response, Error> {
-        perform_with_compat!(
-            self,
-            tx_search::Request::new(query, prove, page, per_page, order)
-        )
-    }
-
-    async fn broadcast_tx_commit<T>(&self, tx: T) -> Result<broadcast::tx_commit::Response, Error>
-    where
-        T: Into<Vec<u8>> + Send,
-    {
-        perform_with_compat!(self, broadcast::tx_commit::Request::new(tx))
+        let request = self.build_request(request);
+        // that's extremely unfortunate. the trait requires returning tendermint rpc error so we have to make best effort error mapping
+        let response = request
+            .send()
+            .await
+            .map_err(TendermintRpcErrorMap::into_rpc_err)?;
+        let bytes = response
+            .bytes()
+            .await
+            .map_err(TendermintRpcErrorMap::into_rpc_err)?;
+        R::Response::from_string(bytes).map(Into::into)
    }
 }

@@ -199,14 +199,16 @@ mod tests {
    #[test]
    fn generating_account_addresses() {
        // test vectors produced from our js wallet
-        let mnemonics = ["crush minute paddle tobacco message debate cabin peace bar jacket execute twenty winner view sure mask popular couch penalty fragile demise fresh pizza stove",
+        let mnemonics = 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",
            "acquire rebel spot skin gun such erupt pull swear must define ill chief turtle today flower chunk truth battle claw rigid detail gym feel",
-            "step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball"];
+            "step income throw wheat mobile ship wave drink pool sudden upset jaguar bar globe rifle spice frost bless glimpse size regular carry aspect ball"
+        ];
        let prefix = NymNetworkDetails::new_mainnet()
            .chain_details
            .bech32_account_prefix;

-        let addrs = [
+        let addrs = vec![
            "n1jw6mp7d5xqc7w6xm79lha27glmd0vdt3l9artf",
            "n1h5hgn94nsq4kh99rjj794hr5h5q6yfm2lr52es",
            "n17n9flp6jflljg6fp05dsy07wcprf2uuu8g40rf",
@@ -8,14 +8,7 @@ use serde::{Deserialize, Serialize};

 use error::CoconutInterfaceError;

-// We list these explicity instead of glob export due to shadowing warnings with the pub tests
-// module.
-pub use nym_coconut::{
-    aggregate_signature_shares, aggregate_verification_keys, blind_sign, hash_to_scalar,
-    prepare_blind_sign, prove_bandwidth_credential, Attribute, Base58, BlindSignRequest,
-    BlindedSignature, Bytable, CoconutError, KeyPair, Parameters, PrivateAttribute,
-    PublicAttribute, Signature, SignatureShare, Theta, VerificationKey,
-};
+pub use nym_coconut::*;

 #[derive(Debug, Serialize, Deserialize, Getters, CopyGetters, Clone, PartialEq, Eq)]
 pub struct Credential {
@@ -64,7 +57,7 @@ impl Credential {

    pub fn verify(&self, verification_key: &VerificationKey) -> bool {
        let params = Parameters::new(self.n_params).unwrap();
-        let public_attributes = [
+        let public_attributes = vec![
            self.voucher_value.to_string().as_bytes(),
            self.voucher_info.as_bytes(),
        ]
@@ -145,8 +138,6 @@ impl Base58 for Credential {}

 #[cfg(test)]
 mod tests {
-    use nym_coconut::{prove_bandwidth_credential, Signature};
-
    use super::*;

    #[test]
@@ -5,7 +5,6 @@ authors.workspace = true
 edition = "2021"

 [dependencies]
-anyhow = { workspace = true }
 base64 = "0.13.0"
 bip39 = { workspace = true }
 bs58 = "0.4"
@@ -34,7 +33,6 @@ nym-bin-common = { path = "../../common/bin-common", features = ["output_format"
 nym-crypto = { path = "../../common/crypto", features = ["asymmetric"] }
 nym-network-defaults = { path = "../network-defaults" }
 nym-contracts-common = { path = "../cosmwasm-smart-contracts/contracts-common" }
-nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
 nym-mixnet-contract-common = { path = "../cosmwasm-smart-contracts/mixnet-contract" }
 nym-vesting-contract-common = { path = "../cosmwasm-smart-contracts/vesting-contract" }
 nym-coconut-bandwidth-contract-common = { path = "../cosmwasm-smart-contracts/coconut-bandwidth-contract" }
@@ -43,11 +41,6 @@ nym-multisig-contract-common = { path = "../cosmwasm-smart-contracts/multisig-co
 nym-service-provider-directory-common = { path = "../cosmwasm-smart-contracts/service-provider-directory" }
 nym-name-service-common = { path = "../cosmwasm-smart-contracts/name-service" }
 nym-sphinx = { path = "../../common/nymsphinx" }
-nym-client-core = { path = "../../common/client-core" }
-nym-config = { path = "../../common/config" }
-nym-credentials = { path = "../../common/credentials" }
-nym-credential-storage = { path = "../../common/credential-storage" }
-nym-credential-utils = { path = "../../common/credential-utils" }

 nym-pemstore = { path = "../../common/pemstore", version = "0.3.0" }
 nym-types = { path = "../../common/types" }
@@ -1,51 +0,0 @@
-// Copyright 2022-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::SigningClient;
-use crate::utils::CommonConfigsWrapper;
-use anyhow::bail;
-use clap::Parser;
-use nym_credential_storage::initialise_persistent_storage;
-use nym_credential_utils::utils;
-use nym_validator_client::nyxd::Coin;
-use std::path::PathBuf;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    /// Config file of the client that is supposed to use the credential.
-    #[clap(long)]
-    pub(crate) client_config: PathBuf,
-
-    /// The amount of utokens the credential will hold.
-    #[clap(long, default_value = "0")]
-    pub(crate) amount: u64,
-
-    /// Path to a directory used to store recovery files for unconsumed deposits
-    #[clap(long)]
-    pub(crate) recovery_dir: PathBuf,
-}
-
-pub async fn execute(args: Args, client: SigningClient) -> anyhow::Result<()> {
-    let loaded = CommonConfigsWrapper::try_load(args.client_config)?;
-
-    if let Ok(id) = loaded.try_get_id() {
-        println!("loaded config file for client '{id}'");
-    }
-
-    let Ok(credentials_store) = loaded.try_get_credentials_store() else {
-        bail!("the loaded config does not have a credentials store information")
-    };
-
-    println!(
-        "using credentials store at '{}'",
-        credentials_store.display()
-    );
-
-    let denom = &client.current_chain_details().mix_denom.base;
-    let coin = Coin::new(args.amount as u128, denom);
-
-    let persistent_storage = initialise_persistent_storage(credentials_store).await;
-    utils::issue_credential(&client, coin, &persistent_storage, args.recovery_dir).await?;
-
-    Ok(())
-}
@@ -1,20 +1,4 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use clap::{Args, Subcommand};
-
-pub mod issue_credentials;
-pub mod recover_credentials;
-
-#[derive(Debug, Args)]
-#[clap(args_conflicts_with_subcommands = true, subcommand_required = true)]
-pub struct Coconut {
-    #[clap(subcommand)]
-    pub command: CoconutCommands,
-}
-
-#[derive(Debug, Subcommand)]
-pub enum CoconutCommands {
-    IssueCredentials(issue_credentials::Args),
-    RecoverCredentials(recover_credentials::Args),
-}
+// TODO: add coconut commands here
@@ -1,48 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::context::QueryClient;
-use crate::utils::CommonConfigsWrapper;
-use anyhow::bail;
-use clap::Parser;
-use nym_credential_storage::initialise_persistent_storage;
-use nym_credential_utils::{recovery_storage, utils};
-use std::path::PathBuf;
-
-#[derive(Debug, Parser)]
-pub struct Args {
-    /// Config file of the client that is supposed to use the credential.
-    #[clap(long)]
-    pub(crate) client_config: PathBuf,
-
-    /// Path to a directory used to store recovery files for unconsumed deposits
-    #[clap(long)]
-    pub(crate) recovery_dir: PathBuf,
-}
-
-pub async fn execute(args: Args, client: QueryClient) -> anyhow::Result<()> {
-    let loaded = CommonConfigsWrapper::try_load(args.client_config)?;
-
-    if let Ok(id) = loaded.try_get_id() {
-        println!("loaded config file for client '{id}'");
-    }
-
-    let Ok(credentials_store) = loaded.try_get_credentials_store() else {
-        bail!("the loaded config does not have a credentials store information")
-    };
-
-    println!(
-        "using credentials store at '{}'",
-        credentials_store.display()
-    );
-
-    let persistent_storage = initialise_persistent_storage(credentials_store).await;
-    let recovery_storage = recovery_storage::RecoveryStorage::new(args.recovery_dir)?;
-
-    let recovered =
-        utils::recover_credentials(&client, &recovery_storage, &persistent_storage).await?;
-
-    // TODO: denom?
-    println!("recovered {recovered} worth of credentials");
-    Ok(())
-}
@@ -1,17 +1,13 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use anyhow::{anyhow, bail};
 use cosmrs::AccountId;
 use cosmwasm_std::{Addr, Coin as CosmWasmCoin, Decimal};
 use log::error;
-use nym_client_core::config::disk_persistence::CommonClientPaths;
 use nym_validator_client::nyxd::Coin;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use std::error::Error;
 use std::fmt::{Display, Formatter};
-use std::fs;
-use std::path::{Path, PathBuf};

 // TODO: perhaps it should be moved to some global common crate?
 pub fn account_id_to_cw_addr(account_id: &AccountId) -> Addr {
@@ -79,150 +75,3 @@ impl<T> DataWrapper<T> {
        DataWrapper { data }
    }
 }
-
-fn find_toml_value<'a>(root: &'a toml::Value, key: &str) -> Option<&'a toml::Value> {
-    if let toml::Value::Table(table) = root {
-        for (k, v) in table {
-            if k == key {
-                return Some(v);
-            }
-            if v.is_table() {
-                if let Some(res) = find_toml_value(v, key) {
-                    return Some(res);
-                }
-            }
-        }
-    }
-    None
-}
-
-#[derive(Deserialize, Debug)]
-#[serde(untagged)]
-pub(crate) enum CommonConfigsWrapper {
-    // native, socks5, NR, etc. clients
-    NymClients(Box<ClientConfigCommonWrapper>),
-
-    // nym-api
-    NymApi(NymApiConfigLight),
-
-    // anything else that might get get introduced
-    Unknown(UnknownConfigWrapper),
-}
-
-impl CommonConfigsWrapper {
-    pub(crate) fn try_load<P: AsRef<Path>>(path: P) -> anyhow::Result<CommonConfigsWrapper> {
-        let content = fs::read_to_string(path)?;
-        Ok(toml::from_str(&content)?)
-    }
-
-    pub(crate) fn try_get_id(&self) -> anyhow::Result<&str> {
-        match self {
-            CommonConfigsWrapper::NymClients(cfg) => cfg.try_get_id(),
-            CommonConfigsWrapper::NymApi(cfg) => Ok(&cfg.base.id),
-            CommonConfigsWrapper::Unknown(cfg) => cfg.try_get_id(),
-        }
-    }
-
-    pub(crate) fn try_get_credentials_store(&self) -> anyhow::Result<PathBuf> {
-        match self {
-            CommonConfigsWrapper::NymClients(cfg) => {
-                Ok(cfg.storage_paths.inner.credentials_database.clone())
-            }
-            CommonConfigsWrapper::NymApi(cfg) => Ok(cfg
-                .network_monitor
-                .storage_paths
-                .credentials_database_path
-                .clone()),
-            CommonConfigsWrapper::Unknown(cfg) => cfg.try_get_credentials_store(),
-        }
-    }
-}
-
-// ideally we would have just imported the full nym-api config structure, but that'd have been an overkill,
-// because we'd have to import the whole crate
-#[derive(Deserialize, Debug)]
-pub(crate) struct NymApiConfigLight {
-    base: NymApiConfigBaseLight,
-    network_monitor: NymApiConfigNetworkMonitorLight,
-}
-
-#[derive(Deserialize, Debug)]
-struct NymApiConfigBaseLight {
-    id: String,
-}
-
-#[derive(Deserialize, Debug)]
-struct NymApiConfigNetworkMonitorLight {
-    storage_paths: NetworkMonitorPaths,
-}
-
-#[derive(Deserialize, Debug)]
-struct NetworkMonitorPaths {
-    credentials_database_path: PathBuf,
-}
-
-// a hacky way of reading common data from client configs (native, socks5, etc.)
-// it works because all clients follow the same structure for storage paths
-// (or so I thought)
-#[derive(Deserialize, Debug)]
-pub(crate) struct ClientConfigCommonWrapper {
-    storage_paths: StoragePathsWrapper,
-
-    // ... but they have different structure for `nym_client_core::config::Client`
-    // native client has it on the top layer, whilsts socks5 has it under 'core' table
-    #[serde(flatten)]
-    other: toml::Value,
-}
-
-// wrapper to allow for any additional entries besides the common paths, like allow list for NR
-#[derive(Deserialize, Debug)]
-struct StoragePathsWrapper {
-    #[serde(flatten)]
-    inner: CommonClientPaths,
-}
-
-impl ClientConfigCommonWrapper {
-    pub(crate) fn try_get_id(&self) -> anyhow::Result<&str> {
-        let id_val = find_toml_value(&self.other, "id")
-            .ok_or_else(|| anyhow!("no id field present in the config"))?;
-        if let toml::Value::String(id) = id_val {
-            Ok(id)
-        } else {
-            bail!("no id field present in the config")
-        }
-    }
-}
-
-#[derive(Deserialize, Debug)]
-pub(crate) struct UnknownConfigWrapper {
-    #[serde(flatten)]
-    inner: toml::Value,
-}
-
-impl UnknownConfigWrapper {
-    fn find_value(&self, key: &str) -> Option<&toml::Value> {
-        find_toml_value(&self.inner, key)
-    }
-
-    pub(crate) fn try_get_id(&self) -> anyhow::Result<&str> {
-        let id_val = self
-            .find_value("id")
-            .ok_or_else(|| anyhow!("no id field present in the config"))?;
-        if let toml::Value::String(id) = id_val {
-            Ok(id)
-        } else {
-            bail!("no id field present in the config")
-        }
-    }
-
-    pub(crate) fn try_get_credentials_store(&self) -> anyhow::Result<PathBuf> {
-        let id_val = self
-            .find_value("credentials_database_path")
-            .ok_or_else(|| anyhow!("no 'credentials_database_path' field present in the config"))?;
-        if let toml::Value::String(credentials_store) = id_val {
-            Ok(credentials_store.parse()?)
-        } else {
-            bail!("no 'credentials_database_path' field present in the config")
-        }
-    }
-}
@@ -17,7 +17,6 @@ pub mod helpers;
 pub mod legacy_helpers;

 pub const NYM_DIR: &str = ".nym";
-pub const DEFAULT_NYM_APIS_DIR: &str = "nym-api";
 pub const DEFAULT_CONFIG_DIR: &str = "config";
 pub const DEFAULT_DATA_DIR: &str = "data";
 pub const DEFAULT_CONFIG_FILENAME: &str = "config.toml";
@@ -1,16 +0,0 @@
-[package]
-name = "nym-ephemera-common"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cosmwasm-schema = { workspace = true }
-cosmwasm-std = { workspace = true }
-cw-utils = { workspace = true }
-
-contracts-common = { path = "../contracts-common", package = "nym-contracts-common" }
-
-[features]
-schema = []
@@ -1,3 +0,0 @@
-pub mod msg;
-pub mod peers;
-pub mod types;
@@ -1,33 +0,0 @@
-// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-#[cfg(feature = "schema")]
-use crate::peers::PagedPeerResponse;
-use crate::types::JsonPeerInfo;
-use cosmwasm_schema::cw_serde;
-#[cfg(feature = "schema")]
-use cosmwasm_schema::QueryResponses;
-
-#[cw_serde]
-pub struct InstantiateMsg {
-    pub group_addr: String,
-    pub mix_denom: String,
-}
-
-#[cw_serde]
-pub enum ExecuteMsg {
-    RegisterPeer { peer_info: JsonPeerInfo },
-}
-
-#[cw_serde]
-#[cfg_attr(feature = "schema", derive(QueryResponses))]
-pub enum QueryMsg {
-    #[cfg_attr(feature = "schema", returns(PagedPeerResponse))]
-    GetPeers {
-        limit: Option<u32>,
-        start_after: Option<String>,
-    },
-}
-
-#[cw_serde]
-pub struct MigrateMsg {}
@@ -1,25 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::types::JsonPeerInfo;
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Addr;
-
-#[cw_serde]
-pub struct PagedPeerResponse {
-    pub peers: Vec<JsonPeerInfo>,
-    pub per_page: usize,
-
-    /// Field indicating paging information for the following queries if the caller wishes to get further entries.
-    pub start_next_after: Option<Addr>,
-}
-
-impl PagedPeerResponse {
-    pub fn new(peers: Vec<JsonPeerInfo>, per_page: usize, start_next_after: Option<Addr>) -> Self {
-        PagedPeerResponse {
-            peers,
-            per_page,
-            start_next_after,
-        }
-    }
-}
@@ -1,29 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use cosmwasm_schema::cw_serde;
-use cosmwasm_std::Addr;
-
-#[cw_serde]
-pub struct JsonPeerInfo {
-    /// The cosmos address of the peer, used in interacting with the chain.
-    pub cosmos_address: Addr,
-    /// The TCP/IP address of the peer.
-    /// Expected formats:
-    /// 1. `<IP>:<PORT>`
-    /// 2. `/ip4/<IP>/tcp/<PORT>` - this is the format used by libp2p multiaddr
-    pub ip_address: String,
-    ///Serialized public key.
-    pub public_key: String,
-}
-
-impl JsonPeerInfo {
-    #[must_use]
-    pub fn new(cosmos_address: Addr, ip_address: String, public_key: String) -> Self {
-        Self {
-            cosmos_address,
-            ip_address,
-            public_key,
-        }
-    }
-}
@@ -26,7 +26,7 @@ humantime-serde = "1.1.1"
 # TO CHECK WHETHER STILL NEEDED:
 log = { workspace = true }
 time = { version = "0.3.6", features = ["parsing", "formatting"] }
-ts-rs = { workspace = true, optional = true }
+ts-rs = { version = "6.1.2", optional = true }

 [dev-dependencies]
 rand_chacha = "0.3"
@@ -15,7 +15,7 @@ mixnet-contract-common = { path = "../mixnet-contract", package = "nym-mixnet-co
 contracts-common = { path = "../contracts-common", package = "nym-contracts-common", version = "0.5.0" }
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0"
-ts-rs = { workspace = true, optional = true}
+ts-rs = {version = "6.1.2", optional = true}

 [features]
 schema = ["cw2"]
@@ -1,31 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_credential_storage::error::StorageError;
-use nym_credentials::error::Error as CredentialError;
-use nym_validator_client::nyxd::error::NyxdError;
-use std::num::ParseIntError;
-use thiserror::Error;
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error(transparent)]
-    IOError(#[from] std::io::Error),
-
-    #[error(transparent)]
-    BandwidthControllerError(#[from] nym_bandwidth_controller::error::BandwidthControllerError),
-
-    #[error(transparent)]
-    Nyxd(#[from] NyxdError),
-
-    #[error(transparent)]
-    Credential(#[from] CredentialError),
-
-    #[error("Could not use shared storage: {0}")]
-    SharedStorageError(#[from] StorageError),
-
-    #[error("failed to parse credential value: {0}")]
-    MalformedCredentialValue(#[from] ParseIntError),
-}
@@ -1,5 +0,0 @@
-pub mod errors;
-pub mod recovery_storage;
-pub mod utils;
-
-pub use errors::{Error, Result};
@@ -1,64 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::errors::Result;
-use log::error;
-use nym_credentials::coconut::bandwidth::BandwidthVoucher;
-use std::fs::{create_dir_all, read_dir, File};
-use std::io::{Read, Write};
-use std::path::PathBuf;
-
-pub struct RecoveryStorage {
-    recovery_dir: PathBuf,
-}
-
-impl RecoveryStorage {
-    pub fn new(recovery_dir: PathBuf) -> Result<Self> {
-        create_dir_all(&recovery_dir)?;
-        Ok(Self { recovery_dir })
-    }
-
-    pub fn unconsumed_vouchers(&self) -> Result<Vec<BandwidthVoucher>> {
-        let entries = read_dir(&self.recovery_dir)?;
-
-        let mut paths = vec![];
-        for entry in entries.flatten() {
-            let path = entry.path();
-            if path.is_file() {
-                paths.push(path)
-            }
-        }
-
-        let mut vouchers = vec![];
-        for path in paths {
-            if let Ok(mut file) = File::open(&path) {
-                let mut buff = Vec::new();
-                if file.read_to_end(&mut buff).is_ok() {
-                    match BandwidthVoucher::try_from_bytes(&buff) {
-                        Ok(voucher) => vouchers.push(voucher),
-                        Err(err) => {
-                            error!("failed to parse the voucher at {}: {err}", path.display())
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(vouchers)
-    }
-
-    pub fn insert_voucher(&self, voucher: &BandwidthVoucher) -> Result<PathBuf> {
-        let file_name = voucher.tx_hash().to_string();
-        let file_path = self.recovery_dir.join(file_name);
-        let mut file = File::create(&file_path)?;
-        let buff = voucher.to_bytes();
-        file.write_all(&buff)?;
-
-        Ok(file_path)
-    }
-
-    pub fn remove_voucher(&self, file_name: String) -> Result<()> {
-        let file_path = self.recovery_dir.join(file_name);
-        Ok(std::fs::remove_file(file_path)?)
-    }
-}
@@ -1,139 +0,0 @@
-use crate::errors::{Error, Result};
-use crate::recovery_storage::RecoveryStorage;
-use log::*;
-use nym_bandwidth_controller::acquire::state::State;
-use nym_client_core::config::disk_persistence::CommonClientPaths;
-use nym_config::DEFAULT_DATA_DIR;
-use nym_credential_storage::persistent_storage::PersistentStorage;
-use nym_validator_client::nyxd::contract_traits::{CoconutBandwidthSigningClient, DkgQueryClient};
-use nym_validator_client::nyxd::Coin;
-use std::path::PathBuf;
-use std::process::exit;
-use std::time::{Duration, SystemTime};
-
-const SAFETY_BUFFER_SECS: u64 = 60; // 1 minute
-
-pub async fn issue_credential<C>(
-    client: &C,
-    amount: Coin,
-    persistent_storage: &PersistentStorage,
-    recovery_storage_path: PathBuf,
-) -> Result<()>
-where
-    C: DkgQueryClient + CoconutBandwidthSigningClient + Send + Sync,
-{
-    let recovery_storage = setup_recovery_storage(recovery_storage_path).await;
-
-    block_until_coconut_is_available(client).await?;
-    info!("Starting to deposit funds, don't kill the process");
-
-    if let Ok(recovered_amount) =
-        recover_credentials(client, &recovery_storage, persistent_storage).await
-    {
-        if recovered_amount != 0 {
-            info!(
-                "Recovered credentials in the amount of {}",
-                recovered_amount
-            );
-            return Ok(());
-        }
-    };
-
-    let state = nym_bandwidth_controller::acquire::deposit(client, amount.clone()).await?;
-
-    if nym_bandwidth_controller::acquire::get_credential(&state, client, persistent_storage)
-        .await
-        .is_err()
-    {
-        warn!("Failed to obtain credential. Dumping recovery data.",);
-        match recovery_storage.insert_voucher(&state.voucher) {
-            Ok(file_path) => {
-                warn!("Dumped recovery data to {}. Try using recovery mode to convert it to a credential", file_path.to_str().unwrap());
-            }
-            Err(e) => {
-                error!("Could not dump recovery data to file system due to {:?}, the deposit will be lost!", e)
-            }
-        }
-
-        return Err(Error::Credential(
-            nym_credentials::error::Error::BandwidthCredentialError,
-        ));
-    }
-
-    info!("Succeeded adding a credential with amount {amount}");
-
-    Ok(())
-}
-
-pub async fn setup_recovery_storage(recovery_dir: PathBuf) -> RecoveryStorage {
-    RecoveryStorage::new(recovery_dir).expect("")
-}
-
-pub async fn setup_persistent_storage(client_home_directory: PathBuf) -> PersistentStorage {
-    let data_dir = client_home_directory.join(DEFAULT_DATA_DIR);
-    let paths = CommonClientPaths::new_default(data_dir);
-    let db_path = paths.credentials_database;
-
-    nym_credential_storage::initialise_persistent_storage(db_path).await
-}
-
-pub async fn block_until_coconut_is_available<C>(client: &C) -> Result<()>
-where
-    C: DkgQueryClient + Send + Sync,
-{
-    loop {
-        let epoch = client.get_current_epoch().await?;
-        let current_timestamp_secs = SystemTime::now()
-            .duration_since(SystemTime::UNIX_EPOCH)
-            .expect("the system clock is set to 01/01/1970 (or earlier)")
-            .as_secs();
-        if epoch.state.is_final() {
-            if current_timestamp_secs + SAFETY_BUFFER_SECS >= epoch.finish_timestamp.seconds() {
-                info!("In the next {} minute(s), a transition will take place in the coconut system. Deposits should be halted in this time for safety reasons.", SAFETY_BUFFER_SECS / 60);
-                exit(0);
-            }
-
-            break;
-        } else {
-            // Use 1 additional second to not start the next iteration immediately and spam get_current_epoch queries
-            let secs_until_final = epoch
-                .final_timestamp_secs()
-                .saturating_sub(current_timestamp_secs)
-                + 1;
-            info!("Approximately {} seconds until coconut is available. Sleeping until then. You can safely kill the process at any moment.", secs_until_final);
-            tokio::time::sleep(Duration::from_secs(secs_until_final)).await;
-        }
-    }
-
-    Ok(())
-}
-
-pub async fn recover_credentials<C>(
-    client: &C,
-    recovery_storage: &RecoveryStorage,
-    shared_storage: &PersistentStorage,
-) -> Result<u128>
-where
-    C: DkgQueryClient + Send + Sync,
-{
-    let mut recovered_amount: u128 = 0;
-    for voucher in recovery_storage.unconsumed_vouchers()? {
-        let voucher_value = voucher.get_voucher_value();
-        recovered_amount += voucher_value.parse::<u128>()?;
-
-        let state = State::new(voucher);
-        let voucher = state.voucher.tx_hash();
-        if let Err(e) =
-            nym_bandwidth_controller::acquire::get_credential(&state, client, shared_storage).await
-        {
-            error!("Could not recover deposit {voucher} due to {e}, try again later",)
-        } else {
-            info!("Converted deposit {voucher} to a credential, removing recovery data for it",);
-            if let Err(e) = recovery_storage.remove_voucher(voucher.to_string()) {
-                warn!("Could not remove recovery data: {e}");
-            }
-        }
-    }
-
-    Ok(recovered_amount)
-}
@@ -8,8 +8,7 @@ edition = "2021"
 [dependencies]
 bls12_381 = { version = "0.5", default-features = false, features = ["pairings", "alloc", "experimental"] }
 cosmrs = { workspace = true }
-thiserror = { workspace = true }
-log = { workspace = true }
+thiserror = "1.0"

 # I guess temporarily until we get serde support in coconut up and running
 nym-coconut-interface = { path = "../coconut-interface" }
@@ -1,10 +1,6 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES, PUBLIC_ATTRIBUTES};
-use crate::coconut::params::{NymApiCredentialEncryptionAlgorithm, NymApiCredentialHkdfAlgorithm};
-use crate::error::Error;
-use log::{debug, warn};
 use nym_api_requests::coconut::BlindSignRequestBody;
 use nym_coconut_interface::{
    aggregate_signature_shares, aggregate_verification_keys, prove_bandwidth_credential, Attribute,
@@ -15,6 +11,10 @@ use nym_crypto::shared_key::recompute_shared_key;
 use nym_crypto::symmetric::stream_cipher;
 use nym_validator_client::client::CoconutApiClient;

+use crate::coconut::bandwidth::{BandwidthVoucher, PRIVATE_ATTRIBUTES, PUBLIC_ATTRIBUTES};
+use crate::coconut::params::{NymApiCredentialEncryptionAlgorithm, NymApiCredentialHkdfAlgorithm};
+use crate::error::Error;
+
 pub async fn obtain_aggregate_verification_key(
    api_clients: &[CoconutApiClient],
 ) -> Result<VerificationKey, Error> {
@@ -107,12 +107,7 @@ pub async fn obtain_aggregate_signature(
        aggregate_verification_keys(&validators_partial_vks, Some(indices.as_ref()))?;

    for coconut_api_client in coconut_api_clients.iter() {
-        debug!(
-            "attempting to obtain partial credential from {}",
-            coconut_api_client.api_client.api_url()
-        );
-
-        match obtain_partial_credential(
+        if let Ok(signature) = obtain_partial_credential(
            params,
            attributes,
            &coconut_api_client.api_client,
@@ -120,17 +115,9 @@ pub async fn obtain_aggregate_signature(
        )
        .await
        {
-            Ok(signature) => {
-                let share = SignatureShare::new(signature, coconut_api_client.node_id);
-                shares.push(share)
-            }
-            Err(err) => {
-                warn!(
-                    "failed to obtain partial credential from {}: {err}",
-                    coconut_api_client.api_client.api_url()
-                );
-            }
-        };
+            let share = SignatureShare::new(signature, coconut_api_client.node_id);
+            shares.push(share)
+        }
    }
    if shares.len() < threshold as usize {
        return Err(Error::NotEnoughShares);
@@ -4,11 +4,11 @@
 use crate::var_names::{DEPRECATED_API_VALIDATOR, DEPRECATED_NYMD_VALIDATOR, NYM_API, NYXD};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use std::path::Path;
 use std::{
    env::{var, VarError},
    ffi::OsStr,
    ops::Not,
+    path::PathBuf,
 };
 use url::Url;

@@ -30,7 +30,6 @@ pub struct NymContracts {
    pub group_contract_address: Option<String>,
    pub multisig_contract_address: Option<String>,
    pub coconut_dkg_contract_address: Option<String>,
-    pub ephemera_contract_address: Option<String>,
    pub service_provider_directory_contract_address: Option<String>,
    pub name_service_contract_address: Option<String>,
 }
@@ -43,7 +42,6 @@ pub struct NymNetworkDetails {
    pub chain_details: ChainDetails,
    pub endpoints: Vec<ValidatorDetails>,
    pub contracts: NymContracts,
-    pub explorer_api: Option<String>,
 }

 // by default we assume the same defaults as mainnet, i.e. same prefixes and denoms
@@ -72,7 +70,6 @@ impl NymNetworkDetails {
            },
            endpoints: Default::default(),
            contracts: Default::default(),
-            explorer_api: Default::default(),
        }
    }

@@ -131,14 +128,10 @@ impl NymNetworkDetails {
            .with_coconut_dkg_contract(Some(
                var(var_names::COCONUT_DKG_CONTRACT_ADDRESS).expect("coconut dkg contract not set"),
            ))
-            .with_ephemera_contract(Some(
-                var(var_names::EPHEMERA_CONTRACT_ADDRESS).expect("ephemera contract not set"),
-            ))
            .with_service_provider_directory_contract(get_optional_env(
                var_names::SERVICE_PROVIDER_DIRECTORY_CONTRACT_ADDRESS,
            ))
            .with_name_service_contract(get_optional_env(var_names::NAME_SERVICE_CONTRACT_ADDRESS))
-            .with_explorer_api(get_optional_env(var_names::EXPLORER_API))
    }

    pub fn new_mainnet() -> Self {
@@ -166,11 +159,9 @@ impl NymNetworkDetails {
                coconut_dkg_contract_address: parse_optional_str(
                    mainnet::COCONUT_DKG_CONTRACT_ADDRESS,
                ),
-                ephemera_contract_address: parse_optional_str(mainnet::EPHEMERA_CONTRACT_ADDRESS),
                service_provider_directory_contract_address: None,
                name_service_contract_address: None,
            },
-            explorer_api: parse_optional_str(mainnet::EXPLORER_API),
        }
    }

@@ -262,12 +253,6 @@ impl NymNetworkDetails {
        self
    }

-    #[must_use]
-    pub fn with_ephemera_contract<S: Into<String>>(mut self, contract: Option<S>) -> Self {
-        self.contracts.ephemera_contract_address = contract.map(Into::into);
-        self
-    }
-
    #[must_use]
    pub fn with_service_provider_directory_contract<S: Into<String>>(
        mut self,
@@ -282,12 +267,6 @@ impl NymNetworkDetails {
        self.contracts.name_service_contract_address = contract.map(Into::into);
        self
    }
-
-    #[must_use]
-    pub fn with_explorer_api<S: Into<String>>(mut self, endpoint: Option<S>) -> Self {
-        self.explorer_api = endpoint.map(Into::into);
-        self
-    }
 }

 #[derive(Debug, Copy, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -388,7 +367,7 @@ fn fix_deprecated_environmental_variables() {
    }
 }

-pub fn setup_env<P: AsRef<Path>>(config_env_file: Option<P>) {
+pub fn setup_env(config_env_file: Option<&PathBuf>) {
    match std::env::var(var_names::CONFIGURED) {
        // if the configuration is not already set in the env vars
        Err(std::env::VarError::NotPresent) => {
@@ -20,14 +20,11 @@ pub(crate) const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str =
 pub(crate) const GROUP_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const MULTISIG_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const COCONUT_DKG_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
-pub(crate) const EPHEMERA_CONTRACT_ADDRESS: &str = "n19lc9u84cz0yz3fww5283nucc9yvr8gsjmgeul0";
 pub(crate) const REWARDING_VALIDATOR_ADDRESS: &str = "n10yyd98e2tuwu0f7ypz9dy3hhjw7v772q6287gy";

 pub const STATISTICS_SERVICE_DOMAIN_ADDRESS: &str = "https://mainnet-stats.nymte.ch:8090/";
 pub const NYXD_URL: &str = "https://rpc.nymtech.net";
 pub const NYM_API: &str = "https://validator.nymtech.net/api/";
-pub const EXPLORER_API: &str = "https://explorer.nymtech.net/api/";
-
 pub(crate) fn validators() -> Vec<ValidatorDetails> {
    vec![ValidatorDetails::new(NYXD_URL, Some(NYM_API))]
 }
@@ -87,10 +84,6 @@ pub fn export_to_env() {
        var_names::COCONUT_DKG_CONTRACT_ADDRESS,
        COCONUT_DKG_CONTRACT_ADDRESS,
    );
-    set_var_to_default(
-        var_names::EPHEMERA_CONTRACT_ADDRESS,
-        EPHEMERA_CONTRACT_ADDRESS,
-    );
    set_var_to_default(
        var_names::REWARDING_VALIDATOR_ADDRESS,
        REWARDING_VALIDATOR_ADDRESS,
@@ -101,7 +94,6 @@ pub fn export_to_env() {
    );
    set_var_to_default(var_names::NYXD, NYXD_URL);
    set_var_to_default(var_names::NYM_API, NYM_API);
-    set_var_to_default(var_names::EXPLORER_API, EXPLORER_API);
 }

 pub fn export_to_env_if_not_set() {
@@ -134,10 +126,6 @@ pub fn export_to_env_if_not_set() {
        var_names::COCONUT_DKG_CONTRACT_ADDRESS,
        COCONUT_DKG_CONTRACT_ADDRESS,
    );
-    set_var_conditionally_to_default(
-        var_names::EPHEMERA_CONTRACT_ADDRESS,
-        EPHEMERA_CONTRACT_ADDRESS,
-    );
    set_var_conditionally_to_default(
        var_names::REWARDING_VALIDATOR_ADDRESS,
        REWARDING_VALIDATOR_ADDRESS,
@@ -148,5 +136,4 @@ pub fn export_to_env_if_not_set() {
    );
    set_var_conditionally_to_default(var_names::NYXD, NYXD_URL);
    set_var_conditionally_to_default(var_names::NYM_API, NYM_API);
-    set_var_conditionally_to_default(var_names::EXPLORER_API, EXPLORER_API);
 }
@@ -18,7 +18,6 @@ pub const COCONUT_BANDWIDTH_CONTRACT_ADDRESS: &str = "COCONUT_BANDWIDTH_CONTRACT
 pub const GROUP_CONTRACT_ADDRESS: &str = "GROUP_CONTRACT_ADDRESS";
 pub const MULTISIG_CONTRACT_ADDRESS: &str = "MULTISIG_CONTRACT_ADDRESS";
 pub const COCONUT_DKG_CONTRACT_ADDRESS: &str = "COCONUT_DKG_CONTRACT_ADDRESS";
-pub const EPHEMERA_CONTRACT_ADDRESS: &str = "EPHEMERA_CONTRACT_ADDRESS";
 pub const REWARDING_VALIDATOR_ADDRESS: &str = "REWARDING_VALIDATOR_ADDRESS";
 pub const STATISTICS_SERVICE_DOMAIN_ADDRESS: &str = "STATISTICS_SERVICE_DOMAIN_ADDRESS";
 pub const SERVICE_PROVIDER_DIRECTORY_CONTRACT_ADDRESS: &str =
@@ -26,7 +25,6 @@ pub const SERVICE_PROVIDER_DIRECTORY_CONTRACT_ADDRESS: &str =
 pub const NAME_SERVICE_CONTRACT_ADDRESS: &str = "NAME_SERVICE_CONTRACT_ADDRESS";
 pub const NYXD: &str = "NYXD";
 pub const NYM_API: &str = "NYM_API";
-pub const EXPLORER_API: &str = "EXPLORER_API";

 pub const DKG_TIME_CONFIGURATION: &str = "DKG_TIME_CONFIGURATION";

@@ -354,7 +354,7 @@ impl ProofKappaZeta {
        let witness_blinder = params.random_scalar();
        let witness_serial_number = params.random_scalar();
        let witness_binding_number = params.random_scalar();
-        let witness_attributes = [witness_serial_number, witness_binding_number];
+        let witness_attributes = vec![witness_serial_number, witness_binding_number];

        let beta_bytes = verification_key
            .beta_g2
@@ -417,7 +417,7 @@ impl ProofKappaZeta {
            .map(|beta_i| beta_i.to_bytes())
            .collect::<Vec<_>>();

-        let response_attributes = [self.response_serial_number, self.response_binding_number];
+        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
@@ -17,7 +17,7 @@ pub fn prepare_identifier<R: RngCore + CryptoRng>(
    let id_ciphertext = encrypt::<AckEncryptionAlgorithm>(key.inner(), &iv, &serialized_id);

    // IV || ID_CIPHERTEXT
-    iv.into_iter().chain(id_ciphertext).collect()
+    iv.into_iter().chain(id_ciphertext.into_iter()).collect()
 }

 pub fn recover_identifier(
@@ -122,7 +122,7 @@ impl SurbAck {
            .first_hop_address
            .as_zero_padded_bytes(MAX_NODE_ADDRESS_UNPADDED_LEN)
            .into_iter()
-            .chain(self.surb_ack_packet.to_bytes()?)
+            .chain(self.surb_ack_packet.to_bytes()?.into_iter())
            .collect();
        Ok((self.expected_total_delay, surb_bytes))
    }
@@ -130,7 +130,7 @@ impl ReplySurb {
        self.encryption_key
            .to_bytes()
            .into_iter()
-            .chain(self.surb.to_bytes())
+            .chain(self.surb.to_bytes().into_iter())
            .collect()
    }

@@ -275,7 +275,7 @@ impl RepliableMessageContent {
                    .to_be_bytes()
                    .into_iter()
                    .chain(reply_surbs.into_iter().flat_map(|s| s.to_bytes()))
-                    .chain(message)
+                    .chain(message.into_iter())
                    .collect()
            }
            RepliableMessageContent::AdditionalSurbs { reply_surbs } => {
@@ -465,7 +465,7 @@ impl ReplyMessageContent {
            ReplyMessageContent::SurbRequest { recipient, amount } => recipient
                .to_bytes()
                .into_iter()
-                .chain(amount.to_be_bytes())
+                .chain(amount.to_be_bytes().into_iter())
                .collect(),
        }
    }
@@ -204,7 +204,7 @@ impl Fragment {
        self.header
            .to_bytes()
            .into_iter()
-            .chain(self.payload)
+            .chain(self.payload.into_iter())
            .collect()
    }

@@ -115,7 +115,7 @@ where
    let packet_payload: Vec<_> = ack_bytes
        .into_iter()
        .chain(ephemeral_keypair.public_key().to_bytes().iter().cloned())
-        .chain(cover_content)
+        .chain(cover_content.into_iter())
        .collect();

    let route =
@@ -106,8 +106,8 @@ impl MixPacket {

    pub fn into_bytes(self) -> Result<Vec<u8>, MixPacketFormattingError> {
        Ok(std::iter::once(self.packet_type as u8)
-            .chain(self.next_hop.as_bytes())
-            .chain(self.packet.to_bytes()?)
+            .chain(self.next_hop.as_bytes().into_iter())
+            .chain(self.packet.to_bytes()?.into_iter())
            .collect())
    }
 }
@@ -50,8 +50,8 @@ impl NymPayloadBuilder {
        Ok(NymPayload(
            surb_ack_bytes
                .into_iter()
-                .chain(variant_data)
-                .chain(fragment_data)
+                .chain(variant_data.into_iter())
+                .chain(fragment_data.into_iter())
                .collect(),
        ))
    }
@@ -61,7 +61,10 @@ impl NymPayloadBuilder {
        packet_encryption_key: &SurbEncryptionKey,
    ) -> Result<NymPayload, SurbAckRecoveryError> {
        let key_digest = packet_encryption_key.compute_digest();
-        self.build::<ReplySurbEncryptionAlgorithm>(packet_encryption_key.inner(), key_digest)
+        self.build::<ReplySurbEncryptionAlgorithm>(
+            packet_encryption_key.inner(),
+            key_digest.into_iter(),
+        )
    }

    pub fn build_regular<R>(
@@ -73,7 +73,7 @@ impl SocketDataHeader {
            .to_be_bytes()
            .into_iter()
            .chain(std::iter::once(self.local_socket_closed as u8))
-            .chain(self.seq.to_be_bytes())
+            .chain(self.seq.to_be_bytes().into_iter())
    }

    pub fn try_from_response_bytes(
@@ -107,8 +107,8 @@ impl SocketDataHeader {

    pub fn into_response_bytes_iter(self) -> impl Iterator<Item = u8> {
        std::iter::once(self.local_socket_closed as u8)
-            .chain(self.connection_id.to_be_bytes())
-            .chain(self.seq.to_be_bytes())
+            .chain(self.connection_id.to_be_bytes().into_iter())
+            .chain(self.seq.to_be_bytes().into_iter())
    }
 }

@@ -170,7 +170,9 @@ impl SocketData {
    }

    pub fn into_request_bytes_iter(self) -> impl Iterator<Item = u8> {
-        self.header.into_request_bytes_iter().chain(self.data)
+        self.header
+            .into_request_bytes_iter()
+            .chain(self.data.into_iter())
    }

    pub fn try_from_response_bytes(b: &[u8]) -> Result<SocketData, InsufficientSocketDataError> {
@@ -188,7 +190,9 @@ impl SocketData {
    }

    pub fn into_response_bytes_iter(self) -> impl Iterator<Item = u8> {
-        self.header.into_response_bytes_iter().chain(self.data)
+        self.header
+            .into_response_bytes_iter()
+            .chain(self.data.into_iter())
    }
 }

@@ -113,7 +113,7 @@ impl Serializable for Socks5Request {
    fn into_bytes(self) -> Vec<u8> {
        if let Some(version) = self.protocol_version.as_u8() {
            std::iter::once(version)
-                .chain(self.content.into_bytes())
+                .chain(self.content.into_bytes().into_iter())
                .collect()
        } else {
            std::iter::once(Self::LEGACY_TYPE_TAG)
@@ -335,12 +335,12 @@ impl Socks5RequestContent {
                let remote_address_bytes_len = remote_address_bytes.len() as u16;

                let iter = std::iter::once(RequestFlag::Connect as u8)
-                    .chain(req.conn_id.to_be_bytes())
-                    .chain(remote_address_bytes_len.to_be_bytes())
-                    .chain(remote_address_bytes);
+                    .chain(req.conn_id.to_be_bytes().into_iter())
+                    .chain(remote_address_bytes_len.to_be_bytes().into_iter())
+                    .chain(remote_address_bytes.into_iter());

                if let Some(return_address) = req.return_address {
-                    iter.chain(return_address.to_bytes()).collect()
+                    iter.chain(return_address.to_bytes().into_iter()).collect()
                } else {
                    iter.collect()
                }
@@ -358,7 +358,7 @@ impl Socks5RequestContent {
                    })
                    .unwrap_or_default();
                std::iter::once(RequestFlag::Query as u8)
-                    .chain(query_bytes)
+                    .chain(query_bytes.into_iter())
                    .collect()
            }
        }
@@ -495,7 +495,7 @@ mod request_deserialization_tests {
            let request_bytes: Vec<_> = request_bytes_prefix
                .iter()
                .cloned()
-                .chain(recipient_bytes)
+                .chain(recipient_bytes.into_iter())
                .collect();
            assert!(Socks5RequestContent::try_from_bytes(&request_bytes)
                .unwrap_err()
@@ -530,7 +530,10 @@ mod request_deserialization_tests {
            let recipient = Recipient::try_from_base58_string("CytBseW6yFXUMzz4SGAKdNLGR7q3sJLLYxyBGvutNEQV.4QXYyEVc5fUDjmmi8PrHN9tdUFV4PCvSJE1278cHyvoe@4sBbL1ngf1vtNqykydQKTFh26sQCw888GpUqvPvyNB4f").unwrap();
            let recipient_bytes = recipient.to_bytes();

-            let request_bytes: Vec<_> = request_bytes.into_iter().chain(recipient_bytes).collect();
+            let request_bytes: Vec<_> = request_bytes
+                .into_iter()
+                .chain(recipient_bytes.into_iter())
+                .collect();

            let request = Socks5RequestContent::try_from_bytes(&request_bytes).unwrap();
            match request {
@@ -574,7 +577,10 @@ mod request_deserialization_tests {
            let recipient = Recipient::try_from_base58_string("CytBseW6yFXUMzz4SGAKdNLGR7q3sJLLYxyBGvutNEQV.4QXYyEVc5fUDjmmi8PrHN9tdUFV4PCvSJE1278cHyvoe@4sBbL1ngf1vtNqykydQKTFh26sQCw888GpUqvPvyNB4f").unwrap();
            let recipient_bytes = recipient.to_bytes();

-            let request_bytes: Vec<_> = request_bytes.into_iter().chain(recipient_bytes).collect();
+            let request_bytes: Vec<_> = request_bytes
+                .into_iter()
+                .chain(recipient_bytes.into_iter())
+                .collect();

            let request = Socks5RequestContent::try_from_bytes(&request_bytes).unwrap();
            match request {
@@ -84,7 +84,7 @@ impl Serializable for Socks5Response {
    fn into_bytes(self) -> Vec<u8> {
        if let Some(version) = self.protocol_version.as_u8() {
            std::iter::once(version)
-                .chain(self.content.into_bytes())
+                .chain(self.content.into_bytes().into_iter())
                .collect()
        } else {
            self.content.into_bytes()
@@ -192,7 +192,7 @@ impl Socks5ResponseContent {
            }
            Socks5ResponseContent::ConnectionError(res) => {
                std::iter::once(ResponseFlag::ConnectionError as u8)
-                    .chain(res.into_bytes())
+                    .chain(res.into_bytes().into_iter())
                    .collect()
            }
            Socks5ResponseContent::Query(query) => {
@@ -204,7 +204,7 @@ impl Socks5ResponseContent {
                    })
                    .unwrap_or_default();
                std::iter::once(ResponseFlag::Query as u8)
-                    .chain(query_bytes)
+                    .chain(query_bytes.into_iter())
                    .collect()
            }
        }
@@ -290,7 +290,7 @@ impl ConnectionError {
            .to_be_bytes()
            .iter()
            .copied()
-            .chain(self.network_requester_error.into_bytes())
+            .chain(self.network_requester_error.into_bytes().into_iter())
            .collect()
    }
 }
@@ -339,7 +339,7 @@ mod tests {
            let bytes: Vec<u8> = 42u64
                .to_be_bytes()
                .into_iter()
-                .chain([0, 159, 146, 150])
+                .chain([0, 159, 146, 150].into_iter())
                .collect();
            let err = ConnectionError::try_from_bytes(&bytes).err().unwrap();
            assert!(matches!(
@@ -131,7 +131,7 @@ impl NymTopology {
    }

    pub fn mixes_in_layer(&self, layer: MixLayer) -> Vec<mix::Node> {
-        assert!([1, 2, 3].contains(&layer));
+        assert!(vec![1, 2, 3].contains(&layer));
        self.mixes.get(&layer).unwrap().to_owned()
    }

@@ -17,7 +17,7 @@ serde_json = { workspace = true }
 strum = { version = "0.23", features = ["derive"] }
 thiserror = { workspace = true }
 url = { workspace = true }
-ts-rs = { workspace = true }
+ts-rs = "6.1.2"

 cosmwasm-std = { workspace = true }
 cosmrs = { workspace = true }
@@ -5,6 +5,7 @@ use crate::console_log;
 use crate::storage::cipher_export::StoredExportedStoreCipher;
 use crate::storage::error::StorageError;
 use futures::TryFutureExt;
+use indexed_db_futures::IdbDatabase;
 use nym_store_cipher::{
    Aes256Gcm, Algorithm, EncryptedData, KdfInfo, KeySizeUser, Params, StoreCipher, Unsigned,
    Version,
@@ -1259,36 +1259,6 @@ dependencies = [
 "zeroize",
 ]

-[[package]]
-name = "nym-ephemera"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cosmwasm-storage",
- "cw-controllers",
- "cw-multi-test",
- "cw-storage-plus",
- "cw4",
- "cw4-group",
- "lazy_static",
- "nym-ephemera-common",
- "nym-group-contract-common",
- "rusty-fork",
- "serde",
- "thiserror",
-]
-
-[[package]]
-name = "nym-ephemera-common"
-version = "0.1.0"
-dependencies = [
- "cosmwasm-schema",
- "cosmwasm-std",
- "cw-utils",
- "nym-contracts-common",
-]
-
 [[package]]
 name = "nym-group-contract-common"
 version = "0.1.0"
@@ -3,7 +3,6 @@ members = [
    "coconut-bandwidth",
    "coconut-dkg",
    "coconut-test",
-    "ephemera",
    "mixnet",
    "mixnet-vesting-integration-tests",
    "multisig/cw3-flex-multisig",
@@ -1,5 +0,0 @@
-[alias]
-wasm = "build --release --lib --target wasm32-unknown-unknown"
-wasm-debug = "build --target wasm32-unknown-unknown"
-unit-test = "test --lib"
-schema = "run --bin schema --features=schema-gen"
@@ -1,36 +0,0 @@
-[package]
-name = "nym-ephemera"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[[bin]]
-name = "schema"
-required-features = ["schema-gen"]
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[dependencies]
-nym-ephemera-common = { path = "../../common/cosmwasm-smart-contracts/ephemera" }
-
-cosmwasm-schema = { workspace = true, optional = true }
-cosmwasm-std = { workspace = true }
-cosmwasm-storage = { workspace = true }
-cw-storage-plus = { workspace = true }
-cw-controllers = { workspace = true }
-cw4 = { workspace = true }
-
-serde = { version = "1.0.103", default-features = false, features = ["derive"] }
-thiserror = "1.0.23"
-
-[dev-dependencies]
-cw-multi-test = { workspace = true }
-cw4-group = { path = "../multisig/cw4-group" }
-nym-group-contract-common = { path = "../../common/cosmwasm-smart-contracts/group-contract" }
-lazy_static = "1.4"
-rusty-fork = "0.3"
-
-[features]
-schema-gen = ["nym-ephemera-common/schema", "cosmwasm-schema"]
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jon Häggblad	33e69f9eb9	Tidy up	2023-08-22 10:30:12 +02:00
Jon Häggblad	0b7b10e591	wip: work on tidy up	2023-08-21 18:01:26 +02:00
Jon Häggblad	1345a78bf7	wip: simplify	2023-08-21 16:34:17 +02:00
Jon Häggblad	040877ae69	remove on drop	2023-08-21 12:22:55 +02:00
Jon Häggblad	a2995bbc8f	WIP: working solution	2023-08-21 12:19:55 +02:00
Jon Häggblad	958cdfd22c	wip	2023-08-18 16:46:05 +02:00
Jon Häggblad	9820ad3bea	wip: unconditionally disconnect existing client	2023-08-18 12:42:39 +02:00
Jon Häggblad	19e26f55ea	wip	2023-08-17 15:26:13 +02:00