@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/serialize/serialize.js

@@ -0,0 +1,258 @@
+import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
+import { Fr } from '../curves/bn254/field.js';
+import { numToUInt32BE } from './free_funcs.js';
+/**
+ * For serializing an array of fixed length buffers.
+ * @param arr - Array of bufferable.
+ * @param prefixLength - The length of the prefix (denominated in bytes).
+ * @returns The serialized buffers.
+ */ export function serializeArrayOfBufferableToVector(objs, prefixLength = 4) {
+    const arr = serializeToBufferArray(objs);
+    let lengthBuf;
+    if (prefixLength === 1) {
+        lengthBuf = Buffer.alloc(1);
+        lengthBuf.writeUInt8(arr.length, 0);
+    } else if (prefixLength === 4) {
+        lengthBuf = Buffer.alloc(4);
+        lengthBuf.writeUInt32BE(arr.length, 0);
+    } else {
+        throw new Error(`Unsupported prefix length. Got ${prefixLength}, expected 1 or 4`);
+    }
+    return Buffer.concat([
+        lengthBuf,
+        ...arr
+    ]);
+}
+/**
+ * Cast a uint8 array to a number.
+ * @param array - The uint8 array.
+ * @returns The number.
+ */ export function uint8ArrayToNum(array) {
+    const buf = Buffer.from(array);
+    return buf.readUint32LE();
+}
+/**
+ * Serializes a boolean to a buffer.
+ * @param value - Value to serialize.
+ * @returns The serialized boolean.
+ */ export function boolToBuffer(value, bufferSize = 1) {
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeUInt8(value ? 1 : 0, bufferSize - 1);
+    return buf;
+}
+/**
+ * Deserialize the 256-bit number at address `offset`.
+ * @param buf - The buffer.
+ * @param offset - The address.
+ * @returns The deserialized 256-bit field.
+ */ export function deserializeField(buf, offset = 0) {
+    const adv = 32;
+    return {
+        elem: buf.slice(offset, offset + adv),
+        adv
+    };
+}
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns A buffer list with the concatenation of all fields.
+ */ export function serializeToBufferArray(...objs) {
+    const ret = [];
+    for (const obj of objs){
+        if (Array.isArray(obj)) {
+            ret.push(...serializeToBufferArray(...obj));
+        } else if (Buffer.isBuffer(obj)) {
+            ret.push(obj);
+        } else if (typeof obj === 'boolean') {
+            ret.push(boolToBuffer(obj));
+        } else if (typeof obj === 'bigint') {
+            // Throw if bigint does not fit into 32 bytes
+            if (obj > BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff')) {
+                throw new Error(`BigInt ${obj} does not fit into 32 bytes`);
+            }
+            ret.push(serializeBigInt(obj));
+        } else if (typeof obj === 'number') {
+            // Note: barretenberg assumes everything is big-endian
+            ret.push(numToUInt32BE(obj)); // TODO: Are we always passing numbers as UInt32?
+        } else if (typeof obj === 'string') {
+            ret.push(numToUInt32BE(obj.length));
+            ret.push(Buffer.from(obj));
+        } else if ('toBuffer' in obj) {
+            ret.push(obj.toBuffer());
+        } else {
+            throw new Error(`Cannot serialize input to buffer: ${typeof obj} ${obj.constructor?.name}`);
+        }
+    }
+    return ret;
+}
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns An array of fields with the concatenation of all fields.
+ */ export function serializeToFields(...objs) {
+    const ret = [];
+    for (const obj of objs){
+        if (Array.isArray(obj)) {
+            ret.push(...serializeToFields(...obj));
+        } else if (obj instanceof Fr) {
+            ret.push(obj);
+        } else if (typeof obj === 'boolean' || typeof obj === 'number' || typeof obj === 'bigint') {
+            ret.push(new Fr(obj));
+        } else if ('toFields' in obj) {
+            ret.push(...obj.toFields());
+        } else if ('toFr' in obj) {
+            ret.push(obj.toFr());
+        } else if ('toField' in obj) {
+            ret.push(obj.toField());
+        } else if (Buffer.isBuffer(obj)) {
+            ret.push(Fr.fromBuffer(obj));
+        } else {
+            throw new Error(`Cannot serialize input to field: ${typeof obj} ${obj.constructor?.name}`);
+        }
+    }
+    return ret;
+}
+/**
+ * Serializes a list of objects contiguously.
+ * @param objs - Objects to serialize.
+ * @returns A single buffer with the concatenation of all fields.
+ */ export function serializeToBuffer(...objs) {
+    return Buffer.concat(serializeToBufferArray(...objs));
+}
+/**
+ * Returns a user-friendly JSON representation of an object, showing buffers as hex strings.
+ * @param obj - Object to json-stringify.
+ * @returns A JSON string.
+ */ export function toFriendlyJSON(obj) {
+    return JSON.stringify(obj, (key, value)=>{
+        if (value !== null && typeof value === 'object' && value.type === 'Buffer' && Array.isArray(value.data)) {
+            return '0x' + Buffer.from(value.data).toString('hex');
+        } else if (typeof value === 'bigint') {
+            return value.toString();
+        } else if (value && value.toFriendlyJSON) {
+            return value.toFriendlyJSON();
+        } else if (value && value.type && [
+            'Fr',
+            'Fq',
+            'AztecAddress',
+            'EthAddress'
+        ].includes(value.type)) {
+            return value.value;
+        } else {
+            return value;
+        }
+    }, 2);
+}
+/**
+ * Serialize a BigInt value into a Buffer of specified width.
+ * The function converts the input BigInt into its big-endian representation and stores it in a Buffer of the given width.
+ * If the width is not provided, a default value of 32 bytes will be used. It is important to provide an appropriate width
+ * to avoid truncation or incorrect serialization of large BigInt values.
+ *
+ * @param n - The BigInt value to be serialized.
+ * @param width - The width (in bytes) of the output Buffer, optional with default value 32.
+ * @returns A Buffer containing the serialized BigInt value in big-endian format.
+ */ export function serializeBigInt(n, width = 32) {
+    return toBufferBE(n, width);
+}
+/**
+ * Serialize a signed BigInt value into a Buffer of specified width using two's complement.
+ * @param n - The signed BigInt value to be serialized.
+ * @param width - The width (in bytes) of the output Buffer, optional with default value 32.
+ * @returns A Buffer containing the serialized signed BigInt value in big-endian format.
+ */ export function serializeSignedBigInt(n, width = 32) {
+    const widthBits = BigInt(width * 8);
+    const max = 1n << widthBits - 1n;
+    if (n < -max || n >= max) {
+        throw new Error(`Signed BigInt ${n.toString()} does not fit into ${width} bytes`);
+    }
+    const unsigned = n < 0n ? (1n << widthBits) + n : n;
+    return toBufferBE(unsigned, width);
+}
+/**
+ * Deserialize a big integer from a buffer, given an offset and width.
+ * Reads the specified number of bytes from the buffer starting at the offset, converts it to a big integer, and returns the deserialized result along with the number of bytes read (advanced).
+ *
+ * @param buf - The buffer containing the big integer to be deserialized.
+ * @param offset - The position in the buffer where the big integer starts. Defaults to 0.
+ * @param width - The number of bytes to read from the buffer for the big integer. Defaults to 32.
+ * @returns An object containing the deserialized big integer value ('elem') and the number of bytes advanced ('adv').
+ */ export function deserializeBigInt(buf, offset = 0, width = 32) {
+    return {
+        elem: toBigIntBE(buf.subarray(offset, offset + width)),
+        adv: width
+    };
+}
+/**
+ * Deserialize a signed BigInt from a buffer (two's complement).
+ * @param buf - The buffer containing the signed big integer to be deserialized.
+ * @param offset - The position in the buffer where the integer starts. Defaults to 0.
+ * @param width - The number of bytes to read from the buffer for the integer. Defaults to 32.
+ * @returns An object containing the deserialized signed bigint value ('elem') and bytes advanced ('adv').
+ */ export function deserializeSignedBigInt(buf, offset = 0, width = 32) {
+    const { elem, adv } = deserializeBigInt(buf, offset, width);
+    const widthBits = BigInt(width * 8);
+    const signBit = 1n << widthBits - 1n;
+    const fullRange = 1n << widthBits;
+    const signed = elem >= signBit ? elem - fullRange : elem;
+    return {
+        elem: signed,
+        adv
+    };
+}
+/**
+ * Serializes a Date object into a Buffer containing its timestamp as a big integer value.
+ * The resulting Buffer has a fixed width of 8 bytes, representing a 64-bit big-endian integer.
+ * This function is useful for converting date values into a binary format that can be stored or transmitted easily.
+ *
+ * @param date - The Date object to be serialized.
+ * @returns A Buffer containing the serialized timestamp of the input Date object.
+ */ export function serializeDate(date) {
+    return serializeBigInt(BigInt(date.getTime()), 8);
+}
+/**
+ * Deserialize a boolean value from a given buffer at the specified offset.
+ * Reads a single byte at the provided offset in the buffer and returns
+ * the deserialized boolean value along with the number of bytes read (adv).
+ *
+ * @param buf - The buffer containing the serialized boolean value.
+ * @param offset - The position in the buffer to start reading the boolean value.
+ * @returns An object containing the deserialized boolean value (elem) and the number of bytes read (adv).
+ */ export function deserializeBool(buf, offset = 0) {
+    const adv = 1;
+    return {
+        elem: buf.readUInt8(offset),
+        adv
+    };
+}
+/**
+ * Deserialize a 4-byte unsigned integer from a buffer, starting at the specified offset.
+ * The deserialization reads 4 bytes from the given buffer and converts it into a number.
+ * Returns an object containing the deserialized unsigned integer and the number of bytes advanced (4).
+ *
+ * @param buf - The buffer containing the serialized unsigned integer.
+ * @param offset - The starting position in the buffer to deserialize from (default is 0).
+ * @returns An object with the deserialized unsigned integer as 'elem' and the number of bytes advanced ('adv') as 4.
+ */ export function deserializeUInt32(buf, offset = 0) {
+    const adv = 4;
+    return {
+        elem: buf.readUInt32BE(offset),
+        adv
+    };
+}
+/**
+ * Deserialize a signed 32-bit integer from a buffer at the given offset.
+ * The input 'buf' should be a Buffer containing binary data, and 'offset' should be the position in the buffer
+ * where the signed 32-bit integer starts. Returns an object with both the deserialized integer (elem) and the
+ * number of bytes advanced in the buffer (adv, always equal to 4).
+ *
+ * @param buf - The buffer containing the binary data.
+ * @param offset - Optional, the position in the buffer where the signed 32-bit integer starts (default is 0).
+ * @returns An object with the deserialized integer as 'elem' and the number of bytes advanced as 'adv'.
+ */ export function deserializeInt32(buf, offset = 0) {
+    const adv = 4;
+    return {
+        elem: buf.readInt32BE(offset),
+        adv
+    };
+}

