return deterministic user tracking id and remove celeste

.env.development

@@ -9,3 +9,6 @@ LOG_LEVEL=debug
 SENTRY_DSN=
 SENTRY_TRACES_SAMPLE_RATE=0.01
 SENTRY_SAMPLE_RATE=0.1
+
+# Tracking
+TRACKING_ENABLED=false

packages/constants/src/constants.ts

@@ -5,7 +5,6 @@ export const TORUS_LEGACY_NETWORK = {
   TESTNET: "testnet",
   CYAN: "cyan",
   AQUA: "aqua",
-  CELESTE: "celeste",
 } as const;
 
 export const TORUS_SAPPHIRE_NETWORK = {
@@ -21,23 +20,15 @@ export const PROXY_CONTRACT_ADDRESS = {
   [TORUS_LEGACY_NETWORK.CYAN]: "0x9f072ba19b3370e512aa1b4bfcdaf97283168005",
 
   [TORUS_LEGACY_NETWORK.AQUA]: "0x29Dea82a0509153b91040ee13cDBba0f03efb625",
-
-  [TORUS_LEGACY_NETWORK.CELESTE]: "0x6Bffb4e89453069E7487f0fa5c9f4a2D771cce6c",
 };
 
 export const MULTI_CLUSTER_NETWORKS: TORUS_LEGACY_NETWORK_TYPE[] = [
   // TORUS_LEGACY_NETWORK.AQUA,
-  // TORUS_LEGACY_NETWORK.CELESTE,
   // TORUS_LEGACY_NETWORK.CYAN,
 ];
 
 export const LEGACY_NETWORKS_ROUTE_MAP: Record<TORUS_LEGACY_NETWORK_TYPE, ILegacyNetworkMigrationInfo> = {
   [TORUS_LEGACY_NETWORK.AQUA]: { migrationCompleted: true, networkIdentifier: "aqua", networkMigratedTo: TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET },
-  [TORUS_LEGACY_NETWORK.CELESTE]: {
-    migrationCompleted: true,
-    networkIdentifier: "celeste",
-    networkMigratedTo: TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET,
-  },
   [TORUS_LEGACY_NETWORK.CYAN]: { migrationCompleted: true, networkIdentifier: "cyan", networkMigratedTo: TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET },
   [TORUS_LEGACY_NETWORK.MAINNET]: {
     migrationCompleted: true,
@@ -56,7 +47,6 @@ export const NETWORK_MAP: Record<TORUS_LEGACY_NETWORK_TYPE, string> = {
   [TORUS_LEGACY_NETWORK.TESTNET]: "goerli",
   [TORUS_LEGACY_NETWORK.CYAN]: "polygon-mainnet",
   [TORUS_LEGACY_NETWORK.AQUA]: "polygon-mainnet",
-  [TORUS_LEGACY_NETWORK.CELESTE]: "polygon-mainnet",
 };
 
 export const SIGNER_MAP: Record<TORUS_NETWORK_TYPE, string> = {
@@ -66,15 +56,13 @@ export const SIGNER_MAP: Record<TORUS_NETWORK_TYPE, string> = {
   [TORUS_LEGACY_NETWORK.TESTNET]: "https://api.web3auth.io/signer-service",
   [TORUS_LEGACY_NETWORK.CYAN]: "https://api.web3auth.io/signer-polygon-service",
   [TORUS_LEGACY_NETWORK.AQUA]: "https://api.web3auth.io/signer-polygon-service",
-  [TORUS_LEGACY_NETWORK.CELESTE]: "https://api.web3auth.io/signer-polygon-service",
 };
 
 export const METADATA_MAP: Record<TORUS_LEGACY_NETWORK_TYPE, string> = {
   [TORUS_LEGACY_NETWORK.MAINNET]: "https://api.web3auth.io/metadata-service",
   [TORUS_LEGACY_NETWORK.TESTNET]: "https://api.web3auth.io/metadata-service",
   [TORUS_LEGACY_NETWORK.CYAN]: "https://api.web3auth.io/metadata-service",
   [TORUS_LEGACY_NETWORK.AQUA]: "https://api.web3auth.io/metadata-service",
-  [TORUS_LEGACY_NETWORK.CELESTE]: "https://api.web3auth.io/metadata-service",
 };
 
 // FND backend service
@@ -97,3 +85,5 @@ export const SIG_TYPE = {
   ED25519: "ed25519",
   BIP340: "bip340",
 } as const;
+
+export const TEST_VERIFIERS = ["torus-test-health"];

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

@@ -83,22 +83,21 @@ class NodeDetailManager {
     };
   }
 
-  async getNodeDetails({ verifier, verifierId }: { verifier: string; verifierId: string }): Promise<INodeDetails> {
+  async getNodeDetails({ verifier, verifierId, trackingId }: { verifier: string; verifierId: string; trackingId?: string }): Promise<INodeDetails> {
     try {
       if (this.updated && !MULTI_CLUSTER_NETWORKS.includes(this.network as TORUS_LEGACY_NETWORK_TYPE)) return this._nodeDetails;
 
       try {
         const { nodeDetails } = await get<{ nodeDetails: INodeDetails }>(
-          `${this.fndServerEndpoint}?network=${this.network}&verifier=${verifier}&verifierId=${verifierId}&keyType=${this._keyType}&sigType=${this._sigType}`
+          `${this.fndServerEndpoint}?network=${this.network}&verifier=${verifier}&verifierId=${verifierId}&keyType=${this._keyType}&sigType=${this._sigType}&trackingId=${trackingId}`
         );
         this.setNodeDetails(nodeDetails);
-
         return this._nodeDetails;
       } catch (error) {
         log.error("Failed to fetch node details from server, using local.", error);
       }
 
-      const nodeDetails = fetchLocalConfig(this.network as TORUS_NETWORK_TYPE, this._keyType, this._sigType);
+      const nodeDetails = fetchLocalConfig(this.network as TORUS_NETWORK_TYPE, this._keyType, this._sigType, trackingId);
       if (!nodeDetails) throw new Error("Failed to fetch node details");
       this.setNodeDetails(nodeDetails);
       return this._nodeDetails;

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

@@ -14,22 +14,25 @@ describe("Fetch Node Details", function () {
       enableLogging: true,
     });
     const details = await nodeDetailManager.getNodeDetails({ verifier: "google", verifierId: "[email protected]" });
+
     delete details.updated;
     const metadataUrl = await nodeDetailManager.getMetadataUrl();
-    deepStrictEqual(details, getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET, TORUS_LEGACY_NETWORK.MAINNET));
+    const expectedDetails = getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET, TORUS_LEGACY_NETWORK.MAINNET);
+    deepStrictEqual(details, expectedDetails);
     strictEqual(metadataUrl, METADATA_MAP[TORUS_LEGACY_NETWORK.MAINNET]);
   });
 
   it("#should return correct values - sapphire devnet", async function () {
+    const trackingId = "eea55f6dede3377be2ba5e8e5839a84afcdb9e6447ad0265";
     const nodeDetailManager = new NodeDetailManager({
       network: TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET,
       fndServerEndpoint,
       enableLogging: true,
     });
-    const details = await nodeDetailManager.getNodeDetails({ verifier: "google", verifierId: "[email protected]" });
+    const details = await nodeDetailManager.getNodeDetails({ verifier: "google", verifierId: "[email protected]", trackingId });
     delete details.updated;
     const metadataUrl = await nodeDetailManager.getMetadataUrl();
-    const compareNodeDetails = getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET);
+    const compareNodeDetails = getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET, undefined, undefined, undefined, trackingId);
     deepStrictEqual(details, compareNodeDetails);
     strictEqual(metadataUrl, compareNodeDetails.torusNodeEndpoints[0].replace("/sss/jrpc", "/metadata"));
   });
