@noble/curves 1.7.0 → 1.8.1

package/src/abstract/modular.ts

@@ -1,5 +1,10 @@
+/**
+ * Utils for modular division and finite fields.
+ * A finite field over 11 is integer number operations `mod 11`.
+ * There is no division: it is replaced by modular multiplicative inverse.
+ * @module
+ */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-// Utilities for modular arithmetics and finite fields
 import {
   bitMask,
   bytesToNumberBE,
@@ -9,6 +14,7 @@ import {
   numberToBytesLE,
   validateObject,
 } from './utils.js';
+
 // prettier-ignore
 const _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);
 // prettier-ignore
@@ -24,10 +30,10 @@ export function mod(a: bigint, b: bigint): bigint {
 /**
  * Efficiently raise num to power and do modular division.
  * Unsafe in some contexts: uses ladder, so can expose bigint bits.
+ * @todo use field version && remove
  * @example
  * pow(2n, 6n, 11n) // 64n % 11n == 9n
  */
-// TODO: use field version && remove
 export function pow(num: bigint, power: bigint, modulo: bigint): bigint {
   if (power < _0n) throw new Error('invalid exponent, negatives unsupported');
   if (modulo <= _0n) throw new Error('invalid modulus');
@@ -41,7 +47,7 @@ export function pow(num: bigint, power: bigint, modulo: bigint): bigint {
   return res;
 }
 
-// Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)
+/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */
 export function pow2(x: bigint, power: bigint, modulo: bigint): bigint {
   let res = x;
   while (power-- > _0n) {
@@ -51,11 +57,13 @@ export function pow2(x: bigint, power: bigint, modulo: bigint): bigint {
   return res;
 }
 
-// Inverses number over modulo
+/**
+ * Inverses number over modulo.
+ * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).
+ */
 export function invert(number: bigint, modulo: bigint): bigint {
   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);
   let b = modulo;
@@ -83,7 +91,7 @@ export function invert(number: bigint, modulo: bigint): bigint {
  * @param P field order
  * @returns function that takes field Fp (created from P) and number n
  */
-export function tonelliShanks(P: bigint) {
+export function tonelliShanks(P: bigint): <T>(Fp: IField<T>, n: T) => T {
   // Legendre constant: used to calculate Legendre symbol (a | p),
   // which denotes the value of a^((p-1)/2) (mod p).
   // (a | p) ≡ 1    if a is a square (mod p)
@@ -142,10 +150,18 @@ export function tonelliShanks(P: bigint) {
   };
 }
 
-export function FpSqrt(P: bigint) {
-  // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.
-  // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).
-
+/**
+ * Square root for a finite field. It will try to check if optimizations are applicable and fall back to 4:
+ *
+ * 1. P ≡ 3 (mod 4)
+ * 2. P ≡ 5 (mod 8)
+ * 3. P ≡ 9 (mod 16)
+ * 4. Tonelli-Shanks algorithm
+ *
+ * Different algorithms can give different roots, it is up to user to decide which one they want.
+ * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).
+ */
+export function FpSqrt(P: bigint): <T>(Fp: IField<T>, n: T) => T {
   // P ≡ 3 (mod 4)
   // √n = n^((P+1)/4)
   if (P % _4n === _3n) {
@@ -203,11 +219,13 @@ export function FpSqrt(P: bigint) {
 }
 
 // Little-endian check for first LE bit (last BE bit);
-export const isNegativeLE = (num: bigint, modulo: bigint) => (mod(num, modulo) & _1n) === _1n;
+export const isNegativeLE = (num: bigint, modulo: bigint): boolean =>
+  (mod(num, modulo) & _1n) === _1n;
 
-// Field is not always over prime: for example, Fp2 has ORDER(q)=p^m
+/** Field is not always over prime: for example, Fp2 has ORDER(q)=p^m. */
 export interface IField<T> {
   ORDER: bigint;
+  isLE: boolean;
   BYTES: number;
   BITS: number;
   MASK: bigint;
@@ -253,7 +271,7 @@ const FIELD_FIELDS = [
   'eql', 'add', 'sub', 'mul', 'pow', 'div',
   'addN', 'subN', 'mulN', 'sqrN'
 ] as const;
-export function validateField<T>(field: IField<T>) {
+export function validateField<T>(field: IField<T>): IField<T> {
   const initial = {
     ORDER: 'bigint',
     MASK: 'bigint',
@@ -316,16 +334,19 @@ export function FpDiv<T>(f: IField<T>, lhs: T, rhs: T | bigint): T {
   return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));
 }
 
-export function FpLegendre(order: bigint) {
-  // (a | p) ≡ 1    if a is a square (mod p), quadratic residue
-  // (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue
-  // (a | p) ≡ 0    if a ≡ 0 (mod p)
+/**
+ * Legendre symbol.
+ * * (a | p) ≡ 1    if a is a square (mod p), quadratic residue
+ * * (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue
+ * * (a | p) ≡ 0    if a ≡ 0 (mod p)
+ */
+export function FpLegendre(order: bigint): <T>(f: IField<T>, x: T) => T {
   const legendreConst = (order - _1n) / _2n; // Integer arithmetic
   return <T>(f: IField<T>, x: T): T => f.pow(x, legendreConst);
 }
 
 // This function returns True whenever the value x is a square in the field F.
-export function FpIsSquare<T>(f: IField<T>) {
+export function FpIsSquare<T>(f: IField<T>): (x: T) => boolean {
   const legendre = FpLegendre(f.ORDER);
   return (x: T): boolean => {
     const p = legendre(f, x);
@@ -334,7 +355,13 @@ export function FpIsSquare<T>(f: IField<T>) {
 }
 
 // CURVE.n lengths
-export function nLength(n: bigint, nBitLength?: number) {
+export function nLength(
+  n: bigint,
+  nBitLength?: number
+): {
+  nBitLength: number;
+  nByteLength: number;
+} {
   // Bit size, byte size of CURVE.n
   const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;
   const nByteLength = Math.ceil(_nBitLength / 8);
@@ -343,15 +370,15 @@ export function nLength(n: bigint, nBitLength?: number) {
 
 type FpField = IField<bigint> & Required<Pick<IField<bigint>, 'isOdd'>>;
 /**
- * Initializes a finite field over prime. **Non-primes are not supported.**
- * Do not init in loop: slow. Very fragile: always run a benchmark on a change.
+ * Initializes a finite field over prime.
  * Major performance optimizations:
  * * a) denormalized operations like mulN instead of mul
  * * b) same object shape: never add or remove keys
  * * c) Object.freeze
- * NOTE: operations don't check 'isValid' for all elements for performance reasons,
+ * Fragile: always run a benchmark on a change.
+ * Security note: operations don't check 'isValid' for all elements for performance reasons,
  * it is caller responsibility to check this.
- * This is low-level code, please make sure you know what you doing.
+ * This is low-level code, please make sure you know what you're doing.
  * @param ORDER prime positive bigint
  * @param bitLen how many bits the field consumes
  * @param isLE (def: false) if encoding / decoding should be in little-endian
@@ -369,6 +396,7 @@ export function Field(
   let sqrtP: ReturnType<typeof FpSqrt>; // cached sqrtP
   const f: Readonly<FpField> = Object.freeze({
     ORDER,
+    isLE,
     BITS,
     BYTES,
     MASK: bitMask(BITS),
@@ -419,13 +447,13 @@ export function Field(
   return Object.freeze(f);
 }
 
-export function FpSqrtOdd<T>(Fp: IField<T>, elm: T) {
+export function FpSqrtOdd<T>(Fp: IField<T>, elm: T): T {
   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) {
+export function FpSqrtEven<T>(Fp: IField<T>, elm: T): T {
   if (!Fp.isOdd) throw new Error("Field doesn't have isOdd");
   const root = Fp.sqrt(elm);
   return Fp.isOdd(root) ? Fp.neg(root) : root;
@@ -435,7 +463,7 @@ export function FpSqrtEven<T>(Fp: IField<T>, elm: T) {
  * "Constant-time" private key generation utility.
  * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).
  * Which makes it slightly more biased, less secure.
- * @deprecated use mapKeyToField instead
+ * @deprecated use `mapKeyToField` instead
  */
 export function hashToPrivateScalar(
   hash: string | Uint8Array,
@@ -497,7 +525,7 @@ export function mapHashToField(key: Uint8Array, fieldOrder: bigint, isLE = false
   // 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);
-  const num = isLE ? bytesToNumberBE(key) : bytesToNumberLE(key);
+  const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(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;
   return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);

package/src/abstract/montgomery.ts

@@ -1,3 +1,9 @@
+/**
+ * Montgomery curve methods. It's not really whole montgomery curve,
+ * just bunch of very specific methods for X25519 / X448 from
+ * [RFC 7748](https://www.rfc-editor.org/rfc/rfc7748)
+ * @module
+ */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import { mod, pow } from './modular.js';
 import {
@@ -24,6 +30,7 @@ export type CurveType = {
   Gu: bigint;
   randomBytes?: (bytesLength?: number) => Uint8Array;
 };
+
 export type CurveFn = {
   scalarMult: (scalar: Hex, u: Hex) => Uint8Array;
   scalarMultBase: (scalar: Hex) => Uint8Array;
@@ -52,7 +59,6 @@ function validateOpts(curve: CurveType) {
   return Object.freeze({ ...curve } as const);
 }
 
-// NOTE: not really montgomery curve, just bunch of very specific methods for X25519/X448 (RFC 7748, https://www.rfc-editor.org/rfc/rfc7748)
 // Uses only one coordinate instead of two
 export function montgomery(curveDef: CurveType): CurveFn {
   const CURVE = validateOpts(curveDef);

package/src/abstract/poseidon.ts

@@ -1,8 +1,14 @@
+/**
+ * Implements [Poseidon](https://www.poseidon-hash.info) ZK-friendly hash.
+ *
+ * There are many poseidon variants with different constants.
+ * We don't provide them: you should construct them manually.
+ * Check out [micro-starknet](https://github.com/paulmillr/micro-starknet) package for a proper example.
+ * @module
+ */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-// Poseidon Hash: https://eprint.iacr.org/2019/458.pdf, https://www.poseidon-hash.info
-import { FpPow, IField, validateField } from './modular.js';
-// We don't provide any constants, since different implementations use different constants.
-// For reference constants see './test/poseidon.test.js'.
+import { FpPow, type IField, validateField } from './modular.js';
+
 export type PoseidonOpts = {
   Fp: IField<bigint>;
   t: number;
@@ -14,7 +20,18 @@ export type PoseidonOpts = {
   roundConstants: bigint[][];
 };
 
-export function validateOpts(opts: PoseidonOpts) {
+export function validateOpts(opts: PoseidonOpts): Readonly<{
+  rounds: number;
+  sboxFn: (n: bigint) => bigint;
+  roundConstants: bigint[][];
+  mds: bigint[][];
+  Fp: IField<bigint>;
+  t: number;
+  roundsFull: number;
+  roundsPartial: number;
+  sboxPower?: number;
+  reversePartialPowIdx?: boolean; // Hack for stark
+}> {
   const { Fp, mds, reversePartialPowIdx: rev, roundConstants: rc } = opts;
   const { roundsFull, roundsPartial, sboxPower, t } = opts;
 
@@ -61,7 +78,7 @@ export function validateOpts(opts: PoseidonOpts) {
   return Object.freeze({ ...opts, rounds, sboxFn, roundConstants, mds: _mds });
 }
 
-export function splitConstants(rc: bigint[], t: number) {
+export function splitConstants(rc: bigint[], t: number): bigint[][] {
   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 = [];
@@ -76,7 +93,12 @@ export function splitConstants(rc: bigint[], t: number) {
   return res;
 }
 
-export function poseidon(opts: PoseidonOpts) {
+/** Poseidon NTT-friendly hash. */
+export function poseidon(opts: PoseidonOpts): {
+  (values: bigint[]): bigint[];
+  // For verification in tests
+  roundConstants: bigint[][];
+} {
   const _opts = validateOpts(opts);
   const { Fp, mds, roundConstants, rounds: totalRounds, roundsPartial, sboxFn, t } = _opts;
   const halfRoundsFull = _opts.roundsFull / 2;

package/src/abstract/tower.ts

@@ -1,20 +1,19 @@
+/**
+ * Towered extension fields.
+ * Rather than implementing a massive 12th-degree extension directly, it is more efficient
+ * to build it up from smaller extensions: a tower of extensions.
+ *
+ * For BLS12-381, the Fp12 field is implemented as a quadratic (degree two) extension,
+ * on top of a cubic (degree three) extension, on top of a quadratic extension of Fp.
+ *
+ * For more info: "Pairings for beginners" by Costello, section 7.3.
+ * @module
+ */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 import * as mod from './modular.js';
 import { bitLen, bitMask, concatBytes, notImplemented } from './utils.js';
 import type { ProjConstructor, ProjPointType } from './weierstrass.js';
 
-/*
-Towered extension fields
-
-Rather than implementing a massive 12th-degree extension directly, it is more efficient
-to build it up from smaller extensions: a tower of extensions.
-
-For BLS12-381, the Fp12 field is implemented as a quadratic (degree two) extension,
-on top of a cubic (degree three) extension, on top of a quadratic extension of Fp.
-
-For more info: "Pairings for beginners" by Costello, section 7.3.
-*/
-
 // Be friendly to bad ECMAScript parsers by not using bigint literals
 // prettier-ignore
 const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);
@@ -75,7 +74,20 @@ function calcFrobeniusCoefficients<T>(
 }
 
 // This works same at least for bls12-381, bn254 and bls12-377
-export function psiFrobenius(Fp: mod.IField<Fp>, Fp2: Fp2Bls, base: Fp2) {
+export function psiFrobenius(
+  Fp: mod.IField<Fp>,
+  Fp2: Fp2Bls,
+  base: Fp2
+): {
+  psi: (x: Fp2, y: Fp2) => [Fp2, Fp2];
+  psi2: (x: Fp2, y: Fp2) => [Fp2, Fp2];
+  G2psi: (c: ProjConstructor<Fp2>, P: ProjPointType<Fp2>) => ProjPointType<Fp2>;
+  G2psi2: (c: ProjConstructor<Fp2>, P: ProjPointType<Fp2>) => ProjPointType<Fp2>;
+  PSI_X: Fp2;
+  PSI_Y: Fp2;
+  PSI2_X: Fp2;
+  PSI2_Y: Fp2;
+} {
   // Ψ endomorphism
   const PSI_X = Fp2.pow(base, (Fp.ORDER - _1n) / _3n); // u^((p-1)/3)
   const PSI_Y = Fp2.pow(base, (Fp.ORDER - _1n) / _2n); // u^((p-1)/2)
@@ -120,7 +132,37 @@ export type Tower12Opts = {
   Fp12finalExponentiate: (num: Fp12) => Fp12;
 };
 
-export function tower12(opts: Tower12Opts) {
+export function tower12(opts: Tower12Opts): {
+  Fp: Readonly<mod.IField<bigint> & Required<Pick<mod.IField<bigint>, 'isOdd'>>>;
+  Fp2: mod.IField<Fp2> & {
+    NONRESIDUE: Fp2;
+    fromBigTuple: (tuple: BigintTuple | bigint[]) => Fp2;
+    reim: (num: Fp2) => { re: bigint; im: bigint };
+    mulByNonresidue: (num: Fp2) => Fp2;
+    mulByB: (num: Fp2) => Fp2;
+    frobeniusMap(num: Fp2, power: number): Fp2;
+  };
+  Fp6: mod.IField<Fp6> & {
+    fromBigSix: (tuple: BigintSix) => Fp6;
+    mulByNonresidue: (num: Fp6) => Fp6;
+    frobeniusMap(num: Fp6, power: number): Fp6;
+    mul1(num: Fp6, b1: Fp2): Fp6;
+    mul01(num: Fp6, b0: Fp2, b1: Fp2): Fp6;
+    mulByFp2(lhs: Fp6, rhs: Fp2): Fp6;
+  };
+  Fp4Square: (a: Fp2, b: Fp2) => { first: Fp2; second: Fp2 };
+  Fp12: mod.IField<Fp12> & {
+    fromBigTwelve: (t: BigintTwelve) => Fp12;
+    frobeniusMap(num: Fp12, power: number): Fp12;
+    mul014(num: Fp12, o0: Fp2, o1: Fp2, o4: Fp2): Fp12;
+    mul034(num: Fp12, o0: Fp2, o3: Fp2, o4: Fp2): Fp12;
+    mulByFp2(lhs: Fp12, rhs: Fp2): Fp12;
+    conjugate(num: Fp12): Fp12;
+    finalExponentiate(num: Fp12): Fp12;
+    _cyclotomicSquare(num: Fp12): Fp12;
+    _cyclotomicExp(num: Fp12, n: bigint): Fp12;
+  };
+} {
   const { ORDER } = opts;
   // Fp
   const Fp = mod.Field(ORDER);
@@ -173,6 +215,7 @@ export function tower12(opts: Tower12Opts) {
   const Fp2Nonresidue = Fp2fromBigTuple(opts.FP2_NONRESIDUE);
   const Fp2: mod.IField<Fp2> & Fp2Utils = {
     ORDER: FP2_ORDER,
+    isLE: Fp.isLE,
     NONRESIDUE: Fp2Nonresidue,
     BITS: bitLen(FP2_ORDER),
     BYTES: Math.ceil(bitLen(FP2_ORDER) / 8),
@@ -339,6 +382,7 @@ export function tower12(opts: Tower12Opts) {
 
   const Fp6: mod.IField<Fp6> & Fp6Utils = {
     ORDER: Fp2.ORDER, // TODO: unused, but need to verify
+    isLE: Fp2.isLE,
     BITS: 3 * Fp2.BITS,
     BYTES: 3 * Fp2.BYTES,
     MASK: bitMask(3 * Fp2.BITS),
@@ -495,6 +539,7 @@ export function tower12(opts: Tower12Opts) {
 
   const Fp12: mod.IField<Fp12> & Fp12Utils = {
     ORDER: Fp2.ORDER, // TODO: unused, but need to verify
+    isLE: Fp6.isLE,
     BITS: 2 * Fp2.BITS,
     BYTES: 2 * Fp2.BYTES,
     MASK: bitMask(2 * Fp2.BITS),

package/src/abstract/utils.ts

@@ -1,4 +1,9 @@
+/**
+ * Hex, bytes and number utilities.
+ * @module
+ */
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+
 // 100 lines of code in the file are duplicated from noble-hashes (utils).
 // This is OK: `abstract` directory does not use noble-hashes.
 // User may opt-in into using different hashing library. This way, noble-hashes
@@ -155,7 +160,7 @@ export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
 }
 
 // Compares 2 u8a-s in kinda constant time
-export function equalBytes(a: Uint8Array, b: Uint8Array) {
+export function equalBytes(a: Uint8Array, b: Uint8Array): boolean {
   if (a.length !== b.length) return false;
   let diff = 0;
   for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
@@ -177,7 +182,7 @@ export function utf8ToBytes(str: string): Uint8Array {
 // Is positive bigint
 const isPosBig = (n: bigint) => typeof n === 'bigint' && _0n <= n;
 
-export function inRange(n: bigint, min: bigint, max: bigint) {
+export function inRange(n: bigint, min: bigint, max: bigint): boolean {
   return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
 }
 
@@ -186,7 +191,7 @@ export function inRange(n: bigint, min: bigint, max: bigint) {
  * @example
  * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)
  */
-export function aInRange(title: string, n: bigint, min: bigint, max: bigint) {
+export function aInRange(title: string, n: bigint, min: bigint, max: bigint): void {
   // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?
   // consider P=256n, min=0n, max=P
   // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`
@@ -202,7 +207,7 @@ export function aInRange(title: string, n: bigint, min: bigint, max: bigint) {
  * Calculates amount of bits in a bigint.
  * Same as `n.toString(2).length`
  */
-export function bitLen(n: bigint) {
+export function bitLen(n: bigint): number {
   let len;
   for (len = 0; n > _0n; n >>= _1n, len += 1);
   return len;
@@ -213,14 +218,14 @@ export function bitLen(n: bigint) {
  * NOTE: first bit position is 0 (same as arrays)
  * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`
  */
-export function bitGet(n: bigint, pos: number) {
+export function bitGet(n: bigint, pos: number): bigint {
   return (n >> BigInt(pos)) & _1n;
 }
 
 /**
  * Sets single bit at position.
  */
-export function bitSet(n: bigint, pos: number, value: boolean) {
+export function bitSet(n: bigint, pos: number, value: boolean): bigint {
   return n | ((value ? _1n : _0n) << BigInt(pos));
 }
 
@@ -228,7 +233,7 @@ export function bitSet(n: bigint, pos: number, value: boolean) {
  * Calculate mask for N bits. Not using ** operator with bigints because of old engines.
  * Same as BigInt(`0b${Array(i).fill('1').join('')}`)
  */
-export const bitMask = (n: number) => (_2n << BigInt(n - 1)) - _1n;
+export const bitMask = (n: number): bigint => (_2n << BigInt(n - 1)) - _1n;
 
 // DRBG
 
@@ -295,15 +300,15 @@ export function createHmacDrbg<T>(
 // Validating curves and fields
 
 const validatorFns = {
-  bigint: (val: any) => typeof val === 'bigint',
-  function: (val: any) => typeof val === 'function',
-  boolean: (val: any) => typeof val === 'boolean',
-  string: (val: any) => typeof val === 'string',
-  stringOrUint8Array: (val: any) => typeof val === 'string' || isBytes(val),
-  isSafeInteger: (val: any) => Number.isSafeInteger(val),
-  array: (val: any) => Array.isArray(val),
-  field: (val: any, object: any) => (object as any).Fp.isValid(val),
-  hash: (val: any) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),
+  bigint: (val: any): boolean => typeof val === 'bigint',
+  function: (val: any): boolean => typeof val === 'function',
+  boolean: (val: any): boolean => typeof val === 'boolean',
+  string: (val: any): boolean => typeof val === 'string',
+  stringOrUint8Array: (val: any): boolean => typeof val === 'string' || isBytes(val),
+  isSafeInteger: (val: any): boolean => Number.isSafeInteger(val),
+  array: (val: any): boolean => Array.isArray(val),
+  field: (val: any, object: any): any => (object as any).Fp.isValid(val),
+  hash: (val: any): boolean => typeof val === 'function' && Number.isSafeInteger(val.outputLen),
 } as const;
 type Validator = keyof typeof validatorFns;
 type ValMap<T extends Record<string, any>> = { [K in keyof T]?: Validator };
@@ -313,7 +318,7 @@ export function validateObject<T extends Record<string, any>>(
   object: T,
   validators: ValMap<T>,
   optValidators: ValMap<T> = {}
-) {
+): T {
   const checkField = (fieldName: keyof T, type: Validator, isOptional: boolean) => {
     const checkVal = validatorFns[type];
     if (typeof checkVal !== 'function') throw new Error('invalid validator function');
@@ -342,7 +347,7 @@ export function validateObject<T extends Record<string, any>>(
 /**
  * throws not implemented error
  */
-export const notImplemented = () => {
+export const notImplemented = (): never => {
   throw new Error('not implemented');
 };
 
@@ -350,7 +355,9 @@ export const notImplemented = () => {
  * Memoizes (caches) computation result.
  * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.
  */
-export function memoized<T extends object, R, O extends any[]>(fn: (arg: T, ...args: O) => R) {
+export function memoized<T extends object, R, O extends any[]>(
+  fn: (arg: T, ...args: O) => R
+): (arg: T, ...args: O) => R {
   const map = new WeakMap<T, R>();
   return (arg: T, ...args: O): R => {
     const val = map.get(arg);