package/dest/serialize/type_registry.d.ts

@@ -0,0 +1,23 @@
+type Deserializable = {
+    fromString(str: string): object;
+};
+/**
+ * Register a class here that has a toJSON method that returns:
+ * ```
+ * {
+ *   "type": "ExampleClassName",
+ *   "value": <result of ExampleClassName.toString()>
+ * }
+ * ```
+ * and has an e.g. ExampleClassName.fromString(string) method.
+ * This means you can then easily serialize/deserialize the type using JSON.stringify and JSON.parse.
+ */
+export declare class TypeRegistry {
+    private static registry;
+    static register(typeName: string, constructor: Deserializable): void;
+    static getConstructor(typeName: string): Deserializable | undefined;
+}
+export declare function resolver(_: any, value: any): any;
+export declare function reviver(key: string, value: any): any;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZV9yZWdpc3RyeS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3NlcmlhbGl6ZS90eXBlX3JlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLEtBQUssY0FBYyxHQUFHO0lBQUUsVUFBVSxDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQUFBO0NBQUUsQ0FBQztBQUUxRDs7Ozs7Ozs7OztHQVVHO0FBQ0gscUJBQWEsWUFBWTtJQUN2QixPQUFPLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBMEM7SUFFakUsT0FBYyxRQUFRLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsY0FBYyxHQUFHLElBQUksQ0FFMUU7SUFFRCxPQUFjLGNBQWMsQ0FBQyxRQUFRLEVBQUUsTUFBTSxHQUFHLGNBQWMsR0FBRyxTQUFTLENBRXpFO0NBQ0Y7QUFtQkQsd0JBQWdCLFFBQVEsQ0FBQyxDQUFDLEVBQUUsR0FBRyxFQUFFLEtBQUssRUFBRSxHQUFHLE9BZ0IxQztBQUdELHdCQUFnQixPQUFPLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsR0FBRyxPQVc5QyJ9

