@noble/curves 1.6.0 → 1.7.0

package/src/abstract/modular.ts

@@ -10,11 +10,11 @@ import {
   validateObject,
 } from './utils.js';
 // prettier-ignore
-const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);
+const _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);
 // prettier-ignore
-const _4n = BigInt(4), _5n = BigInt(5), _8n = BigInt(8);
+const _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _8n = /* @__PURE__ */ BigInt(8);
 // prettier-ignore
-const _9n = BigInt(9), _16n = BigInt(16);
+const _9n =/* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);
 
 // Calculates a modulo b
 export function mod(a: bigint, b: bigint): bigint {
@@ -29,7 +29,8 @@ export function mod(a: bigint, b: bigint): bigint {
  */
 // TODO: use field version && remove
 export function pow(num: bigint, power: bigint, modulo: bigint): bigint {
-  if (modulo <= _0n || power < _0n) throw new Error('Expected power/modulo > 0');
+  if (power < _0n) throw new Error('invalid exponent, negatives unsupported');
+  if (modulo <= _0n) throw new Error('invalid modulus');
   if (modulo === _1n) return _0n;
   let res = _1n;
   while (power > _0n) {
@@ -52,9 +53,8 @@ export function pow2(x: bigint, power: bigint, modulo: bigint): bigint {
 
 // Inverses number over modulo
 export function invert(number: bigint, modulo: bigint): bigint {
-  if (number === _0n || modulo <= _0n) {
-    throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
-  }
+  if (number === _0n) throw new Error('invert: expected non-zero number');
+  if (modulo <= _0n) throw new Error('invert: expected positive modulus, got ' + modulo);
   // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/
   // Fermat's little theorem "CT-like" version inv(n) = n^(m-2) mod m is 30x slower.
   let a = mod(number, modulo);
@@ -97,7 +97,10 @@ export function tonelliShanks(P: bigint) {
   for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++);
 
   // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq
-  for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++);
+  for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++) {
+    // Crash instead of infinity loop, we cannot reasonable count until P.
+    if (Z > 1000) throw new Error('Cannot find square root: likely non-prime P');
+  }
 
   // Fast-path
   if (S === 1) {
@@ -273,7 +276,7 @@ export function validateField<T>(field: IField<T>) {
 export function FpPow<T>(f: IField<T>, num: T, power: bigint): T {
   // Should have same speed as pow for bigints
   // TODO: benchmark!
-  if (power < _0n) throw new Error('Expected power > 0');
+  if (power < _0n) throw new Error('invalid exponent, negatives unsupported');
   if (power === _0n) return f.ONE;
   if (power === _1n) return num;
   let p = f.ONE;
@@ -360,10 +363,10 @@ export function Field(
   isLE = false,
   redef: Partial<IField<bigint>> = {}
 ): Readonly<FpField> {
-  if (ORDER <= _0n) throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
+  if (ORDER <= _0n) throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);
   const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);
-  if (BYTES > 2048) throw new Error('Field lengths over 2048 bytes are not supported');
-  const sqrtP = FpSqrt(ORDER);
+  if (BYTES > 2048) throw new Error('invalid field: expected ORDER of <= 2048 bytes');
+  let sqrtP: ReturnType<typeof FpSqrt>; // cached sqrtP
   const f: Readonly<FpField> = Object.freeze({
     ORDER,
     BITS,
@@ -374,7 +377,7 @@ export function Field(
     create: (num) => mod(num, ORDER),
     isValid: (num) => {
       if (typeof num !== 'bigint')
-        throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
+        throw new Error('invalid field element: expected bigint, got ' + typeof num);
       return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible
     },
     is0: (num) => num === _0n,
@@ -396,7 +399,12 @@ export function Field(
     mulN: (lhs, rhs) => lhs * rhs,
 
     inv: (num) => invert(num, ORDER),
-    sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
+    sqrt:
+      redef.sqrt ||
+      ((n) => {
+        if (!sqrtP) sqrtP = FpSqrt(ORDER);
+        return sqrtP(f, n);
+      }),
     invertBatch: (lst) => FpInvertBatch(f, lst),
     // TODO: do we really need constant cmov?
     // We don't have const-time bigints anyway, so probably will be not very useful
@@ -404,7 +412,7 @@ export function Field(
     toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),
     fromBytes: (bytes) => {
       if (bytes.length !== BYTES)
-        throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);
+        throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);
       return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
     },
   } as FpField);
@@ -412,13 +420,13 @@ export function Field(
 }
 
 export function FpSqrtOdd<T>(Fp: IField<T>, elm: T) {
-  if (!Fp.isOdd) throw new Error(`Field doesn't have isOdd`);
+  if (!Fp.isOdd) throw new Error("Field doesn't have isOdd");
   const root = Fp.sqrt(elm);
   return Fp.isOdd(root) ? root : Fp.neg(root);
 }
 
 export function FpSqrtEven<T>(Fp: IField<T>, elm: T) {
-  if (!Fp.isOdd) throw new Error(`Field doesn't have isOdd`);
+  if (!Fp.isOdd) throw new Error("Field doesn't have isOdd");
   const root = Fp.sqrt(elm);
   return Fp.isOdd(root) ? Fp.neg(root) : root;
 }
@@ -438,7 +446,9 @@ export function hashToPrivateScalar(
   const hashLen = hash.length;
   const minLen = nLength(groupOrder).nByteLength + 8;
   if (minLen < 24 || hashLen < minLen || hashLen > 1024)
-    throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
+    throw new Error(
+      'hashToPrivateScalar: expected ' + minLen + '-1024 bytes of input, got ' + hashLen
+    );
   const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);
   return mod(num, groupOrder - _1n) + _1n;
 }
@@ -486,7 +496,7 @@ export function mapHashToField(key: Uint8Array, fieldOrder: bigint, isLE = false
   const minLen = getMinHashLength(fieldOrder);
   // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.
   if (len < 16 || len < minLen || len > 1024)
-    throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
+    throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);
   const num = isLE ? bytesToNumberBE(key) : bytesToNumberLE(key);
   // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0
   const reduced = mod(num, fieldOrder - _1n) + _1n;

package/src/abstract/montgomery.ts

@@ -158,8 +158,10 @@ export function montgomery(curveDef: CurveType): CurveFn {
   function decodeScalar(n: Hex): bigint {
     const bytes = ensureBytes('scalar', n);
     const len = bytes.length;
-    if (len !== montgomeryBytes && len !== fieldLen)
-      throw new Error(`Expected ${montgomeryBytes} or ${fieldLen} bytes, got ${len}`);
+    if (len !== montgomeryBytes && len !== fieldLen) {
+      let valid = '' + montgomeryBytes + ' or ' + fieldLen;
+      throw new Error('invalid scalar, expected ' + valid + ' bytes, got ' + len);
+    }
     return bytesToNumberLE(adjustScalarBytes(bytes));
   }
   function scalarMult(scalar: Hex, u: Hex): Uint8Array {
@@ -168,7 +170,7 @@ export function montgomery(curveDef: CurveType): CurveFn {
     const pu = montgomeryLadder(pointU, _scalar);
     // The result was not contributory
     // https://cr.yp.to/ecdh.html#validate
-    if (pu === _0n) throw new Error('Invalid private or public key received');
+    if (pu === _0n) throw new Error('invalid private or public key received');
     return encodeUCoordinate(pu);
   }
   // Computes public key from private. By doing scalar multiplication of base point.

package/src/abstract/poseidon.ts

@@ -21,40 +21,37 @@ export function validateOpts(opts: PoseidonOpts) {
   validateField(Fp);
   for (const i of ['t', 'roundsFull', 'roundsPartial'] as const) {
     if (typeof opts[i] !== 'number' || !Number.isSafeInteger(opts[i]))
-      throw new Error(`Poseidon: invalid param ${i}=${opts[i]} (${typeof opts[i]})`);
+      throw new Error('invalid number ' + i);
   }
 
   // MDS is TxT matrix
-  if (!Array.isArray(mds) || mds.length !== t) throw new Error('Poseidon: wrong MDS matrix');
+  if (!Array.isArray(mds) || mds.length !== t) throw new Error('Poseidon: invalid MDS matrix');
   const _mds = mds.map((mdsRow) => {
     if (!Array.isArray(mdsRow) || mdsRow.length !== t)
-      throw new Error(`Poseidon MDS matrix row: ${mdsRow}`);
+      throw new Error('invalid MDS matrix row: ' + mdsRow);
     return mdsRow.map((i) => {
-      if (typeof i !== 'bigint') throw new Error(`Poseidon MDS matrix value=${i}`);
+      if (typeof i !== 'bigint') throw new Error('invalid MDS matrix bigint: ' + i);
       return Fp.create(i);
     });
   });
 
   if (rev !== undefined && typeof rev !== 'boolean')
-    throw new Error(`Poseidon: invalid param reversePartialPowIdx=${rev}`);
+    throw new Error('invalid param reversePartialPowIdx=' + rev);
 
-  if (roundsFull % 2 !== 0) throw new Error(`Poseidon roundsFull is not even: ${roundsFull}`);
+  if (roundsFull & 1) throw new Error('roundsFull is not even' + roundsFull);
   const rounds = roundsFull + roundsPartial;
 
   if (!Array.isArray(rc) || rc.length !== rounds)
-    throw new Error('Poseidon: wrong round constants');
+    throw new Error('Poseidon: invalid round constants');
   const roundConstants = rc.map((rc) => {
-    if (!Array.isArray(rc) || rc.length !== t)
-      throw new Error(`Poseidon wrong round constants: ${rc}`);
+    if (!Array.isArray(rc) || rc.length !== t) throw new Error('invalid round constants');
     return rc.map((i) => {
-      if (typeof i !== 'bigint' || !Fp.isValid(i))
-        throw new Error(`Poseidon wrong round constant=${i}`);
+      if (typeof i !== 'bigint' || !Fp.isValid(i)) throw new Error('invalid round constant');
       return Fp.create(i);
     });
   });
 
-  if (!sboxPower || ![3, 5, 7].includes(sboxPower))
-    throw new Error(`Poseidon wrong sboxPower=${sboxPower}`);
+  if (!sboxPower || ![3, 5, 7].includes(sboxPower)) throw new Error('invalid sboxPower');
   const _sboxPower = BigInt(sboxPower);
   let sboxFn = (n: bigint) => FpPow(Fp, n, _sboxPower);
   // Unwrapped sbox power for common cases (195->142μs)
@@ -65,8 +62,8 @@ export function validateOpts(opts: PoseidonOpts) {
 }
 
 export function splitConstants(rc: bigint[], t: number) {
-  if (typeof t !== 'number') throw new Error('poseidonSplitConstants: wrong t');
-  if (!Array.isArray(rc) || rc.length % t) throw new Error('poseidonSplitConstants: wrong rc');
+  if (typeof t !== 'number') throw new Error('poseidonSplitConstants: invalid t');
+  if (!Array.isArray(rc) || rc.length % t) throw new Error('poseidonSplitConstants: invalid rc');
   const res = [];
   let tmp = [];
   for (let i = 0; i < rc.length; i++) {
@@ -81,7 +78,7 @@ export function splitConstants(rc: bigint[], t: number) {
 
 export function poseidon(opts: PoseidonOpts) {
   const _opts = validateOpts(opts);
-  const { Fp, mds, roundConstants, rounds, roundsPartial, sboxFn, t } = _opts;
+  const { Fp, mds, roundConstants, rounds: totalRounds, roundsPartial, sboxFn, t } = _opts;
   const halfRoundsFull = _opts.roundsFull / 2;
   const partialIdx = _opts.reversePartialPowIdx ? t - 1 : 0;
   const poseidonRound = (values: bigint[], isFull: boolean, idx: number) => {
@@ -95,21 +92,20 @@ export function poseidon(opts: PoseidonOpts) {
   };
   const poseidonHash = function poseidonHash(values: bigint[]) {
     if (!Array.isArray(values) || values.length !== t)
-      throw new Error(`Poseidon: wrong values (expected array of bigints with length ${t})`);
+      throw new Error('invalid values, expected array of bigints with length ' + t);
     values = values.map((i) => {
-      if (typeof i !== 'bigint') throw new Error(`Poseidon: wrong value=${i} (${typeof i})`);
+      if (typeof i !== 'bigint') throw new Error('invalid bigint=' + i);
       return Fp.create(i);
     });
-    let round = 0;
+    let lastRound = 0;
     // Apply r_f/2 full rounds.
-    for (let i = 0; i < halfRoundsFull; i++) values = poseidonRound(values, true, round++);
+    for (let i = 0; i < halfRoundsFull; i++) values = poseidonRound(values, true, lastRound++);
     // Apply r_p partial rounds.
-    for (let i = 0; i < roundsPartial; i++) values = poseidonRound(values, false, round++);
+    for (let i = 0; i < roundsPartial; i++) values = poseidonRound(values, false, lastRound++);
     // Apply r_f/2 full rounds.
-    for (let i = 0; i < halfRoundsFull; i++) values = poseidonRound(values, true, round++);
+    for (let i = 0; i < halfRoundsFull; i++) values = poseidonRound(values, true, lastRound++);
 
-    if (round !== rounds)
-      throw new Error(`Poseidon: wrong number of rounds: last round=${round}, total=${rounds}`);
+    if (lastRound !== totalRounds) throw new Error('invalid number of rounds');
     return values;
   };
   // For verification in tests

package/src/abstract/tower.ts

@@ -47,6 +47,7 @@ export type Fp12Bls = mod.IField<Fp12> & {
   mul034(num: Fp12, o0: Fp2, o3: Fp2, o4: Fp2): Fp12;
   conjugate(num: Fp12): Fp12;
   finalExponentiate(num: Fp12): Fp12;
+  fromBigTwelve(num: BigintTwelve): Fp12;
 };
 
 function calcFrobeniusCoefficients<T>(
@@ -163,7 +164,7 @@ export function tower12(opts: Tower12Opts) {
     frobeniusMap(num: Fp2, power: number): Fp2;
   };
   const Fp2fromBigTuple = (tuple: BigintTuple | bigint[]) => {
-    if (tuple.length !== 2) throw new Error('Invalid tuple');
+    if (tuple.length !== 2) throw new Error('invalid tuple');
     const fps = tuple.map((n) => Fp.create(n)) as [Fp, Fp];
     return { c0: fps[0], c1: fps[1] };
   };
@@ -250,7 +251,7 @@ export function tower12(opts: Tower12Opts) {
     },
     // Bytes util
     fromBytes(b: Uint8Array): Fp2 {
-      if (b.length !== Fp2.BYTES) throw new Error(`fromBytes wrong length=${b.length}`);
+      if (b.length !== Fp2.BYTES) throw new Error('fromBytes invalid length=' + b.length);
       return { c0: Fp.fromBytes(b.subarray(0, Fp.BYTES)), c1: Fp.fromBytes(b.subarray(Fp.BYTES)) };
     },
     toBytes: ({ c0, c1 }) => concatBytes(Fp.toBytes(c0), Fp.toBytes(c1)),
@@ -378,7 +379,7 @@ export function tower12(opts: Tower12Opts) {
     },
     // Bytes utils
     fromBytes: (b: Uint8Array): Fp6 => {
-      if (b.length !== Fp6.BYTES) throw new Error(`fromBytes wrong length=${b.length}`);
+      if (b.length !== Fp6.BYTES) throw new Error('fromBytes invalid length=' + b.length);
       return {
         c0: Fp2.fromBytes(b.subarray(0, Fp2.BYTES)),
         c1: Fp2.fromBytes(b.subarray(Fp2.BYTES, 2 * Fp2.BYTES)),
@@ -393,7 +394,7 @@ export function tower12(opts: Tower12Opts) {
       c2: Fp2.cmov(c2, r2, c),
     }),
     fromBigSix: (t: BigintSix): Fp6 => {
-      if (!Array.isArray(t) || t.length !== 6) throw new Error('Invalid Fp6 usage');
+      if (!Array.isArray(t) || t.length !== 6) throw new Error('invalid Fp6 usage');
       return {
         c0: Fp2.fromBigTuple(t.slice(0, 2)),
         c1: Fp2.fromBigTuple(t.slice(2, 4)),
@@ -526,7 +527,7 @@ export function tower12(opts: Tower12Opts) {
 
     // Bytes utils
     fromBytes: (b: Uint8Array): Fp12 => {
-      if (b.length !== Fp12.BYTES) throw new Error(`fromBytes wrong length=${b.length}`);
+      if (b.length !== Fp12.BYTES) throw new Error('fromBytes invalid length=' + b.length);
       return {
         c0: Fp6.fromBytes(b.subarray(0, Fp6.BYTES)),
         c1: Fp6.fromBytes(b.subarray(Fp6.BYTES)),
@@ -539,7 +540,7 @@ export function tower12(opts: Tower12Opts) {
     }),
     // Utils
     // toString() {
-    //   return `Fp12(${this.c0} + ${this.c1} * w)`;
+    //   return '' + 'Fp12(' + this.c0 + this.c1 + '* w');
     // },
     // fromTuple(c: [Fp6, Fp6]) {
     //   return new Fp12(...c);

package/src/abstract/utils.ts

@@ -17,10 +17,7 @@ export type CHash = {
 export type FHash = (message: Uint8Array | string) => Uint8Array;
 
 export function isBytes(a: unknown): a is Uint8Array {
-  return (
-    a instanceof Uint8Array ||
-    (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array')
-  );
+  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
 }
 
 export function abytes(item: unknown): void {
@@ -28,8 +25,7 @@ export function abytes(item: unknown): void {
 }
 
 export function abool(title: string, value: boolean): void {
-  if (typeof value !== 'boolean')
-    throw new Error(`${title} must be valid boolean, got "${value}".`);
+  if (typeof value !== 'boolean') throw new Error(title + ' boolean expected, got ' + value);
 }
 
 // Array where index 0xf0 (240) is mapped to string 'f0'
@@ -51,21 +47,20 @@ export function bytesToHex(bytes: Uint8Array): string {
 
 export function numberToHexUnpadded(num: number | bigint): string {
   const hex = num.toString(16);
-  return hex.length & 1 ? `0${hex}` : hex;
+  return hex.length & 1 ? '0' + hex : hex;
 }
 
 export function hexToNumber(hex: string): bigint {
   if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
-  // Big Endian
-  return BigInt(hex === '' ? '0' : `0x${hex}`);
+  return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian
 }
 
 // We use optimized technique to convert hex string to byte array
-const asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 } as const;
-function asciiToBase16(char: number): number | undefined {
-  if (char >= asciis._0 && char <= asciis._9) return char - asciis._0;
-  if (char >= asciis._A && char <= asciis._F) return char - (asciis._A - 10);
-  if (char >= asciis._a && char <= asciis._f) return char - (asciis._a - 10);
+const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;
+function asciiToBase16(ch: number): number | undefined {
+  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48
+  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)
+  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)
   return;
 }
 
@@ -76,7 +71,7 @@ export function hexToBytes(hex: string): Uint8Array {
   if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);
   const hl = hex.length;
   const al = hl / 2;
-  if (hl % 2) throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);
   const array = new Uint8Array(al);
   for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
     const n1 = asciiToBase16(hex.charCodeAt(hi));
@@ -85,7 +80,7 @@ export function hexToBytes(hex: string): Uint8Array {
       const char = hex[hi] + hex[hi + 1];
       throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
     }
-    array[ai] = n1 * 16 + n2;
+    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
   }
   return array;
 }
@@ -125,18 +120,18 @@ export function ensureBytes(title: string, hex: Hex, expectedLength?: number): U
     try {
       res = hexToBytes(hex);
     } catch (e) {
-      throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+      throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);
     }
   } else if (isBytes(hex)) {
     // Uint8Array.from() instead of hash.slice() because node.js Buffer
     // is instance of Uint8Array, and its slice() creates **mutable** copy
     res = Uint8Array.from(hex);
   } else {
-    throw new Error(`${title} must be hex string or Uint8Array`);
+    throw new Error(title + ' must be hex string or Uint8Array');
   }
   const len = res.length;
   if (typeof expectedLength === 'number' && len !== expectedLength)
-    throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+    throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);
   return res;
 }
 
@@ -175,7 +170,7 @@ declare const TextEncoder: any;
  * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
  */
 export function utf8ToBytes(str: string): Uint8Array {
-  if (typeof str !== 'string') throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  if (typeof str !== 'string') throw new Error('string expected');
   return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
 }
 
@@ -198,7 +193,7 @@ export function aInRange(title: string, n: bigint, min: bigint, max: bigint) {
   // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`
   // - our way is the cleanest:               `inRange('x', x, 0n, P)
   if (!inRange(n, min, max))
-    throw new Error(`expected valid ${title}: ${min} <= n < ${max}, got ${typeof n} ${n}`);
+    throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);
 }
 
 // Bit operations
@@ -321,14 +316,13 @@ export function validateObject<T extends Record<string, any>>(
 ) {
   const checkField = (fieldName: keyof T, type: Validator, isOptional: boolean) => {
     const checkVal = validatorFns[type];
-    if (typeof checkVal !== 'function')
-      throw new Error(`Invalid validator "${type}", expected function`);
+    if (typeof checkVal !== 'function') throw new Error('invalid validator function');
 
     const val = object[fieldName as keyof typeof object];
     if (isOptional && val === undefined) return;
     if (!checkVal(val, object)) {
       throw new Error(
-        `Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`
+        'param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val
       );
     }
   };