@aztec/foundation 0.0.0-test.0

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=types.d.ts.map

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,51 @@
+/**
+ * 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;
+    /**
+     * 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>;
+//# sourceMappingURL=index.d.ts.map

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;IAE/D;;;;;;;OAOG;IACU,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB7C;;;;;;OAMG;IACI,SAAS,CAAC,gBAAgB,UAAQ,GAAG,IAAI;CAIjD;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEhE"}

package/dest/sleep/index.js

@@ -0,0 +1,67 @@
+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 = [];
+    /**
+   * 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);
+        });
+        const timeoutPromise = new Promise((resolve)=>setTimeout(()=>resolve(false), ms));
+        const shouldThrow = await Promise.race([
+            interruptPromise,
+            timeoutPromise
+        ]);
+        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 = [];
+    }
+}
+/**
+ * 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));
+}

package/dest/string/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+export declare function hasHexPrefix(str: string): str is `0x${string}`;
+export declare function withoutHexPrefix(str: string): 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;
+//# sourceMappingURL=index.d.ts.map

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,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,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"}

package/dest/string/index.js

@@ -0,0 +1,24 @@
+export function hasHexPrefix(str) {
+    return str.startsWith('0x');
+}
+export function withoutHexPrefix(str) {
+    return hasHexPrefix(str) ? str.slice(2) : 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;
+}

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

@@ -0,0 +1,20 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/** 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/noir-protocol-circuits/crates/.
+ * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 to be set
+ * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn test:e2e full.test'
+ * To re-gen public base only, run 'AZTEC_GENERATE_TEST_DATA=1 yarn workspace @aztec/prover-client test orchestrator_public_functions'
+ */
+export declare function updateProtocolCircuitSampleInputs(circuitName: string, value: string): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/testing/files/index.ts"],"names":[],"mappings":";;AAOA,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,sBAAsB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,GAAE,OAAe,QAS5G;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,sBAAsB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAenG;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAMnF"}

package/dest/testing/files/index.js

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { createConsoleLogger } from '../../log/console.js';
+import { fileURLToPath } from '../../url/index.js';
+import { isGenerateTestDataEnabled } from '../test_data.js';
+/** Writes the contents specified to the target file if test data generation is enabled. */ export function writeTestData(targetFileFromRepoRoot, contents, raw = false) {
+    if (!isGenerateTestDataEnabled()) {
+        return;
+    }
+    const targetFile = getPathToFile(targetFileFromRepoRoot);
+    const toWrite = raw ? contents : typeof contents === 'string' ? contents : contents.toString('hex');
+    writeFileSync(targetFile, toWrite);
+    const logger = createConsoleLogger('aztec:testing:test_data');
+    logger(`Wrote test data to ${targetFile}`);
+}
+export function readTestData(repoPath) {
+    const targetFile = getPathToFile(repoPath);
+    return readFileSync(targetFile);
+}
+/**
+ * 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 function updateInlineTestData(targetFileFromRepoRoot, itemName, value) {
+    if (!isGenerateTestDataEnabled()) {
+        return;
+    }
+    const logger = createConsoleLogger('aztec:testing:test_data');
+    const targetFile = getPathToFile(targetFileFromRepoRoot);
+    const contents = readFileSync(targetFile, 'utf8').toString();
+    const regex = new RegExp(`let ${itemName} =[\\s\\S]*?;`, 'g');
+    if (!regex.exec(contents)) {
+        throw new Error(`Test data marker for ${itemName} not found in ${targetFile}`);
+    }
+    const updatedContents = contents.replaceAll(regex, `let ${itemName} = ${value};`);
+    writeFileSync(targetFile, updatedContents);
+    logger(`Updated test data in ${targetFile} for ${itemName} to ${value}`);
+}
+/**
+ * Updates the sample Prover.toml files in noir-projects/noir-protocol-circuits/crates/.
+ * @remarks Requires AZTEC_GENERATE_TEST_DATA=1 to be set
+ * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn test:e2e full.test'
+ * To re-gen public base only, run 'AZTEC_GENERATE_TEST_DATA=1 yarn workspace @aztec/prover-client test orchestrator_public_functions'
+ */ export function updateProtocolCircuitSampleInputs(circuitName, value) {
+    const logger = createConsoleLogger('aztec:testing:test_data');
+    const targetFileFromRepoRoot = `noir-projects/noir-protocol-circuits/crates/${circuitName}/Prover.toml`;
+    const targetFile = getPathToFile(targetFileFromRepoRoot);
+    writeFileSync(targetFile, value);
+    logger(`Updated test data in ${targetFile} for ${circuitName}`);
+}
+function getPathToFile(targetFileFromRepoRoot) {
+    const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../../../../');
+    if (!existsSync(join(repoRoot, 'CODEOWNERS'))) {
+        throw new Error(`Path to repo root is incorrect (got ${repoRoot})`);
+    }
+    return join(repoRoot, targetFileFromRepoRoot);
+}

