feat: test cases

Author: guru-web3

src/helpers/nodeUtils.ts

@@ -151,6 +151,7 @@ export async function retrieveOrImportShare(params: {
     idToken,
     importedShares,
     extraParams,
+    serverTimeOffset,
   } = params;
   await get<void>(
     allowHost,
@@ -397,11 +398,11 @@ export async function retrieveOrImportShare(params: {
               session_token_sig_metadata: sessionTokenSigMetadata,
               keys,
               is_new_key: isNewKey,
-              server_time_offset: serverTimeOffset,
+              server_time_offset: serverTimeOffsetResponse,
             } = currentShareResponse.result;
 
             isNewKeyResponses.push(isNewKey);
-            serverTimeOffsetResponses.push(serverTimeOffset);
+            serverTimeOffsetResponses.push(serverTimeOffsetResponse);
 
             if (sessionTokenSigs?.length > 0) {
               // decrypt sessionSig if enc metadata is sent
@@ -526,15 +527,14 @@ export async function retrieveOrImportShare(params: {
           const thresholdIsNewKey = thresholdSame(isNewKeyResponses, ~~(endpoints.length / 2) + 1);
 
           // Convert each string timestamp to a number
-          const serverOffsetTime = serverTimeOffsetResponses.map((timestamp) => parseInt(timestamp, 10));
-
+          const serverOffsetTimes = serverTimeOffsetResponses.map((timestamp) => parseInt(timestamp, 10));
           return {
             privateKey,
             sessionTokenData,
             thresholdNonceData,
             nodeIndexes,
             isNewKey: thresholdIsNewKey === "true",
-            serverTimeOffsetResponse: Math.max(...serverOffsetTime),
+            serverTimeOffsetResponse: serverTimeOffset || Math.max(...serverOffsetTimes),
           };
         }
         throw new Error("Invalid");
@@ -560,8 +560,7 @@ export async function retrieveOrImportShare(params: {
         finalPubKey = ecCurve.keyFromPublic({ x: oAuthPubkeyX, y: oAuthPubkeyY }).getPublic();
       } else if (LEGACY_NETWORKS_ROUTE_MAP[network as TORUS_LEGACY_NETWORK_TYPE]) {
         if (enableOneKey) {
-          const serverTimeOffsetValue = this.serverTimeOffset || serverTimeOffsetResponse;
-          nonceResult = await getOrSetNonce(legacyMetadataHost, ecCurve, serverTimeOffsetValue, oAuthPubkeyX, oAuthPubkeyY, oAuthKey, !isNewKey);
+          nonceResult = await getOrSetNonce(legacyMetadataHost, ecCurve, serverTimeOffsetResponse, oAuthPubkeyX, oAuthPubkeyY, oAuthKey, !isNewKey);
           metadataNonce = new BN(nonceResult.nonce || "0", 16);
           typeOfUser = nonceResult.typeOfUser;
           if (typeOfUser === "v2") {

src/torus.ts

@@ -587,7 +587,7 @@ class Torus {
         finalKeyResult,
         isNewKey,
         enableOneKey,
-        serverTimeOffset: keyResult.server_time_offset,
+        serverTimeOffset: keyResult?.server_time_offset,
       });
     }
     throw new Error(`node results do not match at final lookup ${JSON.stringify(keyResult || {})}, ${JSON.stringify(errorResult || {})}`);

test/sapphire_devnet.test.ts

@@ -1,6 +1,7 @@
 import { TORUS_LEGACY_NETWORK, TORUS_SAPPHIRE_NETWORK } from "@toruslabs/constants";
 import { generatePrivate } from "@toruslabs/eccrypto";
 import NodeManager from "@toruslabs/fetch-node-details";
+import { fail } from "assert";
 import BN from "bn.js";
 import { expect } from "chai";
 import faker from "faker";
@@ -374,6 +375,55 @@ describe("torus utils sapphire devnet", function () {
     });
   });
 
+  it("should fail at get or set nonce when server time offset is expired", async function () {
+    const email = "[email protected]";
+    const verifier = "google-lrc";
+    const token = generateIdToken(email, "ES256");
+
+    const LEGACY_TORUS_NODE_MANAGER = new NodeManager({
+      network: TORUS_LEGACY_NETWORK.TESTNET,
+    });
+
+    const verifierDetails = { verifier, verifierId: email };
+    const legacyTorus = new TorusUtils({
+      network: TORUS_LEGACY_NETWORK.TESTNET,
+      clientId: "YOUR_CLIENT_ID",
+      enableOneKey: true,
+      serverTimeOffset: -100,
+    });
+    const { torusNodeSSSEndpoints: torusNodeEndpoints, torusIndexes } = await LEGACY_TORUS_NODE_MANAGER.getNodeDetails(verifierDetails);
+    try {
+      await legacyTorus.retrieveShares(torusNodeEndpoints, torusIndexes, TORUS_TEST_VERIFIER, { verifier_id: email }, token);
+      fail("should not reach here");
+    } catch (err) {
+      expect(err.status).to.equal(403);
+    }
+  });
+
+  it("should pass at get or set nonce when server time offset is not passed with default time offset", async function () {
+    const email = "[email protected]";
+    const verifier = "google-lrc";
+    const token = generateIdToken(email, "ES256");
+
+    const LEGACY_TORUS_NODE_MANAGER = new NodeManager({
+      network: TORUS_LEGACY_NETWORK.TESTNET,
+    });
+
+    const verifierDetails = { verifier, verifierId: email };
+    const legacyTorus = new TorusUtils({
+      network: TORUS_LEGACY_NETWORK.TESTNET,
+      clientId: "YOUR_CLIENT_ID",
+      enableOneKey: true,
+    });
+    const { torusNodeSSSEndpoints: torusNodeEndpoints, torusIndexes } = await LEGACY_TORUS_NODE_MANAGER.getNodeDetails(verifierDetails);
+    try {
+      const response = await legacyTorus.retrieveShares(torusNodeEndpoints, torusIndexes, TORUS_TEST_VERIFIER, { verifier_id: email }, token);
+      expect(response.metadata.typeOfUser).to.equal("v2");
+    } catch (err) {
+      fail("should not reach here");
+    }
+  });
+
   it("should be able to update the `sessionTime` of the token signature data", async function () {
     const token = generateIdToken(TORUS_TEST_EMAIL, "ES256");