@@ -74,29 +77,21 @@ describe("Fetch Node Details", function () {
     strictEqual(metadataUrl, METADATA_MAP[TORUS_LEGACY_NETWORK.AQUA]);
   });
 
-  it("#should return correct values - celeste", async function () {
-    const nodeDetailManager = new NodeDetailManager({
-      network: TORUS_LEGACY_NETWORK.CELESTE,
-      fndServerEndpoint,
-      enableLogging: true,
-    });
-    const details = await nodeDetailManager.getNodeDetails({ verifier: "google-celeste", verifierId: "[email protected]" });
-    delete details.updated;
-    const metadataUrl = await nodeDetailManager.getMetadataUrl();
-    deepStrictEqual(details, getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_MAINNET, TORUS_LEGACY_NETWORK.CELESTE));
-    strictEqual(metadataUrl, METADATA_MAP[TORUS_LEGACY_NETWORK.CELESTE]);
-  });
-
   it("#should return correct values - testnet", async function () {
+    const trackingId = "26a8e90f2414039ad745514413591b51e697fce81091cc58";
+
     const nodeDetailManager = new NodeDetailManager({
       network: TORUS_LEGACY_NETWORK.TESTNET,
       fndServerEndpoint,
       enableLogging: true,
     });
-    const details = await nodeDetailManager.getNodeDetails({ verifier: "google-lrc", verifierId: "[email protected]" });
+    const details = await nodeDetailManager.getNodeDetails({ verifier: "google-lrc", verifierId: "[email protected]", trackingId });
     delete details.updated;
     const metadataUrl = await nodeDetailManager.getMetadataUrl();
-    deepStrictEqual(details, getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET, TORUS_LEGACY_NETWORK.TESTNET));
+    deepStrictEqual(
+      details,
+      getSapphireNodeDetails(TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET, TORUS_LEGACY_NETWORK.TESTNET, undefined, undefined, trackingId)
+    );
     strictEqual(metadataUrl, METADATA_MAP[TORUS_LEGACY_NETWORK.TESTNET]);
   });
 