package/dest/testing/index.d.ts

@@ -0,0 +1,4 @@
+export * from './snapshot_serializer.js';
+export * from './port_allocator.js';
+export * from './test_data.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}

package/dest/testing/index.js

@@ -0,0 +1,3 @@
+export * from './snapshot_serializer.js';
+export * from './port_allocator.js';
+export * from './test_data.js';

package/dest/testing/port_allocator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get a random port that is free to use.
+ * Returns undefined if it fails to get a port.
+ *
+ * @attribution: adapted from https://stackoverflow.com/a/71178451
+ *
+ * @returns a random port that is free to use.
+ */
+export declare function getRandomPort(): Promise<number | undefined>;
+//# sourceMappingURL=port_allocator.d.ts.map

package/dest/testing/port_allocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port_allocator.d.ts","sourceRoot":"","sources":["../../src/testing/port_allocator.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAoB3D"}

package/dest/testing/port_allocator.js

@@ -0,0 +1,29 @@
+import net from 'net';
+/**
+ * Get a random port that is free to use.
+ * Returns undefined if it fails to get a port.
+ *
+ * @attribution: adapted from https://stackoverflow.com/a/71178451
+ *
+ * @returns a random port that is free to use.
+ */ export function getRandomPort() {
+    return new Promise((resolve)=>{
+        const server = net.createServer();
+        server.listen(0, ()=>{
+            const address = server.address();
+            if (address && typeof address === 'object' && 'port' in address) {
+                const port = address.port;
+                server.close(()=>{
+                    resolve(port);
+                });
+            } else {
+                server.close(()=>{
+                    resolve(undefined);
+                });
+            }
+        });
+        server.on('error', ()=>{
+            resolve(undefined);
+        });
+    });
+}

package/dest/testing/snapshot_serializer.d.ts

@@ -0,0 +1,5 @@
+import type { NewPlugin } from 'pretty-format';
+export declare function setupCustomSnapshotSerializers(expect: {
+    addSnapshotSerializer: (serializer: NewPlugin) => void;
+}): void;
+//# sourceMappingURL=snapshot_serializer.d.ts.map

package/dest/testing/snapshot_serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot_serializer.d.ts","sourceRoot":"","sources":["../../src/testing/snapshot_serializer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AA2B/C,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IAAE,qBAAqB,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,IAAI,CAAA;CAAE,QAKhH"}

package/dest/testing/snapshot_serializer.js

@@ -0,0 +1,32 @@
+import { inspect } from 'util';
+function makeSerializerForCustomInspect(prefix) {
+    return {
+        serialize (val) {
+            return inspect(val);
+        },
+        test (arg) {
+            return inspect(arg).startsWith(prefix);
+        }
+    };
+}
+const bufferSerializer = {
+    serialize (val) {
+        return `Buffer<0x${val.toString('hex')}>`;
+    },
+    test (arg) {
+        return Buffer.isBuffer(arg);
+    }
+};
+const CUSTOM_INSPECT_SERIALIZABLE_TYPES = [
+    'AztecAddress',
+    'Fr',
+    'Fq',
+    'Selector',
+    'EthAddress'
+];
+export function setupCustomSnapshotSerializers(expect) {
+    for (const type of CUSTOM_INSPECT_SERIALIZABLE_TYPES){
+        expect.addSnapshotSerializer(makeSerializerForCustomInspect(type));
+    }
+    expect.addSnapshotSerializer(bufferSerializer);
+}

package/dest/testing/test_data.d.ts

@@ -0,0 +1,7 @@
+/** Returns whether test data generation is enabled */
+export declare function isGenerateTestDataEnabled(): boolean;
+/** Pushes test data with the given name, only if test data generation is enabled. */
+export declare function pushTestData<T>(itemName: string, data: T): void;
+/** Returns all instances of pushed test data with the given name, or empty if test data generation is not enabled. */
+export declare function getTestData(itemName: string): unknown[];
+//# sourceMappingURL=test_data.d.ts.map

package/dest/testing/test_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_data.d.ts","sourceRoot":"","sources":["../../src/testing/test_data.ts"],"names":[],"mappings":"AAEA,sDAAsD;AACtD,wBAAgB,yBAAyB,YAExC;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,QAgBxD;AAED,sHAAsH;AACtH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,EAAE,CAQvD"}

package/dest/testing/test_data.js

