@aztec/foundation 0.7.2 → 0.7.4

package/dest/eth-address/index.js

@@ -0,0 +1,228 @@
+import { keccak256String, randomBytes } from '../crypto/index.js';
+import { Fr } from '../fields/index.js';
+import { BufferReader } from '../serialize/index.js';
+/**
+ * Represents an Ethereum address as a 20-byte buffer and provides various utility methods
+ * for converting between different representations, generating random addresses, validating
+ * checksums, and comparing addresses. EthAddress can be instantiated using a buffer or string,
+ * and can be serialized/deserialized from a buffer or BufferReader.
+ */
+export class EthAddress {
+    constructor(buffer) {
+        this.buffer = buffer;
+        if (buffer.length === 32) {
+            if (!buffer.slice(0, 12).equals(Buffer.alloc(12))) {
+                throw new Error(`Invalid address buffer: ${buffer.toString('hex')}`);
+            }
+            else {
+                this.buffer = buffer.slice(12);
+            }
+        }
+        else if (buffer.length !== EthAddress.SIZE_IN_BYTES) {
+            throw new Error(`Expect buffer size to be ${EthAddress.SIZE_IN_BYTES}. Got ${buffer.length}.`);
+        }
+    }
+    /**
+     * Creates an EthAddress instance from a valid Ethereum address string.
+     * The input 'address' can be either in checksum format or lowercase, and it can be prefixed with '0x'.
+     * Throws an error if the input is not a valid Ethereum address.
+     *
+     * @param address - The string representing the Ethereum address.
+     * @returns An EthAddress instance.
+     */
+    static fromString(address) {
+        if (!EthAddress.isAddress(address)) {
+            throw new Error(`Invalid address string: ${address}`);
+        }
+        return new EthAddress(Buffer.from(address.replace(/^0x/i, ''), 'hex'));
+    }
+    /**
+     * Create a random EthAddress instance with 20 random bytes.
+     * This method generates a new Ethereum address with a randomly generated set of 20 bytes.
+     * It is useful for generating test addresses or unique identifiers.
+     *
+     * @returns A randomly generated EthAddress instance.
+     */
+    static random() {
+        return new EthAddress(randomBytes(20));
+    }
+    /**
+     * Determines if the given string represents a valid Ethereum address.
+     * A valid address should meet the following criteria:
+     * 1. Contains exactly 40 hex characters (excluding an optional '0x' prefix).
+     * 2. Is either all lowercase, all uppercase, or has a valid checksum based on EIP-55.
+     *
+     * @param address - The string to be checked for validity as an Ethereum address.
+     * @returns True if the input string represents a valid Ethereum address, false otherwise.
+     */
+    static isAddress(address) {
+        if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+            // Does not have the basic requirements of an address.
+            return false;
+        }
+        else if (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)) {
+            // It's ALL lowercase or ALL upppercase.
+            return true;
+        }
+        else {
+            return EthAddress.checkAddressChecksum(address);
+        }
+    }
+    /**
+     * Checks if the EthAddress instance represents a zero address.
+     * A zero address consists of 20 bytes filled with zeros and is considered an invalid address.
+     *
+     * @returns A boolean indicating whether the EthAddress instance is a zero address or not.
+     */
+    isZero() {
+        return this.equals(EthAddress.ZERO);
+    }
+    /**
+     * Checks if the given Ethereum address has a valid checksum.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+     * Returns true if the address has a valid checksum, false otherwise.
+     *
+     * @param address - The hex-encoded string representing the Ethereum address.
+     * @returns A boolean value indicating whether the address has a valid checksum.
+     */
+    static checkAddressChecksum(address) {
+        address = address.replace(/^0x/i, '');
+        const addressHash = keccak256String(address.toLowerCase());
+        for (let i = 0; i < 40; i++) {
+            // The nth letter should be uppercase if the nth digit of casemap is 1.
+            if ((parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) ||
+                (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Converts an Ethereum address to its checksum format.
+     * The input 'address' should be prefixed with '0x' or not, and have exactly 40 hex characters.
+     * The checksum format is created by capitalizing certain characters in the hex string
+     * based on the hash of the lowercase address.
+     * Throws an error if the input address is invalid.
+     *
+     * @param address - The Ethereum address as a hex-encoded string.
+     * @returns The Ethereum address in its checksum format.
+     */
+    static toChecksumAddress(address) {
+        if (!EthAddress.isAddress(address)) {
+            throw new Error('Invalid address string.');
+        }
+        address = address.toLowerCase().replace(/^0x/i, '');
+        const addressHash = keccak256String(address);
+        let checksumAddress = '0x';
+        for (let i = 0; i < address.length; i++) {
+            // If ith character is 9 to f then make it uppercase.
+            if (parseInt(addressHash[i], 16) > 7) {
+                checksumAddress += address[i].toUpperCase();
+            }
+            else {
+                checksumAddress += address[i];
+            }
+        }
+        return checksumAddress;
+    }
+    /**
+     * Checks whether the given EthAddress instance is equal to the current instance.
+     * Equality is determined by comparing the underlying byte buffers of both instances.
+     *
+     * @param rhs - The EthAddress instance to compare with the current instance.
+     * @returns A boolean value indicating whether the two instances are equal (true) or not (false).
+     */
+    equals(rhs) {
+        return this.buffer.equals(rhs.buffer);
+    }
+    /**
+     * Converts the Ethereum address to a hex-encoded string.
+     * The resulting string is prefixed with '0x' and has exactly 40 hex characters.
+     * This method can be used to represent the EthAddress instance in the widely used hexadecimal format.
+     *
+     * @returns A hex-encoded string representation of the Ethereum address.
+     */
+    toString() {
+        return `0x${this.buffer.toString('hex')}`;
+    }
+    /**
+     * Returns the Ethereum address as a checksummed string.
+     * The output string will have characters in the correct upper or lowercase form, according to EIP-55.
+     * This provides a way to verify if an address is typed correctly, by checking the character casing.
+     *
+     * @returns A checksummed Ethereum address string.
+     */
+    toChecksumString() {
+        return EthAddress.toChecksumAddress(this.buffer.toString('hex'));
+    }
+    /**
+     * Alias for toBuffer32.
+     * @returns A 32-byte Buffer containing the padded Ethereum address.
+     */
+    toBuffer() {
+        return this.toBuffer32();
+    }
+    /**
+     * Returns the internal Buffer representation of the Ethereum address.
+     * This method is useful when working with raw binary data or when
+     * integrating with other modules that require a Buffer as input.
+     *
+     * @returns A Buffer instance containing the 20-byte Ethereum address.
+     */
+    toBuffer20() {
+        return this.buffer;
+    }
+    /**
+     * Returns a 32-byte buffer representation of the Ethereum address, with the original 20-byte address
+     * occupying the last 20 bytes and the first 12 bytes being zero-filled.
+     * This format is commonly used in smart contracts when handling addresses as 32-byte values.
+     *
+     * @returns A 32-byte Buffer containing the padded Ethereum address.
+     */
+    toBuffer32() {
+        const buffer = Buffer.alloc(32);
+        this.buffer.copy(buffer, 12);
+        return buffer;
+    }
+    /**
+     * Returns a new field with the same contents as this EthAddress.
+     *
+     * @returns An Fr instance.
+     */
+    toField() {
+        return Fr.fromBuffer(this.toBuffer32());
+    }
+    /**
+     * Converts a field to a eth address.
+     * @param fr - The field to convert.
+     * @returns The eth address.
+     */
+    static fromField(fr) {
+        return new EthAddress(fr.toBuffer().slice(-EthAddress.SIZE_IN_BYTES));
+    }
+    /**
+     * Deserializes from a buffer or reader, corresponding to a write in cpp.
+     * @param buffer - Buffer to read from.
+     * @returns The EthAdress.
+     */
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new EthAddress(reader.readBuffer());
+    }
+    /**
+     * Friendly representation for debugging purposes.
+     * @returns A hex string representing the address.
+     */
+    toFriendlyJSON() {
+        return this.toString();
+    }
+}
+/**
+ * The size of an Ethereum address in bytes.
+ */
+EthAddress.SIZE_IN_BYTES = 20;
+/**
+ * Represents a zero Ethereum address with 20 bytes filled with zeros.
+ */
+EthAddress.ZERO = new EthAddress(Buffer.alloc(EthAddress.SIZE_IN_BYTES));
+//# sourceMappingURL=data:application/json;base64,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

package/dest/fields/coordinate.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Tuple } from '../serialize/types.js';
+import { Fr } from './fields.js';
+/**
+ * Class to wrap a single point coordinate.
+ * This class handles the complexities of representing point coordinates as 32 byte buffers as well as fields.
+ * The coordinate value is split across 2 fields to ensure that the max size of a field is not breached.
+ * This is achieved by placing the most significant byte of the lower field into the least significant byte of the higher field.
+ * Calls to 'toBuffer' or 'toBigInt' undo this change and simply return the original 32 byte value.
+ * Calls to 'toFieldsBuffer' will return a 64 bytes buffer containing the serialised fields.
+ */
+export declare class Coordinate {
+    /**
+     * The fields of the coordinate value. Least significant limb at index 0.
+     */
+    fields: Tuple<Fr, 2>;
+    static ZERO: Coordinate;
+    constructor(
+    /**
+     * The fields of the coordinate value. Least significant limb at index 0.
+     */
+    fields: Tuple<Fr, 2>);
+    /**
+     * Converts the coordinate data into a tuple of fields
+     * @returns A tuple of the coordinate fields
+     */
+    toFields(): Tuple<Fr, 2>;
+    /**
+     * Generates a random coordinate value
+     * @returns The random coordinate
+     */
+    static random(): Coordinate;
+    /**
+     * Serialises the oblect to buffer of 2 fields.
+     * @returns A buffer serialisation of the object.
+     */
+    toFieldsBuffer(): Buffer;
+    /**
+     * Serialises the coordinate to a single 32 byte buffer.
+     * @returns A buffer serialisation of the object.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Returns true if this coordinate is equal to the one provided
+     * @param other - The coordinate against which to compare
+     * @returns True if the coordinates are the same, false otherwise
+     */
+    equals(other: Coordinate): boolean;
+    /**
+     * Returns the coordinate's value as a bigint
+     * @returns The coordinate value as a bigint
+     */
+    toBigInt(): bigint;
+    /**
+     * Creates a coordinate object from a 32 byte coordinate value
+     * @param coordinate - A buffer containing the 32 byte coordinate value
+     * @returns The new coordinate object
+     */
+    static fromBuffer(coordinate: Buffer): Coordinate;
+    /**
+     * Creates a coordinate object from a field
+     * @param coordinate - The field containing the coordinate
+     * @returns The new coordinate object
+     */
+    static fromField(coordinate: Fr): Coordinate;
+}
+//# sourceMappingURL=coordinate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coordinate.d.ts","sourceRoot":"","sources":["../../src/fields/coordinate.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEjC;;;;;;;GAOG;AACH,qBAAa,UAAU;IAInB;;OAEG;IACI,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAN7B,MAAM,CAAC,IAAI,aAAsC;;IAG/C;;OAEG;IACI,MAAM,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAG7B;;;OAGG;IACH,QAAQ,IAAI,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;IAIxB;;;OAGG;IACH,MAAM,CAAC,MAAM,IAAI,UAAU;IAI3B;;;OAGG;IACH,cAAc,IAAI,MAAM;IAIxB;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAOlB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IAIlC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,UAAU,EAAE,MAAM;IAYpC;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,UAAU,EAAE,EAAE;CAOhC"}

package/dest/fields/coordinate.js

@@ -0,0 +1,95 @@
+import { toBigIntBE } from '../bigint-buffer/index.js';
+import { Fr } from './fields.js';
+/**
+ * Class to wrap a single point coordinate.
+ * This class handles the complexities of representing point coordinates as 32 byte buffers as well as fields.
+ * The coordinate value is split across 2 fields to ensure that the max size of a field is not breached.
+ * This is achieved by placing the most significant byte of the lower field into the least significant byte of the higher field.
+ * Calls to 'toBuffer' or 'toBigInt' undo this change and simply return the original 32 byte value.
+ * Calls to 'toFieldsBuffer' will return a 64 bytes buffer containing the serialised fields.
+ */
+export class Coordinate {
+    constructor(
+    /**
+     * The fields of the coordinate value. Least significant limb at index 0.
+     */
+    fields) {
+        this.fields = fields;
+    }
+    /**
+     * Converts the coordinate data into a tuple of fields
+     * @returns A tuple of the coordinate fields
+     */
+    toFields() {
+        return this.fields;
+    }
+    /**
+     * Generates a random coordinate value
+     * @returns The random coordinate
+     */
+    static random() {
+        return this.fromField(Fr.random());
+    }
+    /**
+     * Serialises the oblect to buffer of 2 fields.
+     * @returns A buffer serialisation of the object.
+     */
+    toFieldsBuffer() {
+        return Buffer.concat([this.fields[0].toBuffer(), this.fields[1].toBuffer()]);
+    }
+    /**
+     * Serialises the coordinate to a single 32 byte buffer.
+     * @returns A buffer serialisation of the object.
+     */
+    toBuffer() {
+        const buf0 = this.fields[0].toBuffer();
+        const buf1 = this.fields[1].toBuffer();
+        buf0[0] = buf1[31];
+        return buf0;
+    }
+    /**
+     * Returns true if this coordinate is equal to the one provided
+     * @param other - The coordinate against which to compare
+     * @returns True if the coordinates are the same, false otherwise
+     */
+    equals(other) {
+        return this.toBigInt() === other.toBigInt();
+    }
+    /**
+     * Returns the coordinate's value as a bigint
+     * @returns The coordinate value as a bigint
+     */
+    toBigInt() {
+        return toBigIntBE(this.toBuffer());
+    }
+    /**
+     * Creates a coordinate object from a 32 byte coordinate value
+     * @param coordinate - A buffer containing the 32 byte coordinate value
+     * @returns The new coordinate object
+     */
+    static fromBuffer(coordinate) {
+        if (coordinate.length != 32) {
+            throw new Error(`Invalid size of coordinate buffer`);
+        }
+        const buf0 = Buffer.alloc(32);
+        coordinate.copy(buf0, 0, 0, 32);
+        const buf1 = Buffer.alloc(32);
+        buf1[31] = buf0[0];
+        buf0[0] = 0;
+        return new Coordinate([Fr.fromBuffer(buf0), Fr.fromBuffer(buf1)]);
+    }
+    /**
+     * Creates a coordinate object from a field
+     * @param coordinate - The field containing the coordinate
+     * @returns The new coordinate object
+     */
+    static fromField(coordinate) {
+        const buf0 = coordinate.toBuffer();
+        const buf1 = Buffer.alloc(32);
+        buf1[31] = buf0[0];
+        buf0[0] = 0;
+        return new Coordinate([Fr.fromBuffer(buf0), Fr.fromBuffer(buf1)]);
+    }
+}
+Coordinate.ZERO = new Coordinate([Fr.ZERO, Fr.ZERO]);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29vcmRpbmF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9maWVsZHMvY29vcmRpbmF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFdkQsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUVqQzs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxPQUFPLFVBQVU7SUFHckI7SUFDRTs7T0FFRztJQUNJLE1BQW9CO1FBQXBCLFdBQU0sR0FBTixNQUFNLENBQWM7SUFDMUIsQ0FBQztJQUVKOzs7T0FHRztJQUNILFFBQVE7UUFDTixPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDckIsQ0FBQztJQUVEOzs7T0FHRztJQUNILE1BQU0sQ0FBQyxNQUFNO1FBQ1gsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ3JDLENBQUM7SUFFRDs7O09BR0c7SUFDSCxjQUFjO1FBQ1osT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUMvRSxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsUUFBUTtRQUNOLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDdkMsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN2QyxJQUFJLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ25CLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsS0FBaUI7UUFDdEIsT0FBTyxJQUFJLENBQUMsUUFBUSxFQUFFLEtBQUssS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzlDLENBQUM7SUFFRDs7O09BR0c7SUFDSCxRQUFRO1FBQ04sT0FBTyxVQUFVLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDckMsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLFVBQWtCO1FBQ2xDLElBQUksVUFBVSxDQUFDLE1BQU0sSUFBSSxFQUFFLEVBQUU7WUFDM0IsTUFBTSxJQUFJLEtBQUssQ0FBQyxtQ0FBbUMsQ0FBQyxDQUFDO1NBQ3REO1FBQ0QsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM5QixVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ2hDLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDOUIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNuQixJQUFJLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ1osT0FBTyxJQUFJLFVBQVUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDcEUsQ0FBQztJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsU0FBUyxDQUFDLFVBQWM7UUFDN0IsTUFBTSxJQUFJLEdBQUcsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ25DLE1BQU0sSUFBSSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDOUIsSUFBSSxDQUFDLEVBQUUsQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNuQixJQUFJLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ1osT0FBTyxJQUFJLFVBQVUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDcEUsQ0FBQzs7QUF6Rk0sZUFBSSxHQUFHLElBQUksVUFBVSxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyJ9

package/dest/fields/coordinate.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=coordinate.test.d.ts.map

package/dest/fields/coordinate.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinate.test.d.ts","sourceRoot":"","sources":["../../src/fields/coordinate.test.ts"],"names":[],"mappings":""}

package/dest/fields/coordinate.test.js

@@ -0,0 +1,22 @@
+import { toBufferBE } from '../bigint-buffer/index.js';
+import { Coordinate } from './coordinate.js';
+import { Fr } from './fields.js';
+const MAX_256_VALUE = 2n ** 256n - 1n;
+describe('coordinate', () => {
+    it('stores 256 bits in fields', () => {
+        const max256Value = toBufferBE(MAX_256_VALUE, 32);
+        const coordinate = Coordinate.fromBuffer(max256Value);
+        // this returns a buffer containing the bit pattern split across 2 fields
+        expect(coordinate.toFieldsBuffer()).toEqual(Buffer.concat([Buffer.alloc(1, 0), Buffer.alloc(31, 0xff), Buffer.alloc(31, 0), Buffer.alloc(1, 0xff)]));
+        // this returns the value in a single 32 byte buffer
+        expect(coordinate.toBuffer()).toEqual(max256Value);
+        // this returns the value as a big int
+        expect(coordinate.toBigInt()).toBe(MAX_256_VALUE);
+    });
+    it('can be constructed from a field', () => {
+        const field = Fr.random();
+        const coordinate = Coordinate.fromField(field);
+        expect(coordinate.toBuffer()).toEqual(field.toBuffer());
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29vcmRpbmF0ZS50ZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ZpZWxkcy9jb29yZGluYXRlLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRWpDLE1BQU0sYUFBYSxHQUFHLEVBQUUsSUFBSSxJQUFJLEdBQUcsRUFBRSxDQUFDO0FBRXRDLFFBQVEsQ0FBQyxZQUFZLEVBQUUsR0FBRyxFQUFFO0lBQzFCLEVBQUUsQ0FBQywyQkFBMkIsRUFBRSxHQUFHLEVBQUU7UUFDbkMsTUFBTSxXQUFXLEdBQUcsVUFBVSxDQUFDLGFBQWEsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNsRCxNQUFNLFVBQVUsR0FBRyxVQUFVLENBQUMsVUFBVSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3RELHlFQUF5RTtRQUN6RSxNQUFNLENBQUMsVUFBVSxDQUFDLGNBQWMsRUFBRSxDQUFDLENBQUMsT0FBTyxDQUN6QyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLEVBQUUsSUFBSSxDQUFDLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUN4RyxDQUFDO1FBQ0Ysb0RBQW9EO1FBQ3BELE1BQU0sQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDbkQsc0NBQXNDO1FBQ3RDLE1BQU0sQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDcEQsQ0FBQyxDQUFDLENBQUM7SUFFSCxFQUFFLENBQUMsaUNBQWlDLEVBQUUsR0FBRyxFQUFFO1FBQ3pDLE1BQU0sS0FBSyxHQUFHLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUMxQixNQUFNLFVBQVUsR0FBRyxVQUFVLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQy9DLE1BQU0sQ0FBQyxVQUFVLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDMUQsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMsQ0FBQyJ9

package/dest/fields/fields.d.ts

@@ -0,0 +1,177 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AztecAddress } from '../aztec-address/index.js';
+import { BufferReader } from '../serialize/buffer_reader.js';
+/**
+ * Fr represents a field of integers modulo the prime number MODULUS.
+ * It provides utility functions to work with elements in this field, such as conversions between different representations and checks for equality and zero values. The elements can be serialized to and deserialized from byte buffers or strings.
+ * Some use cases include working with cryptographic operations and finite fields.
+ */
+export declare class Fr {
+    static ZERO: Fr;
+    static MODULUS: bigint;
+    static MAX_VALUE: bigint;
+    static SIZE_IN_BYTES: number;
+    /**
+     * The numeric value of the field element as a bigint.
+     */
+    readonly value: bigint;
+    constructor(value: bigint | number | Fr | AztecAddress);
+    /**
+     * Generates a random Fr or Fq instance with a value modulo the respective class' MODULUS.
+     * This method uses randomBytes to generate a random 32-byte buffer, converts it to a bigint
+     * and takes the modulus of the result with the class' MODULUS constant.
+     *
+     * @returns A new Fr or Fq instance with a random value.
+     */
+    static random(): Fr;
+    /**
+     * Returns a new zero-value field.
+     * @returns A new zero-value field.
+     */
+    static zero(): Fr;
+    /**
+     * Create an instance of the corresponding class (Fr or Fq) from a Buffer or a BufferReader.
+     * Reads 'SIZE_IN_BYTES' bytes from the given Buffer or BufferReader and constructs an instance with the decoded value.
+     * If the input is a Buffer, it is internally converted to a BufferReader before reading.
+     * Throws an error if the input length is invalid or the decoded value is out of range.
+     *
+     * @param buffer - The Buffer or BufferReader containing the bytes representing the value.
+     * @returns An instance of the corresponding class (Fr or Fq) with the decoded value.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): Fr;
+    /**
+     * Create a Fr instance from a hex-encoded string.
+     * The input 'address' can be either prefixed with '0x' or not, and should have exactly 64 hex characters.
+     * Throws an error if the input length is invalid or the address value is out of range.
+     *
+     * @param address - The hex-encoded string representing the field element.
+     * @returns A Fr instance.
+     */
+    static fromString(address: string): Fr;
+    /**
+     * Converts the value of the instance to a buffer with a specified length.
+     * The method uses the provided value and size in bytes to create a buffer representation
+     * of the numeric value. This can be useful for serialization and communication purposes.
+     *
+     * @returns A buffer representing the instance's value.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the value of the Fr or Fq class instance to a hexadecimal string.
+     * The resulting string is prefixed with '0x' and represents the bigint value
+     * in base 16.
+     *
+     * @param padTo32 - Whether to pad the string to 32 bytes.
+     * @returns A hex-encoded string representing the value of the class instance.
+     */
+    toString(padTo32?: boolean): `0x${string}`;
+    /**
+     * Retrieves the underlying bigint.
+     * This method mostly exists to match user expectations, as value is already public.
+     * @returns The underlying bigint.
+     */
+    toBigInt(): bigint;
+    /**
+     * Returns a shortened string representation of the Fr value, formatted with '0x' prefix and ellipsis in the middle.
+     * The resulting string has first 10 characters (including '0x') and last 4 characters of the full hexadecimal value.
+     *
+     * @returns A shorter, human-readable string representation of the Fr value.
+     */
+    toShortString(): string;
+    /**
+     * Checks if the provided Fr instance is equal to the current instance.
+     * Two instances are considered equal if their 'value' properties are the same.
+     *
+     * @param rhs - The Fr instance to compare with the current instance.
+     * @returns A boolean indicating whether the two instances are equal.
+     */
+    equals(rhs: Fr): boolean;
+    /**
+     * Check if the instance value is zero.
+     * The method returns true if the value of the instance is 0n (zero in BigInt representation),
+     * otherwise, it returns false.
+     *
+     * @returns A boolean indicating whether the instance value is zero or not.
+     */
+    isZero(): boolean;
+    /**
+     * Converts the current value of the Fq or Fr instance to a friendly JSON representation.
+     * The output will be a hexadecimal string prefixed with '0x'.
+     *
+     * @returns A '0x' prefixed hexadecimal string representing the current value.
+     */
+    toFriendlyJSON(): `0x${string}`;
+}
+/**
+ * Fq represents a field element in a prime finite field with modulus defined by the constant MODULUS.
+ * It provides methods for creating, manipulating, and comparing field elements, as well as converting
+ * them to/from different data types like Buffers and hex strings. Field elements are used in various
+ * cryptographic protocols and operations, such as elliptic curve cryptography.
+ *
+ * @example
+ * const fqElem = new Fq(BigInt("123456789"));
+ * const randomFqElem = Fq.random();
+ * const fromBufferFqElem = Fq.fromBuffer(buffer);
+ */
+export declare class Fq {
+    /**
+     * The element's value as a bigint in the finite field.
+     */
+    readonly value: bigint;
+    static MODULUS: bigint;
+    static MAX_VALUE: bigint;
+    static SIZE_IN_BYTES: number;
+    constructor(
+    /**
+     * The element's value as a bigint in the finite field.
+     */
+    value: bigint);
+    /**
+     * Generates a random Fr or Fq instance with a value within the range of their respective modulus.
+     * The random value is generated from a byte array of length equal to SIZE_IN_BYTES, then truncated
+     * to the appropriate modulus before creating the new Fr or Fq instance.
+     *
+     * @returns A new Fr or Fq instance with a randomly generated value.
+     */
+    static random(): Fq;
+    /**
+     * Create an instance of the calling class (Fr or Fq) from a given buffer or BufferReader.
+     * Reads SIZE_IN_BYTES from the provided buffer and converts it to a bigint, then creates a new instance
+     * with that value. Throws an error if the value is out of range for the calling class.
+     *
+     * @param buffer - The input buffer or BufferReader containing the bytes representing the value.
+     * @returns An instance of the calling class (Fr or Fq) initialized with the bigint value.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): Fq;
+    /**
+     * Converts the bigint value of the instance to a Buffer representation.
+     * The output buffer has a fixed size, determined by the 'SIZE_IN_BYTES' constant.
+     *
+     * @returns A Buffer containing the byte representation of the instance's value.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Converts the Fq value to a hexadecimal string representation.
+     * The resulting string is prefixed with '0x' and contains the exact number of hex characters required
+     * to represent the numeric value of this instance.
+     *
+     * @returns A hexadecimal string representing the Fq value.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Check if the value of the current instance is zero.
+     * This function compares the internal 'value' property with 0n (BigInt representation of zero).
+     * Returns true if the value is zero, otherwise returns false.
+     *
+     * @returns A boolean indicating whether the value is zero or not.
+     */
+    isZero(): boolean;
+    /**
+     * Converts the value of the Fr or Fq instance to a friendly JSON format.
+     * The output is a hexadecimal string representation of the value with '0x' prefix.
+     *
+     * @returns A string representing the value in the JSON format.
+     */
+    toFriendlyJSON(): `0x${string}`;
+}
+//# sourceMappingURL=fields.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../src/fields/fields.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,EAAE;IACb,MAAM,CAAC,IAAI,KAAc;IACzB,MAAM,CAAC,OAAO,SAAuE;IACrF,MAAM,CAAC,SAAS,SAAmB;IACnC,MAAM,CAAC,aAAa,SAAM;IAE1B;;OAEG;IACH,SAAgB,KAAK,EAAE,MAAM,CAAC;gBAElB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,EAAE,GAAG,YAAY;IAQtD;;;;;;OAMG;IACH,MAAM,CAAC,MAAM;IAKb;;;OAGG;IACH,MAAM,CAAC,IAAI;IAIX;;;;;;;;OAQG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM;IAIjC;;;;;;OAMG;IACH,QAAQ;IAIR;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,UAAQ,GAAG,KAAK,MAAM,EAAE;IAIxC;;;;OAIG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;;OAKG;IACH,aAAa;IAKb;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,EAAE,EAAE;IAId;;;;;;OAMG;IACH,MAAM;IAIN;;;;;OAKG;IACH,cAAc;CAGf;AAED;;;;;;;;;;GAUG;AACH,qBAAa,EAAE;IAMX;;OAEG;aACa,KAAK,EAAE,MAAM;IAR/B,MAAM,CAAC,OAAO,SAAuE;IACrF,MAAM,CAAC,SAAS,SAAmB;IACnC,MAAM,CAAC,aAAa,SAAM;;IAGxB;;OAEG;IACa,KAAK,EAAE,MAAM;IAO/B;;;;;;OAMG;IACH,MAAM,CAAC,MAAM;IAKb;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAK/C;;;;;OAKG;IACH,QAAQ;IAIR;;;;;;OAMG;IACH,QAAQ;IAIR;;;;;;OAMG;IACH,MAAM;IAIN;;;;;OAKG;IACH,cAAc;CAGf"}