packages/fnd-base/src/endpoints.ts

@@ -26,40 +26,44 @@ export const SAPPHIRE_NETWORK_URLS: Record<TORUS_SAPPHIRE_NETWORK_TYPE, string[]
   ],
 };
 
-export const getSSSEndpoints = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE, legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE) => {
+export const getSSSEndpoints = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE, legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE, trackingId?: string) => {
   const endpoints = SAPPHIRE_NETWORK_URLS[sapphireNetwork];
   if (!endpoints || endpoints.length === 0) {
     throw new Error(`Unsupported network: ${sapphireNetwork}`);
   }
   const routeIdentifier = LEGACY_NETWORKS_ROUTE_MAP[legacyNetwork as TORUS_LEGACY_NETWORK_TYPE];
   return endpoints.map((e) => {
+    let endpoint = new URL(`${e}/sss/jrpc`);
     if (routeIdentifier && routeIdentifier.networkIdentifier) {
-      return `${e}/sss/${routeIdentifier.networkIdentifier}/jrpc`;
+      endpoint = new URL(`${e}/sss/${routeIdentifier.networkIdentifier}/jrpc`);
     }
-    return `${e}/sss/jrpc`;
+    if (trackingId) {
+      endpoint.searchParams.set("trackingId", trackingId);
+    }
+    return endpoint.href;
   });
 };
 