@@ -0,0 +1,29 @@
+const testData = {};
+/** Returns whether test data generation is enabled */ export function isGenerateTestDataEnabled() {
+    return [
+        '1',
+        'true'
+    ].includes(process.env.AZTEC_GENERATE_TEST_DATA ?? '') && typeof expect !== 'undefined';
+}
+/** Pushes test data with the given name, only if test data generation is enabled. */ export function pushTestData(itemName, data) {
+    if (!isGenerateTestDataEnabled()) {
+        return;
+    }
+    if (typeof expect === 'undefined') {
+        return;
+    }
+    const testName = expect.getState().currentTestName;
+    const fullItemName = `${testName} ${itemName}`;
+    if (!testData[fullItemName]) {
+        testData[fullItemName] = [];
+    }
+    testData[fullItemName].push(data);
+}
+/** Returns all instances of pushed test data with the given name, or empty if test data generation is not enabled. */ export function getTestData(itemName) {
+    if (!isGenerateTestDataEnabled()) {
+        return [];
+    }
+    const testName = expect.getState().currentTestName;
+    const fullItemName = `${testName} ${itemName}`;
+    return testData[fullItemName];
+}

package/dest/timer/date.d.ts

@@ -0,0 +1,13 @@
+/** Returns current datetime. */
+export declare class DateProvider {
+    now(): number;
+}
+/** Returns current datetime and allows to override it. */
+export declare class TestDateProvider implements DateProvider {
+    private readonly logger;
+    private offset;
+    constructor(logger?: import("../log/pino-logger.js").Logger);
+    now(): number;
+    setTime(timeMs: number): void;
+}
+//# sourceMappingURL=date.d.ts.map

package/dest/timer/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../src/timer/date.ts"],"names":[],"mappings":"AAEA,gCAAgC;AAChC,qBAAa,YAAY;IAChB,GAAG,IAAI,MAAM;CAGrB;AAED,0DAA0D;AAC1D,qBAAa,gBAAiB,YAAW,YAAY;IAGvC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAFnC,OAAO,CAAC,MAAM,CAAK;gBAEU,MAAM,yCAAgD;IAE5E,GAAG,IAAI,MAAM;IAIb,OAAO,CAAC,MAAM,EAAE,MAAM;CAI9B"}

package/dest/timer/date.js

@@ -0,0 +1,24 @@
+import { createLogger } from '../log/pino-logger.js';
+/** Returns current datetime. */ export class DateProvider {
+    now() {
+        return Date.now();
+    }
+}
+/** Returns current datetime and allows to override it. */ export class TestDateProvider {
+    logger;
+    offset;
+    constructor(logger = createLogger('foundation:test-date-provider')){
+        this.logger = logger;
+        this.offset = 0;
+    }
+    now() {
+        return Date.now() + this.offset;
+    }
+    setTime(timeMs) {
+        this.offset = timeMs - Date.now();
+        this.logger.warn(`Time set to ${new Date(timeMs).toISOString()}`, {
+            offset: this.offset,
+            timeMs
+        });
+    }
+}

package/dest/timer/elapsed.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Measures the elapsed execution time of a function call or promise once it is awaited.
+ * @param fn - Function or promise.
+ * @returns The number of ms and the result.
+ */
+export declare function elapsed<T>(fn: Promise<T> | (() => T | Promise<T>)): Promise<[number, T]>;
+/**
+ * Measures the elapsed execution time of a synchronous function call once it is awaited.
+ * @param fn - Function.
+ * @returns The number of ms and the result.
+ */
+export declare function elapsedSync<T>(fn: () => T): [number, T];
+//# sourceMappingURL=elapsed.d.ts.map

package/dest/timer/elapsed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elapsed.d.ts","sourceRoot":"","sources":["../../src/timer/elapsed.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAI9F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAIvD"}

package/dest/timer/elapsed.js

@@ -0,0 +1,25 @@
+import { Timer } from './timer.js';
+/**
+ * Measures the elapsed execution time of a function call or promise once it is awaited.
+ * @param fn - Function or promise.
+ * @returns The number of ms and the result.
+ */ export async function elapsed(fn) {
+    const timer = new Timer();
+    const result = await (typeof fn === 'function' ? fn() : fn);
+    return [
+        timer.ms(),
+        result
+    ];
+}
+/**
+ * Measures the elapsed execution time of a synchronous function call once it is awaited.
+ * @param fn - Function.
+ * @returns The number of ms and the result.
+ */ export function elapsedSync(fn) {
+    const timer = new Timer();
+    const result = fn();
+    return [
+        timer.ms(),
+        result
+    ];
+}

package/dest/timer/index.d.ts

@@ -0,0 +1,5 @@
+export * from './date.js';
+export { elapsed, elapsedSync } from './elapsed.js';
+export { TimeoutTask, executeTimeout } from './timeout.js';
+export { Timer } from './timer.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/timer/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

package/dest/timer/index.js

@@ -0,0 +1,4 @@
+export * from './date.js';
+export { elapsed, elapsedSync } from './elapsed.js';
+export { TimeoutTask, executeTimeout } from './timeout.js';
+export { Timer } from './timer.js';