added info logging

* commenting

.github/actions/nym-hash-releases/.gitignore

@@ -0,0 +1,2 @@
+.tmp
+hashes.json

.github/actions/nym-hash-releases/action.yml

@@ -0,0 +1,25 @@
+name: 'Nym Hash Release'
+author: 'Nym Technologies SA'
+description: 'Generate hashes and signatures for assets in Nym releases'
+inputs:
+  hash-type:
+    description: 'Type of hash to generate (md5, sha1, sha256, sha512)'
+    required: false
+    default: 'sha256'
+  file-name:
+    description: 'File name to save as if desired'
+    required: false
+    default: 'hashes.json'
+  release-tag-or-name-or-id:
+    description: 'The tag/release to process. Uses the release id when trigger from a release.'
+    required: false
+    default: ''
+outputs:
+  hashes:
+    description: 'A string containing JSON with the release asset hashes and signatures'
+runs:
+  using: 'node16'
+  main: 'index.js'
+branding:
+  icon: 'hash'
+  color: 'green'

.github/actions/nym-hash-releases/create-hashes.mjs

@@ -0,0 +1,259 @@
+import hasha from "hasha";
+import fetch from "node-fetch";
+import { Octokit } from "@octokit/rest";
+import fs from "fs";
+import path from "path";
+
+async function run(assets, algorithm, filename, cache) {
+    try {
+        fs.mkdirSync('.tmp');
+    } catch(e) {
+        // ignore
+    }
+
+    const hashes = {};
+    let numAwaiting = 0;
+    for (const asset of assets) {
+        if (filename === "" || asset.name !== filename) { // don't hash the hash file (if the file has the same name)
+            numAwaiting++;
+
+            let buffer = null;
+            let sig = null;
+            if(cache) {
+                // cache in `${WORKING_DIR}/.tmp/`
+                const cacheFilename = path.resolve(`.tmp/${asset.name}`);
+                if(!fs.existsSync(cacheFilename)) {
+                    console.log(`Downloading ${asset.browser_download_url}... to ${cacheFilename}`);
+                    buffer = Buffer.from(await fetch(asset.browser_download_url).then(res => res.arrayBuffer()));
+                    fs.writeFileSync(cacheFilename, buffer);
+                } else {
+                    console.log(`Loading from ${cacheFilename}`);
+                    buffer = Buffer.from(fs.readFileSync(cacheFilename));
+
+                    // console.log('Reading signature from content');
+                    // if(asset.name.endsWith('.sig')) {
+                    //     sig = fs.readFileSync(cacheFilename).toString();
+                    // }
+                }
+            } else {
+                // fetch always
+                buffer = Buffer.from(await fetch(asset.browser_download_url).then(res => res.arrayBuffer()));
+            }
+            if(!hashes[asset.name]) {
+                hashes[asset.name] = {};
+            }
+
+            if(asset.name.endsWith('.sig')) {
+                sig = buffer.toString();
+            }
+
+            hashes[asset.name][algorithm] = hasha(new Uint8Array(buffer), {algorithm: algorithm});
+
+            let platform;
+            let kind;
+            if(asset.name.endsWith('.sig')) {
+                kind = 'signature';
+            }
+            if(asset.name.endsWith('.app.tar.gz')) {
+                platform = 'MacOS';
+                kind = 'auto-updater';
+            }
+            if(asset.name.endsWith('.app.tar.gz.sig')) {
+                platform = 'MacOS';
+                kind = 'auto-updater-signature';
+            }
+            if(asset.name.endsWith('.dmg')) {
+                platform = 'MacOS';
+                kind = 'installer';
+            }
+            if(asset.name.endsWith('.msi.zip')) {
+                platform = 'Windows';
+                kind = 'auto-updater';
+            }
+            if(asset.name.endsWith('.msi.zip.sig')) {
+                platform = 'Windows';
+                kind = 'auto-updater-signature';
+            }
+            if(asset.name.endsWith('.msi')) {
+                platform = 'Windows';
+                kind = 'installer';
+            }
+            if(asset.name.endsWith('.AppImage.tar.gz')) {
+                platform = 'Linux';
+                kind = 'auto-updater';
+            }
+            if(asset.name.endsWith('.AppImage.tar.gz.sig')) {
+                platform = 'Linux';
+                kind = 'auto-updater-signature';
+            }
+            if(asset.name.endsWith('.AppImage')) {
+                platform = 'Linux';
+                kind = 'installer';
+            }
+
+            hashes[asset.name].downloadUrl = asset.browser_download_url;
+
+            if(platform) {
+                hashes[asset.name].platform = platform;
+            }
+            if(kind) {
+                hashes[asset.name].kind = kind;
+            }
+
+            // process Tauri signature files
+            if(asset.name.endsWith('.sig')) {
+                const otherFilename = asset.name.replace('.sig', '');
+                if(!hashes[otherFilename]) {
+                    hashes[otherFilename] = {};
+                }
+                hashes[otherFilename].signature = sig;
+            }
+        }
+    }
+    return hashes;
+}
+
+export async function createHashes({ assets, algorithm, filename, cache }) {
+    const output = await run(assets, algorithm, filename, cache);
+    if(filename?.length) {
+        fs.writeFileSync(filename, JSON.stringify(output, null, 2));
+    }
+    return output;
+}
+
+export async function createHashesFromReleaseTagOrNameOrId({ releaseTagOrNameOrId, algorithm = 'sha256', filename = 'hashes.json', cache = false, upload = true }) {
+    console.log("🚀🚀🚀 Getting releases");
+
+    let auth;
+    let authStrategy;
+    if(process.env.GITHUB_TOKEN) {
+        console.log('Using GITHUB_TOKEN for auth');
+        // authStrategy = createActionAuth();
+        // auth = await authStrategy();
+    }
+
+    const octokit = new Octokit({
+        auth: process.env.GITHUB_TOKEN,
+        request: { fetch }
+    });
+    const owner = "nymtech";
+    const repo = "nym";
+
+    let releases;
+    if(cache) {
+        const cacheFilename = path.resolve(`.tmp/releases.json`);
+        if(!fs.existsSync(cacheFilename)) {
+            releases = await octokit.paginate(
+                octokit.rest.repos.listReleases,
+                {
+                    owner,
+                    repo,
+                    per_page: 100,
+                },
+                (response) => response.data
+            );
+            fs.writeFileSync(cacheFilename, JSON.stringify(releases, null, 2));
+        } else {
+            console.log('Loading releases from cache...');
+            releases = JSON.parse(fs.readFileSync(cacheFilename));
+        }
+    } else {
+        releases = await octokit.paginate(
+            octokit.rest.repos.listReleases,
+            {
+                owner,
+                repo,
+                per_page: 100,
+            },
+            (response) => response.data
+        )
+    }
+
+    // process all releases by default
+    let releasesToProcess = releases;
+
+    // process a single release
+    if(releaseTagOrNameOrId) {
+        releasesToProcess = releases.filter(r => {
+            if (r.tag_name === releaseTagOrNameOrId) {
+                return true;
+            }
+            if (`${r.id}` === `${releaseTagOrNameOrId}`) {
+                return true;
+            }
+            if (r.name === releaseTagOrNameOrId) {
+                return true;
+            }
+
+            return false;
+        });
+    }
+
+    releasesToProcess.forEach(release => {
+        const {tag_name, name} = release;
+        const tagComponents = tag_name.split('-v');
+        const componentName = tagComponents[0];
+        const componentVersion = 'v' + tagComponents[1];
+
+        if(!tagComponents[1] || !name) {
+            return;
+        }
+
+        release.componentName = componentName;
+        release.componentVersion = componentVersion;
+    })
+
+    releasesToProcess = releasesToProcess.filter(release =>
+        !!release.name && !!release.componentVersion
+    );
+
+    console.log('Releases to process:');
+    console.table(releasesToProcess.map(r => {
+        const { id, name, tag_name, componentName, componentVersion, assets } = r;
+        return { id, name, tag_name, componentName, componentVersion, assetCount: assets.length };
+    }));
+
+   for(const release of releasesToProcess) {
+        const {id, name, tag_name, html_url, componentName, componentVersion} = release;
+
+        const hashes = await createHashes({ assets: release.assets, algorithm, filename, cache });
+
+        const output = {
+            id, name, tag_name, html_url,
+            componentName,
+            componentVersion,
+            assets: hashes,
+        };
+
+        if(upload) {
+            console.log(`🚚 Uploading ${filename} to release name="${release.name}" id=${release.id} (${release.upload_url})...`);
+
+            const exists = (await octokit.repos.listReleaseAssets({ owner, repo, release_id: release.id })).data.find(a => a.name === filename)
+            if (exists) {
+                console.log(`Deleting existing asset ${filename}...`);
+                await octokit.repos.deleteReleaseAsset({ owner, repo, asset_id: exists.id })
+                console.log('Deleted existing asset');
+            }
+
+            try {
+                const data = JSON.stringify(output, null, 2);
+                await octokit.rest.repos.uploadReleaseAsset({
+                    owner,
+                    repo,
+                    release_id: release.id,
+                    headers: {
+                        'X-GitHub-Api-Version': '2022-11-28'
+                    },
+                    name: filename,
+                    data,
+                });
+                console.log('✅ Upload to release is complete.');
+            } catch(e) {
+                console.log('❌ failed to upload:', e.message, e.status, e.response.data);
+                console.log(e);
+                process.exit(-1);
+            }
+        }
+   }
+}
+

.github/actions/nym-hash-releases/index.js

@@ -0,0 +1,15 @@
+import core from "@actions/core";
+import github from "@actions/github";
+import { createHashesFromReleaseTagOrNameOrId } from './create-hashes.mjs';
+
+const algorithm = core.getInput('hash-type');
+const filename = core.getInput("file-name");
+
+// use the release id from the payload if it is set
+const releaseTagOrNameOrId = core.getInput("release-tag-or-name-or-id") || github.context.payload.release?.id;
+
+try {
+    await createHashesFromReleaseTagOrNameOrId({ releaseTagOrNameOrId, algorithm, filename  })
+} catch (error) {
+    core.setFailed(error.message);
+}

.github/actions/nym-hash-releases/package-lock.json

@@ -0,0 +1,536 @@
+{
+  "name": "ghaction-generate-release-hashes",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "ghaction-generate-release-hashes",
+      "version": "1.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "@actions/core": "^1.10.0",
+        "@actions/github": "^5.1.1",
+        "@octokit/auth-action": "^4.0.0",
+        "@octokit/rest": "^20.0.1",
+        "hasha": "^5.2.0",
+        "node-fetch": "^3.2.10"
+      }
+    },
+    "node_modules/@actions/core": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.10.0.tgz",
+      "integrity": "sha512-2aZDDa3zrrZbP5ZYg159sNoLRb61nQ7awl5pSvIq5Qpj81vwDzdMRKzkWJGJuwVvWpvZKx7vspJALyvaaIQyug==",
+      "dependencies": {
+        "@actions/http-client": "^2.0.1",
+        "uuid": "^8.3.2"
+      }
+    },
+    "node_modules/@actions/github": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/@actions/github/-/github-5.1.1.tgz",
+      "integrity": "sha512-Nk59rMDoJaV+mHCOJPXuvB1zIbomlKS0dmSIqPGxd0enAXBnOfn4VWF+CGtRCwXZG9Epa54tZA7VIRlJDS8A6g==",
+      "dependencies": {
+        "@actions/http-client": "^2.0.1",
+        "@octokit/core": "^3.6.0",
+        "@octokit/plugin-paginate-rest": "^2.17.0",
+        "@octokit/plugin-rest-endpoint-methods": "^5.13.0"
+      }
+    },
+    "node_modules/@actions/http-client": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.1.1.tgz",
+      "integrity": "sha512-qhrkRMB40bbbLo7gF+0vu+X+UawOvQQqNAA/5Unx774RS8poaOhThDOG6BGmxvAnxhQnDp2BG/ZUm65xZILTpw==",
+      "dependencies": {
+        "tunnel": "^0.0.6"
+      }
+    },
+    "node_modules/@octokit/auth-action": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-action/-/auth-action-4.0.0.tgz",
+      "integrity": "sha512-sMm9lWZdiX6e89YFaLrgE9EFs94k58BwIkvjOtozNWUqyTmsrnWFr/M5LolaRzZ7Kmb5FbhF9hi7FEeE274SoQ==",
+      "dependencies": {
+        "@octokit/auth-token": "^4.0.0",
+        "@octokit/types": "^11.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/auth-action/node_modules/@octokit/auth-token": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-4.0.0.tgz",
+      "integrity": "sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA==",
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/auth-action/node_modules/@octokit/openapi-types": {
+      "version": "18.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-18.0.0.tgz",
+      "integrity": "sha512-V8GImKs3TeQRxRtXFpG2wl19V7444NIOTDF24AWuIbmNaNYOQMWRbjcGDXV5B+0n887fgDcuMNOmlul+k+oJtw=="
+    },
+    "node_modules/@octokit/auth-action/node_modules/@octokit/types": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-11.1.0.tgz",
+      "integrity": "sha512-Fz0+7GyLm/bHt8fwEqgvRBWwIV1S6wRRyq+V6exRKLVWaKGsuy6H9QFYeBVDV7rK6fO3XwHgQOPxv+cLj2zpXQ==",
+      "dependencies": {
+        "@octokit/openapi-types": "^18.0.0"
+      }
+    },
+    "node_modules/@octokit/auth-token": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-2.5.0.tgz",
+      "integrity": "sha512-r5FVUJCOLl19AxiuZD2VRZ/ORjp/4IN98Of6YJoJOkY75CIBuYfmiNHGrDwXr+aLGG55igl9QrxX3hbiXlLb+g==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3"
+      }
+    },
+    "node_modules/@octokit/core": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-3.6.0.tgz",
+      "integrity": "sha512-7RKRKuA4xTjMhY+eG3jthb3hlZCsOwg3rztWh75Xc+ShDWOfDDATWbeZpAHBNRpm4Tv9WgBMOy1zEJYXG6NJ7Q==",
+      "dependencies": {
+        "@octokit/auth-token": "^2.4.4",
+        "@octokit/graphql": "^4.5.8",
+        "@octokit/request": "^5.6.3",
+        "@octokit/request-error": "^2.0.5",
+        "@octokit/types": "^6.0.3",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/endpoint": {
+      "version": "6.0.12",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-6.0.12.tgz",
+      "integrity": "sha512-lF3puPwkQWGfkMClXb4k/eUT/nZKQfxinRWJrdZaJO85Dqwo/G0yOC434Jr2ojwafWJMYqFGFa5ms4jJUgujdA==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/graphql": {
+      "version": "4.8.0",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-4.8.0.tgz",
+      "integrity": "sha512-0gv+qLSBLKF0z8TKaSKTsS39scVKF9dbMxJpj3U0vC7wjNWFuIpL/z76Qe2fiuCbDRcJSavkXsVtMS6/dtQQsg==",
+      "dependencies": {
+        "@octokit/request": "^5.6.0",
+        "@octokit/types": "^6.0.3",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/openapi-types": {
+      "version": "12.11.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-12.11.0.tgz",
+      "integrity": "sha512-VsXyi8peyRq9PqIz/tpqiL2w3w80OgVMwBHltTml3LmVvXiphgeqmY9mvBw9Wu7e0QWk/fqD37ux8yP5uVekyQ=="
+    },
+    "node_modules/@octokit/plugin-paginate-rest": {
+      "version": "2.21.3",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-2.21.3.tgz",
+      "integrity": "sha512-aCZTEf0y2h3OLbrgKkrfFdjRL6eSOo8komneVQJnYecAxIej7Bafor2xhuDJOIFau4pk0i/P28/XgtbyPF0ZHw==",
+      "dependencies": {
+        "@octokit/types": "^6.40.0"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=2"
+      }
+    },
+    "node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "5.16.2",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-5.16.2.tgz",
+      "integrity": "sha512-8QFz29Fg5jDuTPXVtey05BLm7OB+M8fnvE64RNegzX7U+5NUXcOcnpTIK0YfSHBg8gYd0oxIq3IZTe9SfPZiRw==",
+      "dependencies": {
+        "@octokit/types": "^6.39.0",
+        "deprecation": "^2.3.1"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=3"
+      }
+    },
+    "node_modules/@octokit/request": {
+      "version": "5.6.3",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-5.6.3.tgz",
+      "integrity": "sha512-bFJl0I1KVc9jYTe9tdGGpAMPy32dLBXXo1dS/YwSCTL/2nd9XeHsY616RE3HPXDVk+a+dBuzyz5YdlXwcDTr2A==",
+      "dependencies": {
+        "@octokit/endpoint": "^6.0.1",
+        "@octokit/request-error": "^2.1.0",
+        "@octokit/types": "^6.16.1",
+        "is-plain-object": "^5.0.0",
+        "node-fetch": "^2.6.7",
+        "universal-user-agent": "^6.0.0"
+      }
+    },
+    "node_modules/@octokit/request-error": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-2.1.0.tgz",
+      "integrity": "sha512-1VIvgXxs9WHSjicsRwq8PlR2LR2x6DwsJAaFgzdi0JfJoGSO8mYI/cHJQ+9FbN21aa+DrgNLnwObmyeSC8Rmpg==",
+      "dependencies": {
+        "@octokit/types": "^6.0.3",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      }
+    },
+    "node_modules/@octokit/request/node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@octokit/rest": {
+      "version": "20.0.1",
+      "resolved": "https://registry.npmjs.org/@octokit/rest/-/rest-20.0.1.tgz",
+      "integrity": "sha512-wROV21RwHQIMNb2Dgd4+pY+dVy1Dwmp85pBrgr6YRRDYRBu9Gb+D73f4Bl2EukZSj5hInq2Tui9o7gAQpc2k2Q==",
+      "dependencies": {
+        "@octokit/core": "^5.0.0",
+        "@octokit/plugin-paginate-rest": "^8.0.0",
+        "@octokit/plugin-request-log": "^4.0.0",
+        "@octokit/plugin-rest-endpoint-methods": "^9.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/auth-token": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/auth-token/-/auth-token-4.0.0.tgz",
+      "integrity": "sha512-tY/msAuJo6ARbK6SPIxZrPBms3xPbfwBrulZe0Wtr/DIY9lje2HeV1uoebShn6mx7SjCHif6EjMvoREj+gZ+SA==",
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/core": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-5.0.0.tgz",
+      "integrity": "sha512-YbAtMWIrbZ9FCXbLwT9wWB8TyLjq9mxpKdgB3dUNxQcIVTf9hJ70gRPwAcqGZdY6WdJPZ0I7jLaaNDCiloGN2A==",
+      "dependencies": {
+        "@octokit/auth-token": "^4.0.0",
+        "@octokit/graphql": "^7.0.0",
+        "@octokit/request": "^8.0.2",
+        "@octokit/request-error": "^5.0.0",
+        "@octokit/types": "^11.0.0",
+        "before-after-hook": "^2.2.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/endpoint": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-9.0.0.tgz",
+      "integrity": "sha512-szrQhiqJ88gghWY2Htt8MqUDO6++E/EIXqJ2ZEp5ma3uGS46o7LZAzSLt49myB7rT+Hfw5Y6gO3LmOxGzHijAQ==",
+      "dependencies": {
+        "@octokit/types": "^11.0.0",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/graphql": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-7.0.1.tgz",
+      "integrity": "sha512-T5S3oZ1JOE58gom6MIcrgwZXzTaxRnxBso58xhozxHpOqSTgDS6YNeEUvZ/kRvXgPrRz/KHnZhtb7jUMRi9E6w==",
+      "dependencies": {
+        "@octokit/request": "^8.0.1",
+        "@octokit/types": "^11.0.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/openapi-types": {
+      "version": "18.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-18.0.0.tgz",
+      "integrity": "sha512-V8GImKs3TeQRxRtXFpG2wl19V7444NIOTDF24AWuIbmNaNYOQMWRbjcGDXV5B+0n887fgDcuMNOmlul+k+oJtw=="
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-paginate-rest": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-8.0.0.tgz",
+      "integrity": "sha512-2xZ+baZWUg+qudVXnnvXz7qfrTmDeYPCzangBVq/1gXxii/OiS//4shJp9dnCCvj1x+JAm9ji1Egwm1BA47lPQ==",
+      "dependencies": {
+        "@octokit/types": "^11.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=5"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-request-log": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-request-log/-/plugin-request-log-4.0.0.tgz",
+      "integrity": "sha512-2uJI1COtYCq8Z4yNSnM231TgH50bRkheQ9+aH8TnZanB6QilOnx8RMD2qsnamSOXtDj0ilxvevf5fGsBhBBzKA==",
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=5"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "9.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-9.0.0.tgz",
+      "integrity": "sha512-KquMF/VB1IkKNiVnzJKspY5mFgGyLd7HzdJfVEGTJFzqu9BRFNWt+nwTCMuUiWc72gLQhRWYubTwOkQj+w/1PA==",
+      "dependencies": {
+        "@octokit/types": "^11.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": ">=5"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/request": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-8.1.1.tgz",
+      "integrity": "sha512-8N+tdUz4aCqQmXl8FpHYfKG9GelDFd7XGVzyN8rc6WxVlYcfpHECnuRkgquzz+WzvHTK62co5di8gSXnzASZPQ==",
+      "dependencies": {
+        "@octokit/endpoint": "^9.0.0",
+        "@octokit/request-error": "^5.0.0",
+        "@octokit/types": "^11.1.0",
+        "is-plain-object": "^5.0.0",
+        "universal-user-agent": "^6.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/request-error": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-5.0.0.tgz",
+      "integrity": "sha512-1ue0DH0Lif5iEqT52+Rf/hf0RmGO9NWFjrzmrkArpG9trFfDM/efx00BJHdLGuro4BR/gECxCU2Twf5OKrRFsQ==",
+      "dependencies": {
+        "@octokit/types": "^11.0.0",
+        "deprecation": "^2.0.0",
+        "once": "^1.4.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/types": {
+      "version": "11.1.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-11.1.0.tgz",
+      "integrity": "sha512-Fz0+7GyLm/bHt8fwEqgvRBWwIV1S6wRRyq+V6exRKLVWaKGsuy6H9QFYeBVDV7rK6fO3XwHgQOPxv+cLj2zpXQ==",
+      "dependencies": {
+        "@octokit/openapi-types": "^18.0.0"
+      }
+    },
+    "node_modules/@octokit/types": {
+      "version": "6.41.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-6.41.0.tgz",
+      "integrity": "sha512-eJ2jbzjdijiL3B4PrSQaSjuF2sPEQPVCPzBvTHJD9Nz+9dw2SGH4K4xeQJ77YfTq5bRQ+bD8wT11JbeDPmxmGg==",
+      "dependencies": {
+        "@octokit/openapi-types": "^12.11.0"
+      }
+    },
+    "node_modules/before-after-hook": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz",
+      "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ=="
+    },
+    "node_modules/data-uri-to-buffer": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.1.tgz",
+      "integrity": "sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/deprecation": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
+    },
+    "node_modules/fetch-blob": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.2.0.tgz",
+      "integrity": "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "paypal",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "dependencies": {
+        "node-domexception": "^1.0.0",
+        "web-streams-polyfill": "^3.0.3"
+      },
+      "engines": {
+        "node": "^12.20 || >= 14.13"
+      }
+    },
+    "node_modules/formdata-polyfill": {
+      "version": "4.0.10",
+      "resolved": "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz",
+      "integrity": "sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g==",
+      "dependencies": {
+        "fetch-blob": "^3.1.2"
+      },
+      "engines": {
+        "node": ">=12.20.0"
+      }
+    },
+    "node_modules/hasha": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/hasha/-/hasha-5.2.2.tgz",
+      "integrity": "sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==",
+      "dependencies": {
+        "is-stream": "^2.0.0",
+        "type-fest": "^0.8.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-plain-object": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/node-domexception": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz",
+      "integrity": "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/jimmywarting"
+        },
+        {
+          "type": "github",
+          "url": "https://paypal.me/jimmywarting"
+        }
+      ],
+      "engines": {
+        "node": ">=10.5.0"
+      }
+    },
+    "node_modules/node-fetch": {
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-3.3.2.tgz",
+      "integrity": "sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==",
+      "dependencies": {
+        "data-uri-to-buffer": "^4.0.0",
+        "fetch-blob": "^3.1.4",
+        "formdata-polyfill": "^4.0.10"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/node-fetch"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="
+    },
+    "node_modules/tunnel": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/tunnel/-/tunnel-0.0.6.tgz",
+      "integrity": "sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==",
+      "engines": {
+        "node": ">=0.6.11 <=0.7.0 || >=0.7.3"
+      }
+    },
+    "node_modules/type-fest": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.8.1.tgz",
+      "integrity": "sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/universal-user-agent": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
+      "integrity": "sha512-isyNax3wXoKaulPDZWHQqbmIx1k2tb9fb3GGDBRxCscfYV2Ch7WxPArBsFEG8s/safwXTT7H4QGhaIkTp9447w=="
+    },
+    "node_modules/uuid": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz",
+      "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==",
+      "bin": {
+        "uuid": "dist/bin/uuid"
+      }
+    },
+    "node_modules/web-streams-polyfill": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz",
+      "integrity": "sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q==",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+    }
+  }
+}