package/dest/serialize/type_registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_registry.d.ts","sourceRoot":"","sources":["../../src/serialize/type_registry.ts"],"names":[],"mappings":"AAEA,KAAK,cAAc,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAAC;AAE1D;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA0C;IAEjE,OAAc,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,GAAG,IAAI,CAE1E;IAED,OAAc,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAEzE;CACF;AAmBD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,OAgB1C;AAGD,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,OAW9C"}

package/dest/serialize/type_registry.js

@@ -0,0 +1,61 @@
+import { mapValues } from '../collection/object.js';
+/**
+ * Register a class here that has a toJSON method that returns:
+ * ```
+ * {
+ *   "type": "ExampleClassName",
+ *   "value": <result of ExampleClassName.toString()>
+ * }
+ * ```
+ * and has an e.g. ExampleClassName.fromString(string) method.
+ * This means you can then easily serialize/deserialize the type using JSON.stringify and JSON.parse.
+ */ export class TypeRegistry {
+    static registry = new Map();
+    static register(typeName, constructor) {
+        this.registry.set(typeName, constructor);
+    }
+    static getConstructor(typeName) {
+        return this.registry.get(typeName);
+    }
+}
+function replace(value) {
+    if (value && typeof value === 'object' && 'toString' in value && TypeRegistry.getConstructor(value.constructor.name)) {
+        return {
+            type: value.constructor.name,
+            value: value.toString()
+        };
+    }
+    return value;
+}
+// Resolver function that enables JSON serialization of BigInts.
+export function resolver(_, value) {
+    if (typeof value === 'bigint') {
+        return value.toString() + 'n';
+    }
+    if (typeof value === 'object' && value) {
+        if (Array.isArray(value)) {
+            return value.map(replace);
+        } else if (Buffer.isBuffer(value)) {
+            return {
+                type: 'buffer',
+                value: value.toString('hex')
+            };
+        } else {
+            return mapValues(value, replace);
+        }
+    }
+    return value;
+}
+// Reviver function that uses TypeRegistry to instantiate objects.
+export function reviver(key, value) {
+    if (typeof value === 'string' && /^\d+n$/.test(value)) {
+        return BigInt(value.slice(0, -1));
+    }
+    if (value && typeof value === 'object' && 'type' in value && 'value' in value) {
+        const Constructor = TypeRegistry.getConstructor(value.type);
+        if (Constructor) {
+            return Constructor.fromString(value.value);
+        }
+    }
+    return value;
+}

