Some minor conversions

EXISTS return i64
Upgrade to sqlx 0.8.3
2025-03-18 22:04:30 +01:00 · 2025-03-18 21:51:33 +01:00 · 2025-03-18 21:34:51 +01:00
903 changed files with 46578 additions and 51211 deletions
@@ -9,7 +9,7 @@
      "version": "1.0.0",
      "dependencies": {
        "@actions/core": "^1.10.1",
-        "@actions/github": "^6.0.0",
+        "@actions/github": "^5.1.1",
        "@octokit/auth-action": "^4.0.1",
        "@octokit/rest": "^20.0.2",
        "hasha": "^5.2.0",
@@ -29,34 +29,22 @@
      }
    },
    "node_modules/@actions/github": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/@actions/github/-/github-6.0.0.tgz",
-      "integrity": "sha512-alScpSVnYmjNEXboZjarjukQEzgCRmjMv6Xj47fsdnqGS73bjJNDpiiXmp8jr0UZLdUB6d9jW63IcmddUP+l0g==",
-      "license": "MIT",
+      "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.2.0",
-        "@octokit/core": "^5.0.1",
-        "@octokit/plugin-paginate-rest": "^9.0.0",
-        "@octokit/plugin-rest-endpoint-methods": "^10.0.0"
+        "@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.2.3",
-      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-2.2.3.tgz",
-      "integrity": "sha512-mx8hyJi/hjFvbPokCg4uRd4ZX78t+YyRPtnKWwIl+RzNaVuFpQHfmlGVfsKEJN8LwTCvL+DfVgAM04XaHkm6bA==",
-      "license": "MIT",
-      "dependencies": {
-        "tunnel": "^0.0.6",
-        "undici": "^5.25.4"
-      }
-    },
-    "node_modules/@fastify/busboy": {
      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-2.1.1.tgz",
-      "integrity": "sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=14"
+      "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": {
@@ -71,6 +59,14 @@
        "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": "20.0.0",
      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-20.0.0.tgz",
@@ -85,152 +81,115 @@
      }
    },
    "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==",
-      "license": "MIT",
-      "engines": {
-        "node": ">= 18"
+      "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": "5.2.0",
-      "resolved": "https://registry.npmjs.org/@octokit/core/-/core-5.2.0.tgz",
-      "integrity": "sha512-1LFfa/qnMQvEOAdzlQymH0ulepxbxnCYAKJZfMci/5XJyIHWgEYnDmgnKakbTh7CH2tFQ5O60oYDvns4i9RAIg==",
-      "license": "MIT",
+      "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": "^4.0.0",
-        "@octokit/graphql": "^7.1.0",
-        "@octokit/request": "^8.3.1",
-        "@octokit/request-error": "^5.1.0",
-        "@octokit/types": "^13.0.0",
+        "@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"
-      },
-      "engines": {
-        "node": ">= 18"
      }
    },
    "node_modules/@octokit/endpoint": {
-      "version": "9.0.6",
-      "resolved": "https://registry.npmjs.org/@octokit/endpoint/-/endpoint-9.0.6.tgz",
-      "integrity": "sha512-H1fNTMA57HbkFESSt3Y9+FBICv+0jFceJFPWDePYlR/iMGrwM5ph+Dd4XRQs+8X+PUFURLQgX9ChPfhJ/1uNQw==",
-      "license": "MIT",
+      "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": "^13.1.0",
+        "@octokit/types": "^6.0.3",
+        "is-plain-object": "^5.0.0",
        "universal-user-agent": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 18"
      }
    },
    "node_modules/@octokit/graphql": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/@octokit/graphql/-/graphql-7.1.0.tgz",
-      "integrity": "sha512-r+oZUH7aMFui1ypZnAvZmn0KSqAUgE1/tUXIWaqUCa1758ts/Jio84GZuzsvUkme98kv0WFY8//n0J1Z+vsIsQ==",
-      "license": "MIT",
+      "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": "^8.3.0",
-        "@octokit/types": "^13.0.0",
+        "@octokit/request": "^5.6.0",
+        "@octokit/types": "^6.0.3",
        "universal-user-agent": "^6.0.0"
-      },
-      "engines": {
-        "node": ">= 18"
      }
    },
    "node_modules/@octokit/openapi-types": {
-      "version": "23.0.1",
-      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-23.0.1.tgz",
-      "integrity": "sha512-izFjMJ1sir0jn0ldEKhZ7xegCTj/ObmEDlEfpFrx4k/JyZSMRHbO3/rBwgE7f3m2DHt+RrNGIVw4wSmwnm3t/g==",
-      "license": "MIT"
+      "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": "9.2.2",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-9.2.2.tgz",
-      "integrity": "sha512-u3KYkGF7GcZnSD/3UP0S7K5XUFT2FkOQdcfXZGZQPGv3lm4F2Xbf71lvjldr8c1H3nNbF+33cLEkWYbokGWqiQ==",
-      "license": "MIT",
+      "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": "^12.6.0"
-      },
-      "engines": {
-        "node": ">= 18"
+        "@octokit/types": "^6.40.0"
      },
      "peerDependencies": {
-        "@octokit/core": "5"
-      }
-    },
-    "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/openapi-types": {
-      "version": "20.0.0",
-      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-20.0.0.tgz",
-      "integrity": "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA==",
-      "license": "MIT"
-    },
-    "node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/types": {
-      "version": "12.6.0",
-      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-12.6.0.tgz",
-      "integrity": "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw==",
-      "license": "MIT",
-      "dependencies": {
-        "@octokit/openapi-types": "^20.0.0"
+        "@octokit/core": ">=2"
      }
    },
    "node_modules/@octokit/plugin-rest-endpoint-methods": {
-      "version": "10.4.1",
-      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-10.4.1.tgz",
-      "integrity": "sha512-xV1b+ceKV9KytQe3zCVqjg+8GTGfDYwaT1ATU5isiUyVtlVAO3HNdzpS4sr4GBx4hxQ46s7ITtZrAsxG22+rVg==",
-      "license": "MIT",
+      "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": "^12.6.0"
-      },
-      "engines": {
-        "node": ">= 18"
+        "@octokit/types": "^6.39.0",
+        "deprecation": "^2.3.1"
      },
      "peerDependencies": {
-        "@octokit/core": "5"
-      }
-    },
-    "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/openapi-types": {
-      "version": "20.0.0",
-      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-20.0.0.tgz",
-      "integrity": "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA==",
-      "license": "MIT"
-    },
-    "node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": {
-      "version": "12.6.0",
-      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-12.6.0.tgz",
-      "integrity": "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw==",
-      "license": "MIT",
-      "dependencies": {
-        "@octokit/openapi-types": "^20.0.0"
+        "@octokit/core": ">=3"
      }
    },
    "node_modules/@octokit/request": {
-      "version": "8.4.1",
-      "resolved": "https://registry.npmjs.org/@octokit/request/-/request-8.4.1.tgz",
-      "integrity": "sha512-qnB2+SY3hkCmBxZsR/MPCybNmbJe4KAlfWErXq+rBKkQJlbjdJeS85VI9r8UqeLYLvnAenU8Q1okM/0MBsAGXw==",
-      "license": "MIT",
+      "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": "^9.0.6",
-        "@octokit/request-error": "^5.1.1",
-        "@octokit/types": "^13.1.0",
+        "@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"
-      },
-      "engines": {
-        "node": ">= 18"
      }
    },
    "node_modules/@octokit/request-error": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/@octokit/request-error/-/request-error-5.1.1.tgz",
-      "integrity": "sha512-v9iyEQJH6ZntoENr9/yXxjuezh4My67CBSu9r6Ve/05Iu5gNgnisNWOsoJHTP6k0Rr0+HQIpnH+kyammu90q/g==",
-      "license": "MIT",
+      "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": "^13.1.0",
+        "@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": ">= 18"
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
      }
    },
    "node_modules/@octokit/rest": {
@@ -247,6 +206,89 @@
        "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": "9.2.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-paginate-rest/-/plugin-paginate-rest-9.2.1.tgz",
+      "integrity": "sha512-wfGhE/TAkXZRLjksFXuDZdmGnJQHvtU/joFQdweXUgzo1XwvBCD4o4+75NtFfjfLK5IwLf9vHTfSiU3sLRYpRw==",
+      "dependencies": {
+        "@octokit/types": "^12.6.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": "5"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/openapi-types": {
+      "version": "20.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-20.0.0.tgz",
+      "integrity": "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA=="
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-paginate-rest/node_modules/@octokit/types": {
+      "version": "12.6.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-12.6.0.tgz",
+      "integrity": "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw==",
+      "dependencies": {
+        "@octokit/openapi-types": "^20.0.0"
+      }
+    },
    "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",
@@ -258,13 +300,75 @@
        "@octokit/core": ">=5"
      }
    },
-    "node_modules/@octokit/types": {
-      "version": "13.8.0",
-      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-13.8.0.tgz",
-      "integrity": "sha512-x7DjTIbEpEWXK99DMd01QfWy0hd5h4EN+Q7shkdKds3otGQP+oWE/y0A76i1OvH9fygo4ddvNf7ZvF0t78P98A==",
-      "license": "MIT",
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-rest-endpoint-methods": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@octokit/plugin-rest-endpoint-methods/-/plugin-rest-endpoint-methods-10.4.1.tgz",
+      "integrity": "sha512-xV1b+ceKV9KytQe3zCVqjg+8GTGfDYwaT1ATU5isiUyVtlVAO3HNdzpS4sr4GBx4hxQ46s7ITtZrAsxG22+rVg==",
      "dependencies": {
-        "@octokit/openapi-types": "^23.0.1"
+        "@octokit/types": "^12.6.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "@octokit/core": "5"
+      }
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/openapi-types": {
+      "version": "20.0.0",
+      "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-20.0.0.tgz",
+      "integrity": "sha512-EtqRBEjp1dL/15V7WiX5LJMIxxkdiGJnabzYx5Apx4FkQIFgAfKumXeYAqqJCj1s+BMX4cPFIFC4OLCR6stlnA=="
+    },
+    "node_modules/@octokit/rest/node_modules/@octokit/plugin-rest-endpoint-methods/node_modules/@octokit/types": {
+      "version": "12.6.0",
+      "resolved": "https://registry.npmjs.org/@octokit/types/-/types-12.6.0.tgz",
+      "integrity": "sha512-1rhSOfRa6H9w4YwK0yrf5faDaDTb+yLyBUKOCV4xtCDB5VmIPqd/v9yr9o6SAzOAlRxMiRiCic6JVM1/kunVkw==",
+      "dependencies": {
+        "@octokit/openapi-types": "^20.0.0"
+      }
+    },
+    "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/@vercel/ncc": {
@@ -292,8 +396,7 @@
    "node_modules/deprecation": {
      "version": "2.3.1",
      "resolved": "https://registry.npmjs.org/deprecation/-/deprecation-2.3.1.tgz",
-      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ==",
-      "license": "ISC"
+      "integrity": "sha512-xmHIy4F3scKVwMsQ4WnVaS8bHOx0DmVwRywosKhaILI0ywMDWPtBSku2HNxRvF7jtwDRsoEwYQSfbxj8b7RlJQ=="
    },
    "node_modules/fetch-blob": {
      "version": "3.2.0",
@@ -343,6 +446,14 @@
        "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",
@@ -393,11 +504,15 @@
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-      "license": "ISC",
      "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",
@@ -414,18 +529,6 @@
        "node": ">=8"
      }
    },
-    "node_modules/undici": {
-      "version": "5.28.5",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-5.28.5.tgz",
-      "integrity": "sha512-zICwjrDrcrUE0pyyJc1I2QzBkLM8FINsgOrt6WjA+BgajVq9Nxu2PbFFXUrAggLfDXlZGZBVZYw7WNV5KiBiBA==",
-      "license": "MIT",
-      "dependencies": {
-        "@fastify/busboy": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=14.0"
-      }
-    },
    "node_modules/universal-user-agent": {
      "version": "6.0.0",
      "resolved": "https://registry.npmjs.org/universal-user-agent/-/universal-user-agent-6.0.0.tgz",
@@ -447,11 +550,24 @@
        "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==",
-      "license": "ISC"
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
    }
  }
 }
@@ -11,7 +11,7 @@
  },
  "dependencies": {
    "@actions/core": "^1.10.1",
-    "@actions/github": "^6.0.0",
+    "@actions/github": "^5.1.1",
    "@octokit/auth-action": "^4.0.1",
    "@octokit/rest": "^20.0.2",
    "hasha": "^5.2.0",
@@ -5,7 +5,7 @@ on:

 jobs:
  build:
-    runs-on: arc-ubuntu-22.04
+    runs-on: arc-ubuntu-20.04
    defaults:
      run:
        working-directory: documentation/docs
@@ -18,7 +18,7 @@ jobs:
      - name: Install Python3 modules
        run: sudo pip3 install pandas tabulate
      - name: Install rsync
-        run: sudo apt-get install -y rsync
+        run: sudo apt-get install rsync
      - uses: rlespinasse/github-slug-action@v3.x
      - name: Setup pnpm
        uses: pnpm/action-setup@v4.0.0
@@ -33,7 +33,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [arc-ubuntu-22.04]
+        platform: [arc-ubuntu-20.04]

    runs-on: ${{ matrix.platform }}
    steps:
@@ -10,7 +10,7 @@ on:

 jobs:
  build:
-    runs-on: ubuntu-22.04
+    runs-on: arc-ubuntu-20.04
    steps:
    - uses: actions/checkout@v4
    - name: Install rsync
@@ -19,7 +19,7 @@ jobs:
    - uses: rlespinasse/github-slug-action@v3.x
    - uses: actions/setup-node@v4
      with:
-        node-version: 20
+        node-version: 18
    - name: Setup yarn
      run: npm install -g yarn
    - name: Build
@@ -21,7 +21,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ arc-ubuntu-22.04 ]
+        platform: [ arc-ubuntu-20.04 ]

    runs-on: ${{ matrix.platform }}
    env:
@@ -27,18 +27,12 @@ on:
      - '.github/workflows/ci-build.yml'
  workflow_dispatch:

-concurrency:
-  # only 1 concurrent `ci-build` allowed per branch
-  # https://docs.github.com/en/actions/writing-workflows/workflow-syntax-for-github-actions#example-using-concurrency-and-the-default-behavior
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
 jobs:
  build:
    strategy:
      fail-fast: false
      matrix:
-        os: [ arc-ubuntu-22.04, custom-windows-11, custom-runner-mac-m1 ]
+        os: [ arc-ubuntu-20.04, custom-windows-11, custom-runner-mac-m1 ]
    runs-on: ${{ matrix.os }}
    env:
      CARGO_TERM_COLOR: always
@@ -102,8 +96,6 @@ jobs:
      - name: Run all tests
        if: contains(matrix.os, 'ubuntu')
        uses: actions-rs/cargo@v1
-        env:
-          NYM_API: https://sandbox-nym-api1.nymtech.net/api
        with:
          command: test
          args: --workspace
@@ -0,0 +1,6 @@
+[
+  {
+    "rust":"stable",
+    "runOnEvent":"always"
+  }
+]
@@ -11,7 +11,7 @@ on:
 jobs:
  check-schema:
    name: Generate and check schema
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
    env:
      CARGO_TERM_COLOR: always
    steps:
@@ -11,7 +11,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [ arc-ubuntu-22.04 ]
+        platform: [ arc-ubuntu-20.04 ]

    runs-on: ${{ matrix.platform }}
    env:
@@ -31,6 +31,7 @@ jobs:
      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
+          toolchain: 1.77
          target: wasm32-unknown-unknown
          override: true

@@ -39,9 +40,6 @@ jobs:
        with:
          version: '114'

-      - name: Install cosmwasm-check
-        run: cargo install cosmwasm-check
-
      - name: Build release contracts
        run: make contracts

@@ -52,6 +50,7 @@ jobs:
        run: |
          cp contracts/target/wasm32-unknown-unknown/release/mixnet_contract.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/vesting_contract.wasm $OUTPUT_DIR
+          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_bandwidth.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/nym_coconut_dkg.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/cw3_flex_multisig.wasm $OUTPUT_DIR
          cp contracts/target/wasm32-unknown-unknown/release/cw4_group.wasm $OUTPUT_DIR
@@ -14,12 +14,28 @@ on:
      - '.github/workflows/ci-contracts.yml'

 jobs:
+  matrix_prep:
+    runs-on: ubuntu-20.04
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      # creates the matrix strategy from ci-contracts-matrix-includes.json
+      - uses: actions/checkout@v4
+      - id: set-matrix
+        uses: JoshuaTheMiller/conditional-build-matrix@main
+        with:
+          inputFile: '.github/workflows/ci-contracts-matrix-includes.json'
+          filter: '[?runOnEvent==`${{ github.event_name }}` || runOnEvent==`always`]'
  build:
    # since it's going to be compiled into wasm, there's absolutely
    # no point in running CI on different OS-es
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
    env:
      CARGO_TERM_COLOR: always
+    needs: matrix_prep
+    strategy:
+      fail-fast: false
+      matrix: ${{fromJson(needs.matrix_prep.outputs.matrix)}}
    steps:
      - uses: actions/checkout@v4

@@ -27,19 +43,11 @@ jobs:
        uses: actions-rs/toolchain@v1
        with:
          profile: minimal
-          toolchain: stable
+          toolchain: ${{ matrix.rust }}
          target: wasm32-unknown-unknown
          override: true
          components: rustfmt, clippy

-      - name: Install cosmwasm-check
-        run: cargo install cosmwasm-check
-
-      - name: Install wasm-opt
-        uses: ./.github/actions/install-wasm-opt
-        with:
-          version: '114'
-
      - name: Build contracts
        uses: actions-rs/cargo@v1
        env:
@@ -65,7 +73,3 @@ jobs:
        with:
          command: clippy
          args: --lib --manifest-path contracts/Cargo.toml --workspace --all-targets -- -D warnings
-
-      - name: Check chain compatibility against release build
-        # this will build contracts in release mode, run wasm-opt and finally cosmwasm-check
-        run: make contracts
@@ -10,9 +10,7 @@ on:

 jobs:
  build:
-    runs-on: arc-ubuntu-22.04
-    env:
-      RUSTUP_PERMIT_COPY_RENAME: 1
+    runs-on: arc-ubuntu-20.04
    defaults:
      run:
        working-directory: documentation/docs
@@ -25,7 +23,7 @@ jobs:
      - name: Install Python3 modules
        run: sudo pip3 install pandas tabulate
      - name: Install rsync
-        run: sudo apt-get install -y rsync
+        run: sudo apt-get install rsync
      - uses: rlespinasse/github-slug-action@v3.x
      - name: Setup pnpm
        uses: pnpm/action-setup@v4.0.0
@@ -15,16 +15,14 @@ on:

 jobs:
  build:
-    runs-on: ubuntu-22.04
-    env:
-      RUSTUP_PERMIT_COPY_RENAME: 1
+    runs-on: arc-ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - uses: rlespinasse/github-slug-action@v3.x

      - uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18
      - name: Setup yarn
        run: npm install -g yarn

@@ -44,7 +42,7 @@ jobs:
      - name: Set up Go
        uses: actions/setup-go@v5
        with:
-          go-version: "1.23.7"
+          go-version: '1.20'

      - name: Install
        run: yarn
