revert padding and fix variable naming

Author: himanshu

src/Point.ts

@@ -19,11 +19,7 @@ class Point {
   encode(enc: string): Buffer {
     switch (enc) {
       case "arr":
-        return Buffer.concat([
-          Buffer.from("04", "hex"),
-          Buffer.from(this.x.toString("hex", 64), "hex"),
-          Buffer.from(this.y.toString("hex", 64), "hex"),
-        ]);
+        return Buffer.concat([Buffer.from("04", "hex"), Buffer.from(this.x.toString("hex"), "hex"), Buffer.from(this.y.toString("hex"), "hex")]);
       case "elliptic-compressed": {
         const key = this.ecCurve.keyFromPublic({ x: this.x.toString("hex", 64), y: this.y.toString("hex", 64) }, "hex");
         return Buffer.from(key.getPublic(true, "hex"));

src/Share.ts

@@ -19,8 +19,8 @@ class Share {
 
   toJSON(): StringifiedType {
     return {
-      share: this.share.toString("hex", 64),
-      shareIndex: this.shareIndex.toString("hex", 64),
+      share: this.share.toString("hex"),
+      shareIndex: this.shareIndex.toString("hex"),
     };
   }
 }

src/helpers/common.ts

@@ -3,7 +3,7 @@ import { BN } from "bn.js";
 import JsonStringify from "json-stable-stringify";
 
 import { EciesHex, VerifierLookupResponse } from "../interfaces";
-import { keccak256 } from ".";
+import { keccak256 } from "./keyUtils";
 
 // this function normalizes the result from nodes before passing the result to threshold check function
 // For ex: some fields returns by nodes might be different from each other

src/helpers/keyUtils.ts

@@ -1,13 +1,15 @@
 import { INodePub } from "@toruslabs/constants";
 import { Ecies, encrypt } from "@toruslabs/eccrypto";
 import BN from "bn.js";
-import { curve, ec as EC } from "elliptic";
+import { curve as curveUtils, ec as EC } from "elliptic";
 import { keccak256 as keccakHash } from "ethereum-cryptography/keccak";
 import stringify from "json-stable-stringify";
 
-import { ImportedShare, KeyType } from "..";
+import { CurveType, ImportedShare } from "../interfaces";
 import log from "../loglevel";
-import { encParamsBufToHex, generateNonceMetadataParams, generateRandomPolynomial } from ".";
+import { encParamsBufToHex } from "./common";
+import { generateRandomPolynomial } from "./langrangeInterpolatePoly";
+import { generateNonceMetadataParams } from "./metadataUtils";
 
 export function keccak256(a: Buffer): string {
   const hash = Buffer.from(keccakHash(a)).toString("hex");
@@ -64,7 +66,7 @@ export function getPostboxKeyFrom1OutOf1(ecCurve: EC, privKey: string, nonce: st
   return privKeyBN.sub(nonceBN).umod(ecCurve.curve.n).toString("hex");
 }
 
-export function derivePubKey(ecCurve: EC, sk: BN): curve.base.BasePoint {
+export function derivePubKey(ecCurve: EC, sk: BN): curveUtils.base.BasePoint {
   const skHex = sk.toString(16, 64);
   return ecCurve.keyFromPrivate(skHex).getPublic();
 }
@@ -73,7 +75,7 @@ export const encryptionEC = new EC("secp256k1");
 
 export const generateShares = async (
   ecCurve: EC,
-  keyType: KeyType,
+  curve: CurveType,
   serverTimeOffset: number,
   nodeIndexes: number[],
   nodePubkeys: INodePub[],
@@ -94,7 +96,7 @@ export const generateShares = async (
   const oAuthPubKey = ecCurve.keyFromPrivate(oAuthKey.toString("hex").padStart(64, "0")).getPublic();
   const poly = generateRandomPolynomial(ecCurve, degree, oAuthKey);
   const shares = poly.generateShares(nodeIndexesBn);
-  const nonceParams = generateNonceMetadataParams(ecCurve, serverTimeOffset, "getOrSetNonce", oAuthKey, keyType, randomNonce);
+  const nonceParams = generateNonceMetadataParams(ecCurve, serverTimeOffset, "getOrSetNonce", oAuthKey, curve, randomNonce);
   const nonceData = Buffer.from(stringify(nonceParams.set_data), "utf8").toString("base64");
   const sharesData: ImportedShare[] = [];
   const encPromises: Promise<Ecies>[] = [];
@@ -119,7 +121,7 @@ export const generateShares = async (
       encrypted_share: encParamsMetadata.ciphertext,
       encrypted_share_metadata: encParamsMetadata,
       node_index: Number.parseInt(shareJson.shareIndex, 16),
-      key_type: keyType,
+      key_type: curve,
       nonce_data: nonceData,
       nonce_signature: nonceParams.signature,
     };

src/helpers/langrangeInterpolatePoly.ts

@@ -4,7 +4,7 @@ import { ec as EC } from "elliptic";
 import Point from "../Point";
 import Polynomial from "../Polynomial";
 import Share from "../Share";
-import { generatePrivateKey } from ".";
+import { generatePrivateKey } from "./keyUtils";
 
 function generatePrivateExcludingIndexes(shareIndexes: BN[], ecCurve: EC): BN {
   const key = new BN(generatePrivateKey(ecCurve, Buffer));

src/helpers/metadataUtils.ts

@@ -5,7 +5,7 @@ import { ec } from "elliptic";
 import stringify from "json-stable-stringify";
 import log from "loglevel";
 
-import { EciesHex, GetOrSetNonceResult, KeyType, MetadataParams, NonceMetadataParams, SetNonceData } from "../interfaces";
+import { CurveType, EciesHex, GetOrSetNonceResult, MetadataParams, NonceMetadataParams, SetNonceData } from "../interfaces";
 import { encParamsHexToBuf } from "./common";
 import { keccak256 } from "./keyUtils";
 
@@ -96,7 +96,7 @@ export function generateNonceMetadataParams(
   serverTimeOffset: number,
   operation: string,
   privateKey: BN,
-  keyType: KeyType,
+  curve: CurveType,
   nonce?: BN
 ): NonceMetadataParams {
   const key = ecCurve.keyFromPrivate(privateKey.toString("hex", 64));
@@ -113,7 +113,7 @@ export function generateNonceMetadataParams(
     pub_key_X: key.getPublic().getX().toString("hex", 64),
     pub_key_Y: key.getPublic().getY().toString("hex", 64),
     set_data: setData,
-    key_type: keyType,
+    key_type: curve,
     signature: Buffer.from(sig.r.toString(16, 64) + sig.s.toString(16, 64) + new BN("").toString(16, 2), "hex").toString("base64"),
   };
 }

src/helpers/nodeUtils.ts

@@ -2,19 +2,19 @@ import { INodePub, LEGACY_NETWORKS_ROUTE_MAP, TORUS_LEGACY_NETWORK_TYPE, TORUS_N
 import { generatePrivate, getPublic } from "@toruslabs/eccrypto";
 import { generateJsonRPCObject, get, post } from "@toruslabs/http-helpers";
 import BN from "bn.js";
-import { curve, ec } from "elliptic";
+import { curve as curveUtils, ec } from "elliptic";
 
 import { config } from "../config";
 import { JRPC_METHODS } from "../constants";
 import {
   CommitmentRequestResult,
+  CurveType,
   GetOrSetNonceResult,
   ImportedShare,
   ImportShareRequestResult,
   JRPCResponse,
   KeyAssignInput,
   KeyLookupResult,
-  KeyType,
   LegacyKeyLookupResult,
   LegacyVerifierLookupResponse,
   SessionToken,
@@ -38,10 +38,10 @@ export const GetPubKeyOrKeyAssign = async (params: {
   network: TORUS_NETWORK_TYPE;
   verifier: string;
   verifierId: string;
-  keyType: KeyType;
+  curve: CurveType;
   extendedVerifierId?: string;
 }): Promise<KeyLookupResult> => {
-  const { endpoints, network, verifier, verifierId, extendedVerifierId, keyType } = params;
+  const { endpoints, network, verifier, verifierId, extendedVerifierId, curve } = params;
   const lookupPromises = endpoints.map((x) =>
     post<JRPCResponse<VerifierLookupResponse>>(
       x,
@@ -51,7 +51,7 @@ export const GetPubKeyOrKeyAssign = async (params: {
         verifier_id: verifierId.toString(),
         extended_verifier_id: extendedVerifierId,
         one_key_flow: true,
-        key_type: keyType,
+        key_type: curve,
         fetch_node_index: true,
       }),
       null,
@@ -130,7 +130,7 @@ export async function retrieveOrImportShare(params: {
   serverTimeOffset: number;
   enableOneKey: boolean;
   ecCurve: ec;
-  keyType: KeyType;
+  curve: CurveType;
   allowHost: string;
   network: string;
   clientId: string;
@@ -150,7 +150,7 @@ export async function retrieveOrImportShare(params: {
     serverTimeOffset,
     enableOneKey,
     ecCurve,
-    keyType,
+    curve,
     allowHost,
     network,
     clientId,
@@ -195,7 +195,7 @@ export async function retrieveOrImportShare(params: {
     finalImportedShares = newImportedShares;
   } else if (!useDkg) {
     const importedKey = new BN(generatePrivateKey(ecCurve, Buffer));
-    const generatedShares = await generateShares(ecCurve, keyType, serverTimeOffset, indexes, nodePubkeys, importedKey.toString(16, 64));
+    const generatedShares = await generateShares(ecCurve, curve, serverTimeOffset, indexes, nodePubkeys, importedKey.toString(16, 64));
     finalImportedShares = [...finalImportedShares, ...generatedShares];
   }
 
@@ -214,7 +214,7 @@ export async function retrieveOrImportShare(params: {
       endpoints[i],
       generateJsonRPCObject(JRPC_METHODS.COMMITMENT_REQUEST, {
         messageprefix: "mug00",
-        keytype: keyType,
+        keytype: curve,
         tokencommitment: tokenCommitment.slice(2),
         temppubx: pubKeyX,
         temppuby: pubKeyY,
@@ -353,7 +353,7 @@ export async function retrieveOrImportShare(params: {
             encrypted: "yes",
             use_temp: true,
             item: items,
-            key_type: keyType,
+            key_type: curve,
             one_key_flow: true,
           }),
           null,
@@ -376,7 +376,7 @@ export async function retrieveOrImportShare(params: {
                 {
                   ...verifierParams,
                   idtoken: idToken,
-                  key_type: keyType,
+                  key_type: curve,
                   nodesignatures: nodeSigs,
                   verifieridentifier: verifier,
                   ...extraParams,
@@ -624,7 +624,7 @@ export async function retrieveOrImportShare(params: {
       const oAuthPubkeyY = oAuthPubKey.getY().toString("hex", 64);
 
       let metadataNonce = new BN(nonceResult?.nonce ? nonceResult.nonce.padStart(64, "0") : "0", "hex");
-      let finalPubKey: curve.base.BasePoint;
+      let finalPubKey: curveUtils.base.BasePoint;
       let pubNonce: { X: string; Y: string } | undefined;
       let typeOfUser: UserType = "v1";
       // extended_verifier_id is only exception for torus-test-health verifier
@@ -730,15 +730,15 @@ export const legacyKeyLookup = async (
   endpoints: string[],
   verifier: string,
   verifierId: string,
-  keyType: KeyType
+  curve: CurveType
 ): Promise<LegacyKeyLookupResult> => {
   const lookupPromises = endpoints.map((x) =>
     post<JRPCResponse<LegacyVerifierLookupResponse>>(
       x,
       generateJsonRPCObject("VerifierLookupRequest", {
         verifier,
         verifier_id: verifierId.toString(),
-        key_type: keyType,
+        key_type: curve,
       })
     ).catch((err) => log.error("lookup request failed", err))
   );
@@ -769,7 +769,7 @@ export const legacyKeyAssign = async ({
   signerHost,
   network,
   clientId,
-  keyType,
+  curve,
 }: KeyAssignInput): Promise<void> => {
   let nodeNum: number;
   let initialPoint: number | undefined;
@@ -844,7 +844,7 @@ export const legacyKeyAssign = async ({
         signerHost,
         network,
         clientId,
-        keyType,
+        curve,
       });
     throw new Error(
       `Sorry, the Torus Network that powers Web3Auth is currently very busy.
@@ -858,11 +858,11 @@ export const legacyWaitKeyLookup = (
   endpoints: string[],
   verifier: string,
   verifierId: string,
-  keyType: KeyType,
+  curve: CurveType,
   timeout: number
 ): Promise<LegacyKeyLookupResult> =>
   new Promise((resolve, reject) => {
     setTimeout(() => {
-      legacyKeyLookup(endpoints, verifier, verifierId, keyType).then(resolve).catch(reject);
+      legacyKeyLookup(endpoints, verifier, verifierId, curve).then(resolve).catch(reject);
     }, timeout);
   });

src/interfaces.ts

@@ -13,7 +13,7 @@ export type v2NonceResultType = { typeOfUser: "v2"; nonce?: string; pubNonce: {
 
 export type v1NonceResultType = { typeOfUser: "v1"; nonce?: string };
 export type GetOrSetNonceResult = v2NonceResultType | v1NonceResultType;
-export type KeyType = "secp256k1";
+export type CurveType = "secp256k1";
 
 export interface SetNonceData {
   operation: string;
@@ -27,13 +27,13 @@ export interface NonceMetadataParams {
   pub_key_Y: string;
   set_data: Partial<SetNonceData>;
   signature: string;
-  key_type?: KeyType;
+  key_type?: CurveType;
 }
 
 export interface TorusCtorOptions {
   clientId: string;
   network: TORUS_NETWORK_TYPE;
-  keyType?: KeyType;
+  curve?: CurveType;
   enableOneKey?: boolean;
   serverTimeOffset?: number;
   allowHost?: string;
@@ -103,7 +103,7 @@ export interface KeyAssignInput {
   signerHost: string;
   network: string;
   clientId: string;
-  keyType: KeyType;
+  curve: CurveType;
 }
 
 export type EciesHex = {
@@ -227,7 +227,7 @@ export interface MetadataParams {
   namespace?: string;
   pub_key_X: string;
   pub_key_Y: string;
-  key_type?: KeyType;
+  key_type?: CurveType;
   set_data: {
     data: "getNonce" | "getOrSetNonce" | string;
     timestamp: string;