package/dest/serialize/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Represents a fixed-length array.
+ */
+export type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _Tuple<T, N, []>) : never;
+/**
+ * Recursive type helper for constructing a fixed-length tuple of a given type.
+ * This is utilized internally by Tuple to create the final fixed-length tuple.
+ */
+type _Tuple<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _Tuple<T, N, [T, ...R]>;
+/**
+ * Check an array size, and cast it to a tuple.
+ * @param array - The array.
+ * @param n - The size.
+ * @returns The case tuple, or throws Error.
+ */
+export declare function assertLength<T, N extends number>(array: T[], n: N): Tuple<T, N>;
+/**
+ * Annoying, mapping a tuple does not preserve length.
+ * This is a helper to preserve length during a map operation.
+ * @typeparam T - The original array type.
+ */
+type MapTuple<T extends any[], F extends (item: any) => any> = {
+    [K in keyof T]: T[K] extends infer U ? (F extends (item: U) => infer V ? V : never) : never;
+};
+/**
+ * Annoyingly, mapping a tuple does not preserve length.
+ * This is a helper to preserve length during a map operation.
+ * @see https://github.com/microsoft/TypeScript/issues/29841.
+ * @param array - A tuple array.
+ */
+export declare function mapTuple<T extends any[], F extends (item: T[number]) => any>(tuple: T, fn: F): MapTuple<T, F>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJpYWxpemUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLE1BQU0sS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLFNBQVMsTUFBTSxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxNQUFNLFNBQVMsQ0FBQyxHQUFHLENBQUMsRUFBRSxHQUFHLE1BQU0sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLEdBQUcsS0FBSyxDQUFDO0FBQzNHOzs7R0FHRztBQUNILEtBQUssTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLFNBQVMsTUFBTSxFQUFFLENBQUMsU0FBUyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFFNUc7Ozs7O0dBS0c7QUFDSCx3QkFBZ0IsWUFBWSxDQUFDLENBQUMsRUFBRSxDQUFDLFNBQVMsTUFBTSxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBSy9FO0FBQ0Q7Ozs7R0FJRztBQUNILEtBQUssUUFBUSxDQUFDLENBQUMsU0FBUyxHQUFHLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsR0FBRyxLQUFLLEdBQUcsSUFBSTtLQUM1RCxDQUFDLElBQUksTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUMsS0FBSyxNQUFNLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsS0FBSztDQUM1RixDQUFDO0FBRUY7Ozs7O0dBS0c7QUFDSCx3QkFBZ0IsUUFBUSxDQUFDLENBQUMsU0FBUyxHQUFHLEVBQUUsRUFBRSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUUsRUFBRSxDQUFDLEdBQUcsUUFBUSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FFN0cifQ==

