@ohos-ports/crypto 0.0.0-stage → 0.3.1-beta.1

package/dist/noble/abstract/utils.d.ts

@@ -0,0 +1,106 @@
+export type Hex = Uint8Array | string;
+export type PrivKey = Hex | bigint;
+export type CHash = {
+    (message: Uint8Array | string): Uint8Array;
+    blockLen: number;
+    outputLen: number;
+    create(opts?: {
+        dkLen?: number;
+    }): any;
+};
+export type FHash = (message: Uint8Array | string) => Uint8Array;
+export declare function abytes(item: unknown): void;
+/**
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function numberToHexUnpadded(num: number | bigint): string;
+export declare function hexToNumber(hex: string): bigint;
+/**
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function bytesToNumberBE(bytes: Uint8Array): bigint;
+export declare function bytesToNumberLE(bytes: Uint8Array): bigint;
+export declare function numberToBytesBE(n: number | bigint, len: number): Uint8Array;
+export declare function numberToBytesLE(n: number | bigint, len: number): Uint8Array;
+export declare function numberToVarBytesBE(n: number | bigint): Uint8Array;
+/**
+ * Takes hex string or Uint8Array, converts to Uint8Array.
+ * Validates output length.
+ * Will throw error for other types.
+ * @param title descriptive title for an error e.g. 'private key'
+ * @param hex hex string or Uint8Array
+ * @param expectedLength optional, will compare to result array's length
+ * @returns
+ */
+export declare function ensureBytes(title: string, hex: Hex, expectedLength?: number): Uint8Array;
+/**
+ * Copies several Uint8Arrays into one.
+ */
+export declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+export declare function equalBytes(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+export declare function utf8ToBytes(str: string): Uint8Array;
+/**
+ * Calculates amount of bits in a bigint.
+ * Same as `n.toString(2).length`
+ */
+export declare function bitLen(n: bigint): number;
+/**
+ * Gets single bit at position.
+ * NOTE: first bit position is 0 (same as arrays)
+ * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`
+ */
+export declare function bitGet(n: bigint, pos: number): bigint;
+/**
+ * Sets single bit at position.
+ */
+export declare function bitSet(n: bigint, pos: number, value: boolean): bigint;
+/**
+ * Calculate mask for N bits. Not using ** operator with bigints because of old engines.
+ * Same as BigInt(`0b${Array(i).fill('1').join('')}`)
+ */
+export declare const bitMask: (n: number) => bigint;
+type Pred<T> = (v: Uint8Array) => T | undefined;
+/**
+ * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
+ * @returns function that will call DRBG until 2nd arg returns something meaningful
+ * @example
+ *   const drbg = createHmacDRBG<Key>(32, 32, hmac);
+ *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined
+ */
+export declare function createHmacDrbg<T>(hashLen: number, qByteLen: number, hmacFn: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array): (seed: Uint8Array, predicate: Pred<T>) => T;
+declare const validatorFns: {
+    readonly bigint: (val: any) => boolean;
+    readonly function: (val: any) => boolean;
+    readonly boolean: (val: any) => boolean;
+    readonly string: (val: any) => boolean;
+    readonly stringOrUint8Array: (val: any) => boolean;
+    readonly isSafeInteger: (val: any) => boolean;
+    readonly array: (val: any) => boolean;
+    readonly field: (val: any, object: any) => any;
+    readonly hash: (val: any) => boolean;
+};
+type Validator = keyof typeof validatorFns;
+type ValMap<T extends Record<string, any>> = {
+    [K in keyof T]?: Validator;
+};
+export declare function validateObject<T extends Record<string, any>>(object: T, validators: ValMap<T>, optValidators?: ValMap<T>): T;
+/**
+ * Memoizes (caches) computation result.
+ * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.
+ */
+export declare function memoized<T extends object, R, O extends any[]>(fn: (arg: T, ...args: O) => R): (arg: T, ...args: O) => R;
+export declare function abool(title: string, value: boolean): void;
+export declare function isBytes(a: unknown): a is Uint8Array;
+export declare function inRange(n: bigint, min: bigint, max: bigint): boolean;
+/**
+* Asserts min <= n < max. NOTE: It's < max and not <= max.
+* @example
+* aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)
+*/
+export declare function aInRange(title: string, n: bigint, min: bigint, max: bigint): void;
+export {};

package/dist/noble/abstract/utils.js

@@ -0,0 +1,442 @@
+"use strict";
+/*
+THIS IMPLEMENTATION WAS TAKEN FROM `@noble/hashes`
+
+original source: https://github.com/paulmillr/noble-curves/blob/38a4ca1e6b0a80c60b11bbb6b3d71e3bfabd5bbb/src/abstract/utils.ts
+
+it was modified and adapted to this repository
+
+the main reason for copying over and not using as dependency is because of different target in the `tsconfig.json`
+
+`@noble/hashes` targets es2020, which tends to cause problems with some other (older) packages sometimes
+
+this repo targets ES5+
+*/
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aInRange = exports.inRange = exports.isBytes = exports.abool = exports.memoized = exports.validateObject = exports.createHmacDrbg = exports.bitMask = exports.bitSet = exports.bitGet = exports.bitLen = exports.utf8ToBytes = exports.equalBytes = exports.concatBytes = exports.ensureBytes = exports.numberToVarBytesBE = exports.numberToBytesLE = exports.numberToBytesBE = exports.bytesToNumberLE = exports.bytesToNumberBE = exports.hexToBytes = exports.hexToNumber = exports.numberToHexUnpadded = exports.bytesToHex = exports.abytes = void 0;
+/*! 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
+// won't be included into their bundle.
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+function abytes(item) {
+    if (!isBytes(item))
+        throw new Error('Uint8Array expected');
+}
+exports.abytes = abytes;
+// Array where index 0xf0 (240) is mapped to string 'f0'
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, function (_, i) {
+    return i.toString(16).padStart(2, '0');
+});
+/**
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function bytesToHex(bytes) {
+    abytes(bytes);
+    // pre-caching improves the speed 6x
+    var hex = '';
+    for (var i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+exports.bytesToHex = bytesToHex;
+function numberToHexUnpadded(num) {
+    var hex = num.toString(16);
+    return hex.length & 1 ? "0".concat(hex) : hex;
+}
+exports.numberToHexUnpadded = numberToHexUnpadded;
+function hexToNumber(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    // Big Endian
+    return BigInt(hex === '' ? '0' : "0x".concat(hex));
+}
+exports.hexToNumber = hexToNumber;
+// We use optimized technique to convert hex string to byte array
+var asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
+function asciiToBase16(char) {
+    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);
+    return;
+}
+/**
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+function hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    var hl = hex.length;
+    var al = hl / 2;
+    if (hl % 2)
+        throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
+    var array = new Uint8Array(al);
+    for (var ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        var n1 = asciiToBase16(hex.charCodeAt(hi));
+        var n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+        if (n1 === undefined || n2 === undefined) {
+            var 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;
+    }
+    return array;
+}
+exports.hexToBytes = hexToBytes;
+// BE: Big Endian, LE: Little Endian
+function bytesToNumberBE(bytes) {
+    return hexToNumber(bytesToHex(bytes));
+}
+exports.bytesToNumberBE = bytesToNumberBE;
+function bytesToNumberLE(bytes) {
+    abytes(bytes);
+    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+}
+exports.bytesToNumberLE = bytesToNumberLE;
+function numberToBytesBE(n, len) {
+    return hexToBytes(n.toString(16).padStart(len * 2, '0'));
+}
+exports.numberToBytesBE = numberToBytesBE;
+function numberToBytesLE(n, len) {
+    return numberToBytesBE(n, len).reverse();
+}
+exports.numberToBytesLE = numberToBytesLE;
+// Unpadded, rarely used
+function numberToVarBytesBE(n) {
+    return hexToBytes(numberToHexUnpadded(n));
+}
+exports.numberToVarBytesBE = numberToVarBytesBE;
+/**
+ * Takes hex string or Uint8Array, converts to Uint8Array.
+ * Validates output length.
+ * Will throw error for other types.
+ * @param title descriptive title for an error e.g. 'private key'
+ * @param hex hex string or Uint8Array
+ * @param expectedLength optional, will compare to result array's length
+ * @returns
+ */
+function ensureBytes(title, hex, expectedLength) {
+    var res;
+    if (typeof hex === 'string') {
+        try {
+            res = hexToBytes(hex);
+        }
+        catch (e) {
+            throw new Error("".concat(title, " must be valid hex string, got \"").concat(hex, "\". Cause: ").concat(e));
+        }
+    }
+    else if (isBytes(hex)) {
+        // Uint8Array.from() instead of hash.slice() because node Buffer
+        // is instance of Uint8Array, and its slice() creates **mutable** copy
+        res = Uint8Array.from(hex);
+    }
+    else {
+        throw new Error("".concat(title, " must be hex string or Uint8Array"));
+    }
+    var len = res.length;
+    if (typeof expectedLength === 'number' && len !== expectedLength)
+        throw new Error("".concat(title, " expected ").concat(expectedLength, " bytes, got ").concat(len));
+    return res;
+}
+exports.ensureBytes = ensureBytes;
+/**
+ * Copies several Uint8Arrays into one.
+ */
+function concatBytes() {
+    var arrays = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        arrays[_i] = arguments[_i];
+    }
+    var sum = 0;
+    for (var i = 0; i < arrays.length; i++) {
+        var a = arrays[i];
+        abytes(a);
+        sum += a.length;
+    }
+    var res = new Uint8Array(sum);
+    for (var i = 0, pad = 0; i < arrays.length; i++) {
+        var a = arrays[i];
+        res.set(a, pad);
+        pad += a.length;
+    }
+    return res;
+}
+exports.concatBytes = concatBytes;
+// Compares 2 u8a-s in kinda constant time
+function equalBytes(a, b) {
+    if (a.length !== b.length)
+        return false;
+    var diff = 0;
+    for (var i = 0; i < a.length; i++)
+        diff |= a[i] ^ b[i];
+    return diff === 0;
+}
+exports.equalBytes = equalBytes;
+/**
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error("utf8ToBytes expected string, got ".concat(typeof str));
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+exports.utf8ToBytes = utf8ToBytes;
+// Bit operations
+/**
+ * Calculates amount of bits in a bigint.
+ * Same as `n.toString(2).length`
+ */
+function bitLen(n) {
+    var len;
+    for (len = 0; n > _0n; n >>= _1n, len += 1)
+        ;
+    return len;
+}
+exports.bitLen = bitLen;
+/**
+ * Gets single bit at position.
+ * NOTE: first bit position is 0 (same as arrays)
+ * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`
+ */
+function bitGet(n, pos) {
+    return (n >> BigInt(pos)) & _1n;
+}
+exports.bitGet = bitGet;
+/**
+ * Sets single bit at position.
+ */
+function bitSet(n, pos, value) {
+    return n | ((value ? _1n : _0n) << BigInt(pos));
+}
+exports.bitSet = bitSet;
+/**
+ * Calculate mask for N bits. Not using ** operator with bigints because of old engines.
+ * Same as BigInt(`0b${Array(i).fill('1').join('')}`)
+ */
+var bitMask = function (n) { return (_2n << BigInt(n - 1)) - _1n; };
+exports.bitMask = bitMask;
+// DRBG
+var u8n = function (data) { return new Uint8Array(data); }; // creates Uint8Array
+var u8fr = function (arr) { return Uint8Array.from(arr); }; // another shortcut
+/**
+ * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
+ * @returns function that will call DRBG until 2nd arg returns something meaningful
+ * @example
+ *   const drbg = createHmacDRBG<Key>(32, 32, hmac);
+ *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined
+ */
+function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+    if (typeof hashLen !== 'number' || hashLen < 2)
+        throw new Error('hashLen must be a number');
+    if (typeof qByteLen !== 'number' || qByteLen < 2)
+        throw new Error('qByteLen must be a number');
+    if (typeof hmacFn !== 'function')
+        throw new Error('hmacFn must be a function');
+    // Step B, Step C: set hashLen to 8*ceil(hlen/8)
+    var v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
+    var k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same
+    var i = 0; // Iterations counter, will throw when over 1000
+    var reset = function () {
+        v.fill(1);
+        k.fill(0);
+        i = 0;
+    };
+    var h = function () {
+        var b = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            b[_i] = arguments[_i];
+        }
+        return hmacFn.apply(void 0, __spreadArray([k, v], __read(b), false));
+    }; // hmac(k)(v, ...values)
+    var reseed = function (seed) {
+        if (seed === void 0) { seed = u8n(); }
+        // HMAC-DRBG reseed() function. Steps D-G
+        k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)
+        v = h(); // v = hmac(k || v)
+        if (seed.length === 0)
+            return;
+        k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)
+        v = h(); // v = hmac(k || v)
+    };
+    var gen = function () {
+        // HMAC-DRBG generate() function
+        if (i++ >= 1000)
+            throw new Error('drbg: tried 1000 values');
+        var len = 0;
+        var out = [];
+        while (len < qByteLen) {
+            v = h();
+            var sl = v.slice();
+            out.push(sl);
+            len += v.length;
+        }
+        return concatBytes.apply(void 0, __spreadArray([], __read(out), false));
+    };
+    var genUntil = function (seed, pred) {
+        reset();
+        reseed(seed); // Steps D-G
+        var res = undefined; // Step H: grind until k is in [1..n-1]
+        while (!(res = pred(gen())))
+            reseed();
+        reset();
+        return res;
+    };
+    return genUntil;
+}
+exports.createHmacDrbg = createHmacDrbg;
+// Validating curves and fields
+var validatorFns = {
+    bigint: function (val) { return typeof val === 'bigint'; },
+    function: function (val) { return typeof val === 'function'; },
+    boolean: function (val) { return typeof val === 'boolean'; },
+    string: function (val) { return typeof val === 'string'; },
+    stringOrUint8Array: function (val) { return typeof val === 'string' || isBytes(val); },
+    isSafeInteger: function (val) { return Number.isSafeInteger(val); },
+    array: function (val) { return Array.isArray(val); },
+    field: function (val, object) { return object.Fp.isValid(val); },
+    hash: function (val) { return typeof val === 'function' && Number.isSafeInteger(val.outputLen); },
+};
+// type Record<K extends string | number | symbol, T> = { [P in K]: T; }
+function validateObject(object, validators, optValidators) {
+    var e_1, _b, e_2, _c;
+    if (optValidators === void 0) { optValidators = {}; }
+    var checkField = function (fieldName, type, isOptional) {
+        var checkVal = validatorFns[type];
+        if (typeof checkVal !== 'function')
+            throw new Error("Invalid validator \"".concat(type, "\", expected function"));
+        var val = object[fieldName];
+        if (isOptional && val === undefined)
+            return;
+        if (!checkVal(val, object)) {
+            throw new Error("Invalid param ".concat(String(fieldName), "=").concat(val, " (").concat(typeof val, "), expected ").concat(type));
+        }
+    };
+    try {
+        for (var _d = __values(Object.entries(validators)), _e = _d.next(); !_e.done; _e = _d.next()) {
+            var _g = __read(_e.value, 2), fieldName = _g[0], type = _g[1];
+            checkField(fieldName, type, false);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var _h = __values(Object.entries(optValidators)), _j = _h.next(); !_j.done; _j = _h.next()) {
+            var _k = __read(_j.value, 2), fieldName = _k[0], type = _k[1];
+            checkField(fieldName, type, true);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return object;
+}
+exports.validateObject = validateObject;
+// validate type tests
+// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };
+// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!
+// // Should fail type-check
+// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });
+// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });
+// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });
+// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });
+/**
+ * Memoizes (caches) computation result.
+ * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.
+ */
+function memoized(fn) {
+    var map = new WeakMap();
+    return function (arg) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var val = map.get(arg);
+        if (val !== undefined)
+            return val;
+        var computed = fn.apply(void 0, __spreadArray([arg], __read(args), false));
+        map.set(arg, computed);
+        return computed;
+    };
+}
+exports.memoized = memoized;
+function abool(title, value) {
+    if (typeof value !== 'boolean')
+        throw new Error(title + ' boolean expected, got ' + value);
+}
+exports.abool = abool;
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+exports.isBytes = isBytes;
+var isPosBig = function (n) { return typeof n === 'bigint' && _0n <= n; };
+function inRange(n, min, max) {
+    return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
+}
+exports.inRange = inRange;
+/**
+* Asserts min <= n < max. NOTE: It's < max and not <= max.
+* @example
+* aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)
+*/
+function aInRange(title, n, min, max) {
+    // 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)`
+    // - 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 ' + n);
+}
+exports.aInRange = aInRange;

package/dist/noble/bls12_381.d.ts

@@ -0,0 +1,95 @@
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+import { CurveFn } from './abstract/bls.js';
+import * as mod from './abstract/modular.js';
+import { AffinePoint } from './curves/weierstrass.js';
+export declare const Fp: Readonly<mod.IField<bigint> & Required<Pick<mod.IField<bigint>, "isOdd">>>;
+type Fp = bigint;
+type BigintTuple = [bigint, bigint];
+type Fp2 = {
+    c0: bigint;
+    c1: bigint;
+};
+type Fp2Utils = {
+    fromBigTuple: (tuple: BigintTuple | bigint[]) => Fp2;
+    reim: (num: Fp2) => {
+        re: bigint;
+        im: bigint;
+    };
+    mulByNonresidue: (num: Fp2) => Fp2;
+    multiplyByB: (num: Fp2) => Fp2;
+    frobeniusMap(num: Fp2, power: number): Fp2;
+};
+export type Fp2_t = typeof Fp2;
+export declare const Fp2: mod.IField<Fp2> & Fp2Utils;
+type BigintSix = [bigint, bigint, bigint, bigint, bigint, bigint];
+type Fp6 = {
+    c0: Fp2;
+    c1: Fp2;
+    c2: Fp2;
+};
+type Fp6Utils = {
+    fromBigSix: (tuple: BigintSix) => Fp6;
+    mulByNonresidue: (num: Fp6) => Fp6;
+    frobeniusMap(num: Fp6, power: number): Fp6;
+    multiplyBy1(num: Fp6, b1: Fp2): Fp6;
+    multiplyBy01(num: Fp6, b0: Fp2, b1: Fp2): Fp6;
+    multiplyByFp2(lhs: Fp6, rhs: Fp2): Fp6;
+};
+declare const Fp6: mod.IField<Fp6> & Fp6Utils;
+type Fp12 = {
+    c0: Fp6;
+    c1: Fp6;
+};
+type BigintTwelve = [
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint,
+    bigint
+];
+export declare const Fp12Multiply: ({ c0, c1 }: Fp12, rhs: Fp12 | bigint) => {
+    c0: Fp6;
+    c1: Fp6;
+};
+type Fp12Utils = {
+    fromBigTwelve: (t: BigintTwelve) => Fp12;
+    frobeniusMap(num: Fp12, power: number): Fp12;
+    multiplyBy014(num: Fp12, o0: Fp2, o1: Fp2, o4: Fp2): Fp12;
+    multiplyByFp2(lhs: Fp12, rhs: Fp2): Fp12;
+    conjugate(num: Fp12): Fp12;
+    finalExponentiate(num: Fp12): Fp12;
+    _cyclotomicSquare(num: Fp12): Fp12;
+    _cyclotomicExp(num: Fp12, n: bigint): Fp12;
+};
+export declare const Fp12_finalExponentiate: (num: Fp12) => Fp12;
+export declare const Fp12_conjugate: ({ c0, c1 }: Fp12) => Fp12;
+export declare const Fp12_eql: ({ c0, c1 }: Fp12, { c0: r0, c1: r1 }: Fp12) => boolean;
+export declare const Fp12_ONE: {
+    c0: Fp6;
+    c1: Fp6;
+};
+export declare const Fp12: mod.IField<Fp12> & Fp12Utils;
+export declare function parseMask(bytes: Uint8Array): {
+    compressed: boolean;
+    infinity: boolean;
+    sort: boolean;
+    value: Uint8Array;
+};
+export declare const G1_formBytes: (bytes: Uint8Array) => AffinePoint<Fp>;
+export declare const G1_mapToCurve: (scalars: bigint[]) => {
+    x: bigint;
+    y: bigint;
+};
+export declare const G2_mapToCurve: (scalars: bigint[]) => {
+    x: Fp2;
+    y: Fp2;
+};
+export declare const bls12_381: CurveFn<Fp, Fp2, Fp6, Fp12>;
+export {};