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

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);

package/dest/fields/bls12_point.d.ts

@@ -0,0 +1,229 @@
+import type { ProjPointType } from '@noble/curves/abstract/weierstrass';
+import { inspect } from 'util';
+import { BufferReader } from '../serialize/index.js';
+import { BLS12Fq, BLS12Fr } from './bls12_fields.js';
+import { Fr } from './fields.js';
+/**
+ * Represents a Point on an elliptic curve with x and y coordinates.
+ * The Point class provides methods for creating instances from different input types,
+ * converting instances to various output formats, and checking the equality of points.
+ * TODO(#7386): Clean up this class.
+ */
+export declare class BLS12Point {
+    /**
+     * The point's x coordinate
+     */
+    readonly x: BLS12Fq;
+    /**
+     * The point's y coordinate
+     */
+    readonly y: BLS12Fq;
+    /**
+     * Whether the point is at infinity
+     */
+    readonly isInfinite: boolean;
+    static ZERO: BLS12Point;
+    static ONE: BLS12Point;
+    static SIZE_IN_BYTES: number;
+    static COMPRESSED_SIZE_IN_BYTES: number;
+    static COMPRESSED_ZERO: Buffer<ArrayBufferLike>;
+    constructor(
+    /**
+     * The point's x coordinate
+     */
+    x: BLS12Fq, 
+    /**
+     * The point's y coordinate
+     */
+    y: BLS12Fq, 
+    /**
+     * Whether the point is at infinity
+     */
+    isInfinite: boolean);
+    toJSON(): `0x${string}`;
+    [inspect.custom](): string;
+    static get schema(): import("zod").ZodType<BLS12Point, any, string>;
+    /**
+     * Generate a random Point instance.
+     *
+     * @returns A randomly generated Point instance.
+     */
+    static random(): BLS12Point;
+    /**
+     * Create a Point instance from a given buffer or BufferReader.
+     * The input 'buffer' should have exactly 96 bytes representing the x and y coordinates.
+     *
+     * @param buffer - The buffer or BufferReader containing the x and y coordinates of the point.
+     * @returns A Point instance.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): BLS12Point;
+    /**
+     * Create a Point instance from a hex-encoded string.
+     * The input should be prefixed with '0x' or not, and have exactly 128 hex characters representing the x and y coordinates.
+     * Throws an error if the input length is invalid or coordinate values are out of range.
+     *
+     * @param str - The hex-encoded string representing the Point coordinates.
+     * @returns A Point instance.
+     */
+    static fromString(str: string): BLS12Point;
+    /**
+     * Create a compressed buffer instance from a point.
+     * @dev NOTE: The compression standard for BLS12-381 differs from BN curves. Instead of
+     * one is_positive flag, we have three flags to prepend:
+     * - is_compressed: indicator that the point is compressed
+     * - is_infinity: whether the point the point at infinity
+     * - is_greater: only set if is_compressed && !is_infinity && y > (p - 1)/2
+     * See https://github.com/arkworks-rs/algebra/blob/master/curves/bls12_381/src/curves/g1.rs -> serialize_with_mode() -> encoding
+     * and noble-curves/src/bls12-381.ts -> setMask()
+     * @dev Most of the logic below is taken from noble-curves/src/bls12-381.ts -> toBytes()
+     * @param point A BLS12Point instance.
+     * @returns The buffer containing the x coordinate and the flags of the y coordinate.
+     */
+    compress(): Buffer;
+    /**
+     * Create a Point instance from a compressed buffer.
+     * @dev See compress() above for compression encoding for BLS12-381.
+     * @dev Most of the logic below is taken from noble-curves/src/bls12-381.ts -> fromBytes()
+     * @param buffer - The buffer containing the x coordinate and the flags of the y coordinate.
+     * @returns A BLS12Point instance.
+     */
+    static decompress(buffer: Buffer): BLS12Point;
+    /**
+     * Converts a Point to two BN254 Fr elements by storing its compressed form (48 bytes) as:
+     * +-------------------+------------------------+
+     * |      31 bytes     |         17 bytes       |
+     * +-------------------+------------------------+
+     * |  Field Element 1  |     Field Element 2    |
+     * |  [0][bytes 0-30]  |  [0...0][bytes 31-47]  |
+     * +-------------------+------------------------+
+     * Used in the rollup circuits to store blob commitments in the native field type. See blob.ts.
+     * @param point - A BLS12Point instance.
+     * @returns The point fields.
+     */
+    toBN254Fields(): Fr[];
+    /**
+     * Creates a Point instance from 2 BN254 Fr fields as encoded in toBNFields() above.
+     * Used in the rollup circuits to store blob commitments in the native field type. See blob.ts.
+     * @param fields - The encoded BN254 fields.
+     * @returns The point fields.
+     */
+    static fromBN254Fields(fields: [Fr, Fr]): BLS12Point;
+    /**
+     * Creates a point from an array of 2 fields.
+     * @returns The point
+     */
+    static fromBLS12FqFields(fields: BLS12Fq[]): BLS12Point;
+    /**
+     * Creates a point from @noble/curves projective point definition.
+     * @returns The point
+     */
+    static fromNobleProjectivePoint(point: ProjPointType<bigint>): BLS12Point;
+    /**
+     * Uses the x coordinate and isPositive flag (+/-) to reconstruct the point.
+     * @param x - The x coordinate of the point
+     * @param sign - The "sign" of the y coordinate - note that this is not a sign as is known in integer arithmetic.
+     * Instead it is a boolean flag that determines whether the y coordinate is <= (Fr.MODULUS - 1) / 2
+     * @returns The point as an array of 2 fields
+     */
+    static fromXAndSign(x: BLS12Fq, sign: boolean): BLS12Point;
+    /**
+     * @param x - The x coordinate of the point
+     * @returns y^2 such that y^2 = x^3 + 4
+     */
+    static YSquaredFromX(x: BLS12Fq): BLS12Fq;
+    /**
+     * @param x - The x coordinate of the point
+     * @returns The y coordinate of the point, if it exists on BLS12-381
+     */
+    static YFromX(x: BLS12Fq): BLS12Fq | null;
+    /**
+     * @param x - The x coordinate of the point
+     * @param y - The y coordinate of the point
+     * @returns Whether the point exists on BLS12-381
+     */
+    static isOnCurve(x: BLS12Fq, y: BLS12Fq): boolean;
+    /**
+     * Returns the contents of the point as an array of 2 fields.
+     * @returns The point as an array of 2 fields
+     */
+    toBLS12FqFields(): BLS12Fq[];
+    /**
+     * Returns the x coordinate and the sign of the y coordinate.
+     * @dev The y sign can be determined by checking if the y coordinate is greater than half of the modulus.
+     * @returns The x coordinate and the sign of the y coordinate.
+     */
+    toXAndSign(): [BLS12Fq, boolean];
+    /**
+     * Returns the contents of the point as BigInts.
+     * @returns The point as BigInts
+     */
+    toBigInts(): {
+        x: bigint;
+        y: bigint;
+        isInfinite: bigint;
+    };
+    /**
+     * Converts the Point instance to a Buffer representation of the coordinates.
+     * @returns A Buffer representation of the Point instance.
+     * @dev Note that toBuffer does not include the isInfinite flag and other serialization methods do (e.g. toBigInts).
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Convert the Point instance to a hexadecimal string representation.
+     * The output string is prefixed with '0x' and consists of exactly 128 hex characters,
+     * representing the concatenated x and y coordinates of the point.
+     *
+     * @returns A hex-encoded string representing the Point instance.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Check if two Point instances are equal by comparing their buffer values.
+     * Returns true if the buffer values are the same, and false otherwise.
+     *
+     * @param rhs - The Point instance to compare with the current instance.
+     * @returns A boolean indicating whether the two Point instances are equal.
+     */
+    equals(rhs: BLS12Point): boolean;
+    /**
+     * Check whether the point is zero.
+     */
+    isZero(): boolean;
+    /**
+     * Check if this is point at infinity.
+     * Check this is consistent with how bb is encoding the point at infinity
+     */
+    get inf(): boolean;
+    /** Arithmetic - wrapper around noble curves */
+    toNobleProjectivePoint(): ProjPointType<bigint>;
+    add(rhs: BLS12Point): BLS12Point;
+    negate(): BLS12Point;
+    sub(rhs: BLS12Point): BLS12Point;
+    /**
+     * @dev From noble curves package:
+     * Constant time multiplication. Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available, uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    mul(rhs: BLS12Fr): BLS12Point;
+    /**
+     * @dev From noble curves package:
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about an exposed private key e.g. sig verification, which works over *public* keys.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    mulUnsafe(rhs: BLS12Fr): BLS12Point;
+    /**
+     * @dev From noble curves package:
+     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
+     * Not using Strauss-Shamir trick: precomputation tables are faster. The trick could be useful if both P and Q are not G (not in our case).
+     * @returns affine point
+     */
+    mulAndAddUnsafe(a: BLS12Fr, b: BLS12Fr, Q: BLS12Point): BLS12Point;
+}
+export declare class BLSPointNotOnCurveError extends Error {
+    constructor(x: BLS12Fq, y?: BLS12Fq);
+}
+//# sourceMappingURL=bls12_point.d.ts.map

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

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