package/dest/serialize/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/serialize/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;AAC3G;;;GAGG;AACH,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;AAE5G;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAK/E;AACD;;;;GAIG;AACH,KAAK,QAAQ,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,KAAK,GAAG,IAAI;KAC5D,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,KAAK;CAC5F,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,GAAG,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAE7G"}

package/dest/serialize/types.js

@@ -0,0 +1,21 @@
+/**
+ * Represents a fixed-length array.
+ */ /**
+ * Check an array size, and cast it to a tuple.
+ * @param array - The array.
+ * @param n - The size.
+ * @returns The case tuple, or throws Error.
+ */ export function assertLength(array, n) {
+    if (array.length !== n) {
+        throw new Error(`Wrong 'fixed array' size. Expected ${n}, got ${array.length}.`);
+    }
+    return array;
+}
+/**
+ * Annoyingly, mapping a tuple does not preserve length.
+ * This is a helper to preserve length during a map operation.
+ * @see https://github.com/microsoft/TypeScript/issues/29841.
+ * @param array - A tuple array.
+ */ export function mapTuple(tuple, fn) {
+    return tuple.map(fn);
+}

package/dest/sleep/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * InterruptibleSleep is a utility class that allows you to create an interruptible sleep function.
+ * The sleep function can be interrupted at any time by calling the `interrupt` method, which can
+ * also specify whether the sleep should throw an error or just return. This is useful when you need
+ * to terminate long-running processes or perform cleanup tasks in response to external events.
+ *
+ * @example
+ * const sleeper = new InterruptibleSleep();
+ *
+ * async function longRunningTask() \{
+ *   try \{
+ *     await sleeper.sleep(3000);
+ *     console.log('Task completed after 3 seconds');
+ *   \} catch (e) \{
+ *     console.log('Task was interrupted');
+ *   \}
+ * \}
+ *
+ * setTimeout(() =\> sleeper.interrupt(true), 1500); // Interrupt the sleep after 1.5 seconds
+ */
+export declare class InterruptibleSleep {
+    private interrupts;
+    private timeoutIds;
+    /**
+     * Sleep for a specified amount of time in milliseconds.
+     * The sleep function will pause the execution of the current async function
+     * for the given time period, allowing other tasks to run before resuming.
+     *
+     * @param ms - The number of milliseconds to sleep.
+     * @returns A Promise that resolves after the specified time has passed.
+     */
+    sleep(ms: number): Promise<void>;
+    /**
+     * Interrupts the current sleep operation and optionally throws an error if specified.
+     * By default, when interrupted, the sleep operation will resolve without throwing.
+     * If 'sleepShouldThrow' is set to true, the sleep operation will throw an InterruptError instead.
+     *
+     * @param sleepShouldThrow - A boolean value indicating whether the sleep operation should throw an error when interrupted. Default is false.
+     */
+    interrupt(sleepShouldThrow?: boolean): void;
+}
+/**
+ * Puts the current execution context to sleep for a specified duration.
+ * This simulates a blocking sleep operation by using an asynchronous function and a Promise that resolves after the given duration.
+ * The sleep function can be interrupted by the 'interrupt' method of the InterruptibleSleep class.
+ *
+ * @param ms - The duration in milliseconds for which the sleep operation should last.
+ * @param returnValue - The return value of the promise.
+ * @returns A Promise that resolves after the specified duration, allowing the use of 'await' to pause execution.
+ */
+export declare function sleep<T>(ms: number, returnValue?: T): Promise<T>;
+/** Sleeps until the target date */
+export declare function sleepUntil<T>(target: Date, now: Date, returnValue?: T): Promise<T>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zbGVlcC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW1CRztBQUNILHFCQUFhLGtCQUFrQjtJQUM3QixPQUFPLENBQUMsVUFBVSxDQUE2QztJQUMvRCxPQUFPLENBQUMsVUFBVSxDQUF3QjtJQUUxQzs7Ozs7OztPQU9HO0lBQ1UsS0FBSyxDQUFDLEVBQUUsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXFCNUM7SUFFRDs7Ozs7O09BTUc7SUFDSSxTQUFTLENBQUMsZ0JBQWdCLFVBQVEsR0FBRyxJQUFJLENBSy9DO0NBQ0Y7QUFFRDs7Ozs7Ozs7R0FRRztBQUNILHdCQUFnQixLQUFLLENBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsV0FBVyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FFaEU7QUFFRCxtQ0FBbUM7QUFDbkMsd0JBQWdCLFVBQVUsQ0FBQyxDQUFDLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLFdBQVcsQ0FBQyxFQUFFLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBR2xGIn0=