.github/actions/nym-hash-releases/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "nym-hash-release",
+  "version": "1.0.0",
+  "description": "Generate hashes and signatures for assets in Nym releases",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "local": "node run-local.mjs"
+  },
+  "dependencies": {
+    "@actions/core": "^1.10.0",
+    "@actions/github": "^5.1.1",
+    "@octokit/auth-action": "^4.0.0",
+    "@octokit/rest": "^20.0.1",
+    "hasha": "^5.2.0",
+    "node-fetch": "^3.2.10"
+  }
+}

.github/actions/nym-hash-releases/run-local.mjs

@@ -0,0 +1,6 @@
+import {createHashesFromReleaseTagOrNameOrId} from './create-hashes.mjs';
+
+await createHashesFromReleaseTagOrNameOrId({releaseTagOrNameOrId: 119065724, cache: true, upload: false});
+await createHashesFromReleaseTagOrNameOrId({releaseTagOrNameOrId: '119065724', cache: true, upload: false});
+await createHashesFromReleaseTagOrNameOrId({releaseTagOrNameOrId: 'nym-connect-v1.1.19-snickers', cache: true, upload: false});
+await createHashesFromReleaseTagOrNameOrId({releaseTagOrNameOrId: 'Nym Connect v1.1.19-snickers', cache: true, upload: false});

.github/workflows/build-and-upload-binaries-ci.yml

@@ -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
+        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
         continue-on-error: true
 
       - name: Install Rust stable
@@ -83,7 +83,7 @@ jobs:
         run: cargo install --version 0.112.0 wasm-opt
 
       - name: Build release contracts
-        run: make wasm
+        run: make contracts-wasm
 
       - name: Prepare build output
         shell: bash
@@ -98,7 +98,6 @@ 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

.github/workflows/build.yml

@@ -6,6 +6,7 @@ on:
       - 'clients/**'
       - 'common/**'
       - 'explorer-api/**'
+      - 'ephemera/**'
       - 'gateway/**'
       - 'integrations/**'
       - 'mixnode/**'
@@ -15,6 +16,7 @@ on:
       - 'nym-api/**'
       - 'nym-outfox/**'
       - 'tools/nym-cli/**'
+      - 'tools/nym-nr-query/**'
       - 'tools/ts-rs-cli/**'
       - 'Cargo.toml'
   pull_request:
@@ -22,6 +24,7 @@ on:
       - 'clients/**'
       - 'common/**'
       - 'explorer-api/**'
+      - 'ephemera/**'
       - 'gateway/**'
       - 'integrations/**'
       - 'mixnode/**'
@@ -31,6 +34,7 @@ on:
       - 'nym-api/**'
       - 'nym-outfox/**'
       - 'tools/nym-cli/**'
+      - 'tools/nym-nr-query/**'
       - 'tools/ts-rs-cli/**'
       - 'Cargo.toml'
 
@@ -42,7 +46,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
+        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
         continue-on-error: true
 
       - name: Check out repository code

.github/workflows/cd-docs.yml

@@ -38,6 +38,7 @@ jobs:
       - name: Build all projects in documentation/ & move to ~/dist/docs/
         run: cd documentation && ./build_all_to_dist.sh
         continue-on-error: false
+
       - name: Deploy branch master to dev
         continue-on-error: true
         uses: easingthemes/ssh-deploy@main
@@ -49,6 +50,7 @@ jobs:
           REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
           TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
           EXCLUDE: "/node_modules/"
+
       - name: Deploy branch master to prod
         if: github.ref == 'refs/heads/master'
         uses: easingthemes/ssh-deploy@main
@@ -60,6 +62,49 @@ jobs:
           REMOTE_USER: ${{ secrets.CD_WWW_REMOTE_USER }}
           TARGET: ${{ secrets.CD_WWW_REMOTE_TARGET }}/
           EXCLUDE: "/node_modules/"
+
+      - name: Post process
+        run: cd documentation && ./post_process.sh
+        continue-on-error: false
+
+      - name: Create Vercel project file
+        uses: mobiledevops/secret-to-file-action@v1
+        with:
+          base64-encoded-secret: ${{ secrets.VERCEL_PROJECT_JSON_BASE64 }}
+          filename: "project.json"
+          is-executable: true
+          working-directory: "./dist/docs/.vercel"
+
+      - name: Install Vercel CLI
+        run: npm install --global vercel@latest
+
+      - name: Pull Vercel Environment Information (preview)
+        if: github.ref != 'refs/heads/master'
+        run: vercel pull --yes --environment=preview --token=${{ secrets.VERCEL_TOKEN }}
+        working-directory: dist/docs
+      - name: Pull Vercel Environment Information (production)
+        if: github.ref == 'refs/heads/master'
+        run: vercel pull --yes --environment=production --token=${{ secrets.VERCEL_TOKEN }}
+        working-directory: dist/docs
+
+      - name: Build Project Artifacts (preview)
+        if: github.ref != 'refs/heads/master'
+        run: vercel build --token=${{ secrets.VERCEL_TOKEN }}
+        working-directory: dist/docs
+      - name: Build Project Artifacts (production)
+        if: github.ref == 'refs/heads/master'
+        run: vercel build --prod --token=${{ secrets.VERCEL_TOKEN }}
+        working-directory: dist/docs
+
+      - name: Deploy Project Artifacts to Vercel (preview)
+        if: github.ref != 'refs/heads/master'
+        run: vercel deploy --prebuilt --token=${{ secrets.VERCEL_TOKEN }}
+        working-directory: dist/docs
+      - name: Deploy Project Artifacts to Vercel (master)
+        if: github.ref == 'refs/heads/master'
+        run: vercel deploy --prebuilt --prod --token=${{ secrets.VERCEL_TOKEN }}
+        working-directory: dist/docs
+
       - name: Matrix - Node Install
         run: npm install
         working-directory: .github/workflows/support-files

.github/workflows/contracts-build.yml

@@ -23,7 +23,7 @@ jobs:
         run: cargo install --version 0.112.0 wasm-opt
 
       - name: Build release contracts
-        run: make wasm
+        run: make contracts-wasm
 
       - name: Upload Mixnet Contract Artifact
         uses: actions/upload-artifact@v3

.github/workflows/nightly_build.yml

@@ -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
+        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
         continue-on-error: true
         if: matrix.os == 'ubuntu-20.04'
 

.github/workflows/nightly_build_release.yml

@@ -28,7 +28,7 @@ jobs:
         run: git fetch --all
       - name: Set output variable to latest release branch
         id: step2
-        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+$' | sort -V | tail -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
+        run: echo "latest_release=$(git branch -r | grep -E 'release/v[0-9]+\.[0-9]+\.[0-9]+-' | sort -V | tail -n 1 | sed 's/  origin\///')" >> $GITHUB_OUTPUT
   build:
     needs: [get_release,matrix_prep]
     strategy:
@@ -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
+        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
         continue-on-error: true
         if: matrix.os == 'ubuntu-20.04'
 

.github/workflows/nym-connect-publish-macos.yml

