@aztec/foundation 0.0.0-test.1 → 0.0.1-commit.5476d83

package/dest/fields/bls12_fields.d.ts

@@ -0,0 +1,148 @@
+import { inspect } from 'util';
+import { BufferReader } from '../serialize/buffer_reader.js';
+import { Fr } from './fields.js';
+/**
+ * Base BLS12field class.
+ */
+export declare abstract class BLS12Field {
+    private asBuffer?;
+    private asBigInt?;
+    protected constructor(value: number | bigint | Buffer);
+    protected abstract modulus(): bigint;
+    protected abstract size(): number;
+    /**
+     * We return a copy of the Buffer to ensure this remains immutable.
+     */
+    toBuffer(): Buffer;
+    toString(): `0x${string}`;
+    toBigInt(): bigint;
+    toNoirBigNum(): {
+        limbs: string[];
+    };
+    equals(rhs: BLS12Field): boolean;
+    lt(rhs: BLS12Field): boolean;
+    isZero(): boolean;
+    isEmpty(): boolean;
+    isNegative(): boolean;
+    toFriendlyJSON(): string;
+    toField(): this;
+}
+/**
+ * Fr field class.
+ * @dev This class is used to represent elements of BLS12-381 scalar field.
+ */
+export declare class BLS12Fr extends BLS12Field {
+    static SIZE_IN_BYTES: number;
+    static MODULUS: bigint;
+    static ZERO: BLS12Fr;
+    static ONE: BLS12Fr;
+    static MAX_FIELD_VALUE: BLS12Fr;
+    constructor(value: number | bigint | Buffer);
+    [inspect.custom](): string;
+    protected modulus(): bigint;
+    protected size(): number;
+    static random(): BLS12Fr;
+    static zero(): BLS12Fr;
+    static isZero(value: BLS12Fr): boolean;
+    static fromBuffer(buffer: Buffer | BufferReader): BLS12Fr;
+    /**
+     * Creates a BLS12Fr instance from a string.
+     * @param buf - the string to create a BLS12Fr from.
+     * @returns the BLS12Fr instance
+     * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+     * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+     * as to what is being parsed.
+     */
+    static fromString(buf: string): BLS12Fr;
+    /**
+     * Creates a BLS12Fr instance from a hex string.
+     * @param buf - a hex encoded string.
+     * @returns the BLS12Fr instance
+     */
+    static fromHexString(buf: string): BLS12Fr;
+    /**
+     * Constructs a field from noir BigNum type.
+     */
+    static fromNoirBigNum(bignum: {
+        limbs: string[];
+    }): BLS12Fr;
+    /**
+     * Creates a BLS12Fr instance from a BN254 Fr instance.
+     * @dev The BN254 field size < BLS12_381, so we cannot overflow here.
+     * Useful for blob related calculations.
+     * @param field - a BN254 Fr instance.
+     * @returns the BLS12Fr instance
+     */
+    static fromBN254Fr(field: Fr): BLS12Fr;
+    /**
+     * Creates a BN254 Fr instance from a BLS12Fr instance.
+     * @dev The BN254 field size < BLS12_381, so we must check the size here
+     * Useful for blob related calculations.
+     * @param field - a BLS12Fr instance.
+     * @returns the BN254 Fr instance
+     */
+    toBN254Fr(): Fr;
+    /** Arithmetic - wrapper around noble curves */
+    add(rhs: BLS12Fr): BLS12Fr;
+    square(): BLS12Fr;
+    negate(): BLS12Fr;
+    sub(rhs: BLS12Fr): BLS12Fr;
+    mul(rhs: BLS12Fr): BLS12Fr;
+    div(rhs: BLS12Fr): BLS12Fr;
+    sqrt(): BLS12Fr | null;
+    pow(rhs: bigint): BLS12Fr;
+    toJSON(): `0x${string}`;
+    static get schema(): import("zod").ZodType<BLS12Fr, any, string>;
+}
+/**
+ * Fq field class.
+ * @dev This class is used to represent elements of BLS12-381 base field.
+ */
+export declare class BLS12Fq extends BLS12Field {
+    static SIZE_IN_BYTES: number;
+    static MODULUS: bigint;
+    static ZERO: BLS12Fq;
+    static ONE: BLS12Fq;
+    static MAX_FIELD_VALUE: BLS12Fq;
+    constructor(value: number | bigint | Buffer);
+    [inspect.custom](): string;
+    protected modulus(): bigint;
+    protected size(): number;
+    static random(): BLS12Fq;
+    static zero(): BLS12Fq;
+    static isZero(value: BLS12Fq): boolean;
+    static fromBuffer(buffer: Buffer | BufferReader): BLS12Fq;
+    /**
+     * Creates a BLS12Fq instance from a string.
+     * @param buf - the string to create a BLS12Fq from.
+     * @returns the BLS12Fq instance
+     * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+     * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+     * as to what is being parsed.
+     */
+    static fromString(buf: string): BLS12Fq;
+    /**
+     * Creates a BLS12Fq instance from a hex string.
+     * @param buf - a hex encoded string.
+     * @returns the BLS12Fq instance
+     */
+    static fromHexString(buf: string): BLS12Fq;
+    /**
+     * Constructs a field from noir BigNum type.
+     */
+    static fromNoirBigNum(bignum: {
+        limbs: string[];
+    }): BLS12Fq;
+    /** Arithmetic - wrapper around noble curves */
+    add(rhs: BLS12Fq): BLS12Fq;
+    square(): BLS12Fq;
+    negate(): BLS12Fq;
+    sub(rhs: BLS12Fq): BLS12Fq;
+    mul(rhs: BLS12Fq): BLS12Fq;
+    div(rhs: BLS12Fq): BLS12Fq;
+    sqrt(): BLS12Fq | null;
+    pow(rhs: bigint): BLS12Fq;
+    toJSON(): `0x${string}`;
+    static get schema(): import("zod").ZodType<BLS12Fq, any, string>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmxzMTJfZmllbGRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZmllbGRzL2JsczEyX2ZpZWxkcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBSy9CLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUU3RCxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBY2pDOztHQUVHO0FBQ0gsOEJBQXNCLFVBQVU7SUFDOUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFTO0lBQzFCLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBUztJQUUxQixTQUFTLGFBQWEsS0FBSyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsTUFBTSxFQWlCcEQ7SUFFRCxTQUFTLENBQUMsUUFBUSxDQUFDLE9BQU8sSUFBSSxNQUFNLENBQUM7SUFDckMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLElBQUksTUFBTSxDQUFDO0lBRWxDOztPQUVHO0lBQ0gsUUFBUSxJQUFJLE1BQU0sQ0FLakI7SUFFRCxRQUFRLElBQUksS0FBSyxNQUFNLEVBQUUsQ0FFeEI7SUFFRCxRQUFRLElBQUksTUFBTSxDQVFqQjtJQUVELFlBQVksSUFBSTtRQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQTtLQUFFLENBVWxDO0lBRUQsTUFBTSxDQUFDLEdBQUcsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUUvQjtJQUVELEVBQUUsQ0FBQyxHQUFHLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FFM0I7SUFFRCxNQUFNLElBQUksT0FBTyxDQUVoQjtJQUVELE9BQU8sSUFBSSxPQUFPLENBRWpCO0lBRUQsVUFBVSxJQUFJLE9BQU8sQ0FJcEI7SUFFRCxjQUFjLElBQUksTUFBTSxDQUV2QjtJQUVELE9BQU8sU0FFTjtDQUNGO0FBa0REOzs7R0FHRztBQUNILHFCQUFhLE9BQVEsU0FBUSxVQUFVO0lBQ3JDLE1BQU0sQ0FBQyxhQUFhLFNBQTZCO0lBQ2pELE1BQU0sQ0FBQyxPQUFPLFNBQTZCO0lBQzNDLE1BQU0sQ0FBQyxJQUFJLFVBQW1CO0lBQzlCLE1BQU0sQ0FBQyxHQUFHLFVBQW1CO0lBQzdCLE1BQU0sQ0FBQyxlQUFlLFVBQWtDO0lBRXhELFlBQVksS0FBSyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsTUFBTSxFQUUxQztJQUVELENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQUVmO0lBRUQsU0FBUyxDQUFDLE9BQU8sV0FFaEI7SUFFRCxTQUFTLENBQUMsSUFBSSxXQUViO0lBRUQsTUFBTSxDQUFDLE1BQU0sWUFFWjtJQUVELE1BQU0sQ0FBQyxJQUFJLFlBRVY7SUFFRCxNQUFNLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxPQUFPLFdBRTNCO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksV0FFOUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxXQVM1QjtJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsYUFBYSxDQUFDLEdBQUcsRUFBRSxNQUFNLFdBRS9CO0lBRUQ7O09BRUc7SUFDSCxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRTtRQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQTtLQUFFLFdBRWhEO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsTUFBTSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsRUFBRSxXQUUzQjtJQUVEOzs7Ozs7T0FNRztJQUNILFNBQVMsT0FLUjtJQUVELCtDQUErQztJQUUvQyxHQUFHLENBQUMsR0FBRyxFQUFFLE9BQU8sV0FFZjtJQUVELE1BQU0sWUFFTDtJQUVELE1BQU0sWUFFTDtJQUVELEdBQUcsQ0FBQyxHQUFHLEVBQUUsT0FBTyxXQUVmO0lBRUQsR0FBRyxDQUFDLEdBQUcsRUFBRSxPQUFPLFdBRWY7SUFFRCxHQUFHLENBQUMsR0FBRyxFQUFFLE9BQU8sV0FFZjtJQUVELElBQUksbUJBY0g7SUFFRCxHQUFHLENBQUMsR0FBRyxFQUFFLE1BQU0sV0FFZDtJQUVELE1BQU0sa0JBRUw7SUFFRCxNQUFNLEtBQUssTUFBTSxnREFFaEI7Q0FDRjtBQUtEOzs7R0FHRztBQUNILHFCQUFhLE9BQVEsU0FBUSxVQUFVO0lBQ3JDLE1BQU0sQ0FBQyxhQUFhLFNBQTZCO0lBQ2pELE1BQU0sQ0FBQyxPQUFPLFNBQTZCO0lBQzNDLE1BQU0sQ0FBQyxJQUFJLFVBQW1CO0lBQzlCLE1BQU0sQ0FBQyxHQUFHLFVBQW1CO0lBQzdCLE1BQU0sQ0FBQyxlQUFlLFVBQWtDO0lBRXhELFlBQVksS0FBSyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsTUFBTSxFQUUxQztJQUVELENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQUVmO0lBRUQsU0FBUyxDQUFDLE9BQU8sV0FFaEI7SUFFRCxTQUFTLENBQUMsSUFBSSxXQUViO0lBRUQsTUFBTSxDQUFDLE1BQU0sWUFFWjtJQUVELE1BQU0sQ0FBQyxJQUFJLFlBRVY7SUFFRCxNQUFNLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxPQUFPLFdBRTNCO0lBRUQsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksV0FFOUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxXQVM1QjtJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsYUFBYSxDQUFDLEdBQUcsRUFBRSxNQUFNLFdBRS9CO0lBRUQ7O09BRUc7SUFDSCxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRTtRQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsQ0FBQTtLQUFFLFdBRWhEO0lBRUQsK0NBQStDO0lBRS9DLEdBQUcsQ0FBQyxHQUFHLEVBQUUsT0FBTyxXQUVmO0lBRUQsTUFBTSxZQUVMO0lBRUQsTUFBTSxZQUVMO0lBRUQsR0FBRyxDQUFDLEdBQUcsRUFBRSxPQUFPLFdBRWY7SUFFRCxHQUFHLENBQUMsR0FBRyxFQUFFLE9BQU8sV0FFZjtJQUVELEdBQUcsQ0FBQyxHQUFHLEVBQUUsT0FBTyxXQUVmO0lBRUQsSUFBSSxtQkFjSDtJQUVELEdBQUcsQ0FBQyxHQUFHLEVBQUUsTUFBTSxXQUVkO0lBRUQsTUFBTSxrQkFFTDtJQUVELE1BQU0sS0FBSyxNQUFNLGdEQUVoQjtDQUNGIn0=

package/dest/fields/bls12_fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bls12_fields.d.ts","sourceRoot":"","sources":["../../src/fields/bls12_fields.ts"],"names":[],"mappings":"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"}

package/dest/fields/bls12_fields.js

@@ -0,0 +1,359 @@
+/* eslint-disable camelcase */ import { bls12_381 } from '@noble/curves/bls12-381';
+import { inspect } from 'util';
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { randomBytes } from '../crypto/random/index.js';
+import { hexSchemaFor } from '../schemas/utils.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+import { TypeRegistry } from '../serialize/type_registry.js';
+import { Fr } from './fields.js';
+/**
+ * Base BLS12field class.
+ */ export class BLS12Field {
+    asBuffer;
+    asBigInt;
+    constructor(value){
+        if (Buffer.isBuffer(value)) {
+            if (value.length > this.size()) {
+                throw new Error(`Value length ${value.length} exceeds ${this.size()}`);
+            }
+            this.asBuffer = value.length === this.size() ? value : Buffer.concat([
+                Buffer.alloc(this.size() - value.length),
+                value
+            ]);
+            this.toBigInt();
+        } else if (typeof value === 'bigint' || typeof value === 'number') {
+            this.asBigInt = BigInt(value);
+            if (this.asBigInt >= this.modulus()) {
+                throw new Error(`Value 0x${this.asBigInt.toString(16)} is greater or equal to field modulus.`);
+            }
+            this.toBuffer();
+        } else {
+            throw new Error(`Type '${typeof value}' with value '${value}' passed to BLS12Field constructor.`);
+        }
+    }
+    /**
+   * We return a copy of the Buffer to ensure this remains immutable.
+   */ toBuffer() {
+        if (!this.asBuffer) {
+            this.asBuffer = toBufferBE(this.asBigInt, this.size());
+        }
+        return Buffer.from(this.asBuffer);
+    }
+    toString() {
+        return `0x${this.toBuffer().toString('hex')}`;
+    }
+    toBigInt() {
+        if (this.asBigInt === undefined) {
+            this.asBigInt = toBigIntBE(this.asBuffer);
+            if (this.asBigInt >= this.modulus()) {
+                throw new Error(`Value 0x${this.asBigInt.toString(16)} is greater or equal to field modulus.`);
+            }
+        }
+        return this.asBigInt;
+    }
+    toNoirBigNum() {
+        const buffer = this.toBuffer();
+        const limbs = [];
+        // Split into 120 bit (=15 byte) limbs
+        for(let i = 0; i < Math.ceil(this.size() / 15); i++){
+            limbs.push(buffer.subarray(-(i + 1) * 15, this.size() - i * 15));
+        }
+        return {
+            limbs: limbs.map((l)=>`0x${l.toString('hex')}`)
+        };
+    }
+    equals(rhs) {
+        return this.toBuffer().equals(rhs.toBuffer());
+    }
+    lt(rhs) {
+        return this.toBigInt() < rhs.toBigInt();
+    }
+    isZero() {
+        return this.toBigInt() === 0n;
+    }
+    isEmpty() {
+        return this.isZero();
+    }
+    isNegative() {
+        // Returns whether the field element is above the halfway point of (p-1)/2
+        // Generally referred to as 'negative' but also referred to as 'greater' (e.g. in point compression)
+        return this.toBigInt() > (this.modulus() - 1n) / 2n;
+    }
+    toFriendlyJSON() {
+        return this.toString();
+    }
+    toField() {
+        return this;
+    }
+}
+/**
+ * Constructs a field from a Buffer of BufferReader.
+ * It maybe not read the full SIZE_IN_BYTES bytes if the Buffer is shorter, but it will padded in BLS12Field constructor.
+ */ function fromBuffer(buffer, f) {
+    const reader = BufferReader.asReader(buffer);
+    return new f(reader.readBytes(f.SIZE_IN_BYTES));
+}
+/**
+ * Returns a random field element.
+ */ function random(f) {
+    return new f(toBigIntBE(randomBytes(f.SIZE_IN_BYTES * 2)) % f.MODULUS);
+}
+/**
+ * Constructs a field from a 0x prefixed hex string.
+ */ function fromHexString(str, f) {
+    return new f(bufferFromHexString(str));
+}
+/**
+ * Constructs a field from noir BigNum type.
+ */ function fromNoirBigNum(bignum, f) {
+    // We have 120 bit (=15 byte) limbs
+    let bigint = 0n;
+    for(let i = 0; i < bignum.limbs.length; i++){
+        bigint += BigInt(bignum.limbs[i]) << BigInt(120 * i);
+    }
+    return new f(bigint);
+}
+/**
+ * Constructs a buffer from a hex string.
+ * Differs from bigint-buffer's fromHex() by allowing odd number of characters.
+ */ function bufferFromHexString(str) {
+    const withoutPrefix = str.replace(/^0x/i, '');
+    const checked = withoutPrefix.match(/^[0-9A-F]+$/i)?.[0];
+    if (checked === undefined) {
+        throw new Error(`Invalid hex-encoded string: "${str}"`);
+    }
+    return Buffer.from(checked.length % 2 === 1 ? '0' + checked : checked, 'hex');
+}
+/**
+ * Fr field class.
+ * @dev This class is used to represent elements of BLS12-381 scalar field.
+ */ export class BLS12Fr extends BLS12Field {
+    static SIZE_IN_BYTES = bls12_381.fields.Fr.BYTES;
+    static MODULUS = bls12_381.fields.Fr.ORDER;
+    static ZERO = new BLS12Fr(0n);
+    static ONE = new BLS12Fr(1n);
+    static MAX_FIELD_VALUE = new BLS12Fr(this.MODULUS - 1n);
+    constructor(value){
+        super(value);
+    }
+    [inspect.custom]() {
+        return `BLS12Fr<${this.toString()}>`;
+    }
+    modulus() {
+        return BLS12Fr.MODULUS;
+    }
+    size() {
+        return BLS12Fr.SIZE_IN_BYTES;
+    }
+    static random() {
+        return random(BLS12Fr);
+    }
+    static zero() {
+        return BLS12Fr.ZERO;
+    }
+    static isZero(value) {
+        return value.isZero();
+    }
+    static fromBuffer(buffer) {
+        return fromBuffer(buffer, BLS12Fr);
+    }
+    /**
+   * Creates a BLS12Fr instance from a string.
+   * @param buf - the string to create a BLS12Fr from.
+   * @returns the BLS12Fr instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */ static fromString(buf) {
+        if (buf.match(/^\d+$/) !== null) {
+            return new BLS12Fr(toBufferBE(BigInt(buf), BLS12Fr.SIZE_IN_BYTES));
+        }
+        if (buf.match(/^0x/i) !== null) {
+            return fromHexString(buf, BLS12Fr);
+        }
+        throw new Error(`Tried to create a BLS12Fr from an invalid string: ${buf}`);
+    }
+    /**
+   * Creates a BLS12Fr instance from a hex string.
+   * @param buf - a hex encoded string.
+   * @returns the BLS12Fr instance
+   */ static fromHexString(buf) {
+        return fromHexString(buf, BLS12Fr);
+    }
+    /**
+   * Constructs a field from noir BigNum type.
+   */ static fromNoirBigNum(bignum) {
+        return fromNoirBigNum(bignum, BLS12Fr);
+    }
+    /**
+   * Creates a BLS12Fr instance from a BN254 Fr instance.
+   * @dev The BN254 field size < BLS12_381, so we cannot overflow here.
+   * Useful for blob related calculations.
+   * @param field - a BN254 Fr instance.
+   * @returns the BLS12Fr instance
+   */ static fromBN254Fr(field) {
+        return BLS12Fr.fromBuffer(field.toBuffer());
+    }
+    /**
+   * Creates a BN254 Fr instance from a BLS12Fr instance.
+   * @dev The BN254 field size < BLS12_381, so we must check the size here
+   * Useful for blob related calculations.
+   * @param field - a BLS12Fr instance.
+   * @returns the BN254 Fr instance
+   */ toBN254Fr() {
+        if (this.toBigInt() >= Fr.MODULUS) {
+            throw new Error(`BLS12-381 Fr field ${this} too large to be converted into a BN254 Fr field`);
+        }
+        return Fr.fromBuffer(this.toBuffer());
+    }
+    /** Arithmetic - wrapper around noble curves */ add(rhs) {
+        return new BLS12Fr(bls12_381.fields.Fr.add(this.toBigInt(), rhs.toBigInt()));
+    }
+    square() {
+        return new BLS12Fr(bls12_381.fields.Fr.sqr(this.toBigInt()));
+    }
+    negate() {
+        return new BLS12Fr(bls12_381.fields.Fr.neg(this.toBigInt()));
+    }
+    sub(rhs) {
+        return new BLS12Fr(bls12_381.fields.Fr.sub(this.toBigInt(), rhs.toBigInt()));
+    }
+    mul(rhs) {
+        return new BLS12Fr(bls12_381.fields.Fr.mul(this.toBigInt(), rhs.toBigInt()));
+    }
+    div(rhs) {
+        return new BLS12Fr(bls12_381.fields.Fr.div(this.toBigInt(), rhs.toBigInt()));
+    }
+    sqrt() {
+        // The noble library throws when the field does not have a sqrt.
+        // We would rather have it return null to avoid throwing when (e.g.) checking candidates.
+        let res;
+        try {
+            res = bls12_381.fields.Fr.sqrt(this.toBigInt());
+        } catch (error) {
+            if (error.message.includes('Cannot find square root')) {
+                return null;
+            } else {
+                throw error;
+            }
+        }
+        return new BLS12Fr(res);
+    }
+    pow(rhs) {
+        return new BLS12Fr(bls12_381.fields.Fr.pow(this.toBigInt(), rhs));
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(BLS12Fr);
+    }
+}
+// For deserializing JSON.
+TypeRegistry.register('BLS12Fr', BLS12Fr);
+/**
+ * Fq field class.
+ * @dev This class is used to represent elements of BLS12-381 base field.
+ */ export class BLS12Fq extends BLS12Field {
+    static SIZE_IN_BYTES = bls12_381.fields.Fp.BYTES;
+    static MODULUS = bls12_381.fields.Fp.ORDER;
+    static ZERO = new BLS12Fq(0n);
+    static ONE = new BLS12Fq(1n);
+    static MAX_FIELD_VALUE = new BLS12Fq(this.MODULUS - 1n);
+    constructor(value){
+        super(value);
+    }
+    [inspect.custom]() {
+        return `BLS12Fq<${this.toString()}>`;
+    }
+    modulus() {
+        return BLS12Fq.MODULUS;
+    }
+    size() {
+        return BLS12Fq.SIZE_IN_BYTES;
+    }
+    static random() {
+        return random(BLS12Fq);
+    }
+    static zero() {
+        return BLS12Fq.ZERO;
+    }
+    static isZero(value) {
+        return value.isZero();
+    }
+    static fromBuffer(buffer) {
+        return fromBuffer(buffer, BLS12Fq);
+    }
+    /**
+   * Creates a BLS12Fq instance from a string.
+   * @param buf - the string to create a BLS12Fq from.
+   * @returns the BLS12Fq instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */ static fromString(buf) {
+        if (buf.match(/^\d+$/) !== null) {
+            return new BLS12Fq(toBufferBE(BigInt(buf), BLS12Fq.SIZE_IN_BYTES));
+        }
+        if (buf.match(/^0x/i) !== null) {
+            return fromHexString(buf, BLS12Fq);
+        }
+        throw new Error(`Tried to create a BLS12Fq from an invalid string: ${buf}`);
+    }
+    /**
+   * Creates a BLS12Fq instance from a hex string.
+   * @param buf - a hex encoded string.
+   * @returns the BLS12Fq instance
+   */ static fromHexString(buf) {
+        return fromHexString(buf, BLS12Fq);
+    }
+    /**
+   * Constructs a field from noir BigNum type.
+   */ static fromNoirBigNum(bignum) {
+        return fromNoirBigNum(bignum, BLS12Fq);
+    }
+    /** Arithmetic - wrapper around noble curves */ add(rhs) {
+        return new BLS12Fq(bls12_381.fields.Fp.add(this.toBigInt(), rhs.toBigInt()));
+    }
+    square() {
+        return new BLS12Fq(bls12_381.fields.Fp.sqr(this.toBigInt()));
+    }
+    negate() {
+        return new BLS12Fq(bls12_381.fields.Fp.neg(this.toBigInt()));
+    }
+    sub(rhs) {
+        return new BLS12Fq(bls12_381.fields.Fp.sub(this.toBigInt(), rhs.toBigInt()));
+    }
+    mul(rhs) {
+        return new BLS12Fq(bls12_381.fields.Fp.mul(this.toBigInt(), rhs.toBigInt()));
+    }
+    div(rhs) {
+        return new BLS12Fq(bls12_381.fields.Fp.div(this.toBigInt(), rhs.toBigInt()));
+    }
+    sqrt() {
+        // The noble library throws when the field does not have a sqrt.
+        // We would rather have it return null to avoid throwing when (e.g.) checking candidates.
+        let res;
+        try {
+            res = bls12_381.fields.Fp.sqrt(this.toBigInt());
+        } catch (error) {
+            if (error.message.includes('Cannot find square root')) {
+                return null;
+            } else {
+                throw error;
+            }
+        }
+        return new BLS12Fq(res);
+    }
+    pow(rhs) {
+        return new BLS12Fq(bls12_381.fields.Fp.pow(this.toBigInt(), rhs));
+    }
+    toJSON() {
+        return this.toString();
+    }
+    static get schema() {
+        return hexSchemaFor(BLS12Fq);
+    }
+}
+// For deserializing JSON.
+TypeRegistry.register('BLS12Fq', BLS12Fq);