package/dest/sleep/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sleep/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,UAAU,CAA6C;IAC/D,OAAO,CAAC,UAAU,CAAwB;IAE1C;;;;;;;OAOG;IACU,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB5C;IAED;;;;;;OAMG;IACI,SAAS,CAAC,gBAAgB,UAAQ,GAAG,IAAI,CAK/C;CACF;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEhE;AAED,mCAAmC;AACnC,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,WAAW,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAGlF"}

package/dest/sleep/index.js

@@ -0,0 +1,80 @@
+import { InterruptError } from '../error/index.js';
+/**
+ * InterruptibleSleep is a utility class that allows you to create an interruptible sleep function.
+ * The sleep function can be interrupted at any time by calling the `interrupt` method, which can
+ * also specify whether the sleep should throw an error or just return. This is useful when you need
+ * to terminate long-running processes or perform cleanup tasks in response to external events.
+ *
+ * @example
+ * const sleeper = new InterruptibleSleep();
+ *
+ * async function longRunningTask() \{
+ *   try \{
+ *     await sleeper.sleep(3000);
+ *     console.log('Task completed after 3 seconds');
+ *   \} catch (e) \{
+ *     console.log('Task was interrupted');
+ *   \}
+ * \}
+ *
+ * setTimeout(() =\> sleeper.interrupt(true), 1500); // Interrupt the sleep after 1.5 seconds
+ */ export class InterruptibleSleep {
+    interrupts = [];
+    timeoutIds = [];
+    /**
+   * Sleep for a specified amount of time in milliseconds.
+   * The sleep function will pause the execution of the current async function
+   * for the given time period, allowing other tasks to run before resuming.
+   *
+   * @param ms - The number of milliseconds to sleep.
+   * @returns A Promise that resolves after the specified time has passed.
+   */ async sleep(ms) {
+        let interruptResolve;
+        const interruptPromise = new Promise((resolve)=>{
+            interruptResolve = resolve;
+            this.interrupts.push(resolve);
+        });
+        let timeoutId;
+        const timeoutPromise = new Promise((resolve)=>{
+            timeoutId = setTimeout(()=>resolve(false), ms);
+            this.timeoutIds.push(timeoutId);
+        });
+        const shouldThrow = await Promise.race([
+            interruptPromise,
+            timeoutPromise
+        ]);
+        clearTimeout(timeoutId);
+        this.timeoutIds = this.timeoutIds.filter((id)=>id !== timeoutId);
+        this.interrupts = this.interrupts.filter((res)=>res !== interruptResolve);
+        if (shouldThrow) {
+            throw new InterruptError('Interrupted.');
+        }
+    }
+    /**
+   * Interrupts the current sleep operation and optionally throws an error if specified.
+   * By default, when interrupted, the sleep operation will resolve without throwing.
+   * If 'sleepShouldThrow' is set to true, the sleep operation will throw an InterruptError instead.
+   *
+   * @param sleepShouldThrow - A boolean value indicating whether the sleep operation should throw an error when interrupted. Default is false.
+   */ interrupt(sleepShouldThrow = false) {
+        this.interrupts.forEach((resolve)=>resolve(sleepShouldThrow));
+        this.interrupts = [];
+        this.timeoutIds.forEach((id)=>clearTimeout(id));
+        this.timeoutIds = [];
+    }
+}
+/**
+ * Puts the current execution context to sleep for a specified duration.
+ * This simulates a blocking sleep operation by using an asynchronous function and a Promise that resolves after the given duration.
+ * The sleep function can be interrupted by the 'interrupt' method of the InterruptibleSleep class.
+ *
+ * @param ms - The duration in milliseconds for which the sleep operation should last.
+ * @param returnValue - The return value of the promise.
+ * @returns A Promise that resolves after the specified duration, allowing the use of 'await' to pause execution.
+ */ export function sleep(ms, returnValue) {
+    return new Promise((resolve)=>setTimeout(()=>resolve(returnValue), ms));
+}
+/** Sleeps until the target date */ export function sleepUntil(target, now, returnValue) {
+    const ms = target.getTime() - now.getTime();
+    return sleep(ms, returnValue);
+}