@@ -0,0 +1,92 @@
+name: ci-nym-network-explorer
+
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - 'explorer/**'
+      - '.github/workflows/ci-nym-network-explorer.yml'
+
+defaults:
+  run:
+    working-directory: explorer
+
+jobs:
+  build:
+    runs-on: custom-linux
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install rsync
+      run: sudo apt-get install rsync
+      continue-on-error: true
+    - uses: rlespinasse/github-slug-action@v3.x
+    - uses: actions/setup-node@v4
+      with:
+        node-version: 18
+    - name: Setup yarn
+      run: npm install -g yarn
+      continue-on-error: true
+    - name: Build shared packages
+      run: cd .. && yarn && yarn build
+    - name: Set environment from the example
+      run: cp .env.prod .env
+#    - run: yarn test
+#      continue-on-error: true
+    - run: yarn && yarn build
+      continue-on-error: true
+    - run: yarn storybook:build
+      name: Build storybook
+    - name: Deploy branch to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/dist/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/network-explorer-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"
+    - name: Deploy storybook to CI www
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/ne-sb-${{ 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: network-explorer
+        NYM_PROJECT_NAME: "Network Explorer"
+        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+        NYM_CI_WWW_LOCATION: "network-explorer-${{ env.GITHUB_REF_SLUG }}"
+        NYM_CI_WWW_LOCATION_STORYBOOK: "ne-sb-${{ env.GITHUB_REF_SLUG }}"
+        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+        GIT_BRANCH: "${GITHUB_REF##*/}"
+        IS_SUCCESS: "${{ job.status == 'success' }}"
+        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
+        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh
+    - name: Deploy
+      if: github.event_name == 'workflow_dispatch'
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CD_PROD_NE_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "explorer/dist/"
+        REMOTE_HOST: ${{ secrets.CD_PROD_NE_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CD_PROD_NE_REMOTE_USER }}
+        TARGET: ${{ secrets.CD_PROD_NE_REMOTE_TARGET }}
+        EXCLUDE: "/dist/, /node_modules/"
@@ -11,17 +11,12 @@ on:

 jobs:
  build:
-    runs-on: arc-ubuntu-22.04
+    runs-on: arc-ubuntu-20.04
    env:
      CARGO_TERM_COLOR: always
-      RUSTUP_PERMIT_COPY_RENAME: 1
    steps:
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update && sudo apt-get install -y libdbus-1-dev libmnl-dev libnftnl-dev \
-            libwebkit2gtk-4.1-dev build-essential curl wget libssl-dev jq \
-            libgtk-3-dev squashfs-tools libayatana-appindicator3-dev make libfuse2 unzip librsvg2-dev file \
-            libsoup-3.0-dev libjavascriptcoregtk-4.1-dev
+      - 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 squashfs-tools
        continue-on-error: true

      - name: Check out repository code
@@ -10,66 +10,66 @@ jobs:
  build:
    runs-on: custom-linux
    steps:
-      - uses: actions/checkout@v4
+    - uses: actions/checkout@v4

-      - name: Install rsync
-        run: sudo apt-get install rsync
-        continue-on-error: true
+    - name: Install rsync
+      run: sudo apt-get install rsync
+      continue-on-error: true

-      - uses: rlespinasse/github-slug-action@v3.x
+    - uses: rlespinasse/github-slug-action@v3.x

-      - uses: actions/setup-node@v4
-        with:
-          node-version: 20
+    - uses: actions/setup-node@v4
+      with:
+        node-version: 18

-      - name: Setup yarn
-        run: npm install -g yarn
+    - name: Setup yarn
+      run: npm install -g yarn

-      - name: Install Rust stable
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
+    - 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: Install wasm-pack
+      run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

-      - name: Build dependencies
-        run: yarn && yarn build
+    - name: Build dependencies
+      run: yarn && yarn build

-      - name: Build storybook
-        run: yarn storybook:build
-        working-directory: ./nym-wallet
+    - name: Build storybook
+      run: yarn storybook:build
+      working-directory: ./nym-wallet

-      - name: Deploy branch to CI www (storybook)
-        continue-on-error: true
-        uses: easingthemes/ssh-deploy@main
-        env:
-          SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
-          ARGS: "-rltgoDzvO --delete"
-          SOURCE: "nym-wallet/storybook-static/"
-          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
-          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
-          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/wallet-${{ env.GITHUB_REF_SLUG }}
-          EXCLUDE: "/dist/, /node_modules/"
+    - name: Deploy branch to CI www (storybook)
+      continue-on-error: true
+      uses: easingthemes/ssh-deploy@main
+      env:
+        SSH_PRIVATE_KEY: ${{ secrets.CI_WWW_SSH_PRIVATE_KEY }}
+        ARGS: "-rltgoDzvO --delete"
+        SOURCE: "nym-wallet/storybook-static/"
+        REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+        REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+        TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/wallet-${{ env.GITHUB_REF_SLUG }}
+        EXCLUDE: "/dist/, /node_modules/"

-      - name: Matrix - Node Install
-        run: npm install
-        working-directory: .github/workflows/support-files
+    - name: Matrix - Node Install
+      run: npm install
+      working-directory: .github/workflows/support-files

-      - name: Matrix - Send Notification
-        env:
-          NYM_NOTIFICATION_KIND: nym-wallet
-          NYM_PROJECT_NAME: "nym-wallet"
-          NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
-          NYM_CI_WWW_LOCATION: "wallet-${{ env.GITHUB_REF_SLUG }}"
-          GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
-          GIT_BRANCH: "${GITHUB_REF##*/}"
-          IS_SUCCESS: "${{ job.status == 'success' }}"
-          MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
-          MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
-          MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
-          MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
-          MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
-        uses: docker://keybaseio/client:stable-node
-        with:
-          args: .github/workflows/support-files/notifications/entry_point.sh
+    - name: Matrix - Send Notification
+      env:
+        NYM_NOTIFICATION_KIND: nym-wallet
+        NYM_PROJECT_NAME: "nym-wallet"
+        NYM_CI_WWW_BASE: "${{ secrets.NYM_CI_WWW_BASE }}"
+        NYM_CI_WWW_LOCATION: "wallet-${{ env.GITHUB_REF_SLUG }}"
+        GIT_COMMIT_MESSAGE: "${{ github.event.head_commit.message }}"
+        GIT_BRANCH: "${GITHUB_REF##*/}"
+        IS_SUCCESS: "${{ job.status == 'success' }}"
+        MATRIX_SERVER: "${{ secrets.MATRIX_SERVER }}"
+        MATRIX_ROOM: "${{ secrets.MATRIX_ROOM }}"
+        MATRIX_USER_ID: "${{ secrets.MATRIX_USER_ID }}"
+        MATRIX_TOKEN: "${{ secrets.MATRIX_TOKEN }}"
+        MATRIX_DEVICE_ID: "${{ secrets.MATRIX_DEVICE_ID }}"
+      uses: docker://keybaseio/client:stable-node
+      with:
+        args: .github/workflows/support-files/notifications/entry_point.sh
@@ -11,16 +11,15 @@ on:

 jobs:
  wasm:
-    runs-on: arc-ubuntu-22.04
+    runs-on: arc-ubuntu-20.04
    env:
      CARGO_TERM_COLOR: always
-      RUSTUP_PERMIT_COPY_RENAME: 1
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18

      - uses: actions-rs/toolchain@v1
        with:
@@ -33,7 +32,7 @@ jobs:
      - name: Set up Go
        uses: actions/setup-go@v5
        with:
-          go-version: "1.23.7"
+          go-version: '1.20'

      - name: Install wasm-pack
        run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
@@ -11,7 +11,7 @@ jobs:
      fail-fast: false
      matrix:
        rust: [stable, beta]
-        os: [ubuntu-22.04, windows-latest, macos-latest]
+        os: [ubuntu-20.04, windows-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    env:
      CARGO_TERM_COLOR: always
@@ -23,7 +23,7 @@ jobs:

      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get install -y build-essential curl wget libssl-dev libudev-dev squashfs-tools protobuf-compiler
-        if: matrix.os == 'ubuntu-22.04'
+        if: matrix.os == 'ubuntu-20.04'

      - name: Install Rust toolchain
        uses: actions-rs/toolchain@v1
@@ -59,7 +59,7 @@ jobs:

      # To avoid running out of disk space, skip generating debug symbols
      - name: Set debug to false (unix)
-        if: matrix.os == 'ubuntu-22.04' || matrix.os == 'macos-latest'
+        if: matrix.os == 'ubuntu-20.04' || matrix.os == 'macos-latest'
        run: |
          sed -i.bak 's/\[profile.dev\]/\[profile.dev\]\ndebug = false/' Cargo.toml
          git diff
@@ -106,7 +106,7 @@ jobs:
        uses: actions/setup-node@v4
        if: env.WORKFLOW_CONCLUSION == 'failure'
        with:
-          node-version: 20
+          node-version: 18
      - name: Matrix - Node Install
        if: env.WORKFLOW_CONCLUSION == 'failure'
        run: npm install
@@ -10,7 +10,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        os: [ubuntu-22.04, macos-latest, windows-latest]
+        os: [ubuntu-20.04, macos-latest, windows-latest]
    runs-on: ${{ matrix.os }}
    env:
      CARGO_TERM_COLOR: always
@@ -22,7 +22,7 @@ jobs:

      - name: Install Dependencies (Linux)
        run: sudo apt-get update && sudo apt-get install -y libwebkit2gtk-4.0-dev build-essential curl wget libssl-dev libgtk-3-dev squashfs-tools
-        if: matrix.os == 'ubuntu-22.04'
+        if: matrix.os == 'ubuntu-20.04'

      - name: Install rust toolchain
        uses: actions-rs/toolchain@v1
@@ -68,7 +68,7 @@ jobs:
        uses: actions/setup-node@v4
        if: env.WORKFLOW_CONCLUSION == 'failure'
        with:
-          node-version: 20
+          node-version: 18
      - name: Matrix - Node Install
        if: env.WORKFLOW_CONCLUSION == 'failure'
        run: npm install
@@ -5,7 +5,7 @@ on:
    - cron: '5 9 * * *'
 jobs:
  cargo-deny:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-20.04
    steps:
      - name: Checkout repository code
        uses: actions/checkout@v4
@@ -38,7 +38,7 @@ jobs:
      - name: install npm
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18
      - name: Matrix - Node Install
        run: npm install
        working-directory: .github/workflows/support-files
@@ -1,47 +0,0 @@
-name: Integration Tests
-
-on:
-  pull_request:
-    paths:
-      - "nym-api/**"
-      - "tests/**"
-  workflow_dispatch:
-
-jobs:
-  integration-tests:
-    runs-on: ubuntu-latest
-    env:
-      API_BASE_URL: http://localhost:8000
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-
-      - name: Install dependencies
-        run: sudo apt-get update && sudo apt-get install -y pkg-config libssl-dev
-
-      - name: Build nym-api
-        run: cargo build --package nym-api
-
-      - name: Run nym-api in the background
-        run: |
-          ./target/debug/nym-api &
-
-      - name: Wait for nym-api to come alive
-        run: |
-          for i in {1..20}; do
-            curl -sSf http://localhost:8000/v1/status/config-score-details && break
-            echo "Waiting for nym-api to start..."
-            sleep 2
-          done
-
-      - name: Run integration tests
-        env:
-          NYM_API: https://sandbox-nym-api1.nymtech.net/api
-        run: cargo test --test public-api-tests -- --nocapture
@@ -20,7 +20,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [custom-ubuntu-22.04]
+        platform: [custom-ubuntu-20.04]
    runs-on: ${{ matrix.platform }}

    outputs:
@@ -2,18 +2,19 @@ name: publish-nym-contracts
 on:
  workflow_dispatch:
  release:
-    types: [ created ]
+    types: [created]

 jobs:
  build:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-contracts-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
-    runs-on: ubuntu-latest
+    runs-on: [self-hosted, custom-ubuntu-20.04]
    steps:
      - uses: actions/checkout@v4

      - name: Install Rust stable
        uses: actions-rs/toolchain@v1
        with:
+          toolchain: 1.77
          target: wasm32-unknown-unknown
          override: true

@@ -14,11 +14,15 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        platform: [macos-15]
+        platform: [macos-12-large]
    runs-on: ${{ matrix.platform }}

    outputs:
-      release_tag: ${{ github.ref_name }}
+      release_id: ${{ steps.create-release.outputs.id }}
+      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
+      version: ${{ steps.release-info.outputs.version }}
+      filename: ${{ steps.release-info.outputs.filename }}
+      file_hash: ${{ steps.release-info.outputs.file_hash }}

    steps:
      - uses: actions/checkout@v4
@@ -26,19 +30,11 @@ jobs:
      - name: Node
        uses: actions/setup-node@v4
        with:
-          node-version: 21
-          
+          node-version: 18
      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
-          
-      - name: Add Rust target for x86_64-apple-darwin
-        run: rustup target add x86_64-apple-darwin
-
-      - name: Set Cargo build target to x86_64
-        run: echo "CARGO_BUILD_TARGET=x86_64-apple-darwin" >> $GITHUB_ENV
-          
      - name: Install the Apple developer certificate for code signing
        env:
          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
@@ -68,19 +64,11 @@ jobs:
          fileName: '.env'
          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}

-      - name: Yarn cache clean
-        shell: bash
-        run: cd .. && yarn cache clean
-
      - name: Install project dependencies
        shell: bash
        run: cd .. && yarn --network-timeout 100000

-      - name: Yarn build
-        shell: bash
-        run: cd .. && yarn build
-
-      - name: Install dependencies and build it
+      - name: Install app dependencies and build it
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          ENABLE_CODE_SIGNING: ${{ secrets.APPLE_CERTIFICATE }}
@@ -90,48 +78,46 @@ jobs:
          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_IDENTITY_ID }}
          APPLE_ID: ${{ secrets.APPLE_ID }}
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-          # Tauri v2 specific environment variables
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          TAURI_NOTARIZATION_USERNAME: ${{ secrets.APPLE_ID }}
-          TAURI_NOTARIZATION_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-          TAURI_NOTARIZATION_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-        run: |
-          yarn build-macx86 
-
-      - name: Create app tarball
-        run: |
-          # Navigate to where the app bundle is and create the tarball
-          cd target/x86_64-apple-darwin/release/bundle/macos
-          echo "Creating tarball from app bundle"
-          tar -czf nym-wallet.app.tar.gz NymWallet.app
-          cd -
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        run: yarn && yarn build

      - name: Upload Artifact
        uses: actions/upload-artifact@v4
        with:
          name: nym-wallet.app.tar.gz
-          path: nym-wallet/target/x86_64-apple-darwin/release/bundle/macos/nym-wallet.app.tar.gz
+          path: nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz
          retention-days: 5

      - name: Clean up keychain
        if: ${{ always() }}
        run: |
          security delete-keychain $RUNNER_TEMP/app-signing.keychain-db
-          
      - id: create-release
        name: Upload to release based on tag name
        uses: softprops/action-gh-release@v2
        if: github.event_name == 'release'
        with:
          files: |
-            nym-wallet/target/x86_64-apple-darwin/release/bundle/dmg/*.dmg
-            nym-wallet/target/x86_64-apple-darwin/release/bundle/macos/*.app.tar.gz*
+            nym-wallet/target/release/bundle/dmg/*.dmg
+            nym-wallet/target/release/bundle/macos/*.app.tar.gz*
+
+      - name: Deploy artifacts 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: "nym-wallet/target/release/bundle/macos/nym-wallet.app.tar.gz"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
+          EXCLUDE: "/dist/, /node_modules/"            

  push-release-data:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/release-calculate-hash.yml
    needs: publish-tauri
    with:
-      release_tag: ${{ needs.publish-tauri.outputs.release_tag || github.ref_name }}
-    secrets: inherit
+      release_tag: ${{ github.ref_name }}
+    secrets: inherit
@@ -3,108 +3,71 @@ on:
  workflow_dispatch:
  release:
    types: [created]
+
 defaults:
  run:
    working-directory: nym-wallet
+
 jobs:
  publish-tauri:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    strategy:
      fail-fast: false
      matrix:
-        platform: [ubuntu-22.04]
+        platform: [custom-ubuntu-20.04]
    runs-on: ${{ matrix.platform }}
+
    outputs:
-      release_tag: ${{ github.ref_name }}
-      
+      release_id: ${{ steps.create-release.outputs.id }}
+      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
+      version: ${{ steps.release-info.outputs.version }}
+      filename: ${{ steps.release-info.outputs.filename }}
+      file_hash: ${{ steps.release-info.outputs.file_hash }}
+
    steps:
      - uses: actions/checkout@v4
-      
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update && sudo apt-get install -y libdbus-1-dev libmnl-dev libnftnl-dev \
-            libwebkit2gtk-4.1-dev build-essential curl wget libssl-dev jq \
-            libgtk-3-dev squashfs-tools libayatana-appindicator3-dev make libfuse2 unzip librsvg2-dev file \
-            libsoup-3.0-dev libjavascriptcoregtk-4.1-dev
-      
+
+      - name: Tauri dependencies
+        run: >
+          sudo apt-get update &&
+          sudo apt-get install -y webkit2gtk-4.0
+        continue-on-error: true
+
      - name: Node
        uses: actions/setup-node@v4
        with:
-          node-version: 21
-          cache: 'yarn'
-      
+          node-version: 18
+
      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
+        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
-      
+
      - name: Install project dependencies
        shell: bash
        run: cd .. && yarn --network-timeout 100000
-      
+
      - name: Install app dependencies
        run: yarn
-      
      - name: Create env file
        uses: timheuer/base64-to-file@v1.2
        with:
          fileName: '.env'
          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
-      
+
      - name: Build app
        run: yarn build
        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-      
-      - name: Check bundle directory
-        run: |
-          echo "Checking bundle directory structure"
-          ls -la target/release/bundle || echo "Bundle directory not found"
-          if [ -d "target/release/bundle/appimage" ]; then
-            echo "AppImage bundle directory exists, checking contents:"
-            ls -la target/release/bundle/appimage
-          else
-            echo "AppImage bundle directory not found, checking alternatives:"
-            find target/release/bundle -type d -name "*appimage*" -o -name "*AppImage*" || echo "No AppImage directories found"
-            find target/release/bundle -name "*.AppImage" -o -name "*.appimage" || echo "No AppImage files found"
-          fi
-      
-      - name: Create AppImage tarball if needed
-        run: |
-          # Find the AppImage file
-          APPIMAGE_FILE=$(find target/release/bundle -name "*.AppImage" | head -n 1)
-          if [ -n "$APPIMAGE_FILE" ]; then
-            echo "Found AppImage file: $APPIMAGE_FILE"
-            APPIMAGE_DIR=$(dirname "$APPIMAGE_FILE")
-            APPIMAGE_NAME=$(basename "$APPIMAGE_FILE")
-            
-            # Create tarball if it doesn't exist
-            if [ ! -f "${APPIMAGE_FILE}.tar.gz" ]; then
-              echo "Creating tarball for $APPIMAGE_NAME"
-              cd "$APPIMAGE_DIR"
-              tar -czf "${APPIMAGE_NAME}.tar.gz" "$APPIMAGE_NAME"
-              cd -
-              echo "Created tarball: ${APPIMAGE_FILE}.tar.gz"
-            else
-              echo "Tarball already exists: ${APPIMAGE_FILE}.tar.gz"
-            fi
-          else
-            echo "WARNING: No AppImage file found!"
-          fi
-      
+
      - name: Upload Artifact
        uses: actions/upload-artifact@v4
        with:
-          name: nym-wallet-appimage.tar.gz
-          path: |
-            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz
-            nym-wallet/target/release/bundle/*/nym-wallet*.AppImage.tar.gz
+          name: nym-wallet_1.0.0_amd64.AppImage.tar.gz
+          path: nym-wallet/target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz
          retention-days: 30
-      
+
      - id: create-release
        name: Upload to release based on tag name
        uses: softprops/action-gh-release@v2