-export const getRSSEndpoints = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE, legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE) => {
+export const getRSSEndpoints = (sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE, trackingId?: string) => {
   const endpoints = SAPPHIRE_NETWORK_URLS[sapphireNetwork];
   if (!endpoints || endpoints.length === 0) {
     throw new Error(`Unsupported network: ${sapphireNetwork}`);
   }
-
-  const routeIdentifier = LEGACY_NETWORKS_ROUTE_MAP[legacyNetwork as TORUS_LEGACY_NETWORK_TYPE];
   return endpoints.map((e) => {
-    if (routeIdentifier && routeIdentifier.networkIdentifier) {
-      return `${e}/rss/${routeIdentifier.networkIdentifier}`;
+    const endpoint = new URL(`${e}/rss`);
+
+    if (trackingId) {
+      endpoint.searchParams.set("trackingId", trackingId);
     }
-    return `${e}/rss`;
+    return endpoint.href;
   });
 };
 
 export const getTSSEndpoints = (
   sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE,
-  legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE,
   keyType = KEY_TYPE.SECP256K1 as WEB3AUTH_KEY_TYPE,
-  sigType?: WEB3AUTH_SIG_TYPE
+  sigType?: WEB3AUTH_SIG_TYPE,
+  trackingId?: string
 ) => {
   const endpoints = SAPPHIRE_NETWORK_URLS[sapphireNetwork];
   if (!endpoints || endpoints.length === 0) {
@@ -95,11 +99,11 @@ export const getTSSEndpoints = (
     throw new Error("Invalid key type");
   })();
 
-  const routeIdentifier = LEGACY_NETWORKS_ROUTE_MAP[legacyNetwork as TORUS_LEGACY_NETWORK_TYPE];
   return endpoints.map((e) => {
-    if (routeIdentifier && routeIdentifier.networkIdentifier) {
-      return `${e}/${tssPath}/${routeIdentifier.networkIdentifier}`;
+    const endpoint = new URL(`${e}/${tssPath}`);
+    if (trackingId) {
+      endpoint.searchParams.set("trackingId", trackingId);
     }
-    return `${e}/${tssPath}`;
+    return endpoint.href;
   });
 };

packages/fnd-base/src/sapphireNetworkConfig.ts

@@ -7,18 +7,19 @@ export const getSapphireNodeDetails = (
   sapphireNetwork: TORUS_SAPPHIRE_NETWORK_TYPE,
   legacyNetwork?: TORUS_LEGACY_NETWORK_TYPE,
   keyType?: WEB3AUTH_KEY_TYPE,
-  sigType?: WEB3AUTH_SIG_TYPE
+  sigType?: WEB3AUTH_SIG_TYPE,
+  trackingId?: string
 ): INodeDetails => {
   return {
     currentEpoch: "1",
 
-    torusNodeEndpoints: getSSSEndpoints(sapphireNetwork, legacyNetwork),
+    torusNodeEndpoints: getSSSEndpoints(sapphireNetwork, legacyNetwork, trackingId),
 
-    torusNodeSSSEndpoints: getSSSEndpoints(sapphireNetwork, legacyNetwork),
+    torusNodeSSSEndpoints: getSSSEndpoints(sapphireNetwork, legacyNetwork, trackingId),
 
-    torusNodeRSSEndpoints: getRSSEndpoints(sapphireNetwork, legacyNetwork),
+    torusNodeRSSEndpoints: getRSSEndpoints(sapphireNetwork, trackingId),
 
-    torusNodeTSSEndpoints: getTSSEndpoints(sapphireNetwork, legacyNetwork, keyType, sigType),
+    torusNodeTSSEndpoints: getTSSEndpoints(sapphireNetwork, keyType, sigType, trackingId),
     torusIndexes: [1, 2, 3, 4, 5],
 
     torusNodePub: SAPPHIRE_NODE_PUB_KEYS[sapphireNetwork],

packages/fnd-base/src/utils.ts

@@ -12,14 +12,23 @@ import {
 
 import { getSapphireNodeDetails } from "./sapphireNetworkConfig";
 
-export function fetchLocalConfig(network: TORUS_NETWORK_TYPE, keyType: WEB3AUTH_KEY_TYPE, sigType?: WEB3AUTH_SIG_TYPE): INodeDetails | undefined {
+export function fetchLocalConfig(
+  network: TORUS_NETWORK_TYPE,
+  keyType: WEB3AUTH_KEY_TYPE,
+  sigType?: WEB3AUTH_SIG_TYPE,
+  trackingId?: string
+): INodeDetails | undefined {
   if (Object.values(TORUS_SAPPHIRE_NETWORK).includes(network as TORUS_SAPPHIRE_NETWORK_TYPE)) {
-    return getSapphireNodeDetails(network as TORUS_SAPPHIRE_NETWORK_TYPE, undefined, keyType, sigType);
+    const eps = getSapphireNodeDetails(network as TORUS_SAPPHIRE_NETWORK_TYPE, undefined, keyType, sigType, trackingId);
+    return eps;
   }
 
   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, keyType);
+    if (legacyMap.migrationCompleted) {
+      const ep = getSapphireNodeDetails(legacyMap.networkMigratedTo, network as TORUS_LEGACY_NETWORK_TYPE, keyType, sigType, trackingId);
+      return ep;
+    }
   }
 
   return undefined;

packages/fnd-server/src/router.ts

@@ -12,6 +12,8 @@ import { celebrate, Joi } from "celebrate";
 import express, { Request, Response } from "express";
 import log from "loglevel";
 
+import { getTrackingId } from "./utils/tracking";
+
 const router = express.Router();
 
 router.get("/", (_req: Request, res: Response) => {
@@ -38,17 +40,27 @@ router.get(
         sigType: Joi.string()
           .optional()
           .allow(...Object.values(SIG_TYPE)),
+        trackingId: Joi.string().optional(),
       }),
     },
     { allowUnknown: true }
   ),
   async (req: Request, res: Response) => {
     try {
-      const { network, keyType = KEY_TYPE.SECP256K1, sigType = SIG_TYPE.ECDSA_SECP256K1 } = req.query as Record<string, string>;
+      const { network, verifier, verifierId, keyType = KEY_TYPE.SECP256K1, sigType = SIG_TYPE.ECDSA_SECP256K1 } = req.query as Record<string, string>;
       const finalNetwork = network.toLowerCase();
+      let trackingId = req.query.trackingId as string;
+      if (!trackingId || trackingId === "undefined") {
+        // check if tracking is enabled by default
+        trackingId = getTrackingId(verifier, verifierId, finalNetwork as TORUS_NETWORK_TYPE);
+      }
       // use static details for sapphire mainnet and testnet
-      const nodeDetails = fetchLocalConfig(finalNetwork as TORUS_NETWORK_TYPE, keyType as WEB3AUTH_KEY_TYPE, sigType as WEB3AUTH_SIG_TYPE);
-
+      const nodeDetails = fetchLocalConfig(
+        finalNetwork as TORUS_NETWORK_TYPE,
+        keyType as WEB3AUTH_KEY_TYPE,
+        sigType as WEB3AUTH_SIG_TYPE,
+        trackingId
+      );
       return res.status(200).json({
         nodeDetails,
         success: true,

packages/fnd-server/src/utils/tracking.ts

@@ -0,0 +1,27 @@
+import { TEST_VERIFIERS, TORUS_LEGACY_NETWORK, TORUS_NETWORK_TYPE, TORUS_SAPPHIRE_NETWORK } from "@toruslabs/constants";
+import crypto from "crypto";
+const trackingEnabled = process.env.TRACKING_ENABLED;
+export const isTrackingEnabled = (verifier: string, network: TORUS_NETWORK_TYPE) => {
+  if (
+    trackingEnabled === "true" ||
+    TEST_VERIFIERS.includes(verifier) ||
+    network === TORUS_LEGACY_NETWORK.TESTNET ||
+    network === TORUS_SAPPHIRE_NETWORK.SAPPHIRE_DEVNET
+  ) {
+    return true;
+  }
+  return false;
+};
+
+export const getTrackingId = (verifier: string, verifierId: string, network: TORUS_NETWORK_TYPE) => {
+  if (!isTrackingEnabled(verifier, network)) {
+    return undefined;
+  }
+  // to differentiate between requests
+  const randomId = crypto.randomBytes(16).toString("hex");
+  // user's all request can be tracked by this id
+  const userID = crypto.createHash("sha256").update(`${verifier.toLowerCase()}:${verifierId.toLowerCase()}`).digest("hex").slice(0, 16);
+  // a specific request can be tracked by this id
+  const trackingId = userID.concat(randomId);
+  return trackingId;
+};