@@ -112,31 +112,11 @@ jobs:
           files: |
             nym-connect/desktop/target/release/bundle/dmg/*.dmg
             nym-connect/desktop/target/release/bundle/macos/*.app.tar.gz*
-      - id: release-info
-        name: Prepare release info
-        run: |
-          ref=${{ github.ref_name }}
-          semver="${ref##nym-connect-}" && semver="${semver##v}"
-          echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-connect_${semver}_x64.dmg " >> "$GITHUB_OUTPUT"
-          echo "file_hash=${{ hashFiles('nym-connect/desktop/target/release/bundle/dmg/nym-connect_*_x64.dmg') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
+    uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
       release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-tauri.outputs.release_id }}
-      release_date: ${{ needs.publish-tauri.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/nym-connect/desktop/CHANGELOG.md
-      archive_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-connect.app.tar.gz
-      sig_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-connect.app.tar.gz.sig
-      version: ${{ needs.publish-tauri.outputs.version }}
-      filename: ${{ needs.publish-tauri.outputs.filename }}
-      file_hash: ${{ needs.publish-tauri.outputs.file_hash }}
-      name: NymConnect
-      category: connect
-      platform: MacOS
     secrets: inherit

.github/workflows/nym-connect-publish-ubuntu.yml

@@ -79,31 +79,11 @@ jobs:
           files: |
             nym-connect/desktop/target/release/bundle/appimage/*.AppImage
             nym-connect/desktop/target/release/bundle/appimage/*.AppImage.tar.gz*
-      - id: release-info
-        name: Prepare release info
-        run: |
-          ref=${{ github.ref_name }}
-          semver="${ref##nym-connect-}" && semver="${semver##v}"
-          echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-connect_${semver}_amd64.AppImage" >> "$GITHUB_OUTPUT"
-          echo "file_hash=${{ hashFiles('nym-connect/desktop/target/release/bundle/appimage/nym-connect_*_amd64.AppImage') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
+    uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
       release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-tauri.outputs.release_id }}
-      release_date: ${{ needs.publish-tauri.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/nym-connect/desktop/CHANGELOG.md
-      archive_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-connect_${{ needs.publish-tauri.outputs.version }}_amd64.AppImage.tar.gz
-      sig_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-connect_${{ needs.publish-tauri.outputs.version }}_amd64.AppImage.tar.gz.sig
-      version: ${{ needs.publish-tauri.outputs.version }}
-      filename: ${{ needs.publish-tauri.outputs.filename }}
-      file_hash: ${{ needs.publish-tauri.outputs.file_hash }}
-      name: NymConnect
-      category: connect
-      platform: Ubuntu
     secrets: inherit

.github/workflows/nym-connect-publish-windows10.yml

@@ -98,31 +98,11 @@ jobs:
           files: |
             nym-connect/desktop/target/release/bundle/msi/*.msi
             nym-connect/desktop/target/release/bundle/msi/*.msi.zip*
-      - id: release-info
-        name: Prepare release info
-        run: |
-          ref=${{ github.ref_name }}
-          semver="${ref##nym-connect-}" && semver="${semver##v}"
-          echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-connect_${semver}_x64_en-US.msi" >> "$GITHUB_OUTPUT"
-          echo "file_hash=${{ hashFiles('nym-connect/desktop/target/release/bundle/msi/nym-connect_*_x64_en-US.msi') }}" >> "$GITHUB_OUTPUT"
 
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-connect-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
+    uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
       release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-tauri.outputs.release_id }}
-      release_date: ${{ needs.publish-tauri.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/nym-connect/desktop/CHANGELOG.md
-      archive_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-connect_${{ needs.publish-tauri.outputs.version }}_x64_en-US.msi.zip
-      sig_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-connect_${{ needs.publish-tauri.outputs.version }}_x64_en-US.msi.zip.sig
-      version: ${{ needs.publish-tauri.outputs.version }}
-      filename: ${{ needs.publish-tauri.outputs.filename }}
-      file_hash: ${{ needs.publish-tauri.outputs.file_hash }}
-      name: NymConnect
-      category: connect
-      platform: Windows
     secrets: inherit

.github/workflows/nym-release-publish.yml

@@ -96,149 +96,10 @@ jobs:
             target/release/nym-network-statistics
             target/release/nym-cli
 
-      - id: release-info
-        name: Prepare release info
-        run: |
-          semver="${${{ github.ref_name }}##nym-binaries-}" && semver="${semver##v}"
-          echo "version=$semver" >> "$GITHUB_OUTPUT"
-
-      - id: binary-hashes
-        name: Generate binary hashes
-        run: |
-          echo "client_hash=${{ hashFiles('target/release/nym-client') }}" >> "$GITHUB_OUTPUT"
-          echo "mixnode_hash=${{ hashFiles('target/release/nym-mixnode') }}" >> "$GITHUB_OUTPUT"
-          echo "gateway_hash=${{ hashFiles('target/release/nym-gateway') }}" >> "$GITHUB_OUTPUT"
-          echo "socks5_hash=${{ hashFiles('target/release/nym-socks5-client') }}" >> "$GITHUB_OUTPUT"
-          echo "netreq_hash=${{ hashFiles('target/release/nym-network-requester') }}" >> "$GITHUB_OUTPUT"
-          echo "cli_hash=${{ hashFiles('target/release/nym-cli') }}" >> "$GITHUB_OUTPUT"
-          echo "netstat_hash=${{ hashFiles('target/release/nym-network-statistics') }}" >> "$GITHUB_OUTPUT"
-
-      - id: binary-versions
-        name: Get binary versions
-        run: |
-          v=$(rg '^version = "(.*)"' -or '$1' clients/native/Cargo.toml) && echo "client_version=$v" >> "$GITHUB_OUTPUT"
-          v=$(rg '^version = "(.*)"' -or '$1' mixnode/Cargo.toml) && echo "mixnode_version=$v" >> "$GITHUB_OUTPUT"
-          v=$(rg '^version = "(.*)"' -or '$1' gateway/Cargo.toml) && echo "gateway_version=$v" >> "$GITHUB_OUTPUT"
-          v=$(rg '^version = "(.*)"' -or '$1' clients/socks5/Cargo.toml) && echo "socks5_version=$v" >> "$GITHUB_OUTPUT"
-          v=$(rg '^version = "(.*)"' -or '$1' service-providers/network-requester/Cargo.toml) && echo "netreq_version=$v" >> "$GITHUB_OUTPUT"
-          v=$(rg '^version = "(.*)"' -or '$1' tools/nym-cli/Cargo.toml) && echo "cli_version=$v" >> "$GITHUB_OUTPUT"
-          v=$(rg '^version = "(.*)"' -or '$1' service-providers/network-statistics/Cargo.toml) && echo "netstat_version=$v" >> "$GITHUB_OUTPUT"
-
   push-release-data-client:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
+    uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-nym
     with:
       release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-nym.outputs.release_id }}
-      release_date: ${{ needs.publish-nym.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/CHANGELOG.md
-      version: ${{ needs.publish-nym.outputs.client_version }}
-      filename: nym-client
-      file_hash: ${{ needs.publish-nym.outputs.client_hash }}
-      name: Client
-      category: binaries
-    secrets: inherit
-
-  push-release-data-mixnode:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
-    needs: publish-nym
-    with:
-      release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-nym.outputs.release_id }}
-      release_date: ${{ needs.publish-nym.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/CHANGELOG.md
-      version: ${{ needs.publish-nym.outputs.mixnode_version }}
-      filename: nym-mixnode
-      file_hash: ${{ needs.publish-nym.outputs.mixnode_hash }}
-      name: Mixnode
-      category: binaries
-    secrets: inherit
-
-  push-release-data-gateway:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
-    needs: publish-nym
-    with:
-      release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-nym.outputs.release_id }}
-      release_date: ${{ needs.publish-nym.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/CHANGELOG.md
-      version: ${{ needs.publish-nym.outputs.gateway_version }}
-      filename: nym-gateway
-      file_hash: ${{ needs.publish-nym.outputs.gateway_hash }}
-      name: Gateway
-      category: binaries
-    secrets: inherit
-
-  push-release-data-socks5:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
-    needs: publish-nym
-    with:
-      release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-nym.outputs.release_id }}
-      release_date: ${{ needs.publish-nym.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/CHANGELOG.md
-      version: ${{ needs.publish-nym.outputs.socks5_version }}
-      filename: nym-socks5-client
-      file_hash: ${{ needs.publish-nym.outputs.socks5_hash }}
-      name: Socks5 Client
-      category: binaries
-    secrets: inherit
-
-  push-release-data-network-requester:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
-    needs: publish-nym
-    with:
-      release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-nym.outputs.release_id }}
-      release_date: ${{ needs.publish-nym.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/CHANGELOG.md
-      version: ${{ needs.publish-nym.outputs.netreq_version }}
-      filename: nym-network-requester
-      file_hash: ${{ needs.publish-nym.outputs.netreq_hash }}
-      name: Network Requester
-      category: binaries
-    secrets: inherit
-
-  push-release-data-cli:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
-    needs: publish-nym
-    with:
-      release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-nym.outputs.release_id }}
-      release_date: ${{ needs.publish-nym.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/CHANGELOG.md
-      version: ${{ needs.publish-nym.outputs.cli_version }}
-      filename: nym-cli
-      file_hash: ${{ needs.publish-nym.outputs.cli_hash }}
-      name: Cli
-      category: binaries
-    secrets: inherit
-
-  push-release-data-network-stat:
-    if: ${{ (startsWith(github.ref, 'refs/tags/nym-binaries-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
-    needs: publish-nym
-    with:
-      release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-nym.outputs.release_id }}
-      release_date: ${{ needs.publish-nym.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/CHANGELOG.md
-      version: ${{ needs.publish-nym.outputs.netstat_version }}
-      filename: nym-network-statistics
-      file_hash: ${{ needs.publish-nym.outputs.netstat_hash }}
-      name: Network Statistics
-      category: binaries
     secrets: inherit

.github/workflows/nym-wallet-publish-macos.yml

@@ -100,31 +100,10 @@ jobs:
             nym-wallet/target/release/bundle/dmg/*.dmg
             nym-wallet/target/release/bundle/macos/*.app.tar.gz*
 
-      - id: release-info
-        name: Prepare release info
-        run: |
-          ref=${{ github.ref_name }}
-          semver="${ref##nym-wallet-}" && semver="${semver##v}"
-          echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-wallet_${semver}_x64.dmg" >> "$GITHUB_OUTPUT"
-          echo "file_hash=${{ hashFiles('nym-wallet/target/release/bundle/dmg/nym-wallet_*_x64.dmg') }}" >> "$GITHUB_OUTPUT"
-
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
+    uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
       release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-tauri.outputs.release_id }}
-      release_date: ${{ needs.publish-tauri.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/nym-wallet/CHANGELOG.md
-      archive_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-wallet.app.tar.gz
-      sig_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-wallet.app.tar.gz.sig
-      version: ${{ needs.publish-tauri.outputs.version }}
-      filename: ${{ needs.publish-tauri.outputs.filename }}
-      file_hash: ${{ needs.publish-tauri.outputs.file_hash }}
-      name: Wallet
-      category: wallet
-      platform: MacOS
     secrets: inherit

.github/workflows/nym-wallet-publish-ubuntu.yml

@@ -77,31 +77,10 @@ jobs:
             nym-wallet/target/release/bundle/appimage/*.AppImage
             nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz*
 
-      - id: release-info
-        name: Prepare release info
-        run: |
-          ref=${{ github.ref_name }}
-          semver="${ref##nym-wallet-}" && semver="${semver##v}"
-          echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-wallet_${semver}_amd64.AppImage" >> "$GITHUB_OUTPUT"
-          echo "file_hash=${{ hashFiles('nym-wallet/target/release/bundle/appimage/nym-wallet_*_amd64.AppImage') }}" >> "$GITHUB_OUTPUT"
-
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
+    uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
       release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-tauri.outputs.release_id }}
-      release_date: ${{ needs.publish-tauri.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/nym-wallet/CHANGELOG.md
-      archive_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-wallet_${{ needs.publish-tauri.outputs.version }}_amd64.AppImage.tar.gz
-      sig_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-wallet_${{ needs.publish-tauri.outputs.version }}_amd64.AppImage.tar.gz.sig
-      version: ${{ needs.publish-tauri.outputs.version }}
-      filename: ${{ needs.publish-tauri.outputs.filename }}
-      file_hash: ${{ needs.publish-tauri.outputs.file_hash }}
-      name: Wallet
-      category: wallet
-      platform: Ubuntu
     secrets: inherit

.github/workflows/nym-wallet-publish-windows10.yml

@@ -97,31 +97,10 @@ jobs:
             nym-wallet/target/release/bundle/msi/*.msi
             nym-wallet/target/release/bundle/msi/*.msi.zip*
 
-      - id: release-info
-        name: Prepare release info
-        run: |
-          ref=${{ github.ref_name }}
-          semver="${ref##nym-wallet-}" && semver="${semver##v}"
-          echo "version=${semver}" >> "$GITHUB_OUTPUT"
-          echo "filename=nym-wallet_${semver}_x64_en-US.msi" >> "$GITHUB_OUTPUT"
-          echo "file_hash=${{ hashFiles('nym-wallet/target/release/bundle/msi/nym-wallet_*_x64_en-US.msi') }}" >> "$GITHUB_OUTPUT"
-
   push-release-data:
     if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    uses: ./.github/workflows/push-release-data.yml
+    uses: ./.github/workflows/release-calculate-hash.yml
     needs: publish-tauri
     with:
       release_tag: ${{ github.ref_name }}
-      release_id: ${{ needs.publish-tauri.outputs.release_id }}
-      release_date: ${{ needs.publish-tauri.outputs.release_date }}
-      download_base_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}
-      changelog_url: https://github.com/nymtech/nym/blob/${{ github.ref_name }}/nym-wallet/CHANGELOG.md
-      archive_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-wallet_${{ needs.publish-tauri.outputs.version }}_x64_en-US.msi.zip
-      sig_url: https://github.com/nymtech/nym/releases/download/${{ github.ref_name }}/nym-wallet_${{ needs.publish-tauri.outputs.version }}_x64_en-US.msi.zip.sig
-      version: ${{ needs.publish-tauri.outputs.version }}
-      filename: ${{ needs.publish-tauri.outputs.filename }}
-      file_hash: ${{ needs.publish-tauri.outputs.file_hash }}
-      name: Wallet
-      category: wallet
-      platform: Windows
     secrets: inherit

.github/workflows/push-release-data.yml

@@ -1,212 +0,0 @@
-name: Push release data
-
-env:
-  strapi_download_url: 'https://strapi.feat-nym-update-nym-web.websites.dev.nymte.ch/api/downloaders'
-  strapi_updater_url: 'https://strapi.feat-nym-update-nym-web.websites.dev.nymte.ch/api/updaters'
-
-on:
-  workflow_call:
-    inputs:
-      release_tag:
-        required: true
-        description: Release tag
-        type: string
-      release_id:
-        required: true
-        description: Release ID
-        type: string
-      release_date:
-        required: true
-        description: Release date
-        type: string
-      download_base_url:
-        required: true
-        description: Download base URL
-        type: string
-      changelog_url:
-        required: true
-        description: Changelog URL
-        type: string
-      archive_url:
-        required: false
-        description: Binary archive URL
-        type: string
-      sig_url:
-        required: false
-        description: Archive signature URL
-        type: string
-      version:
-        required: true
-        description: Release version (semver)
-        type: string
-      filename:
-        required: true
-        description: Binary file name
-        type: string
-      file_hash:
-        required: true
-        description: Binary hash (sha256)
-        type: string
-      name:
-        required: true
-        description: Name
-        type: string
-      category:
-        required: true
-        description: Category
-        type: string
-      platform:
-        required: false
-        description: Platform
-        type: string
-  workflow_dispatch:
-    inputs:
-      # ⚠ since inputs are limited to 10 max for workflow_dispatch
-      # some properties were omitted
-      version:
-        required: true
-        description: Release version (semver)
-        type: string
-        default: '1.0.0'
-      release_id:
-        required: true
-        description: Release ID
-        type: string
-        default: '1234'
-      release_date:
-        required: true
-        description: Release date
-        type: string
-        default: '2023-06-26T10:09:16Z'
-      download_base_url:
-        required: true
-        description: Download base URL
-        type: string
-        default: 'https://github.com/nymtech/nym/releases/download/nym-wallet-v1.0.0'
-      changelog_url:
-        required: true
-        description: Changelog URL
-        type: string
-        default: 'https://github.com/nymtech/nym/blob/nym-wallet-v1.0.0/nym-wallet/CHANGELOG.md'
-      filename:
-        required: true
-        description: Binary file name
-        type: string
-        default: 'nym-wallet_1.0.0_amd64.AppImage'
-      file_hash:
-        required: true
-        description: Binary hash (sha256)
-        type: string
-        default: 'xxx'
-      name:
-        required: true
-        description: Name
-        type: string
-        default: 'Wallet'
-      category:
-        required: true
-        description: Category
-        default: 'wallet'
-        type: choice
-        options:
-          - wallet
-          - connect
-          - binaries
-      platform:
-        required: false
-        description: Platform
-        default: 'Ubuntu'
-        type: choice
-        options:
-          - Ubuntu
-          - Windows
-          - MacOS
-
-jobs:
-  push-download-data:
-    name: Push download data to Strapi
-    runs-on: custom-runner-linux
-
-    steps:
-      - name: Release info
-        run: |
-          echo "version: ${{ inputs.version }}"
-          echo "tag: ${{ inputs.release_tag }}"
-
-      - id: get_sig
-        name: Get sig
-        if: ${{ inputs.sig_url != null }}
-        run: |
-          output=$(curl -LsSf ${{ inputs.sig_url }})
-          echo "sig=$output" >> "$GITHUB_OUTPUT"
-      - id: strapi-request
-        name: Strapi request
-        uses: fjogeleit/http-request-action@v1
-        with:
-          url: ${{ env.strapi_download_url }}
-          method: 'POST'
-          bearerToken: ${{ secrets.STRAPI_API_TOKEN_RELEASES }}
-          customHeaders: '{"Content-Type": "application/json"}'
-          data: |
-            {
-              "data": {
-                "releaseId": "${{ inputs.release_id }}",
-                "releaseDate": "${{ inputs.release_date }}",
-                "downloadBaseUrl": "${{ inputs.download_base_url }}",
-                "changelogUrl": "${{ inputs.changelog_url }}",
-                "version": "${{ inputs.version }}",
-                "filename": "${{ inputs.filename }}",
-                "name": "${{ inputs.name }}",
-                "category": "${{ inputs.category }}",
-                "platform": "${{ inputs.platform }}",
-                "sha256": "${{ inputs.file_hash }}",
-                "sig": "${{ steps.get_sig.outputs.sig }}"
-              }
-            }
-      - name: Strapi Response
-        run: |
-          echo ${{ steps.strapi-request.outputs.response }}
-
-  push-update-data:
-    name: Push update data to Strapi
-    runs-on: custom-runner-linux
-    # only push update data for tauri apps (desktop wallet and NC)
-    if: ${{ inputs.category == 'wallet' || inputs.category == 'connect' }}
-
-    steps:
-      - name: Release info
-        run: |
-          echo "version: ${{ inputs.version }}"
-          echo "tag: ${{ inputs.release_tag }}"
-      - id: get_sig
-        name: Get sig
-        if: ${{ inputs.sig_url != null }}
-        run: |
-          output=$(curl -LsSf ${{ inputs.sig_url }})
-          echo "sig=$output" >> "$GITHUB_OUTPUT"
-      - id: strapi-request
-        name: Strapi request
-        uses: fjogeleit/http-request-action@v1
-        with:
-          url: ${{ env.strapi_updater_url }}
-          method: 'POST'
-          bearerToken: ${{ secrets.STRAPI_API_TOKEN_RELEASES }}
-          customHeaders: '{"Content-Type": "application/json"}'
-          data: |
-            {
-              "data": {
-                "releaseId": "${{ inputs.release_id }}",
-                "releaseDate": "${{ inputs.release_date }}",
-                "downloadUrl": "${{ inputs.archive_url }}",
-                "changelog": "See ${{ inputs.changelog_url }} for the changelog",
-                "version": "${{ inputs.version }}",
-                "filename": "${{ inputs.filename }}",
-                "category": "${{ inputs.category }}",
-                "platform": "${{ inputs.platform }}",
-                "sha256": "${{ inputs.file_hash }}",
-                "sig": "${{ steps.get_sig.outputs.sig }}"
-              }
-            }
-      - name: Strapi Response
-        run: |
-          echo ${{ steps.strapi-request.outputs.response }}

.github/workflows/release-calculate-hash.yml

@@ -0,0 +1,39 @@
+name: Releases - calculate file hashes
+
+on:
+  workflow_call:
+    inputs:
+      release_tag:
+        description: 'Release tag'
+        required: true
+        type: string
+  workflow_dispatch:
+    release_tag:
+      tag:
+        description: 'Release tag'
+        required: true
+        type: string
+
+jobs:
+  build:
+    name: Calculate hash for assets in release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Install packages
+        run: cd ./.github/actions/nym-hash-releases && npm i
+
+      - uses: ./.github/actions/nym-hash-releases
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          release-tag-or-name-or-id: ${{ inputs.release_tag }}
+
+      - uses: actions/upload-artifact@v2
+        with:
+          name: Asset Hashes
+          path: hashes.json

.github/workflows/run-api-tests.yml

@@ -32,5 +32,5 @@ jobs:
         run: yarn
 
       - name: Run tests
-        run: yarn test:qa
+        run: yarn test:sandbox
         working-directory: nym-api/tests

.github/workflows/sdk-docs-typescript.yml

@@ -4,9 +4,11 @@ on:
   push:
     paths:
       - "sdk/typescript/**"
+      - "wasm/**"
   pull_request:
     paths:
       - "sdk/typescript/**"
+      - "wasm/**"
 
 jobs:
   build:
@@ -26,17 +28,39 @@ jobs:
           toolchain: stable
       - name: Setup yarn
         run: npm install -g yarn
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.20'
+
+      - name: Build branch WASM packages
+        run: make sdk-wasm-build
+
       - name: Install
         run: yarn
+      - name: Build
+        run: yarn docs:prod:build
+      - name: Deploy branch to CI www (docs)
+        continue-on-error: true
+        uses: easingthemes/ssh-deploy@main
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+          ARGS: "-rltgoDzvO --delete"
+          SOURCE: "dist/ts/"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/sdk-ts-docs-${{ 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: ts-packages
-          NYM_PROJECT_NAME: "ts-packages"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "ts-${{ env.GITHUB_REF_SLUG }}"
+          NYM_PROJECT_NAME: "sdk-ts-docs"
+          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}/docs/sdk/typescript"
+          NYM_CI_WWW_LOCATION: "sdk-ts-docs-${{ env.GITHUB_REF_SLUG }}"
           GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
           GIT_BRANCH: "${GITHUB_REF##*/}"
           IS_SUCCESS: "${{ job.status == 'success' }}"

.github/workflows/typescript-lint.yml

@@ -25,27 +25,37 @@ jobs:
     runs-on: custom-runner-linux
     steps:
       - uses: actions/checkout@v2
-      - name: Install rsync
-        run: sudo apt-get install rsync
-        continue-on-error: true
       - uses: rlespinasse/github-slug-action@v3.x
+
       - uses: actions/setup-node@v3
         with:
           node-version: 18
+      - name: Setup yarn
+        run: npm install -g yarn
+
       - name: Install Rust stable
         uses: actions-rs/toolchain@v1
         with:
           toolchain: stable
       - name: Install wasm-pack
         run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-      - name: Setup yarn
-        run: npm install -g yarn
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.20'
+
       - name: Install
         run: yarn
+
       - name: Build packages
-        run: yarn build
+        run: yarn build:ci:sdk
+
       - name: Lint
-        run: yarn lint && yarn tsc
+        run: yarn lint
+      - name: Typecheck with tsc
+        run: yarn tsc
+
       - name: Matrix - Node Install
         run: npm install
         working-directory: .github/workflows/support-files

.github/workflows/upload-nyxd-ci.yml

@@ -1,79 +0,0 @@
-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/"

.github/workflows/wallet.yml