package/dest/string/index.d.ts

@@ -0,0 +1,18 @@
+/** Parameterized hex string type for specific byte lengths */
+export type Hex<TByteLength extends number> = `0x${string}` & {
+    readonly _length: TByteLength;
+};
+export declare function hasHexPrefix(str: string): str is `0x${string}`;
+export declare function withoutHexPrefix(str: string): string;
+export declare function withHexPrefix(str: string): `0x${string}`;
+export declare function isHex(str: string): boolean;
+export declare function hexToBuffer(str: string): Buffer;
+export declare function bufferToHex(buffer: Buffer): `0x${string}`;
+export declare function pluralize(str: string, count: number | bigint, plural?: string): string;
+export declare function count(count: number | bigint, str: string, plural?: string): string;
+export declare function truncate(str: string, length?: number): string;
+/** Formats a duration in seconds into a compact human-readable string (e.g. `45s`, `12m`, `2h 5m`). */
+export declare function formatSeconds(seconds: number): string;
+export declare function isoDate(date?: Date): string;
+export declare function urlJoin(...args: string[]): string;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdHJpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOERBQThEO0FBQzlELE1BQU0sTUFBTSxHQUFHLENBQUMsV0FBVyxTQUFTLE1BQU0sSUFBSSxLQUFLLE1BQU0sRUFBRSxHQUFHO0lBQUUsUUFBUSxDQUFDLE9BQU8sRUFBRSxXQUFXLENBQUE7Q0FBRSxDQUFDO0FBRWhHLHdCQUFnQixZQUFZLENBQUMsR0FBRyxFQUFFLE1BQU0sR0FBRyxHQUFHLElBQUksS0FBSyxNQUFNLEVBQUUsQ0FFOUQ7QUFFRCx3QkFBZ0IsZ0JBQWdCLENBQUMsR0FBRyxFQUFFLE1BQU0sR0FBRyxNQUFNLENBRXBEO0FBRUQsd0JBQWdCLGFBQWEsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLEtBQUssTUFBTSxFQUFFLENBRXhEO0FBRUQsd0JBQWdCLEtBQUssQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FFMUM7QUFFRCx3QkFBZ0IsV0FBVyxDQUFDLEdBQUcsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQUUvQztBQUVELHdCQUFnQixXQUFXLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxLQUFLLE1BQU0sRUFBRSxDQUV6RDtBQUVELHdCQUFnQixTQUFTLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQUV0RjtBQUVELHdCQUFnQixLQUFLLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxNQUFNLEVBQUUsR0FBRyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFBRSxNQUFNLEdBQUcsTUFBTSxDQUVsRjtBQUVELHdCQUFnQixRQUFRLENBQUMsR0FBRyxFQUFFLE1BQU0sRUFBRSxNQUFNLEdBQUUsTUFBVyxHQUFHLE1BQU0sQ0FFakU7QUFFRCx1R0FBdUc7QUFDdkcsd0JBQWdCLGFBQWEsQ0FBQyxPQUFPLEVBQUUsTUFBTSxHQUFHLE1BQU0sQ0FXckQ7QUFFRCx3QkFBZ0IsT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLElBQUksVUFFbEM7QUFFRCx3QkFBZ0IsT0FBTyxDQUFDLEdBQUcsSUFBSSxFQUFFLE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FzQmpEIn0=

package/dest/string/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/string/index.ts"],"names":[],"mappings":"AAAA,8DAA8D;AAC9D,MAAM,MAAM,GAAG,CAAC,WAAW,SAAS,MAAM,IAAI,KAAK,MAAM,EAAE,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAAE,CAAC;AAEhG,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,KAAK,MAAM,EAAE,CAE9D;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,CAExD;AAED,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE1C;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,CAEzD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtF;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,MAAW,GAAG,MAAM,CAEjE;AAED,uGAAuG;AACvG,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAWrD;AAED,wBAAgB,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,UAElC;AAED,wBAAgB,OAAO,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAsBjD"}

package/dest/string/index.js

