added support for tss-frost endpoints

Author: himanshu

packages/constants/src/constants.ts

@@ -79,3 +79,8 @@ export const METADATA_MAP: Record<TORUS_LEGACY_NETWORK_TYPE, string> = {
 
 export const FND_SERVER = "https://fnd.web3auth.io";
 export const SESSION_SERVER = "https://session.web3auth.io";
+
+export const KEY_TYPE = {
+  SECP256K1: "secp256k1",
+  ED25519: "ed25519",
+} as const;

packages/constants/src/interfaces.ts

@@ -1,4 +1,4 @@
-import { TORUS_LEGACY_NETWORK, TORUS_SAPPHIRE_NETWORK } from "./constants";
+import { KEY_TYPE, TORUS_LEGACY_NETWORK, TORUS_SAPPHIRE_NETWORK } from "./constants";
 
 export interface JRPCResponse<T> {
   id: number;
@@ -33,6 +33,8 @@ export type TORUS_SAPPHIRE_NETWORK_TYPE = (typeof TORUS_SAPPHIRE_NETWORK)[keyof
 
 export type TORUS_NETWORK_TYPE = TORUS_LEGACY_NETWORK_TYPE | TORUS_SAPPHIRE_NETWORK_TYPE;
 
+export type WEB3AUTH_KEY_TYPE = (typeof KEY_TYPE)[keyof typeof KEY_TYPE];
+
 export type NODE = {
   address: string;
   node_index: string;

packages/fetch-node-details/src/interfaces.ts

@@ -1,3 +1,8 @@
-import { TORUS_NETWORK_TYPE } from "@toruslabs/constants";
+import { TORUS_NETWORK_TYPE, WEB3AUTH_KEY_TYPE } from "@toruslabs/constants";
 
-export type NodeDetailManagerParams = { network?: TORUS_NETWORK_TYPE; fndServerEndpoint?: string; enableLogging?: boolean };
+export type NodeDetailManagerParams = {
+  network?: TORUS_NETWORK_TYPE;
+  keyType?: WEB3AUTH_KEY_TYPE;
+  fndServerEndpoint?: string;
+  enableLogging?: boolean;
+};

packages/fetch-node-details/src/nodeDetailManager.ts

@@ -2,12 +2,14 @@ import {
   FND_SERVER,
   INodeDetails,
   INodePub,
+  KEY_TYPE,
   METADATA_MAP,
   MULTI_CLUSTER_NETWORKS,
   TORUS_LEGACY_NETWORK,
   TORUS_LEGACY_NETWORK_TYPE,
   TORUS_NETWORK_TYPE,
   TORUS_SAPPHIRE_NETWORK,
+  WEB3AUTH_KEY_TYPE,
 } from "@toruslabs/constants";
 import { fetchLocalConfig } from "@toruslabs/fnd-base";
 import { get } from "@toruslabs/http-helpers";
@@ -22,6 +24,8 @@ class NodeDetailManager {
 
   private _currentEpoch = "1";
 
+  private _keyType: WEB3AUTH_KEY_TYPE;
+
   private _torusNodeEndpoints: string[] = [];
 
   private _torusNodeRSSEndpoints: string[] = [];
@@ -38,9 +42,14 @@ class NodeDetailManager {
 
   private network: TORUS_NETWORK_TYPE;
 
-  constructor({ network = TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET, fndServerEndpoint, enableLogging = false }: NodeDetailManagerParams = {}) {
+  constructor({
+    network = TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET,
+    keyType = KEY_TYPE.SECP256K1,
+    fndServerEndpoint,
+    enableLogging = false,
+  }: NodeDetailManagerParams = {}) {
     this.network = network;
-
+    this._keyType = keyType;
     this.updated = false;
     if (fndServerEndpoint) {
       this.fndServerEndpoint = fndServerEndpoint;
@@ -71,7 +80,7 @@ class NodeDetailManager {
 
       try {
         const { nodeDetails } = await get<{ nodeDetails: INodeDetails }>(
-          `${this.fndServerEndpoint}?network=${this.network}&verifier=${verifier}&verifierId=${verifierId}`
+          `${this.fndServerEndpoint}?network=${this.network}&verifier=${verifier}&verifierId=${verifierId}&keyType=${this._keyType}`
         );
         this.setNodeDetails(nodeDetails);
 
@@ -80,7 +89,7 @@ class NodeDetailManager {
         log.error("Failed to fetch node details from server, using local.", error);
       }
 
-      const nodeDetails = fetchLocalConfig(this.network as TORUS_NETWORK_TYPE);
+      const nodeDetails = fetchLocalConfig(this.network as TORUS_NETWORK_TYPE, this._keyType);
       if (!nodeDetails) throw new Error("Failed to fetch node details");
       this.setNodeDetails(nodeDetails);
       return this._nodeDetails;

packages/fetch-node-details/test/nodeDetail.test.ts

@@ -20,6 +20,7 @@ describe("Fetch Node Details", function () {
     deepStrictEqual(details, getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET, TORUS_LEGACY_NETWORK.MAINNET));
     strictEqual(metadataUrl, METADATA_MAP[TORUS_LEGACY_NETWORK.MAINNET]);
   });
+
   it("#should return correct values - sapphire devnet", async function () {
     const nodeDetailManager = new NodeDetailManager({
       network: TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET,

packages/fnd-base/src/endpoints.ts

@@ -1,4 +1,11 @@
-import { LEGACY_NETWORKS_ROUTE_MAP, TORUS_LEGACY_NETWORK_TYPE, TORUS_SAPPHIRE_NETWORK, TORUS_SAPPHIRE_NETWORK_TYPE } from "@toruslabs/constants";
+import {
+  KEY_TYPE,
+  LEGACY_NETWORKS_ROUTE_MAP,
+  TORUS_LEGACY_NETWORK_TYPE,
+  TORUS_SAPPHIRE_NETWORK,
+  TORUS_SAPPHIRE_NETWORK_TYPE,
+  WEB3AUTH_KEY_TYPE,
+} from "@toruslabs/constants";
 
 export const SAPPHIRE_NETWORK_URLS: Record<TORUS_SAPPHIRE_NETWORK_TYPE, string[]> = {
   [TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET]: [
@@ -46,17 +53,22 @@ export const getRSSEndpoints = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE, le
   });
 };
 
-export const getTSSEndpoints = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE, legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE) => {
+export const getTSSEndpoints = (
+  sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE,
+  legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE,
+  keyType = KEY_TYPE.SECP256K1 as WEB3AUTH_KEY_TYPE
+) => {
   const endpoints = SAPPHIRE_NETWORK_URLS[sapphireNetwork];
   if (!endpoints || endpoints.length === 0) {
     throw new Error(`Unsupported network: ${sapphireNetwork}`);
   }
 
+  const tssPath = keyType === KEY_TYPE.ED25519 ? "tss-frost" : "tss";
   const routeIdentifier = LEGACY_NETWORKS_ROUTE_MAP[legacyNetwork as TORUS_LEGACY_NETWORK_TYPE];
   return endpoints.map((e) => {
     if (routeIdentifier && routeIdentifier.networkIdentifier) {
-      return `${e}/tss/${routeIdentifier.networkIdentifier}`;
+      return `${e}/${tssPath}/${routeIdentifier.networkIdentifier}`;
     }
-    return `${e}/tss`;
+    return `${e}/${tssPath}`;
   });
 };

packages/fnd-base/src/sapphireNetworkConfig.ts

@@ -1,9 +1,13 @@
-import { INodeDetails, TORUS_LEGACY_NETWORK_TYPE, TORUS_SAPPHIRE_NETWORK_TYPE } from "@toruslabs/constants";
+import { INodeDetails, TORUS_LEGACY_NETWORK_TYPE, TORUS_SAPPHIRE_NETWORK_TYPE, WEB3AUTH_KEY_TYPE } from "@toruslabs/constants";
 
 import { getRSSEndpoints, getSSSEndpoints, getTSSEndpoints } from "./endpoints";
 import { SAPPHIRE_NODE_PUB_KEYS } from "./pubKeys";
 
-export const getSapphireNodeDetails = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE, legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE): INodeDetails => {
+export const getSapphireNodeDetails = (
+  sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE,
+  legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE,
+  keyType?: WEB3AUTH_KEY_TYPE
+): INodeDetails => {
   return {
     currentEpoch: "1",
 
@@ -13,7 +17,7 @@ export const getSapphireNodeDetails = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_T
 
     torusNodeRSSEndpoints: getRSSEndpoints(sapphireNetwork, legacyNetwork),
 
-    torusNodeTSSEndpoints: getTSSEndpoints(sapphireNetwork, legacyNetwork),
+    torusNodeTSSEndpoints: getTSSEndpoints(sapphireNetwork, legacyNetwork, keyType),
     torusIndexes: [1, 2, 3, 4, 5],
 
     torusNodePub: SAPPHIRE_NODE_PUB_KEYS[sapphireNetwork],

packages/fnd-base/src/utils.ts

@@ -6,18 +6,19 @@ import {
   TORUS_NETWORK_TYPE,
   TORUS_SAPPHIRE_NETWORK,
   TORUS_SAPPHIRE_NETWORK_TYPE,
+  WEB3AUTH_KEY_TYPE,
 } from "@toruslabs/constants";
 
 import { getSapphireNodeDetails } from "./sapphireNetworkConfig";
 
-export function fetchLocalConfig(network: TORUS_NETWORK_TYPE): INodeDetails | undefined {
+export function fetchLocalConfig(network: TORUS_NETWORK_TYPE, keyType: WEB3AUTH_KEY_TYPE): INodeDetails | undefined {
   if (Object.values(TORUS_SAPPHIRE_NETWORK).includes(network as TORUS_SAPPHIRE_NETWORK_TYPE)) {
-    return getSapphireNodeDetails(network as TORUS_SAPPHIRE_NETWORK_TYPE);
+    return getSapphireNodeDetails(network as TORUS_SAPPHIRE_NETWORK_TYPE, undefined, keyType);
   }
 
   if (Object.values(TORUS_LEGACY_NETWORK).includes(network as TORUS_LEGACY_NETWORK_TYPE)) {
     const legacyMap = LEGACY_NETWORKS_ROUTE_MAP[network as TORUS_LEGACY_NETWORK_TYPE];
-    if (legacyMap.migrationCompleted) return getSapphireNodeDetails(legacyMap.networkMigratedTo, network as TORUS_LEGACY_NETWORK_TYPE);
+    if (legacyMap.migrationCompleted) return getSapphireNodeDetails(legacyMap.networkMigratedTo, network as TORUS_LEGACY_NETWORK_TYPE, keyType);
   }
 
   return undefined;

packages/fnd-server/src/router.ts

@@ -1,10 +1,12 @@
 import {
+  KEY_TYPE,
   MULTI_CLUSTER_NETWORKS,
   PROXY_CONTRACT_ADDRESS,
   TORUS_LEGACY_NETWORK,
   TORUS_LEGACY_NETWORK_TYPE,
   TORUS_NETWORK_TYPE,
   TORUS_SAPPHIRE_NETWORK,
+  WEB3AUTH_KEY_TYPE,
 } from "@toruslabs/constants";
 import { fetchLocalConfig } from "@toruslabs/fnd-base";
 import { celebrate, Joi } from "celebrate";
@@ -41,24 +43,27 @@ router.get(
           .allow(...Object.values(TORUS_LEGACY_NETWORK), ...Object.values(TORUS_SAPPHIRE_NETWORK)),
         verifier: Joi.string().required(),
         verifierId: Joi.string().required(),
+        keyType: Joi.string()
+          .optional()
+          .allow(...Object.values(KEY_TYPE)),
       }),
     },
     { allowUnknown: true }
   ),
   async (req: Request, res: Response) => {
     try {
-      const { network, verifier, verifierId } = req.query as Record<string, string>;
+      const { network, verifier, verifierId, keyType = "secp256k1" } = req.query as Record<string, string>;
       const finalNetwork = network.toLowerCase();
-      const cacheKey = getNetworkRedisKey(finalNetwork as TORUS_NETWORK_TYPE, verifier, verifierId);
-
-      let nodeDetails = fetchLocalConfig(finalNetwork as TORUS_NETWORK_TYPE);
+      // use static details for sapphire mainnet and testnet
+      let nodeDetails = fetchLocalConfig(finalNetwork as TORUS_NETWORK_TYPE, keyType as WEB3AUTH_KEY_TYPE);
       if (nodeDetails) {
         return res.status(200).json({
           nodeDetails,
           success: true,
         });
       }
-      // use static details for mainnet and testnet
+
+      const cacheKey = getNetworkRedisKey(finalNetwork as TORUS_NETWORK_TYPE, verifier, verifierId);
       try {
         const cachedInfo = await redisClient.get(cacheKey);
         if (cachedInfo) {