@@ -31,7 +31,7 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           profile: minimal
-          toolchain: stable
+          toolchain: 1.71.0
           override: true
           components: rustfmt, clippy
 

.github/workflows/wasm_client_build.yml

@@ -1,40 +0,0 @@
-name: Wasm Client
-
-on:
-  pull_request:
-    paths:
-      - 'clients/webassembly/**'
-      - 'clients/client-core/**'
-      - 'common/**'
-      - 'contracts/**'
-      - 'gateway/gateway-requests/**'
-      - 'nym-api/nym-api-requests/**'
-
-jobs:
-  wasm:
-    runs-on: ubuntu-20.04
-    steps:
-      - uses: actions/checkout@v2
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: stable
-          target: wasm32-unknown-unknown
-          override: true
-          components: rustfmt, clippy
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --manifest-path clients/webassembly/Cargo.toml -- --check
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: clippy
-          args: --manifest-path clients/webassembly/Cargo.toml --target wasm32-unknown-unknown -- -D warnings

.github/workflows/wasm_sdk.yml

@@ -0,0 +1,46 @@
+name: Wasm Client
+
+on:
+  pull_request:
+    paths:
+      - 'wasm/**'
+      - 'clients/client-core/**'
+      - 'common/**'
+
+jobs:
+  wasm:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: stable
+          target: wasm32-unknown-unknown
+          override: true
+          components: rustfmt, clippy
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.20'
+
+
+      - name: Install wasm-pack
+        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+
+      - name: Install wasm-opt
+        run: cargo install  wasm-opt
+
+      - name: Install wasm-bindgen-cli
+        run: cargo install wasm-bindgen-cli
+
+      - name: "Build"
+        run: make sdk-wasm-build
+
+      - name: "Test"
+        run: make sdk-wasm-test
+
+      - name: "Lint"
+        run: make sdk-wasm-lint

.gitignore

@@ -43,4 +43,6 @@ envs/qwerty.env
 .parcel-cache
 **/.DS_Store
 cpu-cycles/libcpucycles/build
-foxyfox.env
+foxyfox.env
+
+.next

CHANGELOG.md

@@ -4,7 +4,57 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 
 ## [Unreleased]
 