@@ -0,0 +1,62 @@
+/** Parameterized hex string type for specific byte lengths */ export function hasHexPrefix(str) {
+    return str.startsWith('0x');
+}
+export function withoutHexPrefix(str) {
+    return hasHexPrefix(str) ? str.slice(2) : str;
+}
+export function withHexPrefix(str) {
+    return hasHexPrefix(str) ? str : `0x${str}`;
+}
+export function isHex(str) {
+    return /^(0x)?[0-9a-fA-F]*$/.test(str);
+}
+export function hexToBuffer(str) {
+    return Buffer.from(withoutHexPrefix(str), 'hex');
+}
+export function bufferToHex(buffer) {
+    return `0x${buffer.toString('hex')}`;
+}
+export function pluralize(str, count, plural) {
+    return count === 1 || count === 1n ? str : plural ?? `${str}s`;
+}
+export function count(count, str, plural) {
+    return `${count} ${pluralize(str, count, plural)}`;
+}
+export function truncate(str, length = 64) {
+    return str.length > length ? str.slice(0, length) + '...' : str;
+}
+/** Formats a duration in seconds into a compact human-readable string (e.g. `45s`, `12m`, `2h 5m`). */ export function formatSeconds(seconds) {
+    if (seconds < 60) {
+        return `${Math.round(seconds)}s`;
+    }
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60) {
+        return `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remMinutes = minutes % 60;
+    return remMinutes > 0 ? `${hours}h ${remMinutes}m` : `${hours}h`;
+}
+export function isoDate(date) {
+    return (date ?? new Date()).toISOString().replace(/[-:T]/g, '').replace(/\..+$/, '');
+}
+export function urlJoin(...args) {
+    const processed = [];
+    for (const arg of args){
+        if (arg.length === 0) {
+            continue;
+        }
+        let start = 0;
+        let end = arg.length - 1;
+        while(start <= end && arg[start] === '/'){
+            start++;
+        }
+        while(end >= start && arg[end] === '/'){
+            end--;
+        }
+        if (start <= end) {
+            processed.push(arg.slice(start, end + 1));
+        }
+    }
+    return processed.join('/');
+}

package/dest/testing/files/index.d.ts

@@ -0,0 +1,20 @@
+/** Writes the contents specified to the target file if test data generation is enabled. */
+export declare function writeTestData(targetFileFromRepoRoot: string, contents: string | Buffer, raw?: boolean): void;
+export declare function readTestData(repoPath: string): Buffer;
+/**
+ * Looks for a variable assignment in the target file and updates the value, only if test data generation is enabled.
+ * Note that a magic inline comment would be a cleaner approach, like `/* TEST-DATA-START *\/` and `/* TEST-DATA-END *\/`,
+ * but running nargo fmt on it panics since the comment would be erased, so we roll with this for now.
+ * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 to be set
+ */
+export declare function updateInlineTestData(targetFileFromRepoRoot: string, itemName: string, value: string): void;
+/**
+ * Updates the sample Prover.toml files in noir-projects/fnd/noir-protocol-circuits/crates/.
+ * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 to be set. The block-root, block-merge, checkpoint,
+ * tx-merge, and root rollup samples are regenerated by the prover-client
+ * `regenerate_rollup_sample_inputs.test.ts` suite; the private-kernel and transaction-base rollup
+ * samples by the e2e 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn test:e2e single-node/prover/server/full.test' dump.
+ */
+export declare function updateProtocolCircuitSampleInputs(circuitName: string, value: string): void;
+export declare function getPathToFile(targetFileFromRepoRoot: string): string;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90ZXN0aW5nL2ZpbGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLDJGQUEyRjtBQUMzRix3QkFBZ0IsYUFBYSxDQUFDLHNCQUFzQixFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxHQUFHLEdBQUUsT0FBZSxRQVM1RztBQUVELHdCQUFnQixZQUFZLENBQUMsUUFBUSxFQUFFLE1BQU0sR0FBRyxNQUFNLENBR3JEO0FBRUQ7Ozs7O0dBS0c7QUFDSCx3QkFBZ0Isb0JBQW9CLENBQUMsc0JBQXNCLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sUUFtQm5HO0FBRUQ7Ozs7OztHQU1HO0FBQ0gsd0JBQWdCLGlDQUFpQyxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sUUFNbkY7QUFFRCx3QkFBZ0IsYUFBYSxDQUFDLHNCQUFzQixFQUFFLE1BQU0sVUFPM0QifQ==