@@ -112,26 +75,24 @@ jobs:
        with:
          files: |
            nym-wallet/target/release/bundle/appimage/*.AppImage
-            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz
-            nym-wallet/target/release/bundle/*/nym-wallet*.AppImage
-            nym-wallet/target/release/bundle/*/nym-wallet*.AppImage.tar.gz
-      
-      - name: Find AppImage tarball path for deployment
-        id: find-appimage
-        run: |
-          APPIMAGE_TARBALL=$(find target/release/bundle -name "*.AppImage.tar.gz" | head -n 1)
-          if [ -n "$APPIMAGE_TARBALL" ]; then
-            echo "Found AppImage tarball: $APPIMAGE_TARBALL"
-            echo "appimage_path=$APPIMAGE_TARBALL" >> $GITHUB_OUTPUT
-          else
-            echo "WARNING: No AppImage tarball found for deployment!"
-            echo "appimage_path=target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz" >> $GITHUB_OUTPUT
-          fi
-      
+            nym-wallet/target/release/bundle/appimage/*.AppImage.tar.gz*
+
+      - name: Deploy artifacts 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: "nym-wallet/target/release/bundle/appimage/nym-wallet*.AppImage.tar.gz"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
+          EXCLUDE: "/dist/, /node_modules/"               
+
  push-release-data:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/release-calculate-hash.yml
    needs: publish-tauri
    with:
-      release_tag: ${{ needs.publish-tauri.outputs.release_tag || github.ref_name }}
-    secrets: inherit
+      release_tag: ${{ github.ref_name }}
+    secrets: inherit
@@ -1,12 +1,6 @@
 name: publish-nym-wallet-win11
 on:
  workflow_dispatch:
-    inputs:
-      sign:
-        description: "Sign this build using SSL.com. Signing is billed per signature so be careful"
-        required: false
-        type: boolean
-        default: true
  release:
    types: [created]

@@ -24,61 +18,53 @@ jobs:
    runs-on: ${{ matrix.platform }}

    outputs:
-      release_tag: ${{ github.ref_name }}
+      release_id: ${{ steps.create-release.outputs.id }}
+      release_date: ${{ fromJSON(steps.create-release.outputs.assets)[0].created_at }}
+      version: ${{ steps.release-info.outputs.version }}
+      filename: ${{ steps.release-info.outputs.filename }}
+      file_hash: ${{ steps.release-info.outputs.file_hash }}

    steps:
+      - name: Clean up first
+        continue-on-error: true
+        working-directory: .
+        run: |
+          cd ..
+          del /s /q /A:H nym
+          rmdir /s /q nym
+
      - uses: actions/checkout@v4

-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-
-      - name: Setup MSBuild.exe
-        uses: microsoft/setup-msbuild@v2
+      - name: Import signing certificate
+        env:
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+        run: |
+          New-Item -ItemType directory -Path certificate
+          Set-Content -Path certificate/tempCert.txt -Value $env:WINDOWS_CERTIFICATE
+          certutil -decode certificate/tempCert.txt certificate/certificate.pfx
+          Remove-Item -path certificate -include tempCert.txt
+          Import-PfxCertificate -FilePath certificate/certificate.pfx -CertStoreLocation Cert:\CurrentUser\My -Password (ConvertTo-SecureString -String $env:WINDOWS_CERTIFICATE_PASSWORD -Force -AsPlainText)

      - name: Node
        uses: actions/setup-node@v4
        with:
-          node-version: 21
+          node-version: 18
+
+      - name: Install Rust stable
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+
+      - name: Create env file
+        uses: timheuer/base64-to-file@v1.2
+        with:
+          fileName: '.env'
+          encodedString: ${{ secrets.WALLET_ADMIN_ADDRESS }}
+
+      - name: Install Yarn
+        run: npm install -g yarn

-      - name: Download EV CodeSignTool from ssl.com
-        working-directory: nym-wallet/src-tauri
-        if: ${{ inputs.sign }}
-        shell: bash
-        run: |
-          curl -L0 https://www.ssl.com/download/codesigntool-for-linux-and-macos/ -o codesigntool.zip
-          unzip codesigntool.zip
-      - name: Get EV certificate credential id
-        working-directory: nym-wallet/src-tauri
-        if: ${{ inputs.sign }}
-        id: get_credential_ids
-        shell: bash
-        run: |
-          echo "SSL_COM_CREDENTIAL_ID=$(./CodeSignTool.sh get_credential_ids -username=${{ secrets.SSL_COM_USERNAME }} -password=${{ secrets.SSL_COM_PASSWORD }} | sed -n '1!p' | sed 's/- //')" >> "$GITHUB_OUTPUT"
-      - name: Add custom sign command to tauri.conf.json
-        working-directory: nym-wallet/src-tauri
-        if: ${{ inputs.sign }}
-        shell: bash
-        run: |
-          yq eval --inplace '.bundle.windows +=
-          {
-            "signCommand": {
-              "cmd": "C:\Program Files\Git\bin\bash.EXE",
-              "args": [
-                "/c/actions-runner/_work/nym/nym/nym-wallet/src-tauri/CodeSignTool.sh",
-                "sign",
-                "-username ${{ secrets.SSL_COM_USERNAME }}",
-                "-password ${{ secrets.SSL_COM_PASSWORD }}",
-                "-credential_id ${{ steps.get_credential_ids.outputs.SSL_COM_CREDENTIAL_ID }}",
-                "-totp_secret ${{ secrets.SSL_COM_TOTP_SECRET }}",
-                "-program_name NymWallet",
-                "-input_file_path",
-                "%1",
-                "-override"
-              ]
-            }
-          }' tauri.conf.json
      - name: Install project dependencies
        shell: bash
        run: cd .. && yarn --network-timeout 100000
@@ -91,50 +77,18 @@ jobs:
        shell: bash
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
-          SSL_COM_USERNAME: ${{ inputs.sign && secrets.SSL_COM_USERNAME }}
-          SSL_COM_PASSWORD: ${{ inputs.sign && secrets.SSL_COM_PASSWORD }}
-          SSL_COM_CREDENTIAL_ID: ${{ inputs.sign && steps.get_credential_ids.outputs.SSL_COM_CREDENTIAL_ID }}
-          SSL_COM_TOTP_SECRET: ${{ inputs.sign && secrets.SSL_COM_TOTP_SECRET }}
-        run: |
-          echo "Starting build process..."
-          yarn build
-
-      - name: Check bundle directory
-        shell: bash
-        run: |
-          echo "Checking bundle directory structure"
-          
-          # Check standard location
-          if [ -d "target/release/bundle" ]; then
-            echo "Found bundle directory at standard location"
-            ls -la target/release/bundle || echo "Failed to list bundle directory"
-          fi
-          
-          # Check src-tauri location
-          if [ -d "src-tauri/target/release/bundle" ]; then
-            echo "Found bundle directory in src-tauri"
-            ls -la src-tauri/target/release/bundle || echo "Failed to list src-tauri bundle directory"
-            
-            # Use this path for future steps
-            echo "BUNDLE_PATH=src-tauri/target/release/bundle" >> $GITHUB_ENV
-          else
-            echo "Using standard bundle path"
-            echo "BUNDLE_PATH=target/release/bundle" >> $GITHUB_ENV
-          fi
-          
-          # Check for MSI files in any location
-          find . -name "*.msi" -type f
+          ENABLE_CODE_SIGNING: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
+          WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
+          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
+        run: yarn build

      - name: Upload Artifact
        uses: actions/upload-artifact@v4
        with:
-          name: nym-wallet.msi
-          path: |
-            nym-wallet/${{ env.BUNDLE_PATH }}/msi/*.msi
-            nym-wallet/${{ env.BUNDLE_PATH }}/*/nym-wallet*.msi
-            nym-wallet/src-tauri/target/release/bundle/msi/*.msi
+          name: nym-wallet_1.0.0_x64_en-US.msi
+          path: nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi
          retention-days: 30

      - id: create-release
@@ -143,28 +97,25 @@ jobs:
        if: github.event_name == 'release'
        with:
          files: |
-            nym-wallet/${{ env.BUNDLE_PATH }}/msi/*.msi
-            nym-wallet/${{ env.BUNDLE_PATH }}/msi/*.msi.zip*
-            nym-wallet/${{ env.BUNDLE_PATH }}/*/nym-wallet*.msi
-            nym-wallet/src-tauri/target/release/bundle/msi/*.msi
-          
-      - name: Find MSI path for deployment
-        id: find-msi
-        shell: bash
-        run: |
-          MSI_FILE=$(find . -name "*.msi" -type f | head -n 1)
-          if [ -n "$MSI_FILE" ]; then
-            echo "Found MSI file: $MSI_FILE"
-            echo "msi_path=$MSI_FILE" >> $GITHUB_OUTPUT
-          else
-            echo "WARNING: No MSI file found for deployment!"
-            echo "msi_path=${{ env.BUNDLE_PATH }}/msi/nym-wallet*.msi" >> $GITHUB_OUTPUT
-          fi
+            nym-wallet/target/release/bundle/msi/*.msi
+            nym-wallet/target/release/bundle/msi/*.msi.zip*
+
+      - name: Deploy artifacts 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: "nym-wallet/target/release/bundle/msi/nym-wallet_1.*.msi"
+          REMOTE_HOST: ${{ secrets.CI_WWW_REMOTE_HOST }}
+          REMOTE_USER: ${{ secrets.CI_WWW_REMOTE_USER }}
+          TARGET: ${{ secrets.CI_WWW_REMOTE_TARGET }}/builds/${{ github.ref_name }}/nym-wallet
+          EXCLUDE: "/dist/, /node_modules/"            

  push-release-data:
    if: ${{ (startsWith(github.ref, 'refs/tags/nym-wallet-') && github.event_name == 'release') || github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/release-calculate-hash.yml
    needs: publish-tauri
    with:
-      release_tag: ${{ needs.publish-tauri.outputs.release_tag || github.ref_name }}
-    secrets: inherit
+      release_tag: ${{ github.ref_name }}
+    secrets: inherit
@@ -12,7 +12,7 @@ on:
 jobs:
  build:
    name: Build APK
-    runs-on: custom-ubuntu-22.04
+    runs-on: custom-ubuntu-20.04
    env:
      ANDROID_HOME: ${{ github.workspace }}/android-sdk
      NDK_VERSION: 25.2.9519653
@@ -49,7 +49,7 @@ jobs:
            "build-tools;$SDK_BUILDTOOLS_VERSION"

      - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@1.100.0
+        uses: dtolnay/rust-toolchain@1.90.0

      - name: Install rust android targets
        run: |
@@ -4,14 +4,14 @@ on:

 jobs:
  publish:
-    runs-on: arc-ubuntu-22.04
+    runs-on: arc-ubuntu-20.04
    steps:
      - uses: actions/checkout@v4

      - name: Install Node
        uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18
          registry-url: "https://registry.npmjs.org"

      - name: Setup yarn
@@ -31,7 +31,12 @@ jobs:
      - name: Set up Go
        uses: actions/setup-go@v5
        with:
-          go-version: "1.23.7"
+          go-version: "1.20"
+
+      - name: Install TinyGo
+        uses: acifani/setup-tinygo@v2
+        with:
+          tinygo-version: "0.27.0"

      - name: Install dependencies
        run: yarn
@@ -23,7 +23,7 @@ jobs:
        uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
-          node-version: 20
+          node-version: 18
      - uses: nymtech/nym/.github/actions/nym-hash-releases@develop
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -4,82 +4,6 @@ Post 1.0.0 release, the changelog format is based on [Keep a Changelog](https://

 ## [Unreleased]

-## [2025.6-chuckles] (2025-03-31)
-
- Remove Google public DNS ([#5660])
- Revert using AsyncWrite sink in IPR ([#5656])
- Add fd callback for initial authentication ([#5654])
- Add concurrency limit to CI ([#5651])
- Remove UNIQUE constraint on node pubkey ([#5649])
- Add RUSTUP_PERMIT_COPY_RENAME in two workflows that we forgot about ([#5646])
- Upgrade sha2 to workspace version for validator-client ([#5644])
- Add max_retransmissions flag on each message ([#5642])
- build(deps): bump zip from 2.2.2 to 2.4.1 ([#5639])
- build(deps): bump dtolnay/rust-toolchain from 1.90.0 to 1.100.0 ([#5638])
- / regenerated yarn.lock ([#5636])
- Rework IPR codec to extract out timer and implement AsyncWrite ([#5632])
- build(deps): bump tempfile from 3.18.0 to 3.19.0 ([#5631])
- build(deps): bump zeroize from 1.6.0 to 1.8.1 ([#5630])
- build(deps): bump once_cell from 1.20.3 to 1.21.1 ([#5629])
- build(deps): bump uuid from 1.15.1 to 1.16.0 ([#5628])
- build(deps): bump celes from 2.5.0 to 2.6.0 ([#5627])
- build(deps): bump http from 1.2.0 to 1.3.1 ([#5626])
- build(deps): bump humantime from 2.1.0 to 2.2.0 ([#5625])
- build(deps): bump the patch-updates group with 8 updates ([#5624])
- build(deps): bump @babel/runtime from 7.16.3 to 7.26.10 in /testnet-faucet ([#5621])
- Feature/paginated ticketbooks challenge ([#5619])
- build(deps-dev): bump webpack from 5.77.0 to 5.98.0 in /wasm/client/internal-dev ([#5615])
- build(deps-dev): bump ws from 8.13.0 to 8.18.1 in /wasm/client/internal-dev ([#5614])
- build(deps): bump golang.org/x/net from 0.23.0 to 0.36.0 in /wasm/mix-fetch/go-mix-conn ([#5613])
- build(deps): bump braces from 3.0.2 to 3.0.3 in /sdk/typescript/packages/mix-fetch-node ([#5612])
- Wireguard exit policies (and tests) ([#5557])
- Explorer V2 ([#5548])
- Clean stale partially received buffers ([#5536])
- Corrected typos ([#5497])
- build(deps): bump @octokit/plugin-paginate-rest and @actions/github in /.github/actions/nym-hash-releases/src ([#5488])
- feature: upgrade cosmwasm to 2.2 ([#5479])
- build(deps): bump store2 from 2.14.3 to 2.14.4 ([#5391])
- build(deps): bump nanoid from 3.3.7 to 3.3.8 in /documentation/docs ([#5335])
- build(deps): bump next from 13.5.7 to 14.2.15 in /documentation/docs ([#5281])
- Bump http-proxy-middleware from 2.0.6 to 2.0.7 ([#5019])
-
-[#5660]: https://github.com/nymtech/nym/pull/5660
-[#5656]: https://github.com/nymtech/nym/pull/5656
-[#5654]: https://github.com/nymtech/nym/pull/5654
-[#5651]: https://github.com/nymtech/nym/pull/5651
-[#5649]: https://github.com/nymtech/nym/pull/5649
-[#5646]: https://github.com/nymtech/nym/pull/5646
-[#5644]: https://github.com/nymtech/nym/pull/5644
-[#5642]: https://github.com/nymtech/nym/pull/5642
-[#5639]: https://github.com/nymtech/nym/pull/5639
-[#5638]: https://github.com/nymtech/nym/pull/5638
-[#5636]: https://github.com/nymtech/nym/pull/5636
-[#5632]: https://github.com/nymtech/nym/pull/5632
-[#5631]: https://github.com/nymtech/nym/pull/5631
-[#5630]: https://github.com/nymtech/nym/pull/5630
-[#5629]: https://github.com/nymtech/nym/pull/5629
-[#5628]: https://github.com/nymtech/nym/pull/5628
-[#5627]: https://github.com/nymtech/nym/pull/5627
-[#5626]: https://github.com/nymtech/nym/pull/5626
-[#5625]: https://github.com/nymtech/nym/pull/5625
-[#5624]: https://github.com/nymtech/nym/pull/5624
-[#5621]: https://github.com/nymtech/nym/pull/5621
-[#5619]: https://github.com/nymtech/nym/pull/5619
-[#5615]: https://github.com/nymtech/nym/pull/5615
-[#5614]: https://github.com/nymtech/nym/pull/5614
-[#5613]: https://github.com/nymtech/nym/pull/5613
-[#5612]: https://github.com/nymtech/nym/pull/5612
-[#5557]: https://github.com/nymtech/nym/pull/5557
-[#5548]: https://github.com/nymtech/nym/pull/5548
-[#5536]: https://github.com/nymtech/nym/pull/5536
-[#5497]: https://github.com/nymtech/nym/pull/5497
-[#5488]: https://github.com/nymtech/nym/pull/5488
-[#5479]: https://github.com/nymtech/nym/pull/5479
-[#5391]: https://github.com/nymtech/nym/pull/5391
-[#5335]: https://github.com/nymtech/nym/pull/5335
-[#5281]: https://github.com/nymtech/nym/pull/5281
-[#5019]: https://github.com/nymtech/nym/pull/5019
-
 ## [2025.5-chokito] (2025-03-18)

 - build(deps): bump braces from 3.0.2 to 3.0.3 in /sdk/typescript/packages/nodejs-client ([#5611])
@@ -32,13 +32,15 @@ members = [
    "common/client-libs/validator-client",
    "common/commands",
    "common/config",
+    "common/cosmwasm-smart-contracts/coconut-bandwidth-contract",
    "common/cosmwasm-smart-contracts/coconut-dkg",
-    "common/cosmwasm-smart-contracts/contracts-common", "common/cosmwasm-smart-contracts/easy_addr",
+    "common/cosmwasm-smart-contracts/contracts-common",
    "common/cosmwasm-smart-contracts/ecash-contract",
    "common/cosmwasm-smart-contracts/group-contract",
    "common/cosmwasm-smart-contracts/mixnet-contract",
    "common/cosmwasm-smart-contracts/multisig-contract",
    "common/cosmwasm-smart-contracts/vesting-contract",
+    "common/country-group",
    "common/credential-storage",
    "common/credential-utils",
    "common/credential-verification",
@@ -96,6 +98,9 @@ members = [
    "common/wireguard",
    "common/wireguard-types",
    "documentation/autodoc",
+    # "explorer-api",
+    # "explorer-api/explorer-api-requests",
+    # "explorer-api/explorer-client",
    "gateway",
    "integrations/bity",
    "nym-api",
@@ -199,8 +204,8 @@ bincode = "1.3.3"
 bip39 = { version = "2.0.0", features = ["zeroize"] }
 bit-vec = "0.7.0"                                     # can we unify those?
 bitvec = "1.0.0"
-blake3 = "1.7.0"
-bloomfilter = "3.0.1"
+blake3 = "1.6.1"
+bloomfilter = "1.0.14"
 bs58 = "0.5.1"
 bytecodec = "0.4.15"
 bytes = "1.10.1"
@@ -211,7 +216,7 @@ chacha20 = "0.9.0"
 chacha20poly1305 = "0.10.1"
 chrono = "0.4.40"
 cipher = "0.4.3"
-clap = "4.5.34"
+clap = "4.5.32"
 clap_complete = "4.5"
 clap_complete_fig = "4.5"
 colored = "2.2"
@@ -266,6 +271,7 @@ indicatif = "0.17.11"
 inquire = "0.6.2"
 ip_network = "0.4.1"
 ipnetwork = "0.20"
+isocountry = "0.3.2"
 itertools = "0.14.0"
 k256 = "0.13"
 lazy_static = "1.5.0"
@@ -278,7 +284,7 @@ moka = { version = "0.12", features = ["future"] }
 nix = "0.27.1"
 notify = "5.1.0"
 okapi = "0.7.0"
-once_cell = "1.21.3"
+once_cell = "1.21.1"
 opentelemetry = "0.19.0"
 opentelemetry-jaeger = "0.18.0"
 parking_lot = "0.12.3"
@@ -297,7 +303,10 @@ rand_pcg = "0.3.1"
 rand_seeder = "0.2.3"
 rayon = "1.5.1"
 regex = "1.10.6"
-reqwest = { version = "0.12.15", default-features = false }
+reqwest = { version = "0.12.4", default-features = false }
+rocket = "0.5.0"
+rocket_cors = "0.6.0"
+rocket_okapi = "0.8.0"
 rs_merkle = "1.5.0"
 safer-ffi = "0.1.13"
 schemars = "0.8.22"
@@ -312,8 +321,8 @@ serde_with = "3.9.0"
 serde_yaml = "0.9.25"
 sha2 = "0.10.8"
 si-scale = "0.2.3"
-sphinx-packet = "=0.6.0"
-sqlx = "0.7.4"
+sphinx-packet = "=0.3.2"
+sqlx = "0.8.3"
 strum = "0.26"
 strum_macros = "0.26"
 subtle-encoding = "0.5"
@@ -323,7 +332,7 @@ tap = "1.0.1"
 tar = "0.4.44"
 tempfile = "3.19"
 thiserror = "2.0"
-time = "0.3.41"
+time = "0.3.39"
 tokio = "1.44"
 tokio-postgres = "0.7"
 tokio-stream = "0.1.17"
@@ -339,10 +348,9 @@ tracing-log = "0.2"
 tracing-opentelemetry = "0.19.0"
 tracing-subscriber = "0.3.19"
 tracing-tree = "0.2.2"
-tracing-indicatif = "0.3.9"
 ts-rs = "10.1.0"
 tungstenite = { version = "0.20.1", default-features = false }
-uniffi = "0.29.1"
+uniffi = "0.29.0"
 uniffi_build = "0.29.0"
 url = "2.5"
 utoipa = "5.2"
@@ -353,7 +361,7 @@ vergen = { version = "=8.3.1", default-features = false }
 walkdir = "2"
 wasm-bindgen-test = "0.3.49"
 x25519-dalek = "2.0.0"
-zeroize = "1.7.0"
+zeroize = "1.8.1"

 prometheus = { version = "0.13.0" }

@@ -367,18 +375,19 @@ ff = { version = "0.13.1", default-features = false }
 subtle = "2.5.0"

 # cosmwasm-related
-cosmwasm-schema = "=2.2.2"
-cosmwasm-std = "=2.2.2"
-# use 1.0.1 as that's the version used by cosmwasm-std 2.2.1
+cosmwasm-schema = "=1.4.3"
+cosmwasm-std = "=1.4.3"
+# use 0.5.0 as that's the version used by cosmwasm-std 1.4.3
 # (and ideally we don't want to pull the same dependency twice)
-serde-json-wasm = "=1.0.1"
+serde-json-wasm = "=0.5.0"
+cosmwasm-storage = "=1.4.3"
 # same version as used by cosmwasm
-cw-utils = "=2.0.0"
-cw-storage-plus = "=2.0.0"
-cw2 = { version = "=2.0.0" }
-cw3 = { version = "=2.0.0" }
-cw4 = { version = "=2.0.0" }
-cw-controllers = { version = "=2.0.0" }
+cw-utils = "=1.0.1"
+cw-storage-plus = "=1.2.0"
+cw2 = { version = "=1.1.2" }
+cw3 = { version = "=1.1.2" }
+cw4 = { version = "=1.1.2" }
+cw-controllers = { version = "=1.1.0" }

 # cosmrs-related
 bip32 = { version = "0.5.3", default-features = false }
@@ -402,11 +411,6 @@ wasm-bindgen-futures = "0.4.49"
 wasmtimer = "0.4.1"
 web-sys = "0.3.76"

-
-# for local development:
-#[patch.crates-io]
-#sphinx-packet = { path = "../sphinx" }
-
 # Profile settings for individual crates

 # Compile-time verified queries do quite a bit of work at compile time. Incremental
@@ -133,22 +133,17 @@ clippy: sdk-wasm-lint
 # Build contracts ready for deploy
 # -----------------------------------------------------------------------------

-CONTRACTS=vesting_contract mixnet_contract nym_ecash cw3_flex_multisig cw4_group nym_coconut_dkg
+CONTRACTS=vesting_contract mixnet_contract nym_ecash
 CONTRACTS_WASM=$(addsuffix .wasm, $(CONTRACTS))
 CONTRACTS_OUT_DIR=contracts/target/wasm32-unknown-unknown/release

-contracts: build-release-contracts wasm-opt-contracts cosmwasm-check-contracts
+contracts: build-release-contracts wasm-opt-contracts

 wasm-opt-contracts:
 	for contract in $(CONTRACTS_WASM); do \
 	  wasm-opt --signext-lowering -Os $(CONTRACTS_OUT_DIR)/$$contract -o $(CONTRACTS_OUT_DIR)/$$contract; \
 	done

-cosmwasm-check-contracts:
-	for contract in $(CONTRACTS_WASM); do \
-	  cosmwasm-check $(CONTRACTS_OUT_DIR)/$$contract; \
-	done
-
 # Consider adding 's' to make plural consistent (beware: used in github workflow)
 contract-schema:
 	$(MAKE) -C contracts schema
@@ -157,9 +152,18 @@ contract-schema:
 # Convenience targets for crates that are already part of the main workspace
 # -----------------------------------------------------------------------------

+build-explorer-api:
+	cargo build -p explorer-api
+
 build-nym-cli:
 	cargo build -p nym-cli --release

+build-nym-gateway:
+	cargo build -p nym-gateway --release
+
+build-nym-mixnode:
+	cargo build -p nym-mixnode --release
+
 # -----------------------------------------------------------------------------
 # Misc
 # -----------------------------------------------------------------------------
@@ -168,12 +172,17 @@ generate-typescript:
 	cd tools/ts-rs-cli && cargo run && cd ../..
 	yarn types:lint:fix

-# Run the integration tests for public nym-api endpoints
 run-api-tests:
-	dotenv -f envs/sandbox.env -- cargo test --test public-api-tests
+	cd nym-api/tests/functional_test && yarn test:qa

 # Build debian package, and update PPA
+deb-mixnode: build-nym-mixnode
+	cargo deb -p nym-mixnode 
+
+deb-gateway: build-nym-gateway
+	cargo deb -p nym-gateway
+
 deb-cli: build-nym-cli
 	cargo deb -p nym-cli

-deb: deb-cli
+deb: deb-mixnode deb-gateway deb-cli
@@ -1,6 +1,6 @@
 [package]
 name = "nym-client"
-version = "1.1.53"
+version = "1.1.51"
 authors = ["Dave Hrycyszyn <futurechimp@users.noreply.github.com>", "Jędrzej Stuczyński <andrew@nymtech.net>"]
 description = "Implementation of the Nym Client"
 edition = "2021"
@@ -1,6 +1,6 @@
 [package]
 name = "nym-socks5-client"
-version = "1.1.53"
+version = "1.1.51"
 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"
@@ -87,6 +87,7 @@ impl From<Init> for OverrideConfig {
            use_anonymous_replies: init_config.use_reply_surbs,
            fastmode: init_config.common_args.fastmode,
            no_cover: init_config.common_args.no_cover,
+            geo_routing: None,
            medium_toggle: false,
            nyxd_urls: init_config.common_args.nyxd_urls,
            enabled_credentials_mode: init_config.common_args.enabled_credentials_mode,
@@ -16,7 +16,8 @@ use nym_bin_common::bin_info;
 use nym_bin_common::completions::{fig_generate, ArgShell};
 use nym_client_core::cli_helpers::CliClient;
 use nym_client_core::client::base_client::storage::migration_helpers::v1_1_33;
-use nym_client_core::config::ForgetMe;
+use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
+use nym_client_core::config::{ForgetMe, GroupBy, TopologyStructure};
 use nym_config::OptionalSet;
 use nym_sphinx::addressing::Recipient;
 use nym_sphinx::params::{PacketSize, PacketType};
@@ -106,6 +107,7 @@ pub(crate) struct OverrideConfig {
    use_anonymous_replies: Option<bool>,
    fastmode: bool,
    no_cover: bool,
+    geo_routing: Option<CountryGroup>,
    medium_toggle: bool,
    nyxd_urls: Option<Vec<url::Url>>,
    enabled_credentials_mode: Option<bool>,
@@ -136,6 +138,21 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
    let secondary_packet_size = args.medium_toggle.then_some(PacketSize::ExtendedPacket16);
    let no_per_hop_delays = args.medium_toggle;

+    let topology_structure = if args.medium_toggle {
+        // Use the location of the network-requester
+        let address = config
+            .core
+            .socks5
+            .provider_mix_address
+            .parse()
+            .expect("failed to parse provider mix address");
+        TopologyStructure::GeoAware(GroupBy::NymAddress(address))
+    } else if let Some(code) = args.geo_routing {
+        TopologyStructure::GeoAware(GroupBy::CountryGroup(code))
+    } else {
+        TopologyStructure::default()
+    };
+
    let packet_type = if args.outfox {
        PacketType::Outfox
    } else {
@@ -159,6 +176,10 @@ pub(crate) fn override_config(config: Config, args: OverrideConfig) -> Config {
        // NOTE: see comment above about the order of the other disble cover traffic config
        .with_base(BaseClientConfig::with_disabled_cover_traffic, args.no_cover)
        .with_base(BaseClientConfig::with_packet_type, packet_type)
+        .with_base(
+            BaseClientConfig::with_topology_structure,
+            topology_structure,
+        )
        .with_base(BaseClientConfig::with_forget_me, args.forget_me)
        .with_optional(Config::with_anonymous_replies, args.use_anonymous_replies)
        .with_optional(Config::with_port, args.port)
@@ -6,6 +6,7 @@ use crate::commands::{override_config, OverrideConfig};
 use clap::Args;
 use nym_client_core::cli_helpers::client_run::CommonClientRunArgs;
 use nym_client_core::client::base_client::storage::OnDiskPersistent;
+use nym_client_core::client::topology_control::geo_aware_provider::CountryGroup;
 use nym_socks5_client_core::NymClient;
 use nym_sphinx::addressing::clients::Recipient;
 use std::net::IpAddr;
@@ -36,6 +37,10 @@ pub(crate) struct Run {
    #[clap(long)]
    host: Option<IpAddr>,

+    /// Set geo-aware mixnode selection when sending mixnet traffic, for experiments only.
+    #[clap(long, hide = true, value_parser = validate_country_group, group="routing")]
+    geo_routing: Option<CountryGroup>,
+
    /// Enable medium mixnet traffic, for experiments only.
    /// This includes things like disabling cover traffic, no per hop delays, etc.
    #[clap(long, hide = true)]
@@ -54,6 +59,7 @@ impl From<Run> for OverrideConfig {
            use_anonymous_replies: run_config.use_anonymous_replies,
            fastmode: run_config.common_args.fastmode,
            no_cover: run_config.common_args.no_cover,
+            geo_routing: run_config.geo_routing,
            medium_toggle: run_config.medium_toggle,
            nyxd_urls: run_config.common_args.nyxd_urls,
            enabled_credentials_mode: run_config.common_args.enabled_credentials_mode,
@@ -64,6 +70,13 @@ impl From<Run> for OverrideConfig {
    }
 }

+fn validate_country_group(s: &str) -> Result<CountryGroup, String> {
+    match s.parse() {
+        Ok(cg) => Ok(cg),
+        Err(_) => Err(format!("failed to parse country group: {}", s)),
+    }
+}
+
 pub(crate) async fn execute(args: Run) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    eprintln!("Starting client {}...", args.common_args.id);

@@ -13,7 +13,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
+use nym_crypto::asymmetric::encryption::PrivateKey;
 #[cfg(feature = "verify")]
 use sha2::Sha256;

@@ -82,14 +82,16 @@ impl GatewayClient {
        private_ip: IpAddr,
        nonce: u64,
    ) -> Self {
-        let local_public = PublicKey::from(local_secret);
-        let remote_public = PublicKey::from(remote_public);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
+        let local_public: x25519_dalek::PublicKey = (&static_secret).into();

-        let dh = local_secret.diffie_hellman(&remote_public);
+        let dh = static_secret.diffie_hellman(&remote_public);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(&dh[..])
+        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
            .expect("x25519 shared secret is always 32 bytes long");

        mac.update(local_public.as_bytes());
@@ -97,7 +99,7 @@ impl GatewayClient {
        mac.update(&nonce.to_le_bytes());

        GatewayClient {
-            pub_key: PeerPublicKey::new(local_public.into()),
+            pub_key: PeerPublicKey::new(local_public),
            private_ip,
            mac: ClientMac(mac.finalize().into_bytes().to_vec()),
        }
@@ -107,8 +109,11 @@ impl GatewayClient {
    // Client should perform this step when generating its payload, using its own WG PK
    #[cfg(feature = "verify")]
    pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // use gateways key as a ref to an x25519_dalek key
-        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
+
+        let dh = static_secret.diffie_hellman(&self.pub_key);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
@@ -190,15 +195,15 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use nym_crypto::asymmetric::x25519;
+    use nym_crypto::asymmetric::encryption;

    #[test]
    #[cfg(feature = "verify")]
    fn client_request_roundtrip() {
        let mut rng = rand::thread_rng();

-        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
-        let client_key_pair = x25519::KeyPair::new(&mut rng);
+        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
+        let client_key_pair = encryption::KeyPair::new(&mut rng);

        let nonce = 1234567890;

@@ -14,7 +14,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
+use nym_crypto::asymmetric::encryption::PrivateKey;
 #[cfg(feature = "verify")]
 use sha2::Sha256;

@@ -91,14 +91,16 @@ impl GatewayClient {
        private_ip: IpAddr,
        nonce: u64,
    ) -> Self {
-        let local_public = PublicKey::from(local_secret);
-        let remote_public = PublicKey::from(remote_public);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
+        let local_public: x25519_dalek::PublicKey = (&static_secret).into();

-        let dh = local_secret.diffie_hellman(&remote_public);
+        let dh = static_secret.diffie_hellman(&remote_public);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(&dh[..])
+        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
            .expect("x25519 shared secret is always 32 bytes long");

        mac.update(local_public.as_bytes());
@@ -106,7 +108,7 @@ impl GatewayClient {
        mac.update(&nonce.to_le_bytes());

        GatewayClient {
-            pub_key: PeerPublicKey::new(local_public.into()),
+            pub_key: PeerPublicKey::new(local_public),
            private_ip,
            mac: ClientMac(mac.finalize().into_bytes().to_vec()),
        }
@@ -116,8 +118,11 @@ impl GatewayClient {
    // Client should perform this step when generating its payload, using its own WG PK
    #[cfg(feature = "verify")]
    pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // use gateways key as a ref to an x25519_dalek key
-        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
+
+        let dh = static_secret.diffie_hellman(&self.pub_key);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
@@ -199,15 +204,15 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use nym_crypto::asymmetric::x25519;
+    use nym_crypto::asymmetric::encryption;

    #[test]
    #[cfg(feature = "verify")]
    fn client_request_roundtrip() {
        let mut rng = rand::thread_rng();

-        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
-        let client_key_pair = x25519::KeyPair::new(&mut rng);
+        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
+        let client_key_pair = encryption::KeyPair::new(&mut rng);

        let nonce = 1234567890;

@@ -340,7 +340,7 @@ mod tests {
    use std::{net::IpAddr, str::FromStr};

    use nym_credentials_interface::CredentialSpendingData;
-    use nym_crypto::asymmetric::x25519::PrivateKey;
+    use nym_crypto::asymmetric::encryption::PrivateKey;
    use nym_sphinx::addressing::Recipient;
    use nym_wireguard_types::PeerPublicKey;
    use x25519_dalek::PublicKey;
@@ -14,7 +14,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
+use nym_crypto::asymmetric::encryption::PrivateKey;
 #[cfg(feature = "verify")]
 use sha2::Sha256;

@@ -91,14 +91,16 @@ impl GatewayClient {
        private_ip: IpAddr,
        nonce: u64,
    ) -> Self {
-        let local_public = PublicKey::from(local_secret);
-        let remote_public = PublicKey::from(remote_public);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
+        let local_public: x25519_dalek::PublicKey = (&static_secret).into();

-        let dh = local_secret.diffie_hellman(&remote_public);
+        let dh = static_secret.diffie_hellman(&remote_public);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(&dh[..])
+        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
            .expect("x25519 shared secret is always 32 bytes long");

        mac.update(local_public.as_bytes());
@@ -106,7 +108,7 @@ impl GatewayClient {
        mac.update(&nonce.to_le_bytes());

        GatewayClient {
-            pub_key: PeerPublicKey::new(local_public.into()),
+            pub_key: PeerPublicKey::new(local_public),
            private_ip,
            mac: ClientMac(mac.finalize().into_bytes().to_vec()),
        }
@@ -116,8 +118,11 @@ impl GatewayClient {
    // Client should perform this step when generating its payload, using its own WG PK
    #[cfg(feature = "verify")]
    pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // use gateways key as a ref to an x25519_dalek key
-        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
+
+        let dh = static_secret.diffie_hellman(&self.pub_key);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
@@ -199,15 +204,15 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use nym_crypto::asymmetric::x25519;
+    use nym_crypto::asymmetric::encryption;

    #[test]
    #[cfg(feature = "verify")]
    fn client_request_roundtrip() {
        let mut rng = rand::thread_rng();

-        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
-        let client_key_pair = x25519::KeyPair::new(&mut rng);
+        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
+        let client_key_pair = encryption::KeyPair::new(&mut rng);

        let nonce = 1234567890;

@@ -306,7 +306,7 @@ mod tests {
    };

    use nym_credentials_interface::CredentialSpendingData;
-    use nym_crypto::asymmetric::x25519::PrivateKey;
+    use nym_crypto::asymmetric::encryption::PrivateKey;
    use nym_sphinx::addressing::Recipient;
    use nym_wireguard_types::PeerPublicKey;
    use x25519_dalek::PublicKey;
@@ -15,7 +15,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
+use nym_crypto::asymmetric::encryption::PrivateKey;
 #[cfg(feature = "verify")]
 use sha2::Sha256;

@@ -143,14 +143,16 @@ impl GatewayClient {
        private_ips: IpPair,
        nonce: u64,
    ) -> Self {
-        let local_public = PublicKey::from(local_secret);
-        let remote_public = PublicKey::from(remote_public);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
+        let local_public: x25519_dalek::PublicKey = (&static_secret).into();

-        let dh = local_secret.diffie_hellman(&remote_public);
+        let dh = static_secret.diffie_hellman(&remote_public);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(&dh[..])
+        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
            .expect("x25519 shared secret is always 32 bytes long");

        mac.update(local_public.as_bytes());
@@ -158,7 +160,7 @@ impl GatewayClient {
        mac.update(&nonce.to_le_bytes());

        GatewayClient {
-            pub_key: PeerPublicKey::new(local_public.into()),
+            pub_key: PeerPublicKey::new(local_public),
            private_ips,
            mac: ClientMac(mac.finalize().into_bytes().to_vec()),
        }
@@ -168,8 +170,11 @@ impl GatewayClient {
    // Client should perform this step when generating its payload, using its own WG PK
    #[cfg(feature = "verify")]
    pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // use gateways key as a ref to an x25519_dalek key
-        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
+
+        let dh = static_secret.diffie_hellman(&self.pub_key);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
@@ -251,7 +256,7 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use nym_crypto::asymmetric::x25519;
+    use nym_crypto::asymmetric::encryption;

    #[test]
    fn create_ip_pair() {
@@ -266,8 +271,8 @@ mod tests {
    fn client_request_roundtrip() {
        let mut rng = rand::thread_rng();

-        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
-        let client_key_pair = x25519::KeyPair::new(&mut rng);
+        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
+        let client_key_pair = encryption::KeyPair::new(&mut rng);

        let nonce = 1234567890;

@@ -230,7 +230,7 @@ mod tests {
    };

    use nym_credentials_interface::CredentialSpendingData;
-    use nym_crypto::asymmetric::x25519::PrivateKey;
+    use nym_crypto::asymmetric::encryption::PrivateKey;
    use nym_sphinx::addressing::Recipient;
    use nym_wireguard_types::PeerPublicKey;
    use x25519_dalek::PublicKey;
@@ -15,7 +15,7 @@ use std::{fmt, ops::Deref, str::FromStr};
 #[cfg(feature = "verify")]
 use hmac::{Hmac, Mac};
 #[cfg(feature = "verify")]
-use nym_crypto::asymmetric::x25519::{PrivateKey, PublicKey};
+use nym_crypto::asymmetric::encryption::PrivateKey;
 #[cfg(feature = "verify")]
 use sha2::Sha256;

@@ -143,14 +143,16 @@ impl GatewayClient {
        private_ips: IpPair,
        nonce: u64,
    ) -> Self {
-        let local_public = PublicKey::from(local_secret);
-        let remote_public = PublicKey::from(remote_public);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(local_secret.to_bytes());
+        let local_public: x25519_dalek::PublicKey = (&static_secret).into();

-        let dh = local_secret.diffie_hellman(&remote_public);
+        let dh = static_secret.diffie_hellman(&remote_public);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
-        let mut mac = HmacSha256::new_from_slice(&dh[..])
+        let mut mac = HmacSha256::new_from_slice(dh.as_bytes())
            .expect("x25519 shared secret is always 32 bytes long");

        mac.update(local_public.as_bytes());
@@ -158,7 +160,7 @@ impl GatewayClient {
        mac.update(&nonce.to_le_bytes());

        GatewayClient {
-            pub_key: PeerPublicKey::new(local_public.into()),
+            pub_key: PeerPublicKey::new(local_public),
            private_ips,
            mac: ClientMac(mac.finalize().into_bytes().to_vec()),
        }
@@ -168,8 +170,11 @@ impl GatewayClient {
    // Client should perform this step when generating its payload, using its own WG PK
    #[cfg(feature = "verify")]
    pub fn verify(&self, gateway_key: &PrivateKey, nonce: u64) -> Result<(), Error> {
-        // use gateways key as a ref to an x25519_dalek key
-        let dh = (gateway_key.as_ref()).diffie_hellman(&self.pub_key);
+        // convert from 1.0 x25519-dalek private key into 2.0 x25519-dalek
+        #[allow(clippy::expect_used)]
+        let static_secret = x25519_dalek::StaticSecret::from(gateway_key.to_bytes());
+
+        let dh = static_secret.diffie_hellman(&self.pub_key);

        // TODO: change that to use our nym_crypto::hmac module instead
        #[allow(clippy::expect_used)]
@@ -251,7 +256,7 @@ impl<'de> Deserialize<'de> for ClientMac {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use nym_crypto::asymmetric::x25519;
+    use nym_crypto::asymmetric::encryption;

    #[test]
    fn create_ip_pair() {
@@ -266,8 +271,8 @@ mod tests {
    fn client_request_roundtrip() {
        let mut rng = rand::thread_rng();

-        let gateway_key_pair = x25519::KeyPair::new(&mut rng);
-        let client_key_pair = x25519::KeyPair::new(&mut rng);
+        let gateway_key_pair = encryption::KeyPair::new(&mut rng);
+        let client_key_pair = encryption::KeyPair::new(&mut rng);

        let nonce = 1234567890;

@@ -11,7 +11,7 @@ use nym_credentials::ecash::bandwidth::IssuanceTicketBook;
 use nym_credentials::ecash::utils::obtain_aggregate_wallet;
 use nym_credentials::IssuedTicketBook;
 use nym_credentials_interface::TicketType;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_ecash_time::{ecash_default_expiration_date, Date};
 use nym_validator_client::coconut::all_ecash_api_clients;
 use nym_validator_client::nym_api::EpochId;
@@ -31,7 +31,7 @@ where
    C: EcashSigningClient + EcashQueryClient + Sync,
 {
    let mut rng = OsRng;
-    let signing_key = ed25519::PrivateKey::new(&mut rng);
+    let signing_key = identity::PrivateKey::new(&mut rng);
    let expiration = expiration.unwrap_or_else(ecash_default_expiration_date);

    let deposit_amount = client.get_required_deposit_amount().await?;
@@ -4,8 +4,8 @@
 use nym_credential_storage::error::StorageError;
 use nym_credentials::error::Error as CredentialsError;
 use nym_credentials_interface::CompactEcashError;
-use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
-use nym_crypto::asymmetric::x25519::KeyRecoveryError;
+use nym_crypto::asymmetric::encryption::KeyRecoveryError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use nym_validator_client::coconut::EcashApiError;
 use nym_validator_client::error::ValidatorClientError;
 use thiserror::Error;
@@ -21,7 +21,6 @@ serde_json = { workspace = true, optional = true }
 ## tracing
 tracing-subscriber = { workspace = true, features = ["env-filter"], optional = true }
 tracing-tree = { workspace = true, optional = true }
-tracing = { workspace = true, optional = true }
 opentelemetry-jaeger = { workspace = true, features = ["rt-tokio", "collector_client", "isahc_collector_client"], optional = true }
 tracing-opentelemetry = { workspace = true, optional = true }
 utoipa = { workspace = true, optional = true }
@@ -36,7 +35,7 @@ default = []
 openapi = ["utoipa"]
 output_format = ["serde_json", "dep:clap"]
 bin_info_schema = ["schemars"]
-basic_tracing = ["dep:tracing", "tracing-subscriber"]
+basic_tracing = ["tracing-subscriber"]
 tracing = [
    "basic_tracing",
    "tracing-tree",
@@ -44,38 +44,10 @@ pub fn setup_logging() {
        .init();
 }

-// don't call init so that we could attach additional layers
 #[cfg(feature = "basic_tracing")]
-pub fn build_tracing_logger() -> impl tracing_subscriber::layer::SubscriberExt {
-    use tracing_subscriber::prelude::*;
-
-    tracing_subscriber::registry()
-        .with(default_tracing_fmt_layer(std::io::stderr))
-        .with(default_tracing_env_filter())
-}
-
-#[cfg(feature = "basic_tracing")]
-pub fn default_tracing_env_filter() -> tracing_subscriber::filter::EnvFilter {
-    if ::std::env::var("RUST_LOG").is_ok() {
-        tracing_subscriber::filter::EnvFilter::from_default_env()
-    } else {
-        // if the env value was not found, default to `INFO` level rather than `ERROR`
-        tracing_subscriber::filter::EnvFilter::builder()
-            .with_default_directive(tracing_subscriber::filter::LevelFilter::INFO.into())
-            .parse_lossy("")
-    }
-}
-
-#[cfg(feature = "basic_tracing")]
-pub fn default_tracing_fmt_layer<S, W>(
-    writer: W,
-) -> impl tracing_subscriber::Layer<S> + Sync + Send + 'static
-where
-    S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
-    W: for<'writer> tracing_subscriber::fmt::MakeWriter<'writer> + Sync + Send + 'static,
-{
-    tracing_subscriber::fmt::layer()
-        .with_writer(writer)
+pub fn setup_tracing_logger() {
+    let log_builder = tracing_subscriber::fmt()
+        .with_writer(std::io::stderr)
        // Use a more compact, abbreviated log format
        .compact()
        // Display source code file paths
@@ -83,13 +55,18 @@ where
        // Display source code line numbers
        .with_line_number(true)
        // Don't display the event's target (module path)
-        .with_target(false)
-}
+        .with_target(false);

-#[cfg(feature = "basic_tracing")]
-pub fn setup_tracing_logger() {
-    use tracing_subscriber::util::SubscriberInitExt;
-    build_tracing_logger().init()
+    if ::std::env::var("RUST_LOG").is_ok() {
+        log_builder
+            .with_env_filter(tracing_subscriber::filter::EnvFilter::from_default_env())
+            .init()
+    } else {
+        // default to 'Info
+        log_builder
+            .with_max_level(tracing_subscriber::filter::LevelFilter::INFO)
+            .init()
+    }
 }

 // TODO: This has to be a macro, running it as a function does not work for the file_appender for some reason
@@ -12,6 +12,7 @@ license.workspace = true
 async-trait = { workspace = true }
 base64 = { workspace = true }
 bs58 = { workspace = true }
+cfg-if = { workspace = true }
 clap = { workspace = true, optional = true }
 comfy-table = { workspace = true, optional = true }
 futures = { workspace = true }
@@ -23,6 +24,7 @@ serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
 si-scale = { workspace = true }
+tap = { workspace = true }
 thiserror = { workspace = true }
 url = { workspace = true, features = ["serde"] }
 tokio = { workspace = true, features = ["macros"] }
@@ -33,7 +35,9 @@ zeroize = { workspace = true }
 nym-id = { path = "../nym-id" }
 nym-bandwidth-controller = { path = "../bandwidth-controller" }
 nym-config = { path = "../config" }
+nym-country-group = { path = "../country-group" }
 nym-crypto = { path = "../crypto" }
+nym-explorer-client = { path = "../../explorer-api/explorer-client" }
 nym-gateway-client = { path = "../client-libs/gateway-client" }
 nym-gateway-requests = { path = "../gateway-requests" }
 nym-http-api-client = { path = "../http-api-client" }
@@ -14,6 +14,7 @@ url = { workspace = true, features = ["serde"] }

 nym-config = { path = "../../config" }

+nym-country-group = { path = "../../country-group" }
 nym-pemstore = { path = "../../pemstore", optional = true }

 # those are pulling so many deps T.T
@@ -65,10 +65,11 @@ const DEFAULT_MAXIMUM_REPLY_KEY_AGE: Duration = Duration::from_secs(24 * 60 * 60

 // stats reporting related

-/// Time interval between reporting statistics to the given provider if it exists
+/// Time interval between reporting statistics to the given provider if it exist
 const STATS_REPORT_INTERVAL_SECS: Duration = Duration::from_secs(300);

 use crate::error::InvalidTrafficModeFailure;
+pub use nym_country_group::CountryGroup;

 #[derive(Debug, Clone, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
@@ -257,6 +258,15 @@ impl Config {
        self
    }

+    pub fn with_topology_structure(mut self, topology_structure: TopologyStructure) -> Self {
+        self.set_topology_structure(topology_structure);
+        self
+    }
+
+    pub fn set_topology_structure(&mut self, topology_structure: TopologyStructure) {
+        self.debug.topology.topology_structure = topology_structure;
+    }
+
    pub fn with_no_per_hop_delays(mut self, no_per_hop_delays: bool) -> Self {
        if no_per_hop_delays {
            self.set_no_per_hop_delays()
@@ -405,14 +415,6 @@ pub struct Traffic {
    /// Do not set it unless you understand the consequences of that change.
    pub secondary_packet_size: Option<PacketSize>,

-    /// Specify whether any constructed sphinx packets should use the legacy format,
-    /// where the payload keys are explicitly attached rather than using the seeds
-    /// this affects any forward packets, acks and reply surbs
-    /// this flag should remain disabled until sufficient number of nodes on the network has upgraded
-    /// and support updated format.
-    /// in the case of reply surbs, the recipient must also understand the new encoding
-    pub use_legacy_sphinx_format: bool,
-
    pub packet_type: PacketType,
 }

@@ -440,10 +442,6 @@ impl Default for Traffic {
            primary_packet_size: PacketSize::RegularPacket,
            secondary_packet_size: None,
            packet_type: PacketType::Mix,
-
-            // we should use the legacy format until sufficient number of nodes understand the
-            // improved encoding
-            use_legacy_sphinx_format: true,
        }
    }
 }
@@ -548,6 +546,9 @@ pub struct Topology {
    #[serde(with = "humantime_serde")]
    pub max_startup_gateway_waiting_period: Duration,

+    /// Specifies the mixnode topology to be used for sending packets.
+    pub topology_structure: TopologyStructure,
+
    /// Specifies a minimum performance of a mixnode that is used on route construction.
    /// This setting is only applicable when `NymApi` topology is used.
    pub minimum_mixnode_performance: u8,
@@ -569,6 +570,30 @@ pub struct Topology {
    pub ignore_ingress_epoch_role: bool,
 }

+#[allow(clippy::large_enum_variant)]
+#[derive(Default, Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum TopologyStructure {
+    #[default]
+    NymApi,
+    GeoAware(GroupBy),
+}
+
+#[allow(clippy::large_enum_variant)]
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum GroupBy {
+    CountryGroup(CountryGroup),
+    NymAddress(Recipient),
+}
+
+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 {
    fn default() -> Self {
        Topology {
@@ -576,6 +601,7 @@ impl Default for Topology {
            topology_resolution_timeout: DEFAULT_TOPOLOGY_RESOLUTION_TIMEOUT,
            disable_refreshing: false,
            max_startup_gateway_waiting_period: DEFAULT_MAX_STARTUP_GATEWAY_WAITING_PERIOD,
+            topology_structure: TopologyStructure::default(),
            minimum_mixnode_performance: DEFAULT_MIN_MIXNODE_PERFORMANCE,
            minimum_gateway_performance: DEFAULT_MIN_GATEWAY_PERFORMANCE,
            use_extended_topology: false,
@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::old::v5::{
-    AcknowledgementsV5, ClientV5, ConfigV5, CountryGroupV5, CoverTrafficV5, DebugConfigV5,
-    GatewayConnectionV5, GroupByV5, ReplySurbsV5, TopologyStructureV5, TopologyV5, TrafficV5,
+    AcknowledgementsV5, ClientV5, ConfigV5, CoverTrafficV5, DebugConfigV5, GatewayConnectionV5,
+    GroupByV5, ReplySurbsV5, TopologyStructureV5, TopologyV5, TrafficV5,
 };
+use crate::CountryGroup;
 use nym_sphinx_addressing::Recipient;
 use nym_sphinx_params::{PacketSize, PacketType};
 use serde::{Deserialize, Serialize};
@@ -368,47 +369,31 @@ impl From<TopologyStructureV4> for TopologyStructureV5 {
    }
 }

-#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub enum CountryGroupV4 {
-    Europe,
-    NorthAmerica,
-    SouthAmerica,
-    Oceania,
-    Asia,
-    Africa,
-    Unknown,
-}
-
-impl From<CountryGroupV4> for CountryGroupV5 {
-    fn from(value: CountryGroupV4) -> Self {
-        match value {
-            CountryGroupV4::Europe => CountryGroupV5::Europe,
-            CountryGroupV4::NorthAmerica => CountryGroupV5::NorthAmerica,
-            CountryGroupV4::SouthAmerica => CountryGroupV5::SouthAmerica,
-            CountryGroupV4::Oceania => CountryGroupV5::Oceania,
-            CountryGroupV4::Asia => CountryGroupV5::Asia,
-            CountryGroupV4::Africa => CountryGroupV5::Africa,
-            CountryGroupV4::Unknown => CountryGroupV5::Unknown,
-        }
-    }
-}
-
 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum GroupByV4 {
-    CountryGroup(CountryGroupV4),
+    CountryGroup(CountryGroup),
    NymAddress(Recipient),
 }

 impl From<GroupByV4> for GroupByV5 {
    fn from(value: GroupByV4) -> Self {
        match value {
-            GroupByV4::CountryGroup(country) => GroupByV5::CountryGroup(country.into()),
+            GroupByV4::CountryGroup(country) => GroupByV5::CountryGroup(country),
            GroupByV4::NymAddress(addr) => GroupByV5::NymAddress(addr),
        }
    }
 }

+impl std::fmt::Display for GroupByV4 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GroupByV4::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupByV4::NymAddress(address) => write!(f, "address: {}", address),
+        }
+    }
+}
+
 impl Default for TopologyV4 {
    fn default() -> Self {
        TopologyV4 {
@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::{
-    Acknowledgements, Client, Config, CoverTraffic, DebugConfig, GatewayConnection, ReplySurbs,
-    Topology, Traffic,
+    Acknowledgements, Client, Config, CountryGroup, CoverTraffic, DebugConfig, GatewayConnection,
+    GroupBy, ReplySurbs, Topology, TopologyStructure, Traffic,
 };
 use nym_sphinx_addressing::Recipient;
 use nym_sphinx_params::{PacketSize, PacketType};
@@ -146,6 +146,7 @@ impl From<ConfigV5> for Config {
                        .debug
                        .topology
                        .max_startup_gateway_waiting_period,
+                    topology_structure: value.debug.topology.topology_structure.into(),
                    ..Default::default()
                },
                reply_surbs: ReplySurbs {
@@ -371,24 +372,40 @@ pub enum TopologyStructureV5 {
    GeoAware(GroupByV5),
 }

-#[derive(Copy, Clone, Hash, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub enum CountryGroupV5 {
-    Europe,
-    NorthAmerica,
-    SouthAmerica,
-    Oceania,
-    Asia,
-    Africa,
-    Unknown,
+impl From<TopologyStructureV5> for TopologyStructure {
+    fn from(value: TopologyStructureV5) -> Self {
+        match value {
+            TopologyStructureV5::NymApi => TopologyStructure::NymApi,
+            TopologyStructureV5::GeoAware(group_by) => TopologyStructure::GeoAware(group_by.into()),
+        }
+    }
 }

 #[allow(clippy::large_enum_variant)]
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum GroupByV5 {
-    CountryGroup(CountryGroupV5),
+    CountryGroup(CountryGroup),
    NymAddress(Recipient),
 }

+impl From<GroupByV5> for GroupBy {
+    fn from(value: GroupByV5) -> Self {
+        match value {
+            GroupByV5::CountryGroup(country) => GroupBy::CountryGroup(country),
+            GroupByV5::NymAddress(addr) => GroupBy::NymAddress(addr),
+        }
+    }
+}
+
+impl std::fmt::Display for GroupByV5 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GroupByV5::CountryGroup(group) => write!(f, "group: {}", group),
+            GroupByV5::NymAddress(address) => write!(f, "address: {}", address),
+        }
+    }
+}
+
 impl Default for TopologyV5 {
    fn default() -> Self {
        TopologyV5 {
@@ -87,7 +87,7 @@ impl StorageManager {
        sqlx::query!("SELECT EXISTS (SELECT 1 FROM registered_gateway WHERE gateway_id_bs58 = ?) AS 'exists'", gateway_id)
            .fetch_one(&self.connection_pool)
            .await
-            .map(|result| result.exists == Some(1))
+            .map(|result| result.exists == 1)
    }

    pub(crate) async fn maybe_get_registered_gateway(
@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use nym_gateway_requests::shared_key::SharedKeyConversionError;
 use thiserror::Error;

@@ -5,7 +5,7 @@
 #![warn(clippy::unwrap_used)]

 use async_trait::async_trait;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_gateway_requests::SharedSymmetricKey;
 use std::error::Error;

@@ -36,7 +36,9 @@ pub trait GatewaysDetailsStore {
    async fn all_gateways(&self) -> Result<Vec<GatewayRegistration>, Self::StorageError>;

    /// Return identity keys of all registered gateways.
-    async fn all_gateways_identities(&self) -> Result<Vec<ed25519::PublicKey>, Self::StorageError> {
+    async fn all_gateways_identities(
+        &self,
+    ) -> Result<Vec<identity::PublicKey>, Self::StorageError> {
        Ok(self
            .all_gateways()
            .await?
@@ -62,7 +64,7 @@ pub trait GatewaysDetailsStore {

    async fn upgrade_stored_remote_gateway_key(
        &self,
-        gateway_id: ed25519::PublicKey,
+        gateway_id: identity::PublicKey,
        updated_key: &SharedSymmetricKey,
    ) -> Result<(), Self::StorageError>;

@@ -3,7 +3,7 @@

 use crate::BadGateway;
 use cosmrs::AccountId;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
@@ -29,7 +29,7 @@ pub struct GatewayRegistration {
 }

 impl GatewayRegistration {
-    pub fn gateway_id(&self) -> ed25519::PublicKey {
+    pub fn gateway_id(&self) -> identity::PublicKey {
        self.details.gateway_id()
    }
 }
@@ -64,7 +64,7 @@ impl From<GatewayDetails> for GatewayRegistration {

 impl GatewayDetails {
    pub fn new_remote(
-        gateway_id: ed25519::PublicKey,
+        gateway_id: identity::PublicKey,
        shared_key: Arc<SharedGatewayKey>,
        gateway_owner_address: Option<AccountId>,
        gateway_listener: Url,
@@ -77,11 +77,11 @@ impl GatewayDetails {
        })
    }

-    pub fn new_custom(gateway_id: ed25519::PublicKey, data: Option<Vec<u8>>) -> Self {
+    pub fn new_custom(gateway_id: identity::PublicKey, data: Option<Vec<u8>>) -> Self {
        GatewayDetails::Custom(CustomGatewayDetails { gateway_id, data })
    }

-    pub fn gateway_id(&self) -> ed25519::PublicKey {
+    pub fn gateway_id(&self) -> identity::PublicKey {
        match self {
            GatewayDetails::Remote(details) => details.gateway_id,
            GatewayDetails::Custom(details) => details.gateway_id,
@@ -157,7 +157,7 @@ pub struct RawRegisteredGateway {

 #[derive(Debug, Clone, Copy)]
 pub struct RegisteredGateway {
-    pub gateway_id: ed25519::PublicKey,
+    pub gateway_id: identity::PublicKey,

    pub registration_timestamp: OffsetDateTime,

@@ -179,7 +179,7 @@ impl TryFrom<RawRemoteGatewayDetails> for RemoteGatewayDetails {

    fn try_from(value: RawRemoteGatewayDetails) -> Result<Self, Self::Error> {
        let gateway_id =
-            ed25519::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
+            identity::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
                BadGateway::MalformedGatewayIdentity {
                    gateway_id: value.gateway_id_bs58.clone(),
                    source,
@@ -267,7 +267,7 @@ impl<'a> From<&'a RemoteGatewayDetails> for RawRemoteGatewayDetails {

 #[derive(Debug, Clone)]
 pub struct RemoteGatewayDetails {
-    pub gateway_id: ed25519::PublicKey,
+    pub gateway_id: identity::PublicKey,

    pub shared_key: Arc<SharedGatewayKey>,

@@ -288,7 +288,7 @@ impl TryFrom<RawCustomGatewayDetails> for CustomGatewayDetails {

    fn try_from(value: RawCustomGatewayDetails) -> Result<Self, Self::Error> {
        let gateway_id =
-            ed25519::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
+            identity::PublicKey::from_base58_string(&value.gateway_id_bs58).map_err(|source| {
                BadGateway::MalformedGatewayIdentity {
                    gateway_id: value.gateway_id_bs58.clone(),
                    source,
@@ -314,12 +314,12 @@ impl<'a> From<&'a CustomGatewayDetails> for RawCustomGatewayDetails {

 #[derive(Debug, Clone)]
 pub struct CustomGatewayDetails {
-    pub gateway_id: ed25519::PublicKey,
+    pub gateway_id: identity::PublicKey,
    pub data: Option<Vec<u8>>,
 }

 impl CustomGatewayDetails {
-    pub fn new(gateway_id: ed25519::PublicKey) -> CustomGatewayDetails {
+    pub fn new(gateway_id: identity::PublicKey) -> CustomGatewayDetails {
        Self {
            gateway_id,
            data: None,
@@ -14,7 +14,7 @@ use crate::{
 };
 use log::info;
 use nym_client_core_gateways_storage::GatewayDetails;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_topology::NymTopology;
 use nym_validator_client::UserAgent;
 use std::path::PathBuf;
@@ -29,7 +29,7 @@ pub struct CommonClientAddGatewayArgs {
    /// Explicitly specify id of the gateway to register with.
    /// If unspecified, a random gateway will be chosen instead.
    #[cfg_attr(feature = "cli", clap(long, alias = "gateway"))]
-    pub gateway_id: Option<ed25519::PublicKey>,
+    pub gateway_id: Option<identity::PublicKey>,

    /// Specifies whether the client will attempt to enforce tls connection to the desired gateway.
    #[cfg_attr(feature = "cli", clap(long))]
@@ -139,8 +139,6 @@ where
    let gateway_setup = GatewaySetup::New {
        specification: selection_spec,
        available_gateways,
-        #[cfg(unix)]
-        connection_fd_callback: None,
    };

    let init_details =
@@ -14,7 +14,7 @@ use crate::{
 };
 use log::info;
 use nym_client_core_gateways_storage::GatewayDetails;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_sphinx::addressing::Recipient;
 use nym_topology::NymTopology;
 use nym_validator_client::UserAgent;
@@ -42,7 +42,7 @@ pub struct CommonClientInitArgs {

    /// Id of the gateway we are going to connect to.
    #[cfg_attr(feature = "cli", clap(long))]
-    pub gateway: Option<ed25519::PublicKey>,
+    pub gateway: Option<identity::PublicKey>,

    /// Specifies whether the client will attempt to enforce tls connection to the desired gateway.
    #[cfg_attr(feature = "cli", clap(long))]
@@ -187,8 +187,6 @@ where
    let gateway_setup = GatewaySetup::New {
        specification: selection_spec,
        available_gateways,
-        #[cfg(unix)]
-        connection_fd_callback: None,
    };

    let init_details =
@@ -1,7 +1,7 @@
 // Copyright 2023 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_sphinx::addressing::Recipient;
 use std::path::PathBuf;

@@ -15,7 +15,7 @@ pub struct CommonClientRunArgs {
    /// Id of the gateway we want to connect to. If overridden, it is user's responsibility to
    /// ensure prior registration happened
    #[cfg_attr(feature = "cli", clap(long))]
-    pub gateway: Option<ed25519::PublicKey>,
+    pub gateway: Option<identity::PublicKey>,

    /// Comma separated list of rest endpoints of the nyxd validators
    #[cfg_attr(
@@ -4,7 +4,7 @@
 use crate::cli_helpers::{CliClient, CliClientConfig};
 use crate::client::base_client::non_wasm_helpers::setup_fs_gateways_storage;
 use crate::client::base_client::storage::helpers::set_active_gateway;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;

 #[cfg_attr(feature = "cli", derive(clap::Args))]
 #[derive(Debug, Clone)]
@@ -15,7 +15,7 @@ pub struct CommonClientSwitchGatewaysArgs {

    /// Id of the gateway we want to switch to.
    #[cfg_attr(feature = "cli", clap(long))]
-    pub gateway_id: ed25519::PublicKey,
+    pub gateway_id: identity::PublicKey,
 }

 pub async fn switch_gateway<C, A>(args: A) -> Result<(), C::Error>
@@ -1,7 +1,7 @@
 // Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
 // SPDX-License-Identifier: Apache-2.0

-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 use time::OffsetDateTime;
@@ -10,7 +10,7 @@ use url::Url;
 #[derive(Serialize, Deserialize)]
 pub struct GatewayInfo {
    pub registration: OffsetDateTime,
-    pub identity: ed25519::PublicKey,
+    pub identity: identity::PublicKey,
    pub active: bool,

    pub typ: String,
@@ -39,7 +39,7 @@ use nym_bandwidth_controller::BandwidthController;
 use nym_client_core_config_types::ForgetMe;
 use nym_client_core_gateways_storage::{GatewayDetails, GatewaysDetailsStore};
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::{ed25519, x25519};
+use nym_crypto::asymmetric::{encryption, identity};
 use nym_crypto::hkdf::DerivationMaterial;
 use nym_gateway_client::client::config::GatewayClientConfig;
 use nym_gateway_client::{
@@ -367,7 +367,7 @@ where
    // buffer controlling all messages fetched from provider
    // required so that other components would be able to use them (say the websocket)
    fn start_received_messages_buffer_controller(
-        local_encryption_keypair: Arc<x25519::KeyPair>,
+        local_encryption_keypair: Arc<encryption::KeyPair>,
        query_receiver: ReceivedBufferRequestReceiver,
        mixnet_receiver: MixnetMessageReceiver,
        reply_key_storage: SentReplyKeys,
@@ -552,12 +552,18 @@ where
        user_agent: Option<UserAgent>,
    ) -> Box<dyn TopologyProvider + Send + Sync> {
        // if no custom provider was ... provided ..., create one using nym-api
-        custom_provider.unwrap_or_else(|| {
-            Box::new(NymApiTopologyProvider::new(
+        custom_provider.unwrap_or_else(|| match config_topology.topology_structure {
+            config::TopologyStructure::NymApi => Box::new(NymApiTopologyProvider::new(
                config_topology,
                nym_api_urls,
                user_agent,
-            ))
+            )),
+            config::TopologyStructure::GeoAware(group_by) => {
+                warn!("using deprecated 'GeoAware' topology provider - this option will be removed very soon");
+
+                #[allow(deprecated)]
+                Box::new(crate::client::topology_control::GeoAwareTopologyProvider::new(nym_api_urls, group_by))
+            }
        })
    }

@@ -936,7 +942,7 @@ where

 pub struct BaseClient {
    pub address: Recipient,
-    pub identity_keys: Arc<ed25519::KeyPair>,
+    pub identity_keys: Arc<identity::KeyPair>,
    pub client_input: ClientInputStatus,
    pub client_output: ClientOutputStatus,
    pub client_state: ClientState,
@@ -5,7 +5,7 @@ use crate::client::key_manager::persistence::KeyStore;
 use crate::client::key_manager::ClientKeys;
 use crate::error::ClientCoreError;
 use nym_client_core_gateways_storage::{ActiveGateway, GatewayRegistration, GatewaysDetailsStore};
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;

 // helpers for error wrapping
 pub async fn set_active_gateway<D>(
@@ -26,7 +26,7 @@ where

 pub async fn get_active_gateway_identity<D>(
    details_store: &D,
-) -> Result<Option<ed25519::PublicKey>, ClientCoreError>
+) -> Result<Option<identity::PublicKey>, ClientCoreError>
 where
    D: GatewaysDetailsStore,
    D::StorageError: Send + Sync + 'static,
@@ -42,7 +42,7 @@ where

 pub async fn get_all_registered_identities<D>(
    details_store: &D,
-) -> Result<Vec<ed25519::PublicKey>, ClientCoreError>
+) -> Result<Vec<identity::PublicKey>, ClientCoreError>
 where
    D: GatewaysDetailsStore + Sync,
    D::StorageError: Send + Sync + 'static,
@@ -62,10 +62,6 @@ where
    /// Optional secondary predefined packet size used for the loop cover messages.
    secondary_packet_size: Option<PacketSize>,

-    /// Specify whether any constructed packets should use the legacy format,
-    /// where the payload keys are explicitly attached rather than using the seeds
-    use_legacy_sphinx_format: bool,
-
    packet_type: PacketType,

    stats_tx: ClientStatsSender,
@@ -134,7 +130,6 @@ impl LoopCoverTrafficStream<OsRng> {
            topology_access,
            primary_packet_size: traffic_config.primary_packet_size,
            secondary_packet_size: traffic_config.secondary_packet_size,
-            use_legacy_sphinx_format: traffic_config.use_legacy_sphinx_format,
            packet_type: traffic_config.packet_type,
            stats_tx,
            task_client,
@@ -187,7 +182,6 @@ impl LoopCoverTrafficStream<OsRng> {

        let cover_message = match generate_loop_cover_packet(
            &mut self.rng,
-            self.use_legacy_sphinx_format,
            topology_ref,
            &self.ack_key,
            &self.our_full_destination,
@@ -28,7 +28,6 @@ pub enum InputMessage {
        recipient: Recipient,
        data: Vec<u8>,
        lane: TransmissionLane,
-        max_retransmissions: Option<u32>,
    },

    /// Creates a message used for a duplex anonymous communication where the recipient
@@ -44,7 +43,6 @@ pub enum InputMessage {
        data: Vec<u8>,
        reply_surbs: u32,
        lane: TransmissionLane,
-        max_retransmissions: Option<u32>,
    },

    /// Attempt to use our internally received and stored `ReplySurb` to send the message back
@@ -55,7 +53,6 @@ pub enum InputMessage {
        recipient_tag: AnonymousSenderTag,
        data: Vec<u8>,
        lane: TransmissionLane,
-        max_retransmissions: Option<u32>,
    },

    MessageWrapper {
@@ -95,7 +92,6 @@ impl InputMessage {
            recipient,
            data,
            lane,
-            max_retransmissions: None,
        };
        if let Some(packet_type) = packet_type {
            InputMessage::new_wrapper(message, packet_type)
@@ -116,7 +112,28 @@ impl InputMessage {
            data,
            reply_surbs,
            lane,
-            max_retransmissions: None,
+        };
+        if let Some(packet_type) = packet_type {
+            InputMessage::new_wrapper(message, packet_type)
+        } else {
+            message
+        }
+    }
+
+    // IMHO `new_anonymous` should take `mix_hops: Option<u8>` as an argument instead of creating
+    // this function, but that would potentially break backwards compatibility with the current API
+    pub fn new_anonymous_with_custom_hops(
+        recipient: Recipient,
+        data: Vec<u8>,
+        reply_surbs: u32,
+        lane: TransmissionLane,
+        packet_type: Option<PacketType>,
+    ) -> Self {
+        let message = InputMessage::Anonymous {
+            recipient,
+            data,
+            reply_surbs,
+            lane,
        };
        if let Some(packet_type) = packet_type {
            InputMessage::new_wrapper(message, packet_type)
@@ -135,7 +152,6 @@ impl InputMessage {
            recipient_tag,
            data,
            lane,
-            max_retransmissions: None,
        };
        if let Some(packet_type) = packet_type {
            InputMessage::new_wrapper(message, packet_type)
@@ -153,34 +169,4 @@ impl InputMessage {
            InputMessage::MessageWrapper { message, .. } => message.lane(),
        }
    }
-
-    pub fn set_max_retransmissions(&mut self, max_retransmissions: u32) -> &mut Self {
-        match self {
-            InputMessage::Regular {
-                max_retransmissions: m,
-                ..
-            }
-            | InputMessage::Anonymous {
-                max_retransmissions: m,
-                ..
-            }
-            | InputMessage::Reply {
-                max_retransmissions: m,
-                ..
-            } => {
-                *m = Some(max_retransmissions);
-            }
-            InputMessage::Premade { .. } => {}
-            InputMessage::MessageWrapper { message, .. } => {
-                message.set_max_retransmissions(max_retransmissions);
-            }
-        }
-
-        self
-    }
-
-    pub fn with_max_retransmissions(mut self, max_retransmissions: u32) -> Self {
-        self.set_max_retransmissions(max_retransmissions);
-        self
-    }
 }
@@ -3,7 +3,7 @@

 use crate::client::key_manager::persistence::KeyStore;
 use nym_crypto::{
-    asymmetric::{ed25519, x25519},
+    asymmetric::{encryption, identity},
    hkdf::{DerivationMaterial, InvalidLength},
 };
 use nym_gateway_requests::shared_key::{LegacySharedKeys, SharedGatewayKey, SharedSymmetricKey};
@@ -25,10 +25,10 @@ mod test;
 #[derive(Clone)]
 pub struct ClientKeys {
    /// identity key associated with the client instance.
-    identity_keypair: Arc<ed25519::KeyPair>,
+    identity_keypair: Arc<identity::KeyPair>,

    /// encryption key associated with the client instance.
-    encryption_keypair: Arc<x25519::KeyPair>,
+    encryption_keypair: Arc<encryption::KeyPair>,

    /// key used for producing and processing acknowledgement packets.
    ack_key: Arc<AckKey>,
@@ -41,8 +41,8 @@ impl ClientKeys {
        R: RngCore + CryptoRng,
    {
        ClientKeys {
-            identity_keypair: Arc::new(ed25519::KeyPair::new(rng)),
-            encryption_keypair: Arc::new(x25519::KeyPair::new(rng)),
+            identity_keypair: Arc::new(identity::KeyPair::new(rng)),
+            encryption_keypair: Arc::new(encryption::KeyPair::new(rng)),
            ack_key: Arc::new(AckKey::new(rng)),
        }
    }
@@ -56,18 +56,18 @@ impl ClientKeys {
    {
        let secret = derivation_material.derive_secret()?;
        Ok(ClientKeys {
-            identity_keypair: Arc::new(ed25519::KeyPair::from_secret(
+            identity_keypair: Arc::new(identity::KeyPair::from_secret(
                secret,
                derivation_material.index(),
            )),
-            encryption_keypair: Arc::new(x25519::KeyPair::new(rng)),
+            encryption_keypair: Arc::new(encryption::KeyPair::new(rng)),
            ack_key: Arc::new(AckKey::new(rng)),
        })
    }

    pub fn from_keys(
-        id_keypair: ed25519::KeyPair,
-        enc_keypair: x25519::KeyPair,
+        id_keypair: identity::KeyPair,
+        enc_keypair: encryption::KeyPair,
        ack_key: AckKey,
    ) -> Self {
        Self {
@@ -85,13 +85,13 @@ impl ClientKeys {
        store.store_keys(self).await
    }

-    /// Gets an atomically reference counted pointer to [`ed25519::KeyPair`].
-    pub fn identity_keypair(&self) -> Arc<ed25519::KeyPair> {
+    /// Gets an atomically reference counted pointer to [`identity::KeyPair`].
+    pub fn identity_keypair(&self) -> Arc<identity::KeyPair> {
        Arc::clone(&self.identity_keypair)
    }

-    /// Gets an atomically reference counted pointer to [`x25519::KeyPair`].
-    pub fn encryption_keypair(&self) -> Arc<x25519::KeyPair> {
+    /// Gets an atomically reference counted pointer to [`encryption::KeyPair`].
+    pub fn encryption_keypair(&self) -> Arc<encryption::KeyPair> {
        Arc::clone(&self.encryption_keypair)
    }
    /// Gets an atomically reference counted pointer to [`AckKey`].
@@ -103,8 +103,8 @@ impl ClientKeys {
 fn _assert_keys_zeroize_on_drop() {
    fn _assert_zeroize_on_drop<T: ZeroizeOnDrop>() {}

-    _assert_zeroize_on_drop::<ed25519::KeyPair>();
-    _assert_zeroize_on_drop::<x25519::KeyPair>();
+    _assert_zeroize_on_drop::<identity::KeyPair>();
+    _assert_zeroize_on_drop::<encryption::KeyPair>();
    _assert_zeroize_on_drop::<AckKey>();
    _assert_zeroize_on_drop::<LegacySharedKeys>();
    _assert_zeroize_on_drop::<SharedSymmetricKey>();
@@ -11,7 +11,7 @@ use tokio::sync::Mutex;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::config::disk_persistence::ClientKeysPaths;
 #[cfg(not(target_arch = "wasm32"))]
-use nym_crypto::asymmetric::{ed25519, x25519};
+use nym_crypto::asymmetric::{encryption, identity};
 #[cfg(not(target_arch = "wasm32"))]
 use nym_pemstore::traits::{PemStorableKey, PemStorableKeyPair};
 #[cfg(not(target_arch = "wasm32"))]
@@ -86,13 +86,13 @@ impl OnDiskKeys {
    }

    #[doc(hidden)]
-    pub fn load_encryption_keypair(&self) -> Result<x25519::KeyPair, OnDiskKeysError> {
+    pub fn load_encryption_keypair(&self) -> Result<encryption::KeyPair, OnDiskKeysError> {
        let encryption_paths = self.paths.encryption_key_pair_path();
        self.load_keypair(encryption_paths, "encryption")
    }

    #[doc(hidden)]
-    pub fn load_identity_keypair(&self) -> Result<ed25519::KeyPair, OnDiskKeysError> {
+    pub fn load_identity_keypair(&self) -> Result<identity::KeyPair, OnDiskKeysError> {
        let identity_paths = self.paths.identity_key_pair_path();
        self.load_keypair(identity_paths, "identity")
    }
@@ -52,7 +52,7 @@ impl MixTrafficController {
        let (message_sender, message_receiver) =
            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);

-        let (client_sender, client_receiver) = tokio::sync::mpsc::channel(8);
+        let (client_sender, client_receiver) = tokio::sync::mpsc::channel(1);

        (
            MixTrafficController {
@@ -77,7 +77,7 @@ impl MixTrafficController {
    ) {
        let (message_sender, message_receiver) =
            tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE);
-        let (client_sender, client_receiver) = tokio::sync::mpsc::channel(8);
+        let (client_sender, client_receiver) = tokio::sync::mpsc::channel(1);
        (
            MixTrafficController {
                gateway_transceiver,
@@ -4,7 +4,7 @@
 use async_trait::async_trait;
 use log::{debug, error};
 use nym_credential_storage::storage::Storage as CredentialStorage;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_gateway_client::error::GatewayClientError;
 use nym_gateway_client::GatewayClient;
 pub use nym_gateway_client::{GatewayPacketRouter, PacketRouter};
@@ -30,7 +30,7 @@ fn erase_err<E: std::error::Error + Send + Sync + 'static>(err: E) -> ErasedGate
 /// This combines combines the functionalities of being able to send and receive mix packets.
 #[async_trait]
 pub trait GatewayTransceiver: GatewaySender + GatewayReceiver {
-    fn gateway_identity(&self) -> ed25519::PublicKey;
+    fn gateway_identity(&self) -> identity::PublicKey;
    fn ws_fd(&self) -> Option<RawFd>;
    async fn send_client_request(
        &mut self,
@@ -75,7 +75,7 @@ pub trait GatewayReceiver {
 #[async_trait]
 impl<G: GatewayTransceiver + ?Sized + Send> GatewayTransceiver for Box<G> {
    #[inline]
-    fn gateway_identity(&self) -> ed25519::PublicKey {
+    fn gateway_identity(&self) -> identity::PublicKey {
        (**self).gateway_identity()
    }
    fn ws_fd(&self) -> Option<RawFd> {
@@ -134,7 +134,7 @@ where
    St: CredentialStorage,
    <St as CredentialStorage>::StorageError: Send + Sync + 'static,
 {
-    fn gateway_identity(&self) -> ed25519::PublicKey {
+    fn gateway_identity(&self) -> identity::PublicKey {
        self.gateway_client.gateway_identity()
    }
    fn ws_fd(&self) -> Option<RawFd> {
@@ -190,7 +190,7 @@ pub enum LocalGatewayError {
 #[cfg(not(target_arch = "wasm32"))]
 pub struct LocalGateway {
    /// Identity of the locally managed gateway
-    local_identity: ed25519::PublicKey,
+    local_identity: identity::PublicKey,

    // 'sender' part
    /// Channel responsible for taking mix packets and forwarding them further into the further mixnet layers.
@@ -203,7 +203,7 @@ pub struct LocalGateway {
 #[cfg(not(target_arch = "wasm32"))]
 impl LocalGateway {
    pub fn new(
-        local_identity: ed25519::PublicKey,
+        local_identity: identity::PublicKey,
        packet_forwarder: nym_mixnet_client::forwarder::MixForwardingSender,
        packet_router_tx: oneshot::Sender<PacketRouter>,
    ) -> Self {
@@ -221,7 +221,7 @@ mod nonwasm_sealed {

    #[async_trait]
    impl GatewayTransceiver for LocalGateway {
-        fn gateway_identity(&self) -> ed25519::PublicKey {
+        fn gateway_identity(&self) -> identity::PublicKey {
            self.local_identity
        }
        fn ws_fd(&self) -> Option<RawFd> {
@@ -263,7 +263,7 @@ mod nonwasm_sealed {

 // if we ever decided to start writing unit tests... : )
 pub struct MockGateway {
-    dummy_identity: ed25519::PublicKey,
+    dummy_identity: identity::PublicKey,
    packet_router: Option<PacketRouter>,
    sent: Vec<MixPacket>,
 }
@@ -303,7 +303,7 @@ impl GatewaySender for MockGateway {

 #[async_trait]
 impl GatewayTransceiver for MockGateway {
-    fn gateway_identity(&self) -> ed25519::PublicKey {
+    fn gateway_identity(&self) -> identity::PublicKey {
        self.dummy_identity
    }
    fn ws_fd(&self) -> Option<RawFd> {
@@ -222,6 +222,9 @@ impl ActionController {

    // note: when the entry expires it's automatically removed from pending_acks_timers
    fn handle_expired_ack_timer(&mut self, expired_ack: Expired<FragmentIdentifier>) {
+        // I'm honestly not sure how to handle it, because getting it means other things in our
+        // system are already misbehaving. If we ever see this panic, then I guess we should worry
+        // about it. Perhaps just reschedule it at later point?
        let frag_id = expired_ack.into_inner();

        trace!("{frag_id} has expired");
@@ -65,12 +65,11 @@ where
        recipient_tag: AnonymousSenderTag,
        data: Vec<u8>,
        lane: TransmissionLane,
-        max_retransmissions: Option<u32>,
    ) {
        // offload reply handling to the dedicated task
-        if let Err(err) =
-            self.reply_controller_sender
-                .send_reply(recipient_tag, data, lane, max_retransmissions)
+        if let Err(err) = self
+            .reply_controller_sender
+            .send_reply(recipient_tag, data, lane)
        {
            if !self.task_client.is_shutdown_poll() {
                error!("failed to send a reply - {err}");
@@ -84,11 +83,10 @@ where
        content: Vec<u8>,
        lane: TransmissionLane,
        packet_type: PacketType,
-        max_retransmissions: Option<u32>,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_plain_message(recipient, content, lane, packet_type, max_retransmissions)
+            .try_send_plain_message(recipient, content, lane, packet_type)
            .await
        {
            warn!("failed to send a plain message - {err}")
@@ -102,18 +100,10 @@ where
        reply_surbs: u32,
        lane: TransmissionLane,
        packet_type: PacketType,
-        max_retransmissions: Option<u32>,
    ) {
        if let Err(err) = self
            .message_handler
-            .try_send_message_with_reply_surbs(
-                recipient,
-                content,
-                reply_surbs,
-                lane,
-                packet_type,
-                max_retransmissions,
-            )
+            .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type)
            .await
        {
            warn!("failed to send a repliable message - {err}")
@@ -126,42 +116,25 @@ where
                recipient,
                data,
                lane,
-                max_retransmissions,
            } => {
-                self.handle_plain_message(
-                    recipient,
-                    data,
-                    lane,
-                    PacketType::Mix,
-                    max_retransmissions,
-                )
-                .await
+                self.handle_plain_message(recipient, data, lane, PacketType::Mix)
+                    .await
            }
            InputMessage::Anonymous {
                recipient,
                data,
                reply_surbs,
                lane,
-                max_retransmissions,
            } => {
-                self.handle_repliable_message(
-                    recipient,
-                    data,
-                    reply_surbs,
-                    lane,
-                    PacketType::Mix,
-                    max_retransmissions,
-                )
-                .await
+                self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix)
+                    .await
            }
            InputMessage::Reply {
                recipient_tag,
                data,
                lane,
-                max_retransmissions,
            } => {
-                self.handle_reply(recipient_tag, data, lane, max_retransmissions)
-                    .await;
+                self.handle_reply(recipient_tag, data, lane).await;
            }
            InputMessage::Premade { msgs, lane } => self.handle_premade_packets(msgs, lane).await,
            InputMessage::MessageWrapper {
@@ -172,42 +145,25 @@ where
                    recipient,
                    data,
                    lane,
-                    max_retransmissions,
                } => {
-                    self.handle_plain_message(
-                        recipient,
-                        data,
-                        lane,
-                        packet_type,
-                        max_retransmissions,
-                    )
-                    .await
+                    self.handle_plain_message(recipient, data, lane, packet_type)
+                        .await
                }
                InputMessage::Anonymous {
                    recipient,
                    data,
                    reply_surbs,
                    lane,
-                    max_retransmissions,
                } => {
-                    self.handle_repliable_message(
-                        recipient,
-                        data,
-                        reply_surbs,
-                        lane,
-                        packet_type,
-                        max_retransmissions,
-                    )
-                    .await
+                    self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type)
+                        .await
                }
                InputMessage::Reply {
                    recipient_tag,
                    data,
                    lane,
-                    max_retransmissions,
                } => {
-                    self.handle_reply(recipient_tag, data, lane, max_retransmissions)
-                        .await;
+                    self.handle_reply(recipient_tag, data, lane).await;
                }
                InputMessage::Premade { msgs, lane } => {
                    self.handle_premade_packets(msgs, lane).await
@@ -72,7 +72,6 @@ pub struct PendingAcknowledgement {
    delay: SphinxDelay,
    destination: PacketDestination,
    retransmissions: u32,
-    max_retransmissions: Option<u32>,
 }

 impl PendingAcknowledgement {
@@ -81,14 +80,12 @@ impl PendingAcknowledgement {
        message_chunk: Fragment,
        delay: SphinxDelay,
        recipient: Recipient,
-        max_retransmissions: Option<u32>,
    ) -> Self {
        PendingAcknowledgement {
            message_chunk,
            delay,
            destination: PacketDestination::KnownRecipient(recipient.into()),
            retransmissions: 0,
-            max_retransmissions,
        }
    }

@@ -97,7 +94,6 @@ impl PendingAcknowledgement {
        delay: SphinxDelay,
        recipient_tag: AnonymousSenderTag,
        extra_surb_request: bool,
-        max_retransmissions: Option<u32>,
    ) -> Self {
        PendingAcknowledgement {
            message_chunk,
@@ -107,7 +103,6 @@ impl PendingAcknowledgement {
                extra_surb_request,
            },
            retransmissions: 0,
-            max_retransmissions,
        }
    }

@@ -123,18 +118,6 @@ impl PendingAcknowledgement {
        self.delay = new_delay;
        self.retransmissions += 1;
    }
-
-    pub(crate) fn reached_max_retransmissions(
-        &self,
-        global_max_retransmissions: Option<u32>,
-    ) -> bool {
-        let reached_local_max = self
-            .max_retransmissions
-            .is_some_and(|limit| self.retransmissions >= limit);
-        let reached_global_max =
-            global_max_retransmissions.is_some_and(|limit| self.retransmissions >= limit);
-        reached_local_max || reached_global_max
-    }
 }

 /// AcknowledgementControllerConnectors represents set of channels for communication with
@@ -79,15 +79,17 @@ where

        let frag_id = timed_out_ack.message_chunk.fragment_identifier();

-        if timed_out_ack.reached_max_retransmissions(self.maximum_retransmissions) {
-            debug!("reached maximum number of allowed retransmissions for the packet");
-            if let Err(err) = self
-                .action_sender
-                .unbounded_send(Action::new_remove(frag_id))
-            {
-                error!("Failed to send remove action to the controller: {err}");
+        if let Some(limit) = self.maximum_retransmissions {
+            if timed_out_ack.retransmissions >= limit {
+                warn!("reached maximum number of allowed retransmissions for the packet");
+                if let Err(err) = self
+                    .action_sender
+                    .unbounded_send(Action::new_remove(frag_id))
+                {
+                    error!("Failed to send remove action to the controller: {err}");
+                }
+                return;
            }
-            return;
        }

        let maybe_prepared_fragment = match &timed_out_ack.destination {
@@ -6,7 +6,6 @@ use crate::client::real_messages_control::real_traffic_stream::{
    BatchRealMessageSender, RealMessage,
 };
 use crate::client::real_messages_control::{AckActionSender, Action};
-use crate::client::replies::reply_controller::MaxRetransmissions;
 use crate::client::replies::reply_storage::{ReceivedReplySurbsMap, SentReplyKeys, UsedSenderTags};
 use crate::client::topology_control::{TopologyAccessor, TopologyReadPermit};
 use log::{debug, error, info, trace, warn};
@@ -109,10 +108,6 @@ pub(crate) struct Config {

    /// Optional secondary predefined packet size used for the encapsulated messages.
    secondary_packet_size: Option<PacketSize>,
-
-    /// Specify whether any constructed reply surbs should use the legacy format,
-    /// where the payload keys are explicitly attached rather than using the seeds
-    use_legacy_sphinx_format: bool,
 }

 impl Config {
@@ -122,7 +117,6 @@ impl Config {
        average_packet_delay: Duration,
        average_ack_delay: Duration,
        deterministic_route_selection: bool,
-        use_legacy_reply_surb_format: bool,
    ) -> Self {
        Config {
            ack_key,
@@ -132,7 +126,6 @@ impl Config {
            average_ack_delay,
            primary_packet_size: PacketSize::default(),
            secondary_packet_size: None,
-            use_legacy_sphinx_format: use_legacy_reply_surb_format,
        }
    }

@@ -149,12 +142,6 @@ impl Config {
    }
 }

-#[derive(Clone)]
-pub(crate) struct FragmentWithMaxRetransmissions {
-    pub(crate) fragment: Fragment,
-    pub(crate) max_retransmissions: MaxRetransmissions,
-}
-
 #[derive(Clone)]
 pub(crate) struct MessageHandler<R> {
    config: Config,
@@ -192,7 +179,6 @@ where
            config.sender_address,
            config.average_packet_delay,
            config.average_ack_delay,
-            config.use_legacy_sphinx_format,
        );
        MessageHandler {
            config,
@@ -212,10 +198,10 @@ where
            trace!("we already had sender tag for {recipient}");
            existing
        } else {
-            debug!("creating new sender tag for {recipient}");
+            info!("creating new sender tag for {recipient}");
            let new_tag = AnonymousSenderTag::new_random(&mut self.rng);
            self.tag_storage.insert_new(recipient, new_tag);
-            info!("using {new_tag} for all anonymous messages sent to {recipient}");
+            info!("we'll be using {new_tag} for all anonymous messages sent to {recipient}");
            new_tag
        }
    }
@@ -261,11 +247,9 @@ where
        let topology_permit = self.topology_access.get_read_permit().await;
        let topology = self.get_topology(&topology_permit)?;

-        let reply_surbs = self.message_preparer.generate_reply_surbs(
-            self.config.use_legacy_sphinx_format,
-            amount,
-            topology,
-        )?;
+        let reply_surbs = self
+            .message_preparer
+            .generate_reply_surbs(amount, topology)?;

        let reply_keys = reply_surbs
            .iter()
@@ -310,14 +294,8 @@ where
            Some(chunk.fragment_identifier()),
        );
        let delay = prepared_fragment.total_delay;
-        let max_retransmissions = None;
-        let pending_ack = PendingAcknowledgement::new_anonymous(
-            chunk,
-            delay,
-            target,
-            is_extra_surb_request,
-            max_retransmissions,
-        );
+        let pending_ack =
+            PendingAcknowledgement::new_anonymous(chunk, delay, target, is_extra_surb_request);

        let lane = if is_extra_surb_request {
            TransmissionLane::ReplySurbRequest
@@ -372,7 +350,7 @@ where
    pub(crate) async fn try_send_reply_chunks_on_lane(
        &mut self,
        target: AnonymousSenderTag,
-        fragments: Vec<FragmentWithMaxRetransmissions>,
+        fragments: Vec<Fragment>,
        reply_surbs: Vec<ReplySurb>,
        lane: TransmissionLane,
    ) -> Result<(), SurbWrappedPreparationError> {
@@ -389,12 +367,12 @@ where
    pub(crate) async fn try_send_reply_chunks(
        &mut self,
        target: AnonymousSenderTag,
-        fragments: Vec<(TransmissionLane, FragmentWithMaxRetransmissions)>,
+        fragments: Vec<(TransmissionLane, Fragment)>,
        reply_surbs: Vec<ReplySurb>,
    ) -> Result<(), SurbWrappedPreparationError> {
        let prepared_fragments = self
            .prepare_reply_chunks_for_sending(
-                fragments.iter().map(|(_, f)| f.fragment.clone()).collect(),
+                fragments.iter().map(|(_, f)| f.clone()).collect(),
                reply_surbs,
            )
            .await?;
@@ -404,21 +382,12 @@ where

        for (raw, prepared) in fragments.into_iter().zip(prepared_fragments.into_iter()) {
            let lane = raw.0;
-            let FragmentWithMaxRetransmissions {
-                fragment,
-                max_retransmissions,
-            } = raw.1;
+            let fragment = raw.1;

            let real_message =
                RealMessage::new(prepared.mix_packet, Some(prepared.fragment_identifier));
            let delay = prepared.total_delay;
-            let pending_ack = PendingAcknowledgement::new_anonymous(
-                fragment,
-                delay,
-                target,
-                false,
-                max_retransmissions,
-            );
+            let pending_ack = PendingAcknowledgement::new_anonymous(fragment, delay, target, false);

            let entry = to_forward.entry(lane).or_default();
            entry.push(real_message);
@@ -447,17 +416,10 @@ where
        message: Vec<u8>,
        lane: TransmissionLane,
        packet_type: PacketType,
-        max_retransmissions: Option<u32>,
    ) -> Result<(), PreparationError> {
        let message = NymMessage::new_plain(message);
-        self.try_split_and_send_non_reply_message(
-            message,
-            recipient,
-            lane,
-            packet_type,
-            max_retransmissions,
-        )
-        .await
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+            .await
    }

    pub(crate) async fn try_split_and_send_non_reply_message(
@@ -466,7 +428,6 @@ where
        recipient: Recipient,
        lane: TransmissionLane,
        packet_type: PacketType,
-        max_retransmissions: Option<u32>,
    ) -> Result<(), PreparationError> {
        debug!("Sending non-reply message with packet type {packet_type}");
        // TODO: I really dislike existence of this assertion, it implies code has to be re-organised
@@ -506,8 +467,7 @@ where
                Some(fragment.fragment_identifier()),
            );
            let delay = prepared_fragment.total_delay;
-            let pending_ack =
-                PendingAcknowledgement::new_known(fragment, delay, recipient, max_retransmissions);
+            let pending_ack = PendingAcknowledgement::new_known(fragment, delay, recipient);

            real_messages.push(real_message);
            pending_acks.push(pending_ack);
@@ -531,20 +491,15 @@ where
            self.generate_reply_surbs_with_keys(amount as usize).await?;

        let message = NymMessage::new_repliable(RepliableMessage::new_additional_surbs(
-            self.config.use_legacy_sphinx_format,
            sender_tag,
            reply_surbs,
        ));

-        // When sending SURBs we want to retransmit
-        let max_retransmissions = None;
-
        self.try_split_and_send_non_reply_message(
            message,
            recipient,
            TransmissionLane::AdditionalReplySurbs,
            packet_type,
-            max_retransmissions,
        )
        .await?;

@@ -561,7 +516,6 @@ where
        num_reply_surbs: u32,
        lane: TransmissionLane,
        packet_type: PacketType,
-        max_retransmissions: Option<u32>,
    ) -> Result<(), SurbWrappedPreparationError> {
        debug!("Sending message with reply SURBs with packet type {packet_type}");
        let sender_tag = self.get_or_create_sender_tag(&recipient);
@@ -569,21 +523,11 @@ where
            .generate_reply_surbs_with_keys(num_reply_surbs as usize)
            .await?;

-        let message = NymMessage::new_repliable(RepliableMessage::new_data(
-            self.config.use_legacy_sphinx_format,
-            message,
-            sender_tag,
-            reply_surbs,
-        ));
+        let message =
+            NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs));

-        self.try_split_and_send_non_reply_message(
-            message,
-            recipient,
-            lane,
-            packet_type,
-            max_retransmissions,
-        )
-        .await?;
+        self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type)
+            .await?;

        log::trace!("storing {} reply keys", reply_keys.len());
        self.reply_key_storage.insert_multiple(reply_keys);
@@ -99,7 +99,6 @@ impl<'a> From<&'a Config> for message_handler::Config {
            cfg.traffic.average_packet_delay,
            cfg.acks.average_ack_delay,
            cfg.traffic.deterministic_route_selection,
-            cfg.traffic.use_legacy_sphinx_format,
        )
        .with_custom_primary_packet_size(cfg.traffic.primary_packet_size)
        .with_custom_secondary_packet_size(cfg.traffic.secondary_packet_size)
@@ -154,7 +153,7 @@ impl RealMessagesController<OsRng> {
        let rng = OsRng;

        // create channels for inter-task communication
-        let (real_message_sender, real_message_receiver) = tokio::sync::mpsc::channel(8);
+        let (real_message_sender, real_message_receiver) = tokio::sync::mpsc::channel(1);
        let (sent_notifier_tx, sent_notifier_rx) = mpsc::unbounded();
        let (ack_action_tx, ack_action_rx) = mpsc::unbounded();
        let ack_controller_connectors = AcknowledgementControllerConnectors::new(
@@ -252,7 +252,6 @@ where
                (
                    generate_loop_cover_packet(
                        &mut self.rng,
-                        self.config.traffic.use_legacy_sphinx_format,
                        topology_ref,
                        &self.config.ack_key,
                        &self.config.our_full_destination,
@@ -9,7 +9,7 @@ use futures::channel::mpsc;
 use futures::lock::Mutex;
 use futures::StreamExt;
 use log::*;
-use nym_crypto::asymmetric::x25519;
+use nym_crypto::asymmetric::encryption;
 use nym_crypto::Digest;
 use nym_gateway_client::MixnetMessageReceiver;
 use nym_sphinx::anonymous_replies::requests::{
@@ -23,10 +23,6 @@ use nym_statistics_common::clients::{packet_statistics::PacketStatisticsEvent, C
 use nym_task::TaskClient;
 use std::collections::HashSet;
 use std::sync::Arc;
-use std::time::{Duration, Instant};
-
-// The interval at which we check for stale buffers
-const STALE_BUFFER_CHECK_INTERVAL: Duration = Duration::from_secs(10);

 // Buffer Requests to say "hey, send any reconstructed messages to this channel"
 // or to say "hey, I'm going offline, don't send anything more to me. Just buffer them instead"
@@ -39,7 +35,7 @@ pub type ReconstructedMessagesReceiver = mpsc::UnboundedReceiver<Vec<Reconstruct

 struct ReceivedMessagesBufferInner<R: MessageReceiver> {
    messages: Vec<ReconstructedMessage>,
-    local_encryption_keypair: Arc<x25519::KeyPair>,
+    local_encryption_keypair: Arc<encryption::KeyPair>,

    // TODO: looking how it 'looks' here, perhaps `MessageReceiver` should be renamed to something
    // else instead.
@@ -52,9 +48,6 @@ struct ReceivedMessagesBufferInner<R: MessageReceiver> {
    recently_reconstructed: HashSet<i32>,

    stats_tx: ClientStatsSender,
-
-    // Periodically check for stale buffers to clean up
-    last_stale_check: Instant,
 }

 impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
@@ -103,10 +96,9 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {
                    }
                    None
                }
-                _ => {
-                    error!("unexpected error occurred during message reconstruction: {err}");
-                    None
-                }
+                _ => unreachable!(
+                    "no other error kind should have been returned here! If so, it's a bug!"
+                ),
            },
            Ok(reconstruction_result) => match reconstruction_result {
                Some((reconstructed_message, used_sets)) => {
@@ -152,16 +144,6 @@ impl<R: MessageReceiver> ReceivedMessagesBufferInner<R> {

        self.recover_from_fragment(fragment_data, raw_fragment_size)
    }
-
-    fn cleanup_stale_buffers(&mut self) {
-        let now = Instant::now();
-        if now - self.last_stale_check > STALE_BUFFER_CHECK_INTERVAL {
-            self.last_stale_check = now;
-            self.message_receiver
-                .reconstructor()
-                .cleanup_stale_buffers();
-        }
-    }
 }

 #[derive(Debug, Clone)]
@@ -176,7 +158,7 @@ struct ReceivedMessagesBuffer<R: MessageReceiver> {

 impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
    fn new(
-        local_encryption_keypair: Arc<x25519::KeyPair>,
+        local_encryption_keypair: Arc<encryption::KeyPair>,
        reply_key_storage: SentReplyKeys,
        reply_controller_sender: ReplyControllerSender,
        stats_tx: ClientStatsSender,
@@ -190,7 +172,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                message_sender: None,
                recently_reconstructed: HashSet::new(),
                stats_tx,
-                last_stale_check: Instant::now(),
            })),
            reply_key_storage,
            reply_controller_sender,
@@ -250,10 +231,10 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
        let mut reconstructed = Vec::new();
        for msg in msgs {
            let (reply_surbs, from_surb_request) = match msg.content {
-                RepliableMessageContent::Data(content) => {
-                    let reply_surbs = content.reply_surbs;
-                    let message = content.message;
-
+                RepliableMessageContent::Data {
+                    message,
+                    reply_surbs,
+                } => {
                    trace!(
                        "received message that also contained additional {} reply surbs from {:?}!",
                        reply_surbs.len(),
@@ -264,9 +245,7 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {

                    (reply_surbs, false)
                }
-                RepliableMessageContent::AdditionalSurbs(content) => {
-                    let reply_surbs = content.reply_surbs;
-
+                RepliableMessageContent::AdditionalSurbs { reply_surbs } => {
                    trace!(
                        "received additional {} reply surbs from {:?}!",
                        reply_surbs.len(),
@@ -274,37 +253,9 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
                    );
                    (reply_surbs, true)
                }
-                RepliableMessageContent::Heartbeat(content) => {
-                    let additional_reply_surbs = content.additional_reply_surbs;
-                    error!("received a repliable heartbeat message - we don't know how to handle it yet (and we won't know until future PRs)");
-                    (additional_reply_surbs, false)
-                }
-                RepliableMessageContent::DataV2(content) => {
-                    let reply_surbs = content.reply_surbs;
-                    let message = content.message;
-
-                    trace!(
-                        "received message that also contained additional {} reply surbs from {:?}!",
-                        reply_surbs.len(),
-                        msg.sender_tag
-                    );
-
-                    reconstructed.push(ReconstructedMessage::new(message, msg.sender_tag));
-
-                    (reply_surbs, false)
-                }
-                RepliableMessageContent::AdditionalSurbsV2(content) => {
-                    let reply_surbs = content.reply_surbs;
-
-                    trace!(
-                        "received additional {} reply surbs from {:?}!",
-                        reply_surbs.len(),
-                        msg.sender_tag
-                    );
-                    (reply_surbs, true)
-                }
-                RepliableMessageContent::HeartbeatV2(content) => {
-                    let additional_reply_surbs = content.additional_reply_surbs;
+                RepliableMessageContent::Heartbeat {
+                    additional_reply_surbs,
+                } => {
                    error!("received a repliable heartbeat message - we don't know how to handle it yet (and we won't know until future PRs)");
                    (additional_reply_surbs, false)
                }
@@ -441,11 +392,6 @@ impl<R: MessageReceiver> ReceivedMessagesBuffer<R> {
            }
        }

-        // Cleanup stale buffers, if there are any fragments that simply never arrived.
-        // We do this here as part of handling new received fragments so that we can keep the event
-        // loop focused on processing new messages.
-        inner_guard.cleanup_stale_buffers();
-
        drop(inner_guard);

        if !completed_messages.is_empty() {
@@ -566,7 +512,7 @@ pub(crate) struct ReceivedMessagesBufferController<R: MessageReceiver> {

 impl<R: MessageReceiver + Clone + Send + 'static> ReceivedMessagesBufferController<R> {
    pub(crate) fn new(
-        local_encryption_keypair: Arc<x25519::KeyPair>,
+        local_encryption_keypair: Arc<encryption::KeyPair>,
        query_receiver: ReceivedBufferRequestReceiver,
        mixnet_packet_receiver: MixnetMessageReceiver,
        reply_key_storage: SentReplyKeys,
@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::real_messages_control::acknowledgement_control::PendingAcknowledgement;
-use crate::client::real_messages_control::message_handler::{
-    FragmentWithMaxRetransmissions, MessageHandler, PreparationError,
-};
+use crate::client::real_messages_control::message_handler::{MessageHandler, PreparationError};
 use crate::client::replies::reply_storage::CombinedReplyStorage;
 use futures::channel::oneshot;
 use futures::StreamExt;
@@ -12,7 +10,7 @@ use log::{debug, error, info, trace, warn};
 use nym_sphinx::addressing::clients::Recipient;
 use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag;
 use nym_sphinx::anonymous_replies::ReplySurb;
-use nym_sphinx::chunking::fragment::FragmentIdentifier;
+use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier};
 use nym_task::connections::{ConnectionId, TransmissionLane};
 use nym_task::TaskClient;
 use rand::{CryptoRng, Rng};
@@ -51,8 +49,6 @@ impl Config {
 // - replies to "give additional surbs" requests
 // - will reply to future heartbeats

-pub type MaxRetransmissions = Option<u32>;
-
 // TODO: this should be split into ingress and egress controllers
 // because currently its trying to perform two distinct jobs
 pub struct ReplyController<R> {
@@ -63,8 +59,7 @@ pub struct ReplyController<R> {
    // of surbs required to send the message through
    // expected_reliability: f32,
    request_receiver: ReplyControllerReceiver,
-    pending_replies:
-        HashMap<AnonymousSenderTag, TransmissionBuffer<FragmentWithMaxRetransmissions>>,
+    pending_replies: HashMap<AnonymousSenderTag, TransmissionBuffer<Fragment>>,

    /// Retransmission packets that have already timed out and are waiting for additional reply SURBs
    /// so that they could be sent back to the network. Once we receive more SURBs, we should send them ASAP.
@@ -101,7 +96,7 @@ where
        }
    }

-    fn insert_pending_replies<I: IntoIterator<Item = FragmentWithMaxRetransmissions>>(
+    fn insert_pending_replies<I: IntoIterator<Item = Fragment>>(
        &mut self,
        recipient: &AnonymousSenderTag,
        fragments: I,
@@ -117,7 +112,7 @@ where
    fn re_insert_pending_replies(
        &mut self,
        recipient: &AnonymousSenderTag,
-        fragments: Vec<(TransmissionLane, FragmentWithMaxRetransmissions)>,
+        fragments: Vec<(TransmissionLane, Fragment)>,
    ) {
        trace!("re-inserting pending replies for {recipient}");
        // the buffer should ALWAYS exist at this point, if it doesn't, it's a bug...
@@ -210,7 +205,6 @@ where
        recipient_tag: AnonymousSenderTag,
        data: Vec<u8>,
        lane: TransmissionLane,
-        max_retransmissions: Option<u32>,
    ) {
        if !self
            .full_reply_storage
@@ -248,14 +242,7 @@ where
                .get_reply_surbs(&recipient_tag, max_to_send);

            if let Some(reply_surbs) = surbs {
-                let to_send = fragments
-                    .drain(..max_to_send)
-                    .map(|f| FragmentWithMaxRetransmissions {
-                        fragment: f,
-                        max_retransmissions,
-                    })
-                    .collect::<Vec<_>>();
-
+                let to_send = fragments.drain(..max_to_send).collect::<Vec<_>>();
                if let Err(err) = self
                    .message_handler
                    .try_send_reply_chunks_on_lane(
@@ -289,13 +276,6 @@ where
                "buffering {no_fragments} fragments for {recipient_tag}",
                no_fragments = fragments.len()
            );
-            let fragments: Vec<_> = fragments
-                .into_iter()
-                .map(|fragment| FragmentWithMaxRetransmissions {
-                    fragment,
-                    max_retransmissions,
-                })
-                .collect();
            self.insert_pending_replies(&recipient_tag, fragments, lane);
        }

@@ -429,7 +409,7 @@ where
        &mut self,
        from: &AnonymousSenderTag,
        amount: usize,
-    ) -> Option<Vec<(TransmissionLane, FragmentWithMaxRetransmissions)>> {
+    ) -> Option<Vec<(TransmissionLane, Fragment)>> {
        // if possible, pop all pending replies, if not, pop only entries for which we'd have a reply surb
        let total = self.pending_replies.get(from)?.total_size();
        trace!("pending queue has {total} elements");
@@ -709,11 +689,7 @@ where
                recipient,
                message,
                lane,
-                max_retransmissions,
-            } => {
-                self.handle_send_reply(recipient, message, lane, max_retransmissions)
-                    .await
-            }
+            } => self.handle_send_reply(recipient, message, lane).await,
            ReplyControllerMessage::AdditionalSurbs {
                sender_tag,
                reply_surbs,
@@ -66,14 +66,12 @@ impl ReplyControllerSender {
        recipient: AnonymousSenderTag,
        message: Vec<u8>,
        lane: TransmissionLane,
-        max_retransmissions: Option<u32>,
    ) -> Result<(), ReplyControllerSenderError> {
        self.0
            .unbounded_send(ReplyControllerMessage::SendReply {
                recipient,
                message,
                lane,
-                max_retransmissions,
            })
            .map_err(ReplyControllerSenderError::SendReply)
    }
@@ -162,7 +160,6 @@ pub enum ReplyControllerMessage {
        recipient: AnonymousSenderTag,
        message: Vec<u8>,
        lane: TransmissionLane,
-        max_retransmissions: Option<u32>,
    },

    AdditionalSurbs {
@@ -0,0 +1,214 @@
+use crate::config::GroupBy;
+use log::{debug, error};
+use nym_explorer_client::{ExplorerClient, PrettyDetailedMixNodeBond};
+use nym_network_defaults::var_names::EXPLORER_API;
+use nym_topology::{
+    provider_trait::{async_trait, TopologyProvider},
+    NymTopology,
+};
+use nym_validator_client::client::NodeId;
+use rand::{prelude::SliceRandom, thread_rng};
+use std::collections::HashMap;
+use tap::TapOptional;
+use url::Url;
+
+pub use nym_country_group::CountryGroup;
+
+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)
+}
+
+fn group_mixnodes_by_country_code(
+    mixnodes: Vec<PrettyDetailedMixNodeBond>,
+) -> HashMap<CountryGroup, Vec<NodeId>> {
+    mixnodes
+        .into_iter()
+        .fold(HashMap::<CountryGroup, Vec<NodeId>>::new(), |mut acc, m| {
+            if let Some(ref location) = m.location {
+                let country_code = location.two_letter_iso_country_code.clone();
+                let group_code = CountryGroup::new(country_code.as_str());
+                let mixnodes = acc.entry(group_code).or_default();
+                mixnodes.push(m.mix_id);
+            }
+            acc
+        })
+}
+
+fn log_mixnode_distribution(mixnodes: &HashMap<CountryGroup, Vec<NodeId>>) {
+    let mixnode_distribution = mixnodes
+        .iter()
+        .map(|(k, v)| format!("{}: {}", k, v.len()))
+        .collect::<Vec<_>>()
+        .join(", ");
+    debug!("Mixnode distribution - {}", mixnode_distribution);
+}
+
+fn check_layer_integrity(topology: NymTopology) -> Result<(), ()> {
+    if topology.ensure_minimally_routable().is_err() {
+        error!("Layer is missing in topology!");
+        return Err(());
+    }
+    Ok(())
+}
+
+#[deprecated(note = "use NymApiTopologyProvider instead as explorer API will soon be removed")]
+pub struct GeoAwareTopologyProvider {
+    validator_client: nym_validator_client::client::NymApiClient,
+    filter_on: GroupBy,
+}
+
+#[allow(deprecated)]
+impl GeoAwareTopologyProvider {
+    pub fn new(mut nym_api_urls: Vec<Url>, filter_on: GroupBy) -> GeoAwareTopologyProvider {
+        log::info!(
+            "Creating geo-aware topology provider with filter on {}",
+            filter_on
+        );
+        nym_api_urls.shuffle(&mut thread_rng());
+
+        GeoAwareTopologyProvider {
+            validator_client: nym_validator_client::client::NymApiClient::new(
+                nym_api_urls[0].clone(),
+            ),
+            filter_on,
+        }
+    }
+
+    async fn get_topology(&self) -> Option<NymTopology> {
+        let rewarded_set = self
+            .validator_client
+            .get_current_rewarded_set()
+            .await
+            .inspect_err(|err| error!("failed to get current rewarded set: {err}"))
+            .ok()?;
+
+        let mut topology = NymTopology::new_empty(rewarded_set);
+
+        let mixnodes = match self
+            .validator_client
+            .get_all_basic_active_mixing_assigned_nodes()
+            .await
+        {
+            Err(err) => {
+                error!("failed to get network mixnodes - {err}");
+                return None;
+            }
+            Ok(mixes) => mixes,
+        };
+
+        let gateways = match self
+            .validator_client
+            .get_all_basic_entry_assigned_nodes()
+            .await
+        {
+            Err(err) => {
+                error!("failed to get network gateways - {err}");
+                return None;
+            }
+            Ok(gateways) => gateways,
+        };
+
+        // Also fetch mixnodes cached by explorer-api, with the purpose of getting their
+        // geolocation.
+        debug!("Fetching mixnodes from explorer-api...");
+        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.
+        // The reason we this instead of a straight filter is that this opens up the possibility to
+        // complement a small grouping with mixnodes from adjecent countries.
+        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(&filter_on) else {
+            error!("no mixnodes found for: {}", filter_on);
+            return None;
+        };
+
+        let mixnodes = mixnodes
+            .into_iter()
+            .filter(|m| filtered_mixnode_ids.contains(&m.node_id))
+            .collect::<Vec<_>>();
+
+        topology.add_skimmed_nodes(&mixnodes);
+        topology.add_skimmed_nodes(&gateways);
+
+        // TODO: return real error type
+        check_layer_integrity(topology.clone()).ok()?;
+
+        Some(topology)
+    }
+}
+
+#[allow(deprecated)]
+#[cfg(not(target_arch = "wasm32"))]
+#[async_trait]
+impl TopologyProvider for GeoAwareTopologyProvider {
+    // this will be manually refreshed on a timer specified inside mixnet client config
+    async fn get_new_topology(&mut self) -> Option<NymTopology> {
+        self.get_topology().await
+    }
+}
+
+#[allow(deprecated)]
+#[cfg(target_arch = "wasm32")]
+#[async_trait(?Send)]
+impl TopologyProvider for GeoAwareTopologyProvider {
+    // this will be manually refreshed on a timer specified inside mixnet client config
+    async fn get_new_topology(&mut self) -> Option<NymTopology> {
+        self.get_topology().await
+    }
+}
@@ -17,8 +17,11 @@ use tokio::time::sleep;
 use wasmtimer::tokio::sleep;

 mod accessor;
+pub mod geo_aware_provider;
 pub mod nym_api_provider;

+#[allow(deprecated)]
+pub use geo_aware_provider::GeoAwareTopologyProvider;
 pub use nym_api_provider::{Config as NymApiTopologyProviderConfig, NymApiTopologyProvider};
 pub use nym_topology::provider_trait::TopologyProvider;

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0

 use crate::client::mix_traffic::transceiver::ErasedGatewayError;
-use nym_crypto::asymmetric::ed25519::Ed25519RecoveryError;
+use nym_crypto::asymmetric::identity::Ed25519RecoveryError;
 use nym_gateway_client::error::GatewayClientError;
 use nym_topology::node::RoutingNodeError;
 use nym_topology::{NodeId, NymTopologyError};
@@ -5,14 +5,12 @@ use crate::error::ClientCoreError;
 use crate::init::types::RegistrationResult;
 use futures::{SinkExt, StreamExt};
 use log::{debug, info, trace, warn};
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_gateway_client::GatewayClient;
 use nym_topology::node::RoutingNode;
 use nym_validator_client::client::IdentityKeyRef;
 use nym_validator_client::UserAgent;
 use rand::{seq::SliceRandom, Rng};
-#[cfg(unix)]
-use std::os::fd::RawFd;
 use std::{sync::Arc, time::Duration};
 use tungstenite::Message;
 use url::Url;
@@ -52,7 +50,7 @@ const PING_TIMEOUT: Duration = Duration::from_millis(1000);
 // The abstraction that some of these helpers use
 pub trait ConnectableGateway {
    fn node_id(&self) -> NodeId;
-    fn identity(&self) -> ed25519::PublicKey;
+    fn identity(&self) -> identity::PublicKey;
    fn clients_address(&self, prefer_ipv6: bool) -> Option<String>;
    fn is_wss(&self) -> bool;
 }
@@ -62,7 +60,7 @@ impl ConnectableGateway for RoutingNode {
        self.node_id
    }

-    fn identity(&self) -> ed25519::PublicKey {
+    fn identity(&self) -> identity::PublicKey {
        self.identity_key
    }

@@ -287,7 +285,7 @@ pub(super) fn get_specified_gateway(
    must_use_tls: bool,
 ) -> Result<RoutingNode, ClientCoreError> {
    log::debug!("Requesting specified gateway: {}", gateway_identity);
-    let user_gateway = ed25519::PublicKey::from_base58_string(gateway_identity)
+    let user_gateway = identity::PublicKey::from_base58_string(gateway_identity)
        .map_err(ClientCoreError::UnableToCreatePublicKeyFromGatewayId)?;

    let gateway = gateways
@@ -312,18 +310,12 @@ pub(super) fn get_specified_gateway(
 }

 pub(super) async fn register_with_gateway(
-    gateway_id: ed25519::PublicKey,
+    gateway_id: identity::PublicKey,
    gateway_listener: Url,
-    our_identity: Arc<ed25519::KeyPair>,
-    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
+    our_identity: Arc<identity::KeyPair>,
 ) -> Result<RegistrationResult, ClientCoreError> {
-    let mut gateway_client = GatewayClient::new_init(
-        gateway_listener,
-        gateway_id,
-        our_identity.clone(),
-        #[cfg(unix)]
-        connection_fd_callback,
-    );
+    let mut gateway_client =
+        GatewayClient::new_init(gateway_listener, gateway_id, our_identity.clone());

    gateway_client.establish_connection().await.map_err(|err| {
        log::warn!("Failed to establish connection with gateway!");
@@ -23,8 +23,6 @@ use nym_topology::node::RoutingNode;
 use rand::rngs::OsRng;
 use rand::{CryptoRng, RngCore};
 use serde::Serialize;
-#[cfg(unix)]
-use std::{os::fd::RawFd, sync::Arc};

 pub mod helpers;
 pub mod types;
@@ -55,7 +53,6 @@ async fn setup_new_gateway<K, D>(
    details_store: &D,
    selection_specification: GatewaySelectionSpecification,
    available_gateways: Vec<RoutingNode>,
-    #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
 ) -> Result<InitialisationResult, ClientCoreError>
 where
    K: KeyStore,
@@ -111,14 +108,9 @@ where
            // if we're using a 'normal' gateway setup, do register
            let our_identity = client_keys.identity_keypair();

-            let registration = helpers::register_with_gateway(
-                gateway_id,
-                gateway_listener.clone(),
-                our_identity,
-                #[cfg(unix)]
-                connection_fd_callback,
-            )
-            .await?;
+            let registration =
+                helpers::register_with_gateway(gateway_id, gateway_listener.clone(), our_identity)
+                    .await?;
            (
                GatewayDetails::new_remote(
                    gateway_id,
@@ -211,19 +203,9 @@ where
        GatewaySetup::New {
            specification,
            available_gateways,
-            #[cfg(unix)]
-            connection_fd_callback,
        } => {
            log::debug!("GatewaySetup::New with spec: {specification:?}");
-            setup_new_gateway(
-                key_store,
-                details_store,
-                specification,
-                available_gateways,
-                #[cfg(unix)]
-                connection_fd_callback,
-            )
-            .await
+            setup_new_gateway(key_store, details_store, specification, available_gateways).await
        }
        GatewaySetup::ReuseConnection {
            authenticated_ephemeral_client,
@@ -9,7 +9,7 @@ use crate::init::{setup_gateway, use_loaded_gateway_details};
 use nym_client_core_gateways_storage::{
    GatewayRegistration, GatewaysDetailsStore, RemoteGatewayDetails,
 };
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_gateway_client::client::InitGatewayClient;
 use nym_gateway_requests::shared_key::SharedGatewayKey;
 use nym_sphinx::addressing::clients::Recipient;
@@ -18,22 +18,20 @@ use nym_validator_client::client::IdentityKey;
 use nym_validator_client::nyxd::AccountId;
 use serde::Serialize;
 use std::fmt::{Debug, Display};
-#[cfg(unix)]
-use std::os::fd::RawFd;
 use std::sync::Arc;
 use time::OffsetDateTime;
 use url::Url;

 pub enum SelectedGateway {
    Remote {
-        gateway_id: ed25519::PublicKey,
+        gateway_id: identity::PublicKey,

        gateway_owner_address: Option<AccountId>,

        gateway_listener: Url,
    },
    Custom {
-        gateway_id: ed25519::PublicKey,
+        gateway_id: identity::PublicKey,
        additional_data: Option<Vec<u8>>,
    },
 }
@@ -77,7 +75,7 @@ impl SelectedGateway {
        gateway_id: String,
        additional_data: Option<Vec<u8>>,
    ) -> Result<Self, ClientCoreError> {
-        let gateway_id = ed25519::PublicKey::from_base58_string(&gateway_id)
+        let gateway_id = identity::PublicKey::from_base58_string(&gateway_id)
            .map_err(|source| ClientCoreError::MalformedGatewayIdentity { gateway_id, source })?;

        Ok(SelectedGateway::Custom {
@@ -86,7 +84,7 @@ impl SelectedGateway {
        })
    }

-    pub fn gateway_id(&self) -> &ed25519::PublicKey {
+    pub fn gateway_id(&self) -> &identity::PublicKey {
        match self {
            SelectedGateway::Remote { gateway_id, .. } => gateway_id,
            SelectedGateway::Custom { gateway_id, .. } => gateway_id,
@@ -142,7 +140,7 @@ impl InitialisationResult {
        )
    }

-    pub fn gateway_id(&self) -> ed25519::PublicKey {
+    pub fn gateway_id(&self) -> identity::PublicKey {
        self.gateway_registration.details.gateway_id()
    }
 }
@@ -210,10 +208,6 @@ pub enum GatewaySetup {

        // TODO: seems to be a bit inefficient to pass them by value
        available_gateways: Vec<RoutingNode>,
-
-        /// Callback useful for allowing initial connection to gateway
-        #[cfg(unix)]
-        connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
    },

    ReuseConnection {
@@ -237,8 +231,6 @@ impl Debug for GatewaySetup {
            GatewaySetup::New {
                specification,
                available_gateways,
-                #[cfg(unix)]
-                    connection_fd_callback: _,
            } => f
                .debug_struct("GatewaySetup::New")
                .field("specification", specification)
@@ -271,15 +263,13 @@ impl GatewaySetup {
    }

    /// new gateway setup performed by each client that's inbuilt in a gateway (like NR or IPR)
-    pub fn new_inbuilt(identity: ed25519::PublicKey) -> Self {
+    pub fn new_inbuilt(identity: identity::PublicKey) -> Self {
        GatewaySetup::New {
            specification: GatewaySelectionSpecification::Custom {
                gateway_identity: identity.to_base58_string(),
                additional_data: None,
            },
            available_gateways: vec![],
-            #[cfg(unix)]
-            connection_fd_callback: None,
        }
    }

@@ -17,7 +17,7 @@ use nym_credential_storage::ephemeral_storage::EphemeralStorage as EphemeralCred
 use nym_credential_storage::storage::Storage as CredentialStorage;
 use nym_credentials::CredentialSpendingData;
 use nym_credentials_interface::TicketType;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_gateway_requests::registration::handshake::client_handshake;
 use nym_gateway_requests::{
    BinaryRequest, ClientControlRequest, ClientRequest, GatewayProtocolVersionExt,
@@ -57,7 +57,7 @@ pub(crate) mod websockets;
 use websockets::connect_async;

 pub struct GatewayConfig {
-    pub gateway_identity: ed25519::PublicKey,
+    pub gateway_identity: identity::PublicKey,

    // currently a dead field
    pub gateway_owner: Option<String>,
@@ -67,7 +67,7 @@ pub struct GatewayConfig {

 impl GatewayConfig {
    pub fn new(
-        gateway_identity: ed25519::PublicKey,
+        gateway_identity: identity::PublicKey,
        gateway_owner: Option<String>,
        gateway_listener: String,
    ) -> Self {
@@ -93,8 +93,8 @@ pub struct GatewayClient<C, St = EphemeralCredentialStorage> {
    authenticated: bool,
    bandwidth: ClientBandwidth,
    gateway_address: String,
-    gateway_identity: ed25519::PublicKey,
-    local_identity: Arc<ed25519::KeyPair>,
+    gateway_identity: identity::PublicKey,
+    local_identity: Arc<identity::KeyPair>,
    shared_key: Option<Arc<SharedGatewayKey>>,
    connection: SocketState,
    packet_router: PacketRouter,
@@ -117,7 +117,7 @@ impl<C, St> GatewayClient<C, St> {
    pub fn new(
        cfg: GatewayClientConfig,
        gateway_config: GatewayConfig,
-        local_identity: Arc<ed25519::KeyPair>,
+        local_identity: Arc<identity::KeyPair>,
        // TODO: make it mandatory. if you don't want to pass it, use `new_init`
        shared_key: Option<Arc<SharedGatewayKey>>,
        packet_router: PacketRouter,
@@ -145,7 +145,7 @@ impl<C, St> GatewayClient<C, St> {
        }
    }

-    pub fn gateway_identity(&self) -> ed25519::PublicKey {
+    pub fn gateway_identity(&self) -> identity::PublicKey {
        self.gateway_identity
    }

@@ -1063,9 +1063,8 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
    // for initialisation we do not need credential storage. Though it's still a bit weird we have to set the generic...
    pub fn new_init(
        gateway_listener: Url,
-        gateway_identity: ed25519::PublicKey,
-        local_identity: Arc<ed25519::KeyPair>,
-        #[cfg(unix)] connection_fd_callback: Option<Arc<dyn Fn(RawFd) + Send + Sync>>,
+        gateway_identity: identity::PublicKey,
+        local_identity: Arc<identity::KeyPair>,
    ) -> Self {
        log::trace!("Initialising gateway client");
        use futures::channel::mpsc;
@@ -1091,7 +1090,7 @@ impl GatewayClient<InitOnly, EphemeralCredentialStorage> {
            stats_reporter: ClientStatsSender::new(None, task_client.clone()),
            negotiated_protocol: None,
            #[cfg(unix)]
-            connection_fd_callback,
+            connection_fd_callback: None,
            task_client,
        }
    }
@@ -24,10 +24,10 @@ use tracing::*;

 #[derive(Clone, Copy)]
 pub struct Config {
-    pub initial_reconnection_backoff: Duration,
-    pub maximum_reconnection_backoff: Duration,
-    pub initial_connection_timeout: Duration,
-    pub maximum_connection_buffer_size: usize,
+    initial_reconnection_backoff: Duration,
+    maximum_reconnection_backoff: Duration,
+    initial_connection_timeout: Duration,
+    maximum_connection_buffer_size: usize,
 }

 impl Config {
@@ -50,7 +50,7 @@ pub trait SendWithoutResponse {
    // Without response in this context means we will not listen for anything we might get back (not
    // that we should get anything), including any possible io errors
    fn send_without_response(
-        &self,
+        &mut self,
        address: NymNodeRoutingAddress,
        packet: NymPacket,
        packet_type: PacketType,
@@ -196,7 +196,7 @@ impl Client {
        }
    }

-    fn make_connection(&self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
+    fn make_connection(&mut self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
        let (sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);

        // this CAN'T fail because we just created the channel which has a non-zero capacity
@@ -247,7 +247,7 @@ impl Client {

 impl SendWithoutResponse for Client {
    fn send_without_response(
-        &self,
+        &mut self,
        address: NymNodeRoutingAddress,
        packet: NymPacket,
        packet_type: PacketType,
@@ -16,6 +16,7 @@ nym-coconut-dkg-common = { path = "../../cosmwasm-smart-contracts/coconut-dkg" }
 nym-contracts-common = { path = "../../cosmwasm-smart-contracts/contracts-common" }
 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" }
 nym-ecash-contract-common = { path = "../../cosmwasm-smart-contracts/ecash-contract" }
 nym-multisig-contract-common = { path = "../../cosmwasm-smart-contracts/multisig-contract" }
 nym-group-contract-common = { path = "../../cosmwasm-smart-contracts/group-contract" }
@@ -55,7 +56,7 @@ cw4 = { workspace = true }
 cw-controllers = { workspace = true }
 prost = { workspace = true, default-features = false }
 flate2 = { workspace = true }
-sha2 = { workspace = true }
+sha2 = { version = "0.9.5" }
 itertools = { workspace = true }
 zeroize = { workspace = true, features = ["zeroize_derive"] }
 cosmwasm-std = { workspace = true }
@@ -11,9 +11,7 @@ use crate::{
 use nym_api_requests::ecash::models::{
    AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
    BatchRedeemTicketsBody, EcashBatchTicketRedemptionResponse, EcashTicketVerificationResponse,
-    IssuedTicketbooksChallengeCommitmentRequest, IssuedTicketbooksChallengeCommitmentResponse,
-    IssuedTicketbooksDataRequest, IssuedTicketbooksDataResponse, IssuedTicketbooksForCountResponse,
-    IssuedTicketbooksForResponse, VerifyEcashTicketBody,
+    IssuedTicketbooksChallengeResponse, IssuedTicketbooksForResponse, VerifyEcashTicketBody,
 };
 use nym_api_requests::ecash::{
    BlindSignRequestBody, BlindedSignatureResponse, PartialCoinIndicesSignatureResponse,
@@ -27,14 +25,15 @@ use nym_api_requests::models::{
 use nym_api_requests::models::{LegacyDescribedGateway, MixNodeBondAnnotated};
 use nym_api_requests::nym_nodes::{NodesByAddressesResponse, SkimmedNode};
 use nym_coconut_dkg_common::types::EpochId;
+use nym_ecash_contract_common::deposit::DepositId;
 use nym_http_api_client::UserAgent;
-use nym_mixnet_contract_common::EpochRewardedSet;
 use nym_network_defaults::NymNetworkDetails;
 use std::net::IpAddr;
 use time::Date;
 use url::Url;

 pub use crate::nym_api::NymApiClientExt;
+use nym_mixnet_contract_common::EpochRewardedSet;
 pub use nym_mixnet_contract_common::{
    mixnode::MixNodeDetails, GatewayBond, IdentityKey, IdentityKeyRef, NodeId, NymNodeDetails,
 };
@@ -702,33 +701,17 @@ impl NymApiClient {
        Ok(self.nym_api.issued_ticketbooks_for(expiration_date).await?)
    }

-    pub async fn issued_ticketbooks_for_count(
+    pub async fn issued_ticketbooks_challenge(
        &self,
        expiration_date: Date,
-    ) -> Result<IssuedTicketbooksForCountResponse, ValidatorClientError> {
+        deposits: Vec<DepositId>,
+    ) -> Result<IssuedTicketbooksChallengeResponse, ValidatorClientError> {
        Ok(self
            .nym_api
-            .issued_ticketbooks_for_count(expiration_date)
+            .issued_ticketbooks_challenge(expiration_date, deposits)
            .await?)
    }

-    pub async fn issued_ticketbooks_challenge_commitment(
-        &self,
-        request: &IssuedTicketbooksChallengeCommitmentRequest,
-    ) -> Result<IssuedTicketbooksChallengeCommitmentResponse, ValidatorClientError> {
-        Ok(self
-            .nym_api
-            .issued_ticketbooks_challenge_commitment(request)
-            .await?)
-    }
-
-    pub async fn issued_ticketbooks_data(
-        &self,
-        request: &IssuedTicketbooksDataRequest,
-    ) -> Result<IssuedTicketbooksDataResponse, ValidatorClientError> {
-        Ok(self.nym_api.issued_ticketbooks_data(request).await?)
-    }
-
    pub async fn nodes_by_addresses(
        &self,
        addresses: Vec<IpAddr>,
@@ -7,8 +7,7 @@ use async_trait::async_trait;
 use nym_api_requests::ecash::models::{
    AggregatedCoinIndicesSignatureResponse, AggregatedExpirationDateSignatureResponse,
    BatchRedeemTicketsBody, EcashBatchTicketRedemptionResponse, EcashTicketVerificationResponse,
-    IssuedTicketbooksChallengeCommitmentRequest, IssuedTicketbooksChallengeCommitmentResponse,
-    IssuedTicketbooksDataRequest, IssuedTicketbooksDataResponse, IssuedTicketbooksForCountResponse,
+    IssuedTicketbooksChallengeRequest, IssuedTicketbooksChallengeResponse,
    IssuedTicketbooksForResponse, VerifyEcashTicketBody,
 };
 use nym_api_requests::ecash::VerificationKeyResponse;
@@ -37,7 +36,10 @@ pub use nym_api_requests::{
    nym_nodes::{CachedNodesResponse, SkimmedNode},
    NymNetworkDetailsResponse,
 };
+pub use nym_coconut_dkg_common::types::EpochId;
 use nym_contracts_common::IdentityKey;
+use nym_ecash_contract_common::deposit::DepositId;
+pub use nym_http_api_client::Client;
 use nym_http_api_client::{ApiClient, NO_PARAMS};
 use nym_mixnet_contract_common::mixnode::MixNodeDetails;
 use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, NodeId, NymNodeDetails};
@@ -46,9 +48,6 @@ use time::format_description::BorrowedFormatItem;
 use time::Date;
 use tracing::instrument;

-pub use nym_coconut_dkg_common::types::EpochId;
-pub use nym_http_api_client::Client;
-
 pub mod error;
 pub mod routes;

@@ -1013,52 +1012,22 @@ pub trait NymApiClientExt: ApiClient {
    }

    #[instrument(level = "debug", skip(self))]
-    async fn issued_ticketbooks_for_count(
+    async fn issued_ticketbooks_challenge(
        &self,
        expiration_date: Date,
-    ) -> Result<IssuedTicketbooksForCountResponse, NymAPIError> {
-        self.get_json(
-            &[
-                routes::API_VERSION,
-                routes::ECASH_ROUTES,
-                routes::ECASH_ISSUED_TICKETBOOKS_FOR_COUNT,
-                &expiration_date.to_string(),
-            ],
-            NO_PARAMS,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn issued_ticketbooks_challenge_commitment(
-        &self,
-        request: &IssuedTicketbooksChallengeCommitmentRequest,
-    ) -> Result<IssuedTicketbooksChallengeCommitmentResponse, NymAPIError> {
+        deposits: Vec<DepositId>,
+    ) -> Result<IssuedTicketbooksChallengeResponse, NymAPIError> {
        self.post_json(
            &[
                routes::API_VERSION,
                routes::ECASH_ROUTES,
-                routes::ECASH_ISSUED_TICKETBOOKS_CHALLENGE_COMMITMENT,
+                routes::ECASH_ISSUED_TICKETBOOKS_CHALLENGE,
            ],
            NO_PARAMS,
-            request,
-        )
-        .await
-    }
-
-    #[instrument(level = "debug", skip(self))]
-    async fn issued_ticketbooks_data(
-        &self,
-        request: &IssuedTicketbooksDataRequest,
-    ) -> Result<IssuedTicketbooksDataResponse, NymAPIError> {
-        self.post_json(
-            &[
-                routes::API_VERSION,
-                routes::ECASH_ROUTES,
-                routes::ECASH_ISSUED_TICKETBOOKS_DATA,
-            ],
-            NO_PARAMS,
-            request,
+            &IssuedTicketbooksChallengeRequest {
+                expiration_date,
+                deposits,
+            },
        )
        .await
    }
@@ -26,12 +26,7 @@ pub mod ecash {
    pub const GLOBAL_COIN_INDICES_SIGNATURES: &str = "aggregated-coin-indices-signatures";
    pub const MASTER_VERIFICATION_KEY: &str = "master-verification-key";
    pub const ECASH_ISSUED_TICKETBOOKS_FOR: &str = "issued-ticketbooks-for";
-    pub const ECASH_ISSUED_TICKETBOOKS_COUNT: &str = "issued-ticketbooks-count";
-    pub const ECASH_ISSUED_TICKETBOOKS_FOR_COUNT: &str = "issued-ticketbooks-for-count";
-    pub const ECASH_ISSUED_TICKETBOOKS_ON_COUNT: &str = "issued-ticketbooks-on-count";
-    pub const ECASH_ISSUED_TICKETBOOKS_CHALLENGE_COMMITMENT: &str =
-        "issued-ticketbooks-challenge-commitment";
-    pub const ECASH_ISSUED_TICKETBOOKS_DATA: &str = "issued-ticketbooks-data";
+    pub const ECASH_ISSUED_TICKETBOOKS_CHALLENGE: &str = "issued-ticketbooks-challenge";

    pub const EXPIRATION_DATE_PARAM: &str = "expiration_date";
    pub const EPOCH_ID_PARAM: &str = "epoch_id";
@@ -48,7 +48,7 @@ impl Div<GasPrice> for &Coin {
            panic!("attempted to divide by zero!")
        };

-        let implicit_gas_limit = Uint128::new(self.amount).mul_floor(gas_price_inv);
+        let implicit_gas_limit = gas_price_inv * Uint128::new(self.amount);
        if implicit_gas_limit.u128() >= u64::MAX as u128 {
            u64::MAX
        } else {
@@ -169,7 +169,13 @@ impl CoinConverter for CosmosCoin {
    type Target = CosmWasmCoin;

    fn convert_coin(&self) -> Self::Target {
-        CosmWasmCoin::new(self.amount, self.denom.to_string())
+        CosmWasmCoin::new(
+            self.amount
+                .to_string()
+                .parse()
+                .expect("cosmos coin had an invalid amount assigned"),
+            self.denom.to_string(),
+        )
    }
 }

@@ -7,10 +7,10 @@ use crate::nyxd::error::NyxdError;
 use crate::nyxd::{Coin, Fee, SigningCosmWasmClient};
 use crate::signing::signer::OfflineSigner;
 use async_trait::async_trait;
-use cosmwasm_std::{CosmosMsg, Empty};
+use cosmwasm_std::{to_binary, CosmosMsg, WasmMsg};
 use cw3::Vote;
 use cw4::{MemberChangedHookMsg, MemberDiff};
-use cw_utils::Expiration;
+use nym_coconut_bandwidth_contract_common::msg::ExecuteMsg as CoconutBandwidthExecuteMsg;
 use nym_multisig_contract_common::msg::ExecuteMsg as MultisigExecuteMsg;

 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -24,23 +24,35 @@ pub trait MultisigSigningClient: NymContractsProvider {
        funds: Vec<Coin>,
    ) -> Result<ExecuteResult, NyxdError>;

-    async fn propose(
+    async fn propose_release_funds(
        &self,
        title: String,
-        description: String,
-        msgs: Vec<CosmosMsg<Empty>>,
-        latest: Option<Expiration>,
+        blinded_serial_number: String,
+        voucher_value: Coin,
        fee: Option<Fee>,
    ) -> Result<ExecuteResult, NyxdError> {
+        let ecash_contract_address = self
+            .ecash_contract_address()
+            .ok_or_else(|| NyxdError::unavailable_contract_address("coconut bandwidth contract"))?;
+
+        let release_funds_req = CoconutBandwidthExecuteMsg::ReleaseFunds {
+            funds: voucher_value.into(),
+        };
+        let release_funds_msg = CosmosMsg::Wasm(WasmMsg::Execute {
+            contract_addr: ecash_contract_address.to_string(),
+            msg: to_binary(&release_funds_req)?,
+            funds: vec![],
+        });
+        let req = MultisigExecuteMsg::Propose {
+            title,
+            description: blinded_serial_number,
+            msgs: vec![release_funds_msg],
+            latest: None,
+        };
        self.execute_multisig_contract(
            fee,
-            MultisigExecuteMsg::Propose {
-                title,
-                description,
-                msgs,
-                latest,
-            },
-            "Multisig::Propose".to_string(),
+            req,
+            "Multisig::Propose::Execute::ReleaseFunds".to_string(),
            vec![],
        )
        .await
@@ -149,7 +161,7 @@ where
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::nyxd::contract_traits::tests::IgnoreValue;
+    use crate::nyxd::contract_traits::tests::{mock_coin, IgnoreValue};

    // it's enough that this compiles and clippy is happy about it
    #[allow(dead_code)]
@@ -159,12 +171,9 @@ mod tests {
    ) {
        match msg {
            MultisigExecuteMsg::Propose {
-                title,
-                description,
-                msgs,
-                latest,
+                title, description, ..
            } => client
-                .propose(title, description, msgs, latest, None)
+                .propose_release_funds(title, description, mock_coin(), None)
                .ignore(),
            MultisigExecuteMsg::Vote { proposal_id, vote } => {
                client.vote(proposal_id, vote, None).ignore()
@@ -27,7 +27,7 @@ impl Mul<Gas> for &GasPrice {

    fn mul(self, gas_limit: Gas) -> Self::Output {
        let limit_uint128 = Uint128::from(gas_limit);
-        let mut amount = limit_uint128.mul_floor(self.amount);
+        let mut amount = self.amount * limit_uint128;

        let gas_price_numerator = self.amount.numerator();
        let gas_price_denominator = self.amount.denominator();
@@ -35,7 +35,7 @@ impl Mul<Gas> for &GasPrice {
        // gas price is a fraction of the smallest fee token unit, so we must ensure that
        // for any multiplication, we have rounded up
        //
-        // I don't really like this solution as it has a theoretical chance of
+        // I don't really like the this solution as it has a theoretical chance of
        // overflowing (internally cosmwasm uses U256 to avoid that)
        // however, realistically that is impossible to happen as the resultant value
        // would have to be way higher than our token limit of 10^15 (1 billion of tokens * 1 million for denomination)
@@ -15,7 +15,7 @@ use nym_credentials::{
    AggregatedCoinIndicesSignatures, AggregatedExpirationDateSignatures, EpochVerificationKey,
 };
 use nym_credentials_interface::TicketType;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use std::fs;
 use std::path::PathBuf;
 use tempfile::NamedTempFile;
@@ -83,7 +83,7 @@ async fn issue_client_ticketbook(
    );

    let persistent_storage = initialise_persistent_storage(credentials_store).await;
-    let private_id_key: ed25519::PrivateKey = nym_pemstore::load_key(private_id_key)?;
+    let private_id_key: identity::PrivateKey = nym_pemstore::load_key(private_id_key)?;
    utils::issue_credential(
        &client,
        &persistent_storage,
@@ -155,7 +155,7 @@ async fn fetch_delegation_data(
        match event.event.kind {
            // If a pending undelegate tx is found, remove it from delegation map
            PendingEpochEventKind::Undelegate { owner, node_id, .. } => {
-                if owner.as_str() == address.as_ref()
+                if owner == address.as_ref()
                    && existing_delegation_map.contains_key(&node_id.to_string())
                {
                    existing_delegation_map.remove(&node_id.to_string());
@@ -169,7 +169,7 @@ async fn fetch_delegation_data(
                amount,
                ..
            } => {
-                if owner.as_str() == address.as_ref() {
+                if owner == address.as_ref() {
                    let mut amount = Coin::from(amount);
                    if let Some(pending_record) = pending_delegation_map.get(&node_id.to_string()) {
                        amount.amount += pending_record.amount;
@@ -1,6 +1,6 @@
 use clap::{Args, Parser, Subcommand};
 use nym_bin_common::output_format::OutputFormat;
-use nym_crypto::asymmetric::ed25519;
+use nym_crypto::asymmetric::identity;
 use nym_types::helpers::ConsoleSigningOutput;
 use nym_validator_client::nyxd::error::NyxdError;
 use std::path::PathBuf;
@@ -34,14 +34,14 @@ pub struct SignArgs {

 pub async fn sign(args: SignArgs) -> Result<(), NyxdError> {
    eprintln!(">>> loading: {}", args.private_key.display());
-    let private_identity_key: ed25519::PrivateKey =
+    let private_identity_key: identity::PrivateKey =
        nym_pemstore::load_key(args.private_key).expect("failed to load key");

    print_signed_msg(&private_identity_key, &args.base58_msg, args.output);
    Ok(())
 }

-fn print_signed_msg(private_key: &ed25519::PrivateKey, raw_msg: &str, output: OutputFormat) {
+fn print_signed_msg(private_key: &identity::PrivateKey, raw_msg: &str, output: OutputFormat) {
    let trimmed = raw_msg.trim();
    eprintln!(">>> attempting to sign: {trimmed}");

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jon Häggblad	22d6eaf9b8	Some minor conversions	2025-03-18 22:04:30 +01:00
Jon Häggblad	a6b0b6f0f6	EXISTS return i64	2025-03-18 21:51:33 +01:00
Jon Häggblad	a4bad2e697	Upgrade to sqlx 0.8.3	2025-03-18 21:34:51 +01:00