-## [1.1.28] (2023-08-22)
+## [v1.1.31-kitkat] (2023-09-12)
+
+- feat: add name to `TaskClient` ([#3844])
+- added 'open_proxy', 'enabled_statistics' and 'statistics_recipient' to NR config ([#3839])
+- MixFetch: initial prototype for insecure HTTP ([#3645])
+- MixFetch: prototype implementing TLS in WASM for HTTPS ([#3644])
+- SDK: build package for NodeJS ([#3558])
+- [Issue] There is already an open connection to this client ([#2845])
+
+[#3844]: https://github.com/nymtech/nym/pull/3844
+[#3839]: https://github.com/nymtech/nym/pull/3839
+[#3645]: https://github.com/nymtech/nym/issues/3645
+[#3644]: https://github.com/nymtech/nym/issues/3644
+[#3558]: https://github.com/nymtech/nym/issues/3558
+[#2845]: https://github.com/nymtech/nym/issues/2845
+
+## [v1.1.30-twix] (2023-09-05)
+
+- geo_aware_provider: fix too much filtering of gateways ([#3826])
+- network-requester: add description to config ([#3799])
+- Speedy mode - selects gateway based on latency  in medium / speedy mode ([#3770])
+- Chore/enable versioning ([#3768])
+- Create explorer-client and use in geo aware provider ([#3824])
+
+[#3826]: https://github.com/nymtech/nym/pull/3826
+[#3799]: https://github.com/nymtech/nym/pull/3799
+[#3770]: https://github.com/nymtech/nym/issues/3770
+[#3768]: https://github.com/nymtech/nym/pull/3768
+[#3824]: https://github.com/nymtech/nym/pull/3824
+
+## [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])
@@ -19,7 +69,7 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://
 [#3767]: https://github.com/nymtech/nym/pull/3767
 
 
-## [1.1.27] (2023-08-16)
+## [v1.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])

Cargo.toml

@@ -17,7 +17,6 @@ opt-level = 3
 
 resolver = "2"
 members = [
-    "clients/credential",
     "clients/native",
     "clients/native/websocket-requests",
     "clients/socks5",
@@ -43,9 +42,11 @@ members = [
     "common/cosmwasm-smart-contracts/vesting-contract",
     "common/credential-storage",
     "common/credentials",
+    "common/credential-utils",
     "common/crypto",
     "common/dkg",
     "common/execute",
+    "common/http-requests",
     "common/inclusion-probability",
     "common/ledger",
     "common/mixnode-common",
@@ -73,9 +74,13 @@ members = [
     "common/task",
     "common/topology",
     "common/types",
-    "common/wasm-utils",
+    "common/wasm/client-core",
+    "common/wasm/storage",
+    "common/wasm/utils",
+    "common/wireguard",
     "explorer-api",
     "explorer-api/explorer-api-requests",
+    "explorer-api/explorer-client",
     "gateway",
     "gateway/gateway-requests",
     "integrations/bity",
@@ -86,11 +91,18 @@ members = [
     "service-providers/network-requester",
     "service-providers/network-statistics",
     "nym-api",
+    "nym-browser-extension/storage",
     "nym-api/nym-api-requests",
     "nym-outfox",
+    "tools/internal/ssl-inject",
+    "tools/internal/sdk-version-bump",
     "tools/nym-cli",
     "tools/nym-nr-query",
-    "tools/ts-rs-cli"
+    "tools/ts-rs-cli",
+    "wasm/client",
+    "wasm/full-nym-wasm",
+    "wasm/mix-fetch",
+    "wasm/node-tester",
 ]
 
 default-members = [
@@ -104,7 +116,7 @@ default-members = [
     "explorer-api",
 ]
 
-exclude = ["explorer", "contracts", "clients/webassembly", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "nym-browser-extension/storage", "cpu-cycles"]
+exclude = ["explorer", "contracts", "nym-wallet", "nym-connect/mobile/src-tauri", "nym-connect/desktop", "cpu-cycles"]
 
 [workspace.package]
 authors = ["Nym Technologies SA"]
@@ -116,7 +128,7 @@ license = "Apache-2.0"
 
 [workspace.dependencies]
 anyhow = "1.0.71"
-async-trait = "0.1.64"
+async-trait = "0.1.68"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
 cfg-if = "1.0.0"
 cosmwasm-derive = "=1.3.0"
@@ -150,8 +162,16 @@ 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"
 
 # wasm-related dependencies
+gloo-utils = "0.1.7"
+js-sys = "0.3.63"
+serde-wasm-bindgen = "0.5.0"
+tsify = "0.4.5"
+wasm-bindgen = "0.2.86"
+wasm-bindgen-futures = "0.4.37"
 wasmtimer = "0.2.0"
+web-sys = "0.3.63"

Makefile

@@ -1,17 +1,21 @@
 # Default target
 all: test
 
-test: clippy-all cargo-test wasm fmt
+test: clippy-all cargo-test contracts-wasm sdk-wasm-test fmt
 
 test-all: test cargo-test-expensive
 
-no-clippy: build cargo-test wasm fmt
+no-clippy: build cargo-test contracts-wasm fmt fmt-browser-extension-storage
 
 happy: fmt clippy-happy test
 
+build: sdk-wasm-build build-browser-extension-storage
+
 # Building release binaries is a little manual as we can't just build --release
 # on all workspaces.
-build-release: build-release-main wasm
+build-release: build-release-main contracts-wasm
+
+clippy: sdk-wasm-lint clippy-browser-extension-storage
 
 # Deprecated
 # For backwards compatibility
@@ -43,6 +47,9 @@ test-$(1):
 test-expensive-$(1):
 	cargo test --manifest-path $(2)/Cargo.toml --workspace -- --ignored
 
+build-standalone-$(1):
+	cargo build --manifest-path $(2)/Cargo.toml $(3)
+
 build-$(1):
 	cargo build --manifest-path $(2)/Cargo.toml --workspace $(3)
 
@@ -74,12 +81,9 @@ endef
 
 $(eval $(call add_cargo_workspace,main,.))
 $(eval $(call add_cargo_workspace,contracts,contracts,--lib --target wasm32-unknown-unknown))
-$(eval $(call add_cargo_workspace,wasm-client,clients/webassembly,--target wasm32-unknown-unknown))
+#$(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
@@ -91,6 +95,67 @@ build-explorer-api:
 build-nym-cli:
 	cargo build -p nym-cli --release
 
+build-browser-extension-storage:
+	cargo build -p extension-storage --target wasm32-unknown-unknown
+
+fmt-browser-extension-storage:
+	cargo fmt -p extension-storage -- --check
+
+clippy-browser-extension-storage:
+	cargo clippy -p extension-storage --target wasm32-unknown-unknown -- -Dwarnings
+
+sdk-wasm: sdk-wasm-build sdk-wasm-test sdk-wasm-lint
+
+sdk-wasm-build:
+	# browser storage
+	$(MAKE) -C nym-browser-extension/storage wasm-pack
+
+	# client
+	$(MAKE) -C wasm/client build
+
+	# node-tester
+	$(MAKE) -C wasm/node-tester build
+
+	# mix-fetch
+	$(MAKE) -C wasm/mix-fetch build
+
+	# full
+	$(MAKE) -C wasm/full-nym-wasm build-full
+
+# run this from npm/yarn to ensure tools are in the path, e.g. yarn build:sdk from root of repo
+sdk-typescript-build:
+	lerna run --scope @nymproject/sdk build --stream
+	lerna run --scope @nymproject/mix-fetch build --stream
+	lerna run --scope @nymproject/node-tester build --stream
+
+sdk-wasm-test:
+#	# client
+#	cargo test -p nym-client-wasm --target wasm32-unknown-unknown
+#
+#	# node-tester
+#	cargo test -p nym-node-tester-wasm --target wasm32-unknown-unknown
+#
+#	# mix-fetch
+#	#cargo test -p nym-wasm-sdk --target wasm32-unknown-unknown
+#
+#	# full
+#	cargo test -p nym-wasm-sdk --target wasm32-unknown-unknown
+
+
+sdk-wasm-lint:
+	# client
+	cargo clippy -p nym-client-wasm --target wasm32-unknown-unknown -- -Dwarnings
+
+	# node-tester
+	cargo clippy -p nym-node-tester-wasm --target wasm32-unknown-unknown -- -Dwarnings
+
+	# mix-fetch
+	$(MAKE) -C wasm/mix-fetch check-fmt
+
+	# full
+	cargo clippy -p nym-wasm-sdk --target wasm32-unknown-unknown -- -Dwarnings
+
+
 # -----------------------------------------------------------------------------
 # Build contracts ready for deploy
 # -----------------------------------------------------------------------------
@@ -101,12 +166,12 @@ MIXNET_CONTRACT=$(CONTRACTS_OUT_DIR)/mixnet_contract.wasm
 SERVICE_PROVIDER_DIRECTORY_CONTRACT=$(CONTRACTS_OUT_DIR)/nym_service_provider_directory.wasm
 NAME_SERVICE_CONTRACT=$(CONTRACTS_OUT_DIR)/nym_name_service.wasm
 
-wasm: wasm-build wasm-opt
+contracts-wasm: contracts-wasm-build contracts-wasm-opt
 
-wasm-build:
+contracts-wasm-build:
 	RUSTFLAGS='-C link-arg=-s' cargo build --lib --manifest-path contracts/Cargo.toml --release --target wasm32-unknown-unknown
 
-wasm-opt:
+contracts-wasm-opt:
 	wasm-opt --disable-sign-ext -Os $(VESTING_CONTRACT) -o $(VESTING_CONTRACT)
 	wasm-opt --disable-sign-ext -Os $(MIXNET_CONTRACT) -o $(MIXNET_CONTRACT)
 	wasm-opt --disable-sign-ext -Os $(SERVICE_PROVIDER_DIRECTORY_CONTRACT) -o $(SERVICE_PROVIDER_DIRECTORY_CONTRACT)
@@ -120,7 +185,7 @@ contract-schema:
 # -----------------------------------------------------------------------------
 
 # NOTE: this seems deprecated an not needed anymore?
-mixnet-opt: wasm
+mixnet-opt: contracts-wasm
 	cd contracts/mixnet && make opt
 
 generate-typescript:

clients/credential/README.md

@@ -1,32 +0,0 @@
-<!--
-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.
-

clients/credential/src/client.rs

@@ -1,55 +0,0 @@
-// 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())
-    }
-}

clients/credential/src/commands.rs

@@ -1,82 +0,0 @@
-// 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(())
-}

clients/credential/src/error.rs

@@ -1,36 +0,0 @@
-// 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),
-}

clients/credential/src/main.rs

@@ -1,131 +0,0 @@
-// 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(())
-}

clients/credential/src/recovery_storage.rs

@@ -1,56 +0,0 @@
-// 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)
-    }
-}

clients/native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.26"
+version = "1.1.29"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"

clients/native/src/client/config/old_config_v1_1_20_2.rs

@@ -1,8 +1,13 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::client::config::persistence::ClientPaths;
-use crate::client::config::{default_config_filepath, Config, Socket, SocketType};
+use crate::{
+    client::config::{
+        default_config_filepath, persistence::ClientPaths, Config, Socket, SocketType,
+    },
+    error::ClientError,
+};
+
 use nym_bin_common::logging::LoggingSettings;
 use nym_client_core::config::disk_persistence::old_v1_1_20_2::CommonClientPathsV1_1_20_2;
 use nym_client_core::config::old_config_v1_1_20_2::ConfigV1_1_20_2 as BaseConfigV1_1_20_2;
@@ -43,18 +48,18 @@ impl ConfigV1_1_20_2 {
 
     // in this upgrade, gateway endpoint configuration was moved out of the config file,
     // so its returned to be stored elsewhere.
-    pub fn upgrade(self) -> (Config, GatewayEndpointConfig) {
+    pub fn upgrade(self) -> Result<(Config, GatewayEndpointConfig), ClientError> {
         let gateway_details = self.base.client.gateway_endpoint.clone().into();
         let config = Config {
             base: self.base.into(),
             socket: self.socket.into(),
             storage_paths: ClientPaths {
-                common_paths: self.storage_paths.common_paths.upgrade_default(),
+                common_paths: self.storage_paths.common_paths.upgrade_default()?,
             },
             logging: self.logging,
         };
 
-        (config, gateway_details)
+        Ok((config, gateway_details))
     }
 }
 

clients/native/src/commands/mod.rs

@@ -157,7 +157,7 @@ fn try_upgrade_v1_1_13_config(id: &str) -> Result<bool, ClientError> {
 
     let updated_step1: ConfigV1_1_20 = old_config.into();
     let updated_step2: ConfigV1_1_20_2 = updated_step1.into();
-    let (updated, gateway_config) = updated_step2.upgrade();
+    let (updated, gateway_config) = updated_step2.upgrade()?;
     persist_gateway_details(&updated, gateway_config)?;
 
     updated.save_to_default_location()?;
@@ -177,7 +177,7 @@ fn try_upgrade_v1_1_20_config(id: &str) -> Result<bool, ClientError> {
     info!("It is going to get updated to the current specification.");
 
     let updated_step1: ConfigV1_1_20_2 = old_config.into();
-    let (updated, gateway_config) = updated_step1.upgrade();
+    let (updated, gateway_config) = updated_step1.upgrade()?;
     persist_gateway_details(&updated, gateway_config)?;
 
     updated.save_to_default_location()?;
@@ -194,7 +194,7 @@ fn try_upgrade_v1_1_20_2_config(id: &str) -> Result<bool, ClientError> {
     info!("It seems the client is using <= v1.1.20_2 config template.");
     info!("It is going to get updated to the current specification.");
 
-    let (updated, gateway_config) = old_config.upgrade();
+    let (updated, gateway_config) = old_config.upgrade()?;
     persist_gateway_details(&updated, gateway_config)?;
 
     updated.save_to_default_location()?;

clients/native/websocket-requests/src/requests.rs

@@ -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().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())
+            .chain(recipient.to_bytes()) // will not be length prefixed because the length is constant
+            .chain(conn_id_bytes)
+            .chain(data_len_bytes)
+            .chain(data)
             .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().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())
+            .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)
             .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().into_iter())
-            .chain(conn_id_bytes.into_iter())
-            .chain(message_len_bytes.into_iter())
-            .chain(message.into_iter())
+            .chain(sender_tag.to_bytes())
+            .chain(conn_id_bytes)
+            .chain(message_len_bytes)
+            .chain(message)
             .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.into_iter())
+            .chain(conn_id_bytes)
             .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.into_iter())
+            .chain(conn_id_bytes)
             .collect()
     }
 

clients/native/websocket-requests/src/responses.rs

@@ -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().into_iter())
+                .chain(sender_tag.to_bytes())
                 .chain(message_len_bytes.iter().cloned())
-                .chain(reconstructed_message.message.into_iter())
+                .chain(reconstructed_message.message)
                 .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.into_iter())
+                .chain(reconstructed_message.message)
                 .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().into_iter())
+            .chain(address.to_bytes())
             .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.into_iter())
-            .chain(error.message.into_bytes().into_iter())
+            .chain(message_len_bytes)
+            .chain(error.message.into_bytes())
             .collect()
     }
 

clients/socks5/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.26"
+version = "1.1.29"
 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"

clients/socks5/src/commands/mod.rs

@@ -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, TopologyStructure};
+use nym_client_core::config::{GatewayEndpointConfig, GroupBy, TopologyStructure};
 use nym_client_core::error::ClientCoreError;
 use nym_config::OptionalSet;
 use nym_sphinx::params::{PacketSize, PacketType};
@@ -101,9 +101,17 @@ 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 || 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))
+    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))
     } else {
         TopologyStructure::default()
     };
@@ -191,7 +199,7 @@ fn try_upgrade_v1_1_13_config(id: &str) -> Result<bool, Socks5ClientError> {
 
     let updated_step1: ConfigV1_1_20 = old_config.into();
     let updated_step2: ConfigV1_1_20_2 = updated_step1.into();
-    let (updated, gateway_config) = updated_step2.upgrade();
+    let (updated, gateway_config) = updated_step2.upgrade()?;
     persist_gateway_details(&updated, gateway_config)?;
 
     updated.save_to_default_location()?;
@@ -211,7 +219,7 @@ fn try_upgrade_v1_1_20_config(id: &str) -> Result<bool, Socks5ClientError> {
     info!("It is going to get updated to the current specification.");
 
     let updated_step1: ConfigV1_1_20_2 = old_config.into();
-    let (updated, gateway_config) = updated_step1.upgrade();
+    let (updated, gateway_config) = updated_step1.upgrade()?;
     persist_gateway_details(&updated, gateway_config)?;
 
     updated.save_to_default_location()?;
@@ -228,7 +236,7 @@ fn try_upgrade_v1_1_20_2_config(id: &str) -> Result<bool, Socks5ClientError> {
     info!("It seems the client is using <= v1.1.20_2 config template.");
     info!("It is going to get updated to the current specification.");
 
-    let (updated, gateway_config) = old_config.upgrade();
+    let (updated, gateway_config) = old_config.upgrade()?;
     persist_gateway_details(&updated, gateway_config)?;
 
     updated.save_to_default_location()?;

clients/socks5/src/config/old_config_v1_1_20_2.rs

@@ -1,17 +1,21 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-use crate::config::persistence::SocksClientPaths;
-use crate::config::{default_config_filepath, Config};
+use crate::{
+    config::{default_config_filepath, persistence::SocksClientPaths, Config},
+    error::Socks5ClientError,
+};
+
 use nym_bin_common::logging::LoggingSettings;
 use nym_client_core::config::disk_persistence::old_v1_1_20_2::CommonClientPathsV1_1_20_2;
 use nym_client_core::config::GatewayEndpointConfig;
 use nym_config::read_config_from_toml_file;
-pub use nym_socks5_client_core::config::old_config_v1_1_20_2::ConfigV1_1_20_2 as CoreConfigV1_1_20_2;
 use serde::{Deserialize, Serialize};
 use std::io;
 use std::path::Path;
 
+pub use nym_socks5_client_core::config::old_config_v1_1_20_2::ConfigV1_1_20_2 as CoreConfigV1_1_20_2;
+
 #[derive(Debug, Deserialize, PartialEq, Eq, Serialize, Clone)]
 pub struct SocksClientPathsV1_1_20_2 {
     #[serde(flatten)]
@@ -39,16 +43,16 @@ impl ConfigV1_1_20_2 {
 
     // in this upgrade, gateway endpoint configuration was moved out of the config file,
     // so its returned to be stored elsewhere.
-    pub fn upgrade(self) -> (Config, GatewayEndpointConfig) {
+    pub fn upgrade(self) -> Result<(Config, GatewayEndpointConfig), Socks5ClientError> {
         let gateway_details = self.core.base.client.gateway_endpoint.clone().into();
         let config = Config {
             core: self.core.into(),
             storage_paths: SocksClientPaths {
-                common_paths: self.storage_paths.common_paths.upgrade_default(),
+                common_paths: self.storage_paths.common_paths.upgrade_default()?,
             },
             logging: self.logging,
         };
 
-        (config, gateway_details)
+        Ok((config, gateway_details))
     }
 }

clients/webassembly/.appveyor.yml

@@ -1,11 +0,0 @@
-install:
-  - appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - if not defined RUSTFLAGS rustup-init.exe -y --default-host x86_64-pc-windows-msvc --default-toolchain nightly
-  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
-  - rustc -V
-  - cargo -V
-
-build: false
-
-test_script:
-  - cargo test --locked

clients/webassembly/.cargo/config.toml

@@ -1,2 +0,0 @@
-[build]
-target = "wasm32-unknown-unknown"

clients/webassembly/.gitignore

@@ -1,6 +0,0 @@
-/target
-**/*.rs.bk
-bin/
-pkg/
-wasm-pack.log
-node_modules

clients/webassembly/.travis.yml

@@ -1,69 +0,0 @@
-language: rust
-sudo: false
-
-cache: cargo
-
-matrix:
-  include:
-
-  # Builds with wasm-pack.
-  - rust: beta
-    env: RUST_BACKTRACE=1
-    addons:
-      firefox: latest
-      chrome: stable
-    before_script:
-      - (test -x $HOME/.cargo/bin/cargo-install-update || cargo install cargo-update)
-      - (test -x $HOME/.cargo/bin/cargo-generate || cargo install --vers "^0.2" cargo-generate)
-      - cargo install-update -a
-      - curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh -s -- -f
-    script:
-      - cargo generate --git . --name testing
-      # Having a broken Cargo.toml (in that it has curlies in fields) anywhere
-      # in any of our parent dirs is problematic.
-      - mv Cargo.toml Cargo.toml.tmpl
-      - cd testing
-      - wasm-pack build
-      - wasm-pack test --chrome --firefox --headless
-
-  # Builds on nightly.
-  - rust: nightly
-    env: RUST_BACKTRACE=1
-    before_script:
-      - (test -x $HOME/.cargo/bin/cargo-install-update || cargo install cargo-update)
-      - (test -x $HOME/.cargo/bin/cargo-generate || cargo install --vers "^0.2" cargo-generate)
-      - cargo install-update -a
-      - rustup target add wasm32-unknown-unknown
-    script:
-      - cargo generate --git . --name testing
-      - mv Cargo.toml Cargo.toml.tmpl
-      - cd testing
-      - cargo check
-      - cargo check --target wasm32-unknown-unknown
-      - cargo check                                 --no-default-features
-      - cargo check --target wasm32-unknown-unknown --no-default-features
-      - cargo check                                 --no-default-features --features console_error_panic_hook
-      - cargo check --target wasm32-unknown-unknown --no-default-features --features console_error_panic_hook
-      - cargo check                                 --no-default-features --features "console_error_panic_hook wee_alloc"
-      - cargo check --target wasm32-unknown-unknown --no-default-features --features "console_error_panic_hook wee_alloc"
-
-  # Builds on beta.
-  - rust: beta
-    env: RUST_BACKTRACE=1
-    before_script:
-      - (test -x $HOME/.cargo/bin/cargo-install-update || cargo install cargo-update)
-      - (test -x $HOME/.cargo/bin/cargo-generate || cargo install --vers "^0.2" cargo-generate)
-      - cargo install-update -a
-      - rustup target add wasm32-unknown-unknown
-    script:
-      - cargo generate --git . --name testing
-      - mv Cargo.toml Cargo.toml.tmpl
-      - cd testing
-      - cargo check
-      - cargo check --target wasm32-unknown-unknown
-      - cargo check                                 --no-default-features
-      - cargo check --target wasm32-unknown-unknown --no-default-features
-      - cargo check                                 --no-default-features --features console_error_panic_hook
-      - cargo check --target wasm32-unknown-unknown --no-default-features --features console_error_panic_hook
-      # Note: no enabling the `wee_alloc` feature here because it requires
-      # nightly for now.

clients/webassembly/Cargo.toml

@@ -1,74 +0,0 @@
-[package]
-name = "nym-client-wasm"
-authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jedrzej Stuczynski <andrew@nymtech.net>"]
-version = "1.1.1"
-edition = "2021"
-keywords = ["nym", "sphinx", "wasm", "webassembly", "privacy"]
-license = "Apache-2.0"
-repository = "https://github.com/nymtech/nym"
-description = "A webassembly client which can be used to interact with the the Nym privacy platform. Wasm is used for Sphinx packet generation."
-rust-version = "1.56"
-
-[lib]
-crate-type = ["cdylib", "rlib"]
-
-[features]
-default = ["console_error_panic_hook"]
-offline-test = []
-
-[dependencies]
-async-trait = "0.1.68"
-bs58 = "0.4.0"
-futures = "0.3"
-js-sys = "0.3"
-rand = { version = "0.7.3", features = ["wasm-bindgen"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-anyhow = "1.0"
-serde-wasm-bindgen = "0.5"
-tokio = { version = "1.24.1", features = ["sync"] }
-url = "2.2"
-wasm-bindgen = { version = "=0.2.83", features = ["serde-serialize"]  }
-wasm-bindgen-futures = "0.4"
-thiserror = "1.0.40"
-zeroize = "1.6.0"
-
-wasmtimer = { version = "0.2.0", features = ["tokio"] }
-
-# internal
-nym-node-tester-utils = { path = "../../common/node-tester-utils" }
-nym-client-core = { path = "../../common/client-core", default-features = false, features = ["wasm"] }
-nym-bandwidth-controller = { path = "../../common/bandwidth-controller" }
-nym-coconut-interface = { path = "../../common/coconut-interface" }
-nym-credentials = { path = "../../common/credentials" }
-nym-credential-storage = { path = "../../common/credential-storage" }
-nym-crypto = { path = "../../common/crypto", features = ["asymmetric", "serde"] }
-nym-sphinx = { path = "../../common/nymsphinx" }
-nym-sphinx-acknowledgements = { path = "../../common/nymsphinx/acknowledgements", features = ["serde"]}
-nym-topology = { path = "../../common/topology" }
-nym-gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm"] }
-nym-validator-client = { path = "../../common/client-libs/validator-client", default-features = false }
-nym-task = { path = "../../common/task" }
-wasm-utils = { path = "../../common/wasm-utils", features = ["storage"], default-features = false }
-# The `console_error_panic_hook` crate provides better debugging of panics by
-# logging them with `console.error`. This is great for development, but requires
-# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
-# code size when deploying.
-console_error_panic_hook = { version = "0.1", optional = true }
-
-# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
-# compared to the default allocator's ~10K. It is slower than the default
-# allocator, however.
-#
-# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
-wee_alloc = { version = "0.4", optional = true }
-
-[dev-dependencies]
-wasm-bindgen-test = "0.3"
-
-[package.metadata.wasm-pack.profile.release]
-wasm-opt = false
-
-[profile.release]
-lto = true
-opt-level = 'z'

clients/webassembly/LICENSE_APACHE

@@ -1,176 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS

clients/webassembly/Makefile

@@ -1,8 +0,0 @@
-clippy:
-	cargo clippy --all-features --target wasm32-unknown-unknown -- -D warnings
-
-test:
-	wasm-pack test --node
-
-wasm-build:
-	wasm-pack build

clients/webassembly/internal-dev/worker.js

@@ -1,382 +0,0 @@
-// Copyright 2020-2023 Nym Technologies SA
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-importScripts("nym_client_wasm.js");
-
-console.log("Initializing worker");
-
-// wasm_bindgen creates a global variable (with the exports attached) that is in scope after `importScripts`
-const {
-  NymNodeTester,
-  WasmGateway,
-  WasmMixNode,
-  WasmNymTopology,
-  default_debug,
-  NymClientBuilder,
-  NymClient,
-  set_panic_hook,
-  Config,
-  GatewayEndpointConfig,
-  ClientStorage,
-  current_network_topology,
-  make_key,
-  make_key2,
-} = wasm_bindgen;
-
-let client = null;
-let tester = null;
-
-const preferredGateway = "336yuXAeGEgedRfqTJZsG2YV7P13QH1bHv1SjCZYarc9";
-
-function dummyTopology() {
-  const l1Mixnode = new WasmMixNode(
-    1,
-    "n1fzv4jc7fanl9s0qj02ge2ezk3kts545kjtek47",
-    "178.79.143.65",
-    1789,
-    "4Yr4qmEHd9sgsuQ83191FR2hD88RfsbMmB4tzhhZWriz",
-    "8ndjk5oZ6HxUZNScLJJ7hk39XtUqGexdKgW7hSX6kpWG",
-    1,
-    "1.10.0"
-  );
-  const l2Mixnode = new WasmMixNode(
-    2,
-    "n1z93z44vf8ssvdhujjvxcj4rd5e3lz0l60wdk70",
-    "109.74.197.180",
-    1789,
-    "7sVjiMrPYZrDWRujku9QLxgE8noT7NTgBAqizCsu7AoK",
-    "GepXwRnKZDd8x2nBWAajGGBVvF3mrpVMQBkgfrGuqRCN",
-    2,
-    "1.10.0"
-  );
-  const l3Mixnode = new WasmMixNode(
-    3,
-    "n1ptg680vnmef2cd8l0s9uyc4f0hgf3x8sed6w77",
-    "176.58.101.80",
-    1789,
-    "FoM5Mx9Pxk1g3zEqkS3APgtBeTtTo3M8k7Yu4bV6kK1R",
-    "DeYjrDC2AcQRVFshiKnbUo6bRvPyZ33QGYR2DLeFJ9qD",
-    3,
-    "1.10.0"
-  );
-
-  const gateway = new WasmGateway(
-    "n16evnn8glr0sham3matj8rg2s24m6x56ayk87ts",
-    "85.159.212.96",
-    1789,
-    9000,
-    "336yuXAeGEgedRfqTJZsG2YV7P13QH1bHv1SjCZYarc9",
-    "BtYjoWihiuFihGKQypmpSspbhmWDPxzqeTVSd8ciCpWL",
-    "1.10.1"
-  );
-
-  const mixnodes = new Map();
-  mixnodes.set(1, [l1Mixnode]);
-  mixnodes.set(2, [l2Mixnode]);
-  mixnodes.set(3, [l3Mixnode]);
-
-  const gateways = [gateway];
-
-  return new WasmNymTopology(mixnodes, gateways);
-}
-
-function printAndDisplayTestResult(result) {
-  result.log_details();
-
-  self.postMessage({
-    kind: "DisplayTesterResults",
-    args: {
-      score: result.score(),
-      sentPackets: result.sent_packets,
-      receivedPackets: result.received_packets,
-      receivedAcks: result.received_acks,
-      duplicatePackets: result.duplicate_packets,
-      duplicateAcks: result.duplicate_acks,
-    },
-  });
-}
-
-async function testWithTester() {
-  // A) construct with hardcoded topology
-  const topology = dummyTopology();
-  const nodeTester = await new NymNodeTester(topology, preferredGateway);
-
-  // B) first get topology directly from nym-api
-  // const validator = 'https://qwerty-validator-api.qa.nymte.ch/api';
-  // const topology = await current_network_topology(validator)
-  // const nodeTester = await new NymNodeTester(topology, preferredGateway);
-  //
-  // C) use nym-api in the constructor (note: it does no filtering for 'good' nodes on other layers)
-  // const validator = 'https://qwerty-validator-api.qa.nymte.ch/api';
-  // const nodeTester = await NymNodeTester.new_with_api(validator, preferredGateway)
-
-  // B) first get topology directly from nym-api
-  // const validator = 'https://qwerty-validator-api.qa.nymte.ch/api';
-  // const topology = await current_network_topology(validator)
-  // const nodeTester = await new NymNodeTester(topology, undefined, preferredGateway);
-  //
-  // C) use nym-api in the constructor (note: it does no filtering for 'good' nodes on other layers)
-  // const validator = 'https://qwerty-validator-api.qa.nymte.ch/api';
-  // const nodeTester = await NymNodeTester.new_with_api(validator, undefined, preferredGateway)
-  // D, E, F) you also don't have to specify the gateway. if you don't, a random one (from your topology) will be used
-  // const topology = dummyTopology()
-  // const nodeTester = await new NymNodeTester(topology);
-
-  self.onmessage = async (event) => {
-    if (event.data && event.data.kind) {
-      switch (event.data.kind) {
-        case "TestPacket": {
-          const { mixnodeIdentity } = event.data.args;
-          console.log("starting node test...");
-
-          let result = await nodeTester.test_node(mixnodeIdentity);
-          printAndDisplayTestResult(result);
-        }
-      }
-    }
-  };
-}
-
-async function testerReconnection() {
-  const validator = "https://qwerty-validator-api.qa.nymte.ch/api";
-  const nodeTester = await NymNodeTester.new_with_api(validator);
-
-  self.onmessage = async (event) => {
-    if (event.data && event.data.kind) {
-      switch (event.data.kind) {
-        case "TestPacket": {
-          const { mixnodeIdentity } = event.data.args;
-          console.log("starting node test...");
-
-          let result1 = await nodeTester.test_node(mixnodeIdentity);
-          console.log("sleeping for 5s");
-          await new Promise((r) => setTimeout(r, 5000));
-          await nodeTester.disconnect_from_gateway();
-
-          console.log("sleeping for 5s");
-          await new Promise((r) => setTimeout(r, 5000));
-
-          await nodeTester.reconnect_to_gateway();
-          let result2 = await nodeTester.test_node(mixnodeIdentity);
-
-          printAndDisplayTestResult(result1);
-          printAndDisplayTestResult(result2);
-        }
-      }
-    }
-  };
-}
-
-async function testWithNymClient() {
-  const topology = dummyTopology();
-
-  let received = 0;
-
-  const onMessageHandler = (message) => {
-    received += 1;
-    self.postMessage({
-      kind: "ReceiveMessage",
-      args: {
-        message,
-        senderTag: undefined,
-        isTestPacket: true,
-      },
-    });
-
-    // it's really up to the user to create proper callback here...
-    console.log(`received ${received} packets so far`);
-  };
-
-  console.log("Instantiating WASM client...");
-
-  let clientBuilder = NymClientBuilder.new_tester(
-    topology,
-    onMessageHandler,
-    preferredGateway
-  );
-
-  console.log("Web worker creating WASM client...");
-  let local_client = await clientBuilder.start_client();
-  console.log("WASM client running!");
-
-  const selfAddress = local_client.self_address();
-
-  // set the global (I guess we don't have to anymore?)
-  client = local_client;
-
-  console.log(`Client address is ${selfAddress}`);
-  self.postMessage({
-    kind: "Ready",
-    args: {
-      selfAddress,
-    },
-  });
-
-  // Set callback to handle messages passed to the worker.
-  self.onmessage = async (event) => {
-    console.log(event);
-    if (event.data && event.data.kind) {
-      switch (event.data.kind) {
-        case "SendMessage": {
-          const { message, recipient } = event.data.args;
-          let uint8Array = new TextEncoder().encode(message);
-          await client.send_regular_message(uint8Array, recipient);
-          break;
-        }
-        case "TestPacket": {
-          const { mixnodeIdentity } = event.data.args;
-          const req = await client.try_construct_test_packet_request(
-            mixnodeIdentity
-          );
-          await client.change_hardcoded_topology(req.injectable_topology());
-          await client.try_send_test_packets(req);
-          break;
-        }
-      }
-    }
-  };
-}
-
-async function normalNymClientUsage() {
-  self.postMessage({ kind: "DisableMagicTestButton" });
-
-  // only really useful if you want to adjust some settings like traffic rate
-  // (if not needed you can just pass a null)
-  const debug = default_debug();
-
-  debug.disable_main_poisson_packet_distribution = true;
-  debug.disable_loop_cover_traffic_stream = true;
-  debug.use_extended_packet_size = false;
-  // debug.average_packet_delay_ms = BigInt(10);
-  // debug.average_ack_delay_ms = BigInt(10);
-  // debug.ack_wait_addition_ms = BigInt(3000);
-  // debug.ack_wait_multiplier = 10;
-
-  debug.topology_refresh_rate_ms = BigInt(60000);
-
-  const preferredGateway = "336yuXAeGEgedRfqTJZsG2YV7P13QH1bHv1SjCZYarc9";
-  const validator = "https://qwerty-validator-api.qa.nymte.ch/api";
-
-  const config = new Config("my-awesome-wasm-client", validator, debug);
-
-  const onMessageHandler = (message) => {
-    console.log(message);
-    self.postMessage({
-      kind: "ReceiveMessage",
-      args: {
-        message,
-      },
-    });
-  };
-
-  console.log("Instantiating WASM client...");
-
-  let localClient = await new NymClient(config, onMessageHandler);
-  console.log("WASM client running!");
-
-  const selfAddress = localClient.self_address();
-
-  // set the global (I guess we don't have to anymore?)
-  client = localClient;
-
-  console.log(`Client address is ${selfAddress}`);
-  self.postMessage({
-    kind: "Ready",
-    args: {
-      selfAddress,
-    },
-  });
-
-  // Set callback to handle messages passed to the worker.
-  self.onmessage = async (event) => {
-    console.log(event);
-    if (event.data && event.data.kind) {
-      switch (event.data.kind) {
-        case "SendMessage": {
-          const { message, recipient } = event.data.args;
-          let uint8Array = new TextEncoder().encode(message);
-          await client.send_regular_message(uint8Array, recipient);
-          break;
-        }
-      }
-    }
-  };
-}
-
-async function messWithStorage() {
-  self.onmessage = async (event) => {
-    if (event.data && event.data.kind) {
-      switch (event.data.kind) {
-        case "TestPacket": {
-          const { mixnodeIdentity } = event.data.args;
-          console.log("button clicked...", mixnodeIdentity);
-
-          let id1 = "one";
-          let id2 = "two";
-
-          console.log("making store1 NO-ENC");
-          let _storage1 = await ClientStorage.new_unencrypted(id1);
-
-          console.log("making store2 ENC");
-          let _storage2 = await new ClientStorage(id2, "my-secret-password");
-          //
-          //
-          //
-          //     console.log("attempting to use store1 WITH PASSWORD")
-          //     let _storage1_alt = await new ClientStorage(id1, "password");
-          //
-          //
-          //
-          //     console.log("attempting to use store2 WITHOUT PASSWORD")
-          //     let _storage2_alt = await ClientStorage.new_unencrypted(id2);
-          //
-          //
-          //
-          //     console.log("attempting to use store2 with WRONG PASSWORD")
-          //     let _storage2_bad = await new ClientStorage(id2, "bad-password")
-
-          //
-          // console.log("read1: ", await storage1.read());
-          // console.log("read2: ", await storage2.read());
-          //
-          // console.log("store1: ", await storage1.store("FOOMP"));
-          //
-          // console.log("read1: ", await storage1.read());
-          // console.log("read2: ", await storage2.read());
-        }
-      }
-    }
-  };
-}
-
-async function main() {
-  // load WASM package
-  await wasm_bindgen("nym_client_wasm_bg.wasm");
-  console.log("Loaded WASM");
-
-  // sets up better stack traces in case of in-rust panics
-  set_panic_hook();
-
-  // show reconnection capabilities
-  // await testerReconnection()
-
-  // run test on simplified and dedicated tester:
-  await testWithTester();
-
-  // 'Normal' client setup (to send 'normal' messages)
-  // await normalNymClientUsage()
-}
-
-// Let's get started!
-main();

clients/webassembly/src/constants.rs

@@ -1,5 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-pub(crate) const NODE_TESTER_ID: &str = "_nym-node-tester";
-pub(crate) const NODE_TESTER_CLIENT_ID: &str = "_nym-node-tester-client";

clients/webassembly/src/gateway_selector.rs

@@ -1,45 +0,0 @@
-// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_client_core::config::GatewayEndpointConfig;
-use wasm_bindgen::prelude::*;
-
-#[wasm_bindgen]
-pub async fn get_gateway(api_server: String, preferred: Option<String>) -> GatewayEndpointConfig {
-    let validator_client =
-        nym_validator_client::client::NymApiClient::new(api_server.parse().unwrap());
-
-    let gateways = match validator_client.get_cached_gateways().await {
-        Err(err) => panic!("failed to obtain list of all gateways - {err}"),
-        Ok(gateways) => gateways,
-    };
-
-    if let Some(preferred) = preferred {
-        if let Some(details) = gateways
-            .iter()
-            .find(|g| g.gateway.identity_key == preferred)
-        {
-            return GatewayEndpointConfig {
-                gateway_id: details.gateway.identity_key.clone(),
-                gateway_owner: details.owner.to_string(),
-                gateway_listener: format!(
-                    "ws://{}:{}",
-                    details.gateway.host, details.gateway.clients_port
-                ),
-            };
-        }
-    }
-
-    let details = gateways
-        .first()
-        .expect("current topology holds no gateways");
-
-    GatewayEndpointConfig {
-        gateway_id: details.gateway.identity_key.clone(),
-        gateway_owner: details.owner.to_string(),
-        gateway_listener: format!(
-            "ws://{}:{}",
-            details.gateway.host, details.gateway.clients_port
-        ),
-    }
-}

clients/webassembly/src/lib.rs

@@ -1,38 +0,0 @@
-// Copyright 2021-2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use wasm_bindgen::prelude::*;
-
-#[cfg(target_arch = "wasm32")]
-mod client;
-#[cfg(target_arch = "wasm32")]
-pub mod encoded_payload_helper;
-#[cfg(target_arch = "wasm32")]
-pub mod error;
-#[cfg(target_arch = "wasm32")]
-pub mod gateway_selector;
-#[cfg(target_arch = "wasm32")]
-pub mod storage;
-#[cfg(target_arch = "wasm32")]
-pub mod tester;
-#[cfg(target_arch = "wasm32")]
-pub mod topology;
-#[cfg(target_arch = "wasm32")]
-pub mod validation;
-
-#[cfg(target_arch = "wasm32")]
-mod helpers;
-
-mod constants;
-
-#[wasm_bindgen]
-pub fn set_panic_hook() {
-    // When the `console_error_panic_hook` feature is enabled, we can call the
-    // `set_panic_hook` function at least once during initialization, and then
-    // we will get better error messages if our code ever panics.
-    //
-    // For more details see
-    // https://github.com/rustwasm/console_error_panic_hook#readme
-    #[cfg(feature = "console_error_panic_hook")]
-    console_error_panic_hook::set_once();
-}

clients/webassembly/src/storage/error.rs

@@ -1,28 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use thiserror::Error;
-use wasm_bindgen::JsValue;
-use wasm_utils::simple_js_error;
-use wasm_utils::storage::error::StorageError;
-
-#[derive(Debug, Error)]
-pub enum ClientStorageError {
-    #[error("failed to use the storage: {source}")]
-    StorageError {
-        #[from]
-        source: StorageError,
-    },
-
-    #[error("{typ} cryptographic key is not available in storage")]
-    CryptoKeyNotInStorage { typ: String },
-
-    #[error("the prior gateway details are not available in the storage")]
-    GatewayDetailsNotInStorage,
-}
-
-impl From<ClientStorageError> for JsValue {
-    fn from(value: ClientStorageError) -> Self {
-        simple_js_error(value.to_string())
-    }
-}

clients/webassembly/src/storage/mod.rs

@@ -1,294 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use crate::client::config::Config;
-use crate::storage::error::ClientStorageError;
-use js_sys::Promise;
-use nym_client_core::client::base_client::storage::gateway_details::PersistedGatewayDetails;
-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};
-use wasm_utils::PromisableResult;
-use zeroize::Zeroizing;
-
-pub(crate) mod error;
-pub(crate) mod traits;
-
-const STORAGE_NAME_PREFIX: &str = "wasm-client-storage";
-const STORAGE_VERSION: u32 = 1;
-
-// v1 tables
-mod v1 {
-    // stores
-    pub const KEYS_STORE: &str = "keys";
-    pub const CORE_STORE: &str = "core";
-
-    // keys
-    pub const CONFIG: &str = "config";
-    pub const GATEWAY_DETAILS: &str = "gateway_details";
-
-    pub const ED25519_IDENTITY_KEYPAIR: &str = "ed25519_identity_keypair";
-    pub const X25519_ENCRYPTION_KEYPAIR: &str = "x25519_encryption_keypair";
-
-    // TODO: for those we could actually use the subtle crypto storage
-    pub const AES128CTR_ACK_KEY: &str = "aes128ctr_ack_key";
-    pub const AES128CTR_BLAKE3_HMAC_GATEWAY_KEYS: &str = "aes128ctr_blake3_hmac_gateway_keys";
-}
-
-#[wasm_bindgen]
-pub struct ClientStorage {
-    #[allow(dead_code)]
-    pub(crate) name: String,
-    pub(crate) inner: Arc<WasmStorage>,
-}
-
-#[wasm_bindgen]
-impl ClientStorage {
-    fn db_name(client_id: &str) -> String {
-        format!("{STORAGE_NAME_PREFIX}-{client_id}")
-    }
-
-    pub(crate) async fn new_async(
-        client_id: &str,
-        passphrase: Option<String>,
-    ) -> Result<Self, ClientStorageError> {
-        let name = Self::db_name(client_id);
-
-        // make sure the password is zeroized when no longer used, especially if we error out.
-        // special care must be taken on JS side to ensure it's correctly used there.
-        let passphrase = Zeroizing::new(passphrase);
-
-        let migrate_fn = Some(|evt: &IdbVersionChangeEvent| -> Result<(), JsValue> {
-            // Even if the web-sys bindings expose the version as a f64, the IndexedDB API
-            // works with an unsigned integer.
-            // See <https://github.com/rustwasm/wasm-bindgen/issues/1149>
-            let old_version = evt.old_version() as u32;
-
-            if old_version < 1 {
-                // migrating to version 1
-                let db = evt.db();
-
-                db.create_object_store(v1::KEYS_STORE)?;
-                db.create_object_store(v1::CORE_STORE)?;
-            }
-
-            Ok(())
-        });
-
-        let inner = WasmStorage::new(
-            &name,
-            STORAGE_VERSION,
-            migrate_fn,
-            passphrase.as_ref().map(|p| p.as_bytes()),
-        )
-        .await?;
-
-        Ok(ClientStorage {
-            inner: Arc::new(inner),
-            name,
-        })
-    }
-
-    #[wasm_bindgen(constructor)]
-    #[allow(clippy::new_ret_no_self)]
-    pub fn new(client_id: String, passphrase: String) -> Promise {
-        future_to_promise(async move {
-            Self::new_async(&client_id, Some(passphrase))
-                .await
-                .into_promise_result()
-        })
-    }
-
-    pub fn new_unencrypted(client_id: String) -> Promise {
-        future_to_promise(async move {
-            Self::new_async(&client_id, None)
-                .await
-                .into_promise_result()
-        })
-    }
-
-    // TODO: persist client's config
-    #[allow(dead_code)]
-    pub(crate) async fn read_config(&self) -> Result<Option<Config>, ClientStorageError> {
-        self.inner
-            .read_value(v1::CORE_STORE, JsValue::from_str(v1::CONFIG))
-            .await
-            .map_err(Into::into)
-    }
-
-    pub(crate) async fn may_read_gateway_details(
-        &self,
-    ) -> Result<Option<PersistedGatewayDetails>, ClientStorageError> {
-        self.inner
-            .read_value(v1::CORE_STORE, JsValue::from_str(v1::GATEWAY_DETAILS))
-            .await
-            .map_err(Into::into)
-    }
-
-    pub(crate) async fn must_read_gateway_details(
-        &self,
-    ) -> Result<PersistedGatewayDetails, ClientStorageError> {
-        self.may_read_gateway_details()
-            .await?
-            .ok_or(ClientStorageError::GatewayDetailsNotInStorage)
-    }
-
-    async fn may_read_identity_keypair(
-        &self,
-    ) -> Result<Option<identity::KeyPair>, ClientStorageError> {
-        self.inner
-            .read_value(
-                v1::KEYS_STORE,
-                JsValue::from_str(v1::ED25519_IDENTITY_KEYPAIR),
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn may_read_encryption_keypair(
-        &self,
-    ) -> Result<Option<encryption::KeyPair>, ClientStorageError> {
-        self.inner
-            .read_value(
-                v1::KEYS_STORE,
-                JsValue::from_str(v1::X25519_ENCRYPTION_KEYPAIR),
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn may_read_ack_key(&self) -> Result<Option<AckKey>, ClientStorageError> {
-        self.inner
-            .read_value(v1::KEYS_STORE, JsValue::from_str(v1::AES128CTR_ACK_KEY))
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn may_read_gateway_shared_key(&self) -> Result<Option<SharedKeys>, ClientStorageError> {
-        self.inner
-            .read_value(
-                v1::KEYS_STORE,
-                JsValue::from_str(v1::AES128CTR_BLAKE3_HMAC_GATEWAY_KEYS),
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn must_read_identity_keypair(&self) -> Result<identity::KeyPair, ClientStorageError> {
-        self.may_read_identity_keypair()
-            .await?
-            .ok_or(ClientStorageError::CryptoKeyNotInStorage {
-                typ: v1::ED25519_IDENTITY_KEYPAIR.to_string(),
-            })
-    }
-
-    async fn must_read_encryption_keypair(
-        &self,
-    ) -> Result<encryption::KeyPair, ClientStorageError> {
-        self.may_read_encryption_keypair()
-            .await?
-            .ok_or(ClientStorageError::CryptoKeyNotInStorage {
-                typ: v1::X25519_ENCRYPTION_KEYPAIR.to_string(),
-            })
-    }
-
-    async fn must_read_ack_key(&self) -> Result<AckKey, ClientStorageError> {
-        self.may_read_ack_key()
-            .await?
-            .ok_or(ClientStorageError::CryptoKeyNotInStorage {
-                typ: v1::AES128CTR_ACK_KEY.to_string(),
-            })
-    }
-
-    async fn must_read_gateway_shared_key(&self) -> Result<SharedKeys, ClientStorageError> {
-        self.may_read_gateway_shared_key()
-            .await?
-            .ok_or(ClientStorageError::CryptoKeyNotInStorage {
-                typ: v1::AES128CTR_BLAKE3_HMAC_GATEWAY_KEYS.to_string(),
-            })
-    }
-
-    async fn store_identity_keypair(
-        &self,
-        keypair: &identity::KeyPair,
-    ) -> Result<(), ClientStorageError> {
-        self.inner
-            .store_value(
-                v1::KEYS_STORE,
-                JsValue::from_str(v1::ED25519_IDENTITY_KEYPAIR),
-                keypair,
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn store_encryption_keypair(
-        &self,
-        keypair: &encryption::KeyPair,
-    ) -> Result<(), ClientStorageError> {
-        self.inner
-            .store_value(
-                v1::KEYS_STORE,
-                JsValue::from_str(v1::X25519_ENCRYPTION_KEYPAIR),
-                keypair,
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn store_ack_key(&self, key: &AckKey) -> Result<(), ClientStorageError> {
-        self.inner
-            .store_value(
-                v1::KEYS_STORE,
-                JsValue::from_str(v1::AES128CTR_ACK_KEY),
-                key,
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    async fn store_gateway_shared_key(&self, key: &SharedKeys) -> Result<(), ClientStorageError> {
-        self.inner
-            .store_value(
-                v1::KEYS_STORE,
-                JsValue::from_str(v1::AES128CTR_BLAKE3_HMAC_GATEWAY_KEYS),
-                key,
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    pub(crate) async fn store_gateway_details(
-        &self,
-        gateway_endpoint: &PersistedGatewayDetails,
-    ) -> Result<(), ClientStorageError> {
-        self.inner
-            .store_value(
-                v1::CORE_STORE,
-                JsValue::from_str(v1::GATEWAY_DETAILS),
-                gateway_endpoint,
-            )
-            .await
-            .map_err(Into::into)
-    }
-
-    // TODO: persist client's config
-    #[allow(dead_code)]
-    pub(crate) async fn store_config(&self, config: &Config) -> Result<(), ClientStorageError> {
-        self.inner
-            .store_value(v1::CORE_STORE, JsValue::from_str(v1::CONFIG), config)
-            .await
-            .map_err(Into::into)
-    }
-
-    pub(crate) async fn has_full_gateway_info(&self) -> Result<bool, ClientStorageError> {
-        let has_keys = self.may_read_gateway_shared_key().await?.is_some();
-        let has_details = self.may_read_gateway_details().await?.is_some();
-
-        Ok(has_keys && has_details)
-    }
-}

clients/webassembly/src/topology.rs

@@ -1,267 +0,0 @@
-// Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
-// SPDX-License-Identifier: Apache-2.0
-
-use nym_client_core::config::GatewayEndpointConfig;
-use nym_crypto::asymmetric::{encryption, identity};
-use nym_topology::gateway::GatewayConversionError;
-use nym_topology::mix::{Layer, MixnodeConversionError};
-use nym_topology::{gateway, mix, MixLayer, NymTopology};
-use nym_validator_client::client::{IdentityKeyRef, MixId};
-use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-use thiserror::Error;
-use wasm_bindgen::prelude::wasm_bindgen;
-use wasm_bindgen::JsValue;
-use wasm_utils::{console_log, simple_js_error};
-
-#[derive(Debug, Error)]
-pub enum WasmTopologyError {
-    #[error("got invalid mix layer {value}. Expected 1, 2 or 3.")]
-    InvalidMixLayer { value: u8 },
-
-    #[error(transparent)]
-    GatewayConversion(#[from] GatewayConversionError),
-
-    #[error(transparent)]
-    MixnodeConversion(#[from] MixnodeConversionError),
-
-    #[error("The provided mixnode map was malformed: {source}")]
-    MalformedMixnodeMap { source: serde_wasm_bindgen::Error },
-
-    #[error("The provided gateway list was malformed: {source}")]
-    MalformedGatewayList { source: serde_wasm_bindgen::Error },
-}
-
-impl From<WasmTopologyError> for JsValue {
-    fn from(value: WasmTopologyError) -> Self {
-        simple_js_error(value.to_string())
-    }
-}
-
-#[wasm_bindgen]
-#[derive(Debug)]
-pub struct WasmNymTopology {
-    inner: NymTopology,
-}
-
-#[wasm_bindgen]
-impl WasmNymTopology {
-    #[wasm_bindgen(constructor)]
-    pub fn new(
-        // expected: BTreeMap<MixLayer, Vec<WasmMixNode>>,
-        // HashMap<MixLayer, Vec<WasmMixNode>> will also work because it has the same json representation
-        mixnodes: JsValue,
-        // expected: Vec<WasmGateway>
-        gateways: JsValue,
-    ) -> Result<WasmNymTopology, WasmTopologyError> {
-        let mixnodes: BTreeMap<MixLayer, Vec<WasmMixNode>> =
-            serde_wasm_bindgen::from_value(mixnodes)
-                .map_err(|source| WasmTopologyError::MalformedMixnodeMap { source })?;
-
-        let gateways: Vec<WasmGateway> = serde_wasm_bindgen::from_value(gateways)
-            .map_err(|source| WasmTopologyError::MalformedGatewayList { source })?;
-
-        let mut converted_mixes = BTreeMap::new();
-
-        for (layer, nodes) in mixnodes {
-            let layer_nodes = nodes
-                .into_iter()
-                .map(TryInto::try_into)
-                .collect::<Result<_, _>>()?;
-
-            converted_mixes.insert(layer, layer_nodes);
-        }
-
-        let gateways = gateways
-            .into_iter()
-            .map(TryInto::try_into)
-            .collect::<Result<_, _>>()?;
-
-        Ok(WasmNymTopology {
-            inner: NymTopology::new(converted_mixes, gateways),
-        })
-    }
-
-    #[allow(dead_code)]
-    pub(crate) fn ensure_contains(&self, gateway_config: &GatewayEndpointConfig) -> bool {
-        self.ensure_contains_gateway_id(&gateway_config.gateway_id)
-    }
-
-    pub(crate) fn ensure_contains_gateway_id(&self, gateway_id: IdentityKeyRef) -> bool {
-        self.inner
-            .gateways()
-            .iter()
-            .any(|g| g.identity_key.to_base58_string() == gateway_id)
-    }
-
-    pub fn print(&self) {
-        if !self.inner.mixes().is_empty() {
-            console_log!("mixnodes:");
-            for (layer, nodes) in self.inner.mixes() {
-                console_log!("\tlayer {layer}:");
-                for node in nodes {
-                    console_log!("\t\t{} - {}", node.mix_id, node.identity_key)
-                }
-            }
-        } else {
-            console_log!("NO MIXNODES")
-        }
-
-        if !self.inner.gateways().is_empty() {
-            console_log!("gateways:");
-            for gateway in self.inner.gateways() {
-                console_log!("\t{}", gateway.identity_key)
-            }
-        } else {
-            console_log!("NO GATEWAYS")
-        }
-    }
-}
-
-impl From<WasmNymTopology> for NymTopology {
-    fn from(value: WasmNymTopology) -> Self {
-        value.inner
-    }
-}
-
-impl From<NymTopology> for WasmNymTopology {
-    fn from(value: NymTopology) -> Self {
-        WasmNymTopology { inner: value }
-    }
-}
-
-#[wasm_bindgen]
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct WasmMixNode {
-    pub mix_id: MixId,
-    #[wasm_bindgen(getter_with_clone)]
-    pub owner: String,
-    #[wasm_bindgen(getter_with_clone)]
-    pub host: String,
-    pub mix_port: u16,
-    #[wasm_bindgen(getter_with_clone)]
-    pub identity_key: String,
-    #[wasm_bindgen(getter_with_clone)]
-    pub sphinx_key: String,
-    pub layer: MixLayer,
-    #[wasm_bindgen(getter_with_clone)]
-    pub version: String,
-}
-
-#[wasm_bindgen]
-impl WasmMixNode {
-    #[wasm_bindgen(constructor)]
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        mix_id: MixId,
-        owner: String,
-        host: String,
-        mix_port: u16,
-        identity_key: String,
-        sphinx_key: String,
-        layer: MixLayer,
-        version: String,
-    ) -> Self {
-        Self {
-            mix_id,
-            owner,
-            host,
-            mix_port,
-            identity_key,
-            sphinx_key,
-            layer,
-            version,
-        }
-    }
-}
-
-impl TryFrom<WasmMixNode> for mix::Node {
-    type Error = WasmTopologyError;
-
-    fn try_from(value: WasmMixNode) -> Result<Self, Self::Error> {
-        let host = mix::Node::parse_host(&value.host)?;
-
-        // try to completely resolve the host in the mix situation to avoid doing it every
-        // single time we want to construct a path
-        let mix_host = mix::Node::extract_mix_host(&host, value.mix_port)?;
-
-        Ok(mix::Node {
-            mix_id: value.mix_id,
-            owner: value.owner,
-            host,
-            mix_host,
-            identity_key: identity::PublicKey::from_base58_string(&value.identity_key)
-                .map_err(MixnodeConversionError::from)?,
-            sphinx_key: encryption::PublicKey::from_base58_string(&value.sphinx_key)
-                .map_err(MixnodeConversionError::from)?,
-            layer: Layer::try_from(value.layer)
-                .map_err(|_| WasmTopologyError::InvalidMixLayer { value: value.layer })?,
-            version: value.version,
-        })
-    }
-}
-
-#[wasm_bindgen]
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct WasmGateway {
-    #[wasm_bindgen(getter_with_clone)]
-    pub owner: String,
-    #[wasm_bindgen(getter_with_clone)]
-    pub host: String,
-    pub mix_port: u16,
-    pub clients_port: u16,
-    #[wasm_bindgen(getter_with_clone)]
-    pub identity_key: String,
-    #[wasm_bindgen(getter_with_clone)]
-    pub sphinx_key: String,
-    #[wasm_bindgen(getter_with_clone)]
-    pub version: String,
-}
-
-#[wasm_bindgen]
-impl WasmGateway {
-    #[wasm_bindgen(constructor)]
-    pub fn new(
-        owner: String,
-        host: String,
-        mix_port: u16,
-        clients_port: u16,
-        identity_key: String,
-        sphinx_key: String,
-        version: String,
-    ) -> Self {
-        Self {
-            owner,
-            host,
-            mix_port,
-            clients_port,
-            identity_key,
-            sphinx_key,
-            version,
-        }
-    }
-}
-
-impl TryFrom<WasmGateway> for gateway::Node {
-    type Error = WasmTopologyError;
-
-    fn try_from(value: WasmGateway) -> Result<Self, Self::Error> {
-        let host = gateway::Node::parse_host(&value.host)?;
-
-        // try to completely resolve the host in the mix situation to avoid doing it every
-        // single time we want to construct a path
-        let mix_host = gateway::Node::extract_mix_host(&host, value.mix_port)?;
-
-        Ok(gateway::Node {
-            owner: value.owner,
-            host,
-            mix_host,
-            clients_port: value.clients_port,
-            identity_key: identity::PublicKey::from_base58_string(&value.identity_key)
-                .map_err(GatewayConversionError::from)?,
-            sphinx_key: encryption::PublicKey::from_base58_string(&value.sphinx_key)
-                .map_err(GatewayConversionError::from)?,
-            version: value.version,
-        })
-    }
-}

clients/webassembly/src/validation.rs

@@ -1,35 +0,0 @@
-use nym_sphinx::addressing::clients::Recipient;
-use wasm_bindgen::prelude::*;
-
-#[wasm_bindgen]
-pub fn validate_recipient(recipient: String) -> Result<(), JsError> {
-    match Recipient::try_from_base58_string(recipient) {
-        Ok(_) => Ok(()),
-        Err(e) => Err(JsError::new(format!("{}", e).as_str())),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::validate_recipient;
-    use wasm_bindgen_test::*;
-
-    #[wasm_bindgen_test]
-    fn test_recipient_validation_ok() {
-        let res = validate_recipient("DyQmXnst5NGGjzUZxRC5Bjs5bd7CBF3xMpsSmbRiizr2.GH6YTBP2NXU3AVqd8WjiTMVyeMjunXMEsp7gVCMEJqpD@336yuXAeGEgedRfqTJZsG2YV7P13QH1bHv1SjCZYarc9".to_string());
-        assert!(res.is_ok())
-    }
-
-    #[wasm_bindgen_test]
-    fn test_recipient_validation_fails() {
-        assert!(validate_recipient("  DyQmXnst5NGGjzUZxRC5Bjs5bd7CBF3xMpsSmbRiizr2.GH6YTBP2NXU3AVqd8WjiTMVyeMjunXMEsp7gVCMEJqpD@336yuXAeGEgedRfqTJZsG2YV7P13QH1bHv1SjCZYarc9".to_string()).is_err());
-        assert!(validate_recipient(
-            "DyQmXnst5NGGjzUZxRC5BjbRiizr2.GH6YTBP2NXU3AVqd8WD@336yuXAeGEgedRfqTJZQH1bHv1SjCZYarc9"
-                .to_string()
-        )
-        .is_err());
-        assert!(validate_recipient("🙀🙀🙀🙀".to_string()).is_err());
-        assert!(validate_recipient("".to_string()).is_err());
-        assert!(validate_recipient(" ".to_string()).is_err());
-    }
-}

clients/webassembly/tests/web.rs

@@ -1,13 +0,0 @@
-//! Test suite for the Web and headless browsers.
-
-#![cfg(target_arch = "wasm32")]
-
-extern crate wasm_bindgen_test;
-use wasm_bindgen_test::*;
-
-wasm_bindgen_test_configure!(run_in_browser);
-
-#[wasm_bindgen_test]
-fn pass() {
-    assert_eq!(1 + 1, 2);
-}

common/client-core/Cargo.toml

@@ -10,6 +10,7 @@ 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 }
@@ -21,18 +22,18 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = "0.10.6"
 tap = "1.0.1"
-thiserror = "1.0.34"
-time = "0.3.17"
-tokio = { version = "1.24.1", features = ["macros"]}
-tungstenite = { version = "0.13.0", default-features = false }
+thiserror = { workspace = true }
 url = { workspace = true, features = ["serde"] }
+tungstenite = { version = "0.13.0", default-features = false }
+tokio = { workspace = true, features = ["macros"]}
+time = "0.3.17"
 zeroize = { workspace = true }
 
 # internal
 nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
 nym-crypto = { path = "../crypto" }
-nym-explorer-api-requests = { path = "../../explorer-api/explorer-api-requests" }
+nym-explorer-client = { path = "../../explorer-api/explorer-client" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 #gateway-client = { path = "../../common/client-libs/gateway-client", default-features = false, features = ["wasm", "coconut"] }
 nym-gateway-requests = { path = "../../gateway/gateway-requests" }
@@ -50,7 +51,7 @@ version = "0.1.11"
 features = ["time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-version = "1.24.1"
+workspace = true
 features = ["time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-tungstenite]
@@ -62,10 +63,10 @@ features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"]
 optional = true
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
-version = "0.4"
+workspace = true
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
-version = "0.2.83"
+workspace = true
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasmtimer]
 workspace = true
@@ -76,7 +77,7 @@ version = "0.2.4"
 features = ["futures"]
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
-path = "../wasm-utils"
+path = "../wasm/utils"
 features = ["websocket"]
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.time]
@@ -87,7 +88,7 @@ features = ["wasm-bindgen"]
 tempfile = "3.1.0"
 
 [build-dependencies]
-tokio = { version = "1.24.1", features = ["rt-multi-thread", "macros"] }
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 sqlx = { version = "0.6.2", features = ["runtime-tokio-rustls", "sqlite", "macros", "migrate"] }
 
 [features]

common/client-core/src/client/base_client/mod.rs

@@ -46,7 +46,6 @@ use nym_task::{TaskClient, TaskManager};
 use nym_topology::provider_trait::TopologyProvider;
 use nym_validator_client::nyxd::contract_traits::DkgQueryClient;
 use std::sync::Arc;
-use tap::TapFallible;
 use url::Url;
 
 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]
@@ -329,13 +328,18 @@ where
                 )
             };
 
+        let gateway_id = gateway_client.gateway_identity();
         gateway_client.set_disabled_credentials_mode(config.client.disabled_credentials_mode);
 
         let shared_key = gateway_client
             .authenticate_and_start()
             .await
-            .tap_err(|err| {
-                log::error!("Could not authenticate and start up the gateway connection - {err}")
+            .map_err(|err| {
+                log::error!("Could not authenticate and start up the gateway connection - {err}");
+                ClientCoreError::GatewayClientError {
+                    gateway_id: gateway_id.to_base58_string(),
+                    source: err,
+                }
             })?;
 
         managed_keys.ensure_gateway_key(shared_key);
@@ -354,11 +358,13 @@ where
                 nym_api_urls,
                 env!("CARGO_PKG_VERSION").to_string(),
             )),
-            config::TopologyStructure::GeoAware(group) => Box::new(GeoAwareTopologyProvider::new(
-                nym_api_urls,
-                env!("CARGO_PKG_VERSION").to_string(),
-                group,
-            )),
+            config::TopologyStructure::GeoAware(group_by) => {
+                Box::new(GeoAwareTopologyProvider::new(
+                    nym_api_urls,
+                    env!("CARGO_PKG_VERSION").to_string(),
+                    group_by,
+                ))
+            }
         })
     }
 

common/client-core/src/client/replies/reply_storage/backend/mod.rs

@@ -6,7 +6,7 @@ use async_trait::async_trait;
 use std::error::Error;
 use thiserror::Error;
 
-#[cfg(target_arch = "wasm32")]
+// TODO: this should now live inside our wasm/client-core
 pub mod browser_backend;
 
 #[cfg(all(not(target_arch = "wasm32"), feature = "fs-surb-storage"))]

common/client-core/src/client/topology_control/geo_aware_provider.rs

@@ -1,7 +1,8 @@
 use std::{collections::HashMap, fmt};
 
 use log::{debug, error, info};
-use nym_explorer_api_requests::PrettyDetailedMixNodeBond;
+use nym_explorer_client::{ExplorerClient, PrettyDetailedMixNodeBond};
+use nym_network_defaults::var_names::EXPLORER_API;
 use nym_topology::{
     nym_topology_from_detailed,
     provider_trait::{async_trait, TopologyProvider},
@@ -10,19 +11,31 @@ use nym_topology::{
 use nym_validator_client::client::MixId;
 use rand::{prelude::SliceRandom, thread_rng};
 use serde::{Deserialize, Serialize};
+use tap::TapOptional;
 use url::Url;
 
-const MIN_NODES_PER_LAYER: usize = 1;
-const EXPLORER_API_MIXNODES_URL: &str = "https://explorer.nymtech.net/api/v1/mix-nodes";
+use crate::config::GroupBy;
 
-// TODO: create a explorer-api-client
-async fn fetch_mixnodes_from_explorer_api() -> Option<Vec<PrettyDetailedMixNodeBond>> {
-    reqwest::get(EXPLORER_API_MIXNODES_URL)
-        .await
-        .ok()?
-        .json::<Vec<PrettyDetailedMixNodeBond>>()
-        .await
-        .ok()
+const MIN_NODES_PER_LAYER: usize = 1;
+
+fn create_explorer_client() -> Option<ExplorerClient> {
+    let Ok(explorer_api_url) = std::env::var(EXPLORER_API) else {
+        error!("Missing EXPLORER_API");
+        return None;
+    };
+
+    let Ok(explorer_api_url) = explorer_api_url.parse() else {
+        error!("Failed to parse EXPLORER_API");
+        return None;
+    };
+
+    log::debug!("Using explorer-api url: {}", explorer_api_url);
+    let Ok(client) = nym_explorer_client::ExplorerClient::new(explorer_api_url) else {
+        error!("Failed to create explorer-api client");
+        return None;
+    };
+
+    Some(client)
 }
 
 #[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
@@ -39,6 +52,8 @@ pub enum CountryGroup {
 impl CountryGroup {
     // We map contry codes into group, which initially are continent codes to a first approximation,
     // but we do it manually to reserve the right to tweak this distribution for our purposes.
+    // NOTE: I did this quickly and it's not a complete list of all countries, but only those that
+    // were present in the network at the time. Please add more as needed.
     fn new(country_code: &str) -> Self {
         let country_code = country_code.to_uppercase();
         use CountryGroup::*;
@@ -222,7 +237,7 @@ fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {
 
 pub struct GeoAwareTopologyProvider {
     validator_client: nym_validator_client::client::NymApiClient,
-    filter_on: CountryGroup,
+    filter_on: GroupBy,
     client_version: String,
 }
 
@@ -230,10 +245,10 @@ impl GeoAwareTopologyProvider {
     pub fn new(
         mut nym_api_urls: Vec<Url>,
         client_version: String,
-        filter_on: CountryGroup,
+        filter_on: GroupBy,
     ) -> GeoAwareTopologyProvider {
         log::info!(
-            "Creating geo-aware topology provider with filter on {:?}",
+            "Creating geo-aware topology provider with filter on {}",
             filter_on
         );
         nym_api_urls.shuffle(&mut thread_rng());
@@ -267,11 +282,44 @@ impl GeoAwareTopologyProvider {
         // Also fetch mixnodes cached by explorer-api, with the purpose of getting their
         // geolocation.
         debug!("Fetching mixnodes from explorer-api...");
-        let Some(mixnodes_from_explorer_api) = fetch_mixnodes_from_explorer_api().await else {
+        let explorer_client = create_explorer_client()?;
+        let Ok(mixnodes_from_explorer_api) = explorer_client.get_mixnodes().await else {
             error!("failed to get mixnodes from explorer-api");
             return None;
         };
 
+        debug!("Fetching gateways from explorer-api...");
+        let Ok(gateways_from_explorer_api) = explorer_client.get_gateways().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.
@@ -280,8 +328,8 @@ impl GeoAwareTopologyProvider {
         let mixnode_distribution = group_mixnodes_by_country_code(mixnodes_from_explorer_api);
         log_mixnode_distribution(&mixnode_distribution);
 
-        let Some(filtered_mixnode_ids) = mixnode_distribution.get(&self.filter_on) else {
-            error!("no mixnodes found for: {}", self.filter_on);
+        let Some(filtered_mixnode_ids) = mixnode_distribution.get(&filter_on) else {
+            error!("no mixnodes found for: {}", filter_on);
             return None;
         };
 

common/client-core/src/config/disk_persistence/old_v1_1_20_2.rs

@@ -3,6 +3,7 @@
 
 use crate::config::disk_persistence::keys_paths::ClientKeysPaths;
 use crate::config::disk_persistence::{CommonClientPaths, DEFAULT_GATEWAY_DETAILS_FILENAME};
+use crate::error::ClientCoreError;
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 
@@ -15,16 +16,17 @@ pub struct CommonClientPathsV1_1_20_2 {
 }
 
 impl CommonClientPathsV1_1_20_2 {
-    pub fn upgrade_default(self) -> CommonClientPaths {
-        let data_dir = self
-            .reply_surb_database
-            .parent()
-            .expect("client paths upgrade failure");
-        CommonClientPaths {
+    pub fn upgrade_default(self) -> Result<CommonClientPaths, ClientCoreError> {
+        let data_dir = self.reply_surb_database.parent().ok_or_else(|| {
+            ClientCoreError::UnableToUpgradeConfigFile {
+                new_version: "1.1.20-2".to_string(),
+            }
+        })?;
+        Ok(CommonClientPaths {
             keys: self.keys,
             gateway_details: data_dir.join(DEFAULT_GATEWAY_DETAILS_FILENAME),
             credentials_database: self.credentials_database,
             reply_surb_database: self.reply_surb_database,
-        }
+        })
     }
 }

common/client-core/src/config/mod.rs

@@ -3,7 +3,10 @@
 
 use nym_config::defaults::NymNetworkDetails;
 use nym_crypto::asymmetric::identity;
-use nym_sphinx::params::{PacketSize, PacketType};
+use nym_sphinx::{
+    addressing::clients::Recipient,
+    params::{PacketSize, PacketType},
+};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use url::Url;
@@ -66,7 +69,11 @@ pub struct Config {
 }
 
 impl Config {
-    pub fn new<S: Into<String>>(id: S, version: S) -> Self {
+    pub fn new<S1, S2>(id: S1, version: S2) -> Self
+    where
+        S1: Into<String>,
+        S2: Into<String>,
+    {
         Config {
             client: Client::new_default(id, version),
             debug: Default::default(),
@@ -284,7 +291,11 @@ pub struct Client {
 }
 
 impl Client {
-    pub fn new_default<S: Into<String>>(id: S, version: S) -> Self {
+    pub fn new_default<S1, S2>(id: S1, version: S2) -> Self
+    where
+        S1: Into<String>,
+        S2: Into<String>,
+    {
         let network = NymNetworkDetails::new_mainnet();
         let nyxd_urls = network
             .endpoints
@@ -480,11 +491,28 @@ 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(CountryGroup),
+    GeoAware(GroupBy),
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum GroupBy {
+    CountryGroup(CountryGroup),
+    NymAddress(Recipient),
+}
+
+impl std::fmt::Display for GroupBy {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GroupBy::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupBy::NymAddress(address) => write!(f, "address: {}", address),
+        }
+    }
 }
 
 impl Default for Topology {

common/client-core/src/error.rs

@@ -13,8 +13,11 @@ pub enum ClientCoreError {
     #[error("I/O error: {0}")]
     IoError(#[from] std::io::Error),
 
-    #[error("Gateway client error: {0}")]
-    GatewayClientError(#[from] GatewayClientError),
+    #[error("Gateway client error ({gateway_id}): {source}")]
+    GatewayClientError {
+        gateway_id: String,
+        source: GatewayClientError,
+    },
 
     #[error("Ed25519 error: {0}")]
     Ed25519RecoveryError(#[from] Ed25519RecoveryError),
@@ -116,6 +119,9 @@ pub enum ClientCoreError {
 
     #[error("the provided gateway details (for gateway {gateway_id}) do not correspond to the shared keys")]
     MismatchedGatewayDetails { gateway_id: String },
+
+    #[error("unable to upgrade config file to `{new_version}`")]
+    UnableToUpgradeConfigFile { new_version: String },
 }
 
 /// Set of messages that the client can send to listeners via the task manager

common/client-core/src/init/helpers.rs

@@ -11,7 +11,6 @@ use nym_gateway_client::GatewayClient;
 use nym_topology::{filter::VersionFilterable, gateway};
 use rand::{seq::SliceRandom, Rng};
 use std::{sync::Arc, time::Duration};
-use tap::TapFallible;
 use tungstenite::Message;
 use url::Url;
 
@@ -149,7 +148,7 @@ async fn measure_latency(gateway: &gateway::Node) -> Result<GatewayWithLatency,
     Ok(GatewayWithLatency::new(gateway, avg))
 }
 
-pub(super) async fn choose_gateway_by_latency<R: Rng>(
+pub async fn choose_gateway_by_latency<R: Rng>(
     rng: &mut R,
     gateways: &[gateway::Node],
 ) -> Result<gateway::Node, ClientCoreError> {
@@ -209,14 +208,26 @@ pub(super) async fn register_with_gateway(
         our_identity.clone(),
         timeout,
     );
-    gateway_client
-        .establish_connection()
-        .await
-        .tap_err(|_| log::warn!("Failed to establish connection with gateway!"))?;
+    gateway_client.establish_connection().await.map_err(|err| {
+        log::warn!("Failed to establish connection with gateway!");
+        ClientCoreError::GatewayClientError {
+            gateway_id: gateway.gateway_id.clone(),
+            source: err,
+        }
+    })?;
     let shared_keys = gateway_client
         .perform_initial_authentication()
         .await
-        .tap_err(|_| log::warn!("Failed to register with the gateway!"))?;
+        .map_err(|err| {
+            log::warn!(
+                "Failed to register with the gateway {}!",
+                gateway.gateway_id
+            );
+            ClientCoreError::GatewayClientError {
+                gateway_id: gateway.gateway_id.clone(),
+                source: err,
+            }
+        })?;
     Ok(RegistrationResult {
         shared_keys,
         authenticated_ephemeral_client: Some(gateway_client),

common/client-core/src/init/mod.rs

@@ -106,14 +106,17 @@ pub enum GatewaySetup {
         /// Should the new gateway be selected based on latency.
         by_latency: bool,
     },
+
     Specified {
         /// Identity key of the gateway we want to try to use.
         gateway_identity: IdentityKey,
     },
+
     Predefined {
         /// Full gateway configuration
         details: PersistedGatewayDetails,
     },
+
     ReuseConnection {
         /// The authenticated ephemeral client that was created during `init`
         authenticated_ephemeral_client: GatewayClient<InitOnly>,

common/client-libs/gateway-client/Cargo.toml

@@ -36,7 +36,7 @@ default-features = false
 
 # non-wasm-only dependencies
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio]
-version = "1.24.1"
+workspace = true
 features = ["macros", "rt", "net", "sync", "time"]
 
 [target."cfg(not(target_arch = \"wasm32\"))".dependencies.tokio-stream]
@@ -48,15 +48,18 @@ version = "0.14"
 
 # wasm-only dependencies
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen]
-version = "0.2"
+workspace = true
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-bindgen-futures]
-version = "0.4"
+workspace = true
 
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasm-utils]
-path = "../../wasm-utils"
+path = "../../wasm/utils"
 features = ["websocket"]
 
+[target."cfg(target_arch = \"wasm32\")".dependencies.gloo-utils]
+workspace = true
+
 # only import it in wasm. Prefer proper tokio timer in non-wasm
 [target."cfg(target_arch = \"wasm32\")".dependencies.wasmtimer]
 workspace = true
@@ -68,7 +71,7 @@ features = ["tokio"]
 # containing javascript (such as a web browser or node.js).
 # refer to https://docs.rs/getrandom/0.2.2/getrandom/#webassembly-support for more information
 [target."cfg(target_arch = \"wasm32\")".dependencies.getrandom]
-version = "0.2"
+workspace = true
 features = ["js"]
 
 [dev-dependencies]

common/client-libs/gateway-client/src/client.rs

@@ -141,8 +141,8 @@ impl<C, St> GatewayClient<C, St> {
     #[cfg(target_arch = "wasm32")]
     async fn _close_connection(&mut self) -> Result<(), GatewayClientError> {
         match std::mem::replace(&mut self.connection, SocketState::NotConnected) {
-            SocketState::Available(mut socket) => {
-                (*socket).close(None).await;
+            SocketState::Available(socket) => {
+                (*socket).close(None, None).await?;
                 Ok(())
             }
             SocketState::PartiallyDelegated(_) => {
@@ -175,7 +175,9 @@ impl<C, St> GatewayClient<C, St> {
     pub async fn establish_connection(&mut self) -> Result<(), GatewayClientError> {
         let ws_stream = match JSWebsocket::new(&self.gateway_address) {
             Ok(ws_stream) => ws_stream,
-            Err(e) => return Err(GatewayClientError::NetworkErrorWasm(e)),
+            Err(e) => {
+                return Err(GatewayClientError::NetworkErrorWasm(e));
+            }
         };
 
         self.connection = SocketState::Available(Box::new(ws_stream));

common/client-libs/gateway-client/src/error.rs

@@ -1,12 +1,12 @@
 // Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
+#[cfg(target_arch = "wasm32")]
+use gloo_utils::errors::JsError;
 use nym_gateway_requests::registration::handshake::error::HandshakeError;
 use std::io;
 use thiserror::Error;
 use tungstenite::Error as WsError;
-#[cfg(target_arch = "wasm32")]
-use wasm_bindgen::JsValue;
 
 #[derive(Debug, Error)]
 pub enum GatewayClientError {
@@ -19,10 +19,9 @@ pub enum GatewayClientError {
     #[error("There was a network error - {0}")]
     NetworkError(#[from] WsError),
 
-    // TODO: see if `JsValue` is a reasonable type for this
     #[cfg(target_arch = "wasm32")]
     #[error("There was a network error")]
-    NetworkErrorWasm(JsValue),
+    NetworkErrorWasm(#[from] JsError),
 
     #[error("Invalid URL - {0}")]
     InvalidURL(String),

common/client-libs/validator-client/Cargo.toml

@@ -65,7 +65,7 @@ features = ["tokio"]
 [dev-dependencies]
 bip39 = { workspace = true }
 cosmrs = { workspace = true, features = ["bip32"] }
-ts-rs = "6.1.2"
+ts-rs = { workspace = true }
 
 [[example]]
 name = "offline_signing"

common/client-libs/validator-client/examples/offline_signing.rs

@@ -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 = HttpClient::new(validator).unwrap();
+    let broadcaster = http_client(validator).unwrap();
 
     // get signer information
     let sequence_response = broadcaster.get_sequence(&signer_address).await.unwrap();

common/client-libs/validator-client/examples/query_name_service.rs

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

common/client-libs/validator-client/examples/query_service_provider_directory.rs

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

common/client-libs/validator-client/src/client.rs

@@ -26,6 +26,8 @@ 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};
 
@@ -95,7 +97,7 @@ impl Client<HttpRpcClient, DirectSecp256k1HdWallet> {
         config: Config,
         mnemonic: bip39::Mnemonic,
     ) -> Result<DirectSigningHttpRpcValidatorClient, ValidatorClientError> {
-        let rpc_client = HttpRpcClient::new(config.nyxd_url.as_str())?;
+        let rpc_client = http_client(config.nyxd_url.as_str())?;
         let prefix = &config.nyxd_config.chain_details.bech32_account_prefix;
         let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
 
@@ -126,7 +128,7 @@ impl Client<ReqwestRpcClient, DirectSecp256k1HdWallet> {
 #[cfg(feature = "http-client")]
 impl Client<HttpRpcClient> {
     pub fn new_query(config: Config) -> Result<QueryHttpRpcValidatorClient, ValidatorClientError> {
-        let rpc_client = HttpRpcClient::new(config.nyxd_url.as_str())?;
+        let rpc_client = http_client(config.nyxd_url.as_str())?;
         Ok(Self::new_with_rpc_client(config, rpc_client))
     }
 
@@ -170,6 +172,10 @@ 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)
     }
@@ -240,6 +246,10 @@ 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);
     }

common/client-libs/validator-client/src/lib.rs

@@ -20,6 +20,8 @@ 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
 

common/client-libs/validator-client/src/nyxd/cosmwasm_client/mod.rs

@@ -3,18 +3,25 @@
 
 use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
 use crate::nyxd::error::NyxdError;
-use crate::nyxd::{Config, GasPrice};
+use crate::nyxd::{Config, GasPrice, Hash, Height};
 use crate::rpc::TendermintRpcClient;
 use crate::signing::{
     signer::{NoSigner, OfflineSigner},
     AccountData,
 };
 use async_trait::async_trait;
-use tendermint_rpc::{Error as TendermintRpcError, SimpleRequest};
+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};
 
+#[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;
@@ -73,7 +80,7 @@ impl<S> MaybeSigningClient<HttpClient, S> {
     where
         U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
     {
-        self.client = HttpClient::new(new_endpoint)?;
+        self.client = http_client(new_endpoint)?;
         Ok(())
     }
 }
@@ -85,6 +92,216 @@ 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,

common/client-libs/validator-client/src/nyxd/mod.rs

@@ -9,19 +9,25 @@ 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::Serialize;
+use serde::{de::DeserializeOwned, Serialize};
+use std::fmt::Debug;
 use std::time::SystemTime;
 use tendermint_rpc::endpoint::block::Response as BlockResponse;
-use tendermint_rpc::Error as TendermintRpcError;
+use tendermint_rpc::endpoint::*;
+use tendermint_rpc::{Error as TendermintRpcError, Order};
+use url::Url;
 
 pub use crate::nyxd::cosmwasm_client::client_traits::{CosmWasmClient, SigningCosmWasmClient};
 pub use crate::nyxd::fee::Fee;
@@ -45,14 +51,13 @@ pub use tendermint_rpc::{
 };
 pub use tendermint_rpc::{Request, Response, SimpleRequest};
 
-// #[cfg(feature = "http-client")]
-use crate::signing::direct_wallet::DirectSecp256k1HdWallet;
+#[cfg(feature = "http-client")]
+use crate::http_client;
 #[cfg(feature = "http-client")]
 use crate::{DirectSigningHttpRpcNyxdClient, QueryHttpRpcNyxdClient};
-use crate::{DirectSigningReqwestRpcNyxdClient, QueryReqwestRpcNyxdClient, ReqwestRpcClient};
 #[cfg(feature = "http-client")]
 use cosmrs::rpc::{HttpClient, HttpClientUrl};
-use url::Url;
+use tendermint_rpc::query::Query;
 
 pub mod coin;
 pub mod contract_traits;
@@ -97,7 +102,7 @@ impl NyxdClient<HttpClient> {
     where
         U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
     {
-        let client = HttpClient::new(endpoint)?;
+        let client = http_client(endpoint)?;
 
         Ok(NyxdClient {
             client: MaybeSigningClient::new(client, (&config).into()),
@@ -140,7 +145,7 @@ impl NyxdClient<HttpClient, DirectSecp256k1HdWallet> {
     where
         U: TryInto<HttpClientUrl, Error = TendermintRpcError>,
     {
-        let client = HttpClient::new(endpoint)?;
+        let client = http_client(endpoint)?;
 
         let prefix = &config.chain_details.bech32_account_prefix;
         let wallet = DirectSecp256k1HdWallet::from_mnemonic(prefix, mnemonic);
@@ -568,6 +573,216 @@ 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,

common/client-libs/validator-client/src/rpc/mod.rs

@@ -11,8 +11,27 @@ 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))]

common/client-libs/validator-client/src/rpc/reqwest.rs

@@ -3,12 +3,32 @@
 
 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::{Error, Response, SimpleRequest};
+use tendermint_rpc::{
+    client::CompatMode,
+    dialect::{self, Dialect},
+    endpoint::{self, *},
+    query::Query,
+    Error, Order, 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,
 }
@@ -16,12 +36,21 @@ pub struct ReqwestRpcClient {
 impl ReqwestRpcClient {
     pub fn new(url: Url) -> Self {
         ReqwestRpcClient {
+            compat: CompatMode::V0_34,
             inner: reqwest::Client::new(),
             url,
         }
     }
 
-    fn build_request<R: SimpleRequest>(&self, request: R) -> RequestBuilder {
+    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,
+    {
         let mut headers = HeaderMap::new();
         headers.insert(header::CONTENT_TYPE, "application/json".parse().unwrap());
         headers.insert(
@@ -39,6 +68,38 @@ 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 {
@@ -58,17 +119,81 @@ impl TendermintRpcClient for ReqwestRpcClient {
     where
         R: SimpleRequest,
     {
-        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)
+        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))
     }
 }
 

common/client-libs/validator-client/src/signing/direct_wallet.rs

@@ -199,16 +199,14 @@ mod tests {
     #[test]
     fn generating_account_addresses() {
         // test vectors produced from our js wallet
-        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",
+        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",
             "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 = vec![
+        let addrs = [
             "n1jw6mp7d5xqc7w6xm79lha27glmd0vdt3l9artf",
             "n1h5hgn94nsq4kh99rjj794hr5h5q6yfm2lr52es",
             "n17n9flp6jflljg6fp05dsy07wcprf2uuu8g40rf",

common/coconut-interface/src/lib.rs

@@ -8,7 +8,14 @@ use serde::{Deserialize, Serialize};
 
 use error::CoconutInterfaceError;
 
-pub use nym_coconut::*;
+// 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,
+};
 
 #[derive(Debug, Serialize, Deserialize, Getters, CopyGetters, Clone, PartialEq, Eq)]
 pub struct Credential {
@@ -57,7 +64,7 @@ impl Credential {
 
     pub fn verify(&self, verification_key: &VerificationKey) -> bool {
         let params = Parameters::new(self.n_params).unwrap();
-        let public_attributes = vec![
+        let public_attributes = [
             self.voucher_value.to_string().as_bytes(),
             self.voucher_info.as_bytes(),
         ]
@@ -138,6 +145,8 @@ impl Base58 for Credential {}
 
 #[cfg(test)]
 mod tests {
+    use nym_coconut::{prove_bandwidth_credential, Signature};
+
     use super::*;
 
     #[test]

common/commands/Cargo.toml

@@ -5,6 +5,7 @@ authors.workspace = true
 edition = "2021"
 
 [dependencies]
+anyhow = { workspace = true }
 base64 = "0.13.0"
 bip39 = { workspace = true }
 bs58 = "0.4"
@@ -33,6 +34,7 @@ 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" }
@@ -41,6 +43,11 @@ 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" }

common/commands/src/coconut/issue_credentials.rs

@@ -0,0 +1,51 @@
+// 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(())
+}

common/commands/src/coconut/mod.rs

@@ -1,4 +1,20 @@
 // Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0
 
-// TODO: add coconut commands here
+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),
+}

common/commands/src/coconut/recover_credentials.rs

@@ -0,0 +1,48 @@
+// 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(())
+}

common/commands/src/utils.rs

@@ -1,13 +1,17 @@
 // 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::Serialize;
+use serde::{Deserialize, 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 {
@@ -75,3 +79,150 @@ 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")
+        }
+    }
+}

common/cosmwasm-smart-contracts/mixnet-contract/Cargo.toml

@@ -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 = { version = "6.1.2", optional = true }
+ts-rs = { workspace = true, optional = true }
 
 [dev-dependencies]
 rand_chacha = "0.3"

common/cosmwasm-smart-contracts/mixnet-contract/src/pending_events.rs

@@ -144,7 +144,7 @@ pub struct PendingIntervalEventData {
 #[cw_serde]
 pub enum PendingIntervalEventKind {
     /// Request to update cost parameters of given mixnode.
-    #[serde(alias = "PendingIntervalEventKind")]
+    #[serde(alias = "ChangeMixCostParams")]
     ChangeMixCostParams {
         /// The id of the mixnode that will have its cost parameters updated.
         mix_id: MixId,

common/cosmwasm-smart-contracts/vesting-contract/Cargo.toml

@@ -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 = {version = "6.1.2", optional = true}
+ts-rs = { workspace = true, optional = true}
 
 [features]
 schema = ["cw2"]

common/credential-storage/src/ephemeral_storage.rs

@@ -5,9 +5,10 @@ use crate::backends::memory::CoconutCredentialManager;
 use crate::error::StorageError;
 use crate::models::CoconutCredential;
 use crate::storage::Storage;
-
 use async_trait::async_trait;
 
+pub type EphemeralCredentialStorage = EphemeralStorage;
+
 // note that clone here is fine as upon cloning the same underlying pool will be used
 #[derive(Clone)]
 pub struct EphemeralStorage {

common/credential-utils/Cargo.toml

@@ -1,25 +1,18 @@
 [package]
-name = "nym-credential-client"
+name = "nym-credential-utils"
 version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-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
-
+log = { workspace = true }
+thiserror = { workspace = true }
+tokio = { workspace = true }
 
 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" }

common/credential-utils/src/errors.rs

@@ -0,0 +1,31 @@
+// 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),
+}