feat: default server time offset

Author: guru-web3

src/helpers/common.ts

@@ -8,9 +8,10 @@ import { EciesHex, VerifierLookupResponse } from "../interfaces";
 // like created_at field might vary and nonce_data might not be returned by all nodes because
 // of the metadata implementation in sapphire.
 export const normalizeKeysResult = (result: VerifierLookupResponse) => {
-  const finalResult: Pick<VerifierLookupResponse, "keys" | "is_new_key"> = {
+  const finalResult: Pick<VerifierLookupResponse, "keys" | "is_new_key" | "server_time_offset"> = {
     keys: [],
     is_new_key: result.is_new_key,
+    server_time_offset: result.server_time_offset,
   };
   if (result && result.keys && result.keys.length > 0) {
     const finalKey = result.keys[0];

src/helpers/nodeUtils.ts

@@ -139,7 +139,6 @@ export async function retrieveOrImportShare(params: {
 }): Promise<TorusKey> {
   const {
     legacyMetadataHost,
-    serverTimeOffset,
     enableOneKey,
     ecCurve,
     allowHost,
@@ -317,7 +316,14 @@ export async function retrieveOrImportShare(params: {
       let thresholdNonceData: GetOrSetNonceResult;
       return Some<
         void | JRPCResponse<ShareRequestResult>,
-        | { privateKey: BN; sessionTokenData: SessionToken[]; thresholdNonceData: GetOrSetNonceResult; nodeIndexes: BN[]; isNewKey: boolean }
+        | {
+            privateKey: BN;
+            sessionTokenData: SessionToken[];
+            thresholdNonceData: GetOrSetNonceResult;
+            nodeIndexes: BN[];
+            isNewKey: boolean;
+            serverTimeOffsetResponse?: number;
+          }
         | undefined
       >(promiseArrRequest, async (shareResponses, sharedState) => {
         // check if threshold number of nodes have returned the same user public key
@@ -377,6 +383,7 @@ export async function retrieveOrImportShare(params: {
           const nodeIndexes: BN[] = [];
           const sessionTokenData: SessionToken[] = [];
           const isNewKeyResponses: string[] = [];
+          const serverTimeOffsetResponses: string[] = [];
 
           for (let i = 0; i < completedRequests.length; i += 1) {
             const currentShareResponse = completedRequests[i] as JRPCResponse<ShareRequestResult>;
@@ -387,9 +394,11 @@ export async function retrieveOrImportShare(params: {
               session_token_sig_metadata: sessionTokenSigMetadata,
               keys,
               is_new_key: isNewKey,
+              server_time_offset: serverTimeOffset,
             } = currentShareResponse.result;
 
             isNewKeyResponses.push(isNewKey);
+            serverTimeOffsetResponses.push(serverTimeOffset);
 
             if (sessionTokenSigs?.length > 0) {
               // decrypt sessionSig if enc metadata is sent
@@ -513,13 +522,24 @@ export async function retrieveOrImportShare(params: {
           }
           const thresholdIsNewKey = thresholdSame(isNewKeyResponses, ~~(endpoints.length / 2) + 1);
 
-          return { privateKey, sessionTokenData, thresholdNonceData, nodeIndexes, isNewKey: thresholdIsNewKey === "true" };
+          // Convert each string timestamp to a number
+          const epochTimes = serverTimeOffsetResponses.map((timestamp) => parseInt(timestamp, 10));
+
+          // console.log(epochTimes); // Output: 1709299134
+          return {
+            privateKey,
+            sessionTokenData,
+            thresholdNonceData,
+            nodeIndexes,
+            isNewKey: thresholdIsNewKey === "true",
+            serverTimeOffsetResponse: Math.max(...epochTimes),
+          };
         }
         throw new Error("Invalid");
       });
     })
     .then(async (res) => {
-      const { privateKey, sessionTokenData, thresholdNonceData, nodeIndexes, isNewKey } = res;
+      const { privateKey, sessionTokenData, thresholdNonceData, nodeIndexes, isNewKey, serverTimeOffsetResponse } = res;
       let nonceResult = thresholdNonceData;
       if (!privateKey) throw new Error("Invalid private key returned");
       const oAuthKey = privateKey;
@@ -538,7 +558,8 @@ 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) {
-          nonceResult = await getOrSetNonce(legacyMetadataHost, ecCurve, serverTimeOffset, oAuthPubkeyX, oAuthPubkeyY, oAuthKey, !isNewKey);
+          const serverTimeOffsetValue = this.serverTimeOffset || serverTimeOffsetResponse;
+          nonceResult = await getOrSetNonce(legacyMetadataHost, ecCurve, serverTimeOffsetValue, oAuthPubkeyX, oAuthPubkeyY, oAuthKey, !isNewKey);
           metadataNonce = new BN(nonceResult.nonce || "0", 16);
           typeOfUser = nonceResult.typeOfUser;
           if (typeOfUser === "v2") {

src/interfaces.ts

@@ -39,6 +39,7 @@ export interface TorusCtorOptions {
 
 export interface LegacyVerifierLookupResponse {
   keys: { pub_key_X: string; pub_key_Y: string; address: string }[];
+  server_time_offset?: string;
 }
 
 export interface VerifierLookupResponse {
@@ -51,6 +52,7 @@ export interface VerifierLookupResponse {
   }[];
   is_new_key: boolean;
   node_index: string;
+  server_time_offset?: string;
 }
 
 export interface CommitmentRequestResult {
@@ -73,12 +75,12 @@ export interface JRPCResponse<T> {
 }
 
 export interface LegacyKeyLookupResult {
-  keyResult: Pick<LegacyVerifierLookupResponse, "keys">;
+  keyResult: Pick<LegacyVerifierLookupResponse, "keys" | "server_time_offset">;
   errorResult: JRPCResponse<LegacyVerifierLookupResponse>["error"];
 }
 
 export interface KeyLookupResult {
-  keyResult: Pick<VerifierLookupResponse, "keys" | "is_new_key">;
+  keyResult: Pick<VerifierLookupResponse, "keys" | "is_new_key" | "server_time_offset">;
   nodeIndexes: number[];
   errorResult: JRPCResponse<VerifierLookupResponse>["error"];
   nonceResult?: GetOrSetNonceResult;
@@ -147,6 +149,7 @@ export interface ShareRequestResult {
   node_pubx: string;
   node_puby: string;
   is_new_key: string;
+  server_time_offset?: string;
 }
 
 export interface ImportedShare {

src/torus.ts

@@ -582,12 +582,12 @@ class Torus {
     } else {
       throw new Error(`node results do not match at first lookup ${JSON.stringify(keyResult || {})}, ${JSON.stringify(errorResult || {})}`);
     }
-
     if (finalKeyResult) {
       return this.formatLegacyPublicKeyData({
         finalKeyResult,
         isNewKey,
         enableOneKey,
+        serverTimeOffset: keyResult.server_time_offset,
       });
     }
     throw new Error(`node results do not match at final lookup ${JSON.stringify(keyResult || {})}, ${JSON.stringify(errorResult || {})}`);
@@ -659,6 +659,7 @@ class Torus {
         finalKeyResult: {
           keys: keyResult.keys,
         },
+        serverTimeOffset: keyResult.server_time_offset,
       });
     } else {
       const v2NonceResult = nonceResult as v2NonceResultType;
@@ -711,8 +712,9 @@ class Torus {
     finalKeyResult: LegacyVerifierLookupResponse;
     enableOneKey: boolean;
     isNewKey: boolean;
+    serverTimeOffset: string;
   }): Promise<TorusPublicKey> {
-    const { finalKeyResult, enableOneKey, isNewKey } = params;
+    const { finalKeyResult, enableOneKey, isNewKey, serverTimeOffset } = params;
     const { pub_key_X: X, pub_key_Y: Y } = finalKeyResult.keys[0];
     let nonceResult: GetOrSetNonceResult;
     let nonce: BN;
@@ -722,9 +724,10 @@ class Torus {
 
     const oAuthPubKey = this.ec.keyFromPublic({ x: X, y: Y }).getPublic();
 
+    const serverTimeOffsetValue = this.serverTimeOffset || parseInt(serverTimeOffset);
     if (enableOneKey) {
       try {
-        nonceResult = await getOrSetNonce(this.legacyMetadataHost, this.ec, this.serverTimeOffset, X, Y, undefined, !isNewKey);
+        nonceResult = await getOrSetNonce(this.legacyMetadataHost, this.ec, serverTimeOffsetValue, X, Y, undefined, !isNewKey);
         nonce = new BN(nonceResult.nonce || "0", 16);
         typeOfUser = nonceResult.typeOfUser;
       } catch {