more comments resolved

Author: chaitanyapotti

src/Polynomial.ts

@@ -1,7 +1,6 @@
 import { mod } from "@noble/curves/abstract/modular.js";
 
-import { bigintToHex, Curve, toBigIntBE } from "./helpers/common";
-import { BigIntString } from "./interfaces";
+import { bigintToHex, Curve } from "./helpers/common";
 import Share from "./Share";
 
 export type ShareMap = {
@@ -22,36 +21,23 @@ class Polynomial {
     return this.polynomial.length;
   }
 
-  polyEval(x: BigIntString): bigint {
+  polyEval(x: bigint): bigint {
     const n = this.ecCurve.Point.CURVE().n;
-    const tmpX = toBigIntBE(x);
-    let xi = tmpX;
+    let xi = x;
     let sum = this.polynomial[0];
     for (let i = 1; i < this.polynomial.length; i += 1) {
       const tmp = xi * this.polynomial[i];
       sum = mod(sum + tmp, n);
-      xi = mod(xi * tmpX, n);
+      xi = mod(xi * x, n);
     }
     return sum;
   }
 
-  generateShares(shareIndexes: BigIntString[]): ShareMap {
-    const newShareIndexes = shareIndexes.map((index) => {
-      if (typeof index === "number") {
-        return BigInt(index);
-      }
-      if (typeof index === "bigint") {
-        return index;
-      }
-      if (typeof index === "string") {
-        return toBigIntBE(index);
-      }
-      return index;
-    });
-
+  generateShares(shareIndexes: bigint[]): ShareMap {
     const shares: ShareMap = {};
-    for (let x = 0; x < newShareIndexes.length; x += 1) {
-      shares[bigintToHex(newShareIndexes[x])] = new Share(newShareIndexes[x], this.polyEval(newShareIndexes[x]));
+    for (let x = 0; x < shareIndexes.length; x += 1) {
+      const idx = shareIndexes[x];
+      shares[bigintToHex(idx)] = new Share(idx, this.polyEval(idx));
     }
     return shares;
   }

src/Share.ts

@@ -1,19 +1,19 @@
 import { bigintToHex, toBigIntBE } from "./helpers/common";
-import { BigIntString, ShareJSON, StringifiedType } from "./interfaces";
+import { ShareJSON, StringifiedType } from "./interfaces";
 
 class Share {
   share: bigint;
 
   shareIndex: bigint;
 
-  constructor(shareIndex: BigIntString, share: BigIntString) {
-    this.share = toBigIntBE(share);
-    this.shareIndex = toBigIntBE(shareIndex);
+  constructor(shareIndex: bigint, share: bigint) {
+    this.share = share;
+    this.shareIndex = shareIndex;
   }
 
   static fromJSON(value: StringifiedType): Share {
     const { share, shareIndex } = value as ShareJSON;
-    return new Share(shareIndex, share);
+    return new Share(toBigIntBE(shareIndex), toBigIntBE(share));
   }
 
   toJSON(): ShareJSON {

src/helpers/common.ts

@@ -69,14 +69,13 @@ export function keccak256Bytes(a: Uint8Array): Uint8Array {
   return keccakHash(a);
 }
 
-export const generatePrivateKey = (keyType: KeyType): Uint8Array => {
-  if (keyType === KEY_TYPE.SECP256K1) {
-    return secp256k1.utils.randomSecretKey();
-  } else if (keyType === KEY_TYPE.ED25519) {
-    return ed25519.utils.randomSecretKey();
-  }
-  throw new Error(`Invalid keyType: ${keyType}`);
-};
+/** Generate a random private key. Prefer passing ecCurve when you already have it (better for tree-shaking). */
+export function generatePrivateKey(keyType: KeyType): Uint8Array;
+export function generatePrivateKey(ecCurve: Curve): Uint8Array;
+export function generatePrivateKey(ecCurveOrKeyType: Curve | KeyType): Uint8Array {
+  const ec = typeof ecCurveOrKeyType === "string" ? getKeyCurve(ecCurveOrKeyType) : ecCurveOrKeyType;
+  return ec.utils.randomSecretKey();
+}
 
 export const getSecp256k1 = () => secp256k1;
 export const getEd25519 = () => ed25519;
@@ -170,6 +169,7 @@ export const thresholdSame = <T>(arr: T[], t: number): T | undefined => {
   return undefined;
 };
 
+/** ECIES params: bytes → hex. \@toruslabs/eccrypto v7 does not export these; we keep them local. */
 export function encParamsBufToHex(encParams: Ecies): EciesHex {
   return {
     iv: bytesToHex(encParams.iv),
@@ -180,6 +180,7 @@ export function encParamsBufToHex(encParams: Ecies): EciesHex {
   };
 }
 
+/** ECIES params: hex → bytes. \@toruslabs/eccrypto v7 does not export these; we keep them local. */
 export function encParamsHexToBuf(eciesData: Omit<EciesHex, "ciphertext">): Omit<Ecies, "ciphertext"> {
   return {
     ephemPublicKey: hexToBytes(eciesData.ephemPublicKey),