@aztec/foundation 0.7.2 → 0.7.4

package/dest/log/logger.js

@@ -0,0 +1,78 @@
+import debug from 'debug';
+import isNode from 'detect-node';
+import { isatty } from 'tty';
+// Matches a subset of Winston log levels
+const LogLevels = ['silent', 'error', 'warn', 'info', 'verbose', 'debug'];
+const DefaultLogLevel = 'info';
+const envLogLevel = process.env.LOG_LEVEL?.toLowerCase();
+const currentLevel = LogLevels.includes(envLogLevel) ? envLogLevel : DefaultLogLevel;
+/**
+ * Creates a new DebugLogger for the current module, defaulting to the LOG_LEVEL env var.
+ * If DEBUG="[module]" env is set, will enable debug logging if the module matches.
+ * Uses npm debug for debug level and console.error for other levels.
+ * @param name - Name of the module.
+ * @returns A debug logger.
+ */
+export function createDebugLogger(name) {
+    const debugLogger = debug(name);
+    if (currentLevel === 'debug')
+        debugLogger.enabled = true;
+    const logger = {
+        silent: () => { },
+        error: (...args) => logWithDebug(debugLogger, 'error', args),
+        warn: (...args) => logWithDebug(debugLogger, 'warn', args),
+        info: (...args) => logWithDebug(debugLogger, 'info', args),
+        verbose: (...args) => logWithDebug(debugLogger, 'verbose', args),
+        debug: (...args) => logWithDebug(debugLogger, 'debug', args),
+    };
+    return Object.assign((...args) => logWithDebug(debugLogger, 'debug', args), logger);
+}
+const logHandlers = [];
+/**
+ * Registers a callback for all logs, whether they are emitted in the current log level or not.
+ * @param handler - Callback to be called on every log.
+ */
+export function onLog(handler) {
+    logHandlers.push(handler);
+}
+/**
+ * Logs args to npm debug if enabled or log level is debug, console.error otherwise.
+ * @param debug - Instance of npm debug.
+ * @param level - Intended log level.
+ * @param args - Args to log.
+ */
+function logWithDebug(debug, level, args) {
+    for (const handler of logHandlers) {
+        handler(level, debug.namespace, args);
+    }
+    if (debug.enabled) {
+        debug(args[0], ...args.slice(1));
+    }
+    else if (LogLevels.indexOf(level) <= LogLevels.indexOf(currentLevel) && process.env.NODE_ENV !== 'test') {
+        printLog([getPrefix(debug, level), ...args]);
+    }
+}
+/**
+ * Returns a log prefix that emulates that of npm debug. Uses colors if in node and in a tty.
+ * @param debugLogger - Instance of npm debug logger.
+ * @param level - Intended log level (printed out if strictly above current log level).
+ * @returns Log prefix.
+ */
+function getPrefix(debugLogger, level) {
+    const levelLabel = currentLevel !== level ? ` ${level.toUpperCase()}` : '';
+    const prefix = `${debugLogger.namespace.replace(/^aztec:/, '')}${levelLabel}`;
+    if (!isNode || !isatty(process.stderr.fd))
+        return prefix;
+    const colorIndex = debug.selectColor(debugLogger.namespace);
+    const colorCode = '\u001B[3' + (colorIndex < 8 ? colorIndex : '8;5;' + colorIndex);
+    return `  ${colorCode};1m${prefix}\u001B[0m`;
+}
+/**
+ * Outputs to console error.
+ * @param args - Args to log.
+ */
+function printLog(args) {
+    // eslint-disable-next-line no-console
+    console.error(...args);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/mutex/index.d.ts

@@ -0,0 +1,53 @@
+import { MutexDatabase } from './mutex_database.js';
+export * from './mutex_database.js';
+/**
+ * Mutex class provides a mutual exclusion mechanism for critical sections of code using a named lock.
+ * The lock is acquired and released via the `lock` and `unlock` methods. Locks can be optionally pinged
+ * to keep them alive when they are held for longer durations, avoiding unintended release due to timeouts.
+ *
+ * The underlying lock state is managed in a MutexDatabase instance which can be shared across multiple Mutex instances.
+ * This allows for synchronization between different parts of an application or even across different instances of an application.
+ *
+ * @example
+ * const mutex = new Mutex(mutexDatabase, 'myLock');
+ * await mutex.lock();
+ * // Critical section here
+ * await mutex.unlock();
+ */
+export declare class Mutex {
+    private readonly db;
+    private readonly name;
+    private readonly timeout;
+    private readonly tryLockInterval;
+    private readonly pingInterval;
+    private id;
+    private pingTimeout;
+    constructor(db: MutexDatabase, name: string, timeout?: number, tryLockInterval?: number, pingInterval?: number);
+    /**
+     * Acquire a lock on the mutex. If 'untilAcquired' is true, the method will keep trying to acquire the lock until it
+     * successfully acquires it. If 'untilAcquired' is false, the method will try to acquire the lock once and return
+     * immediately with a boolean indicating if the lock has been acquired or not.
+     *
+     * @param untilAcquired - Optional parameter, set to true by default. If true, the method will keep trying to acquire the lock until success. If false, the method will try only once and return a boolean value.
+     * @returns A Promise that resolves to true if the lock has been acquired, or false when 'untilAcquired' is false and the lock could not be immediately acquired.
+     */
+    lock(untilAcquired?: boolean): Promise<boolean>;
+    /**
+     * Unlocks the mutex, allowing other instances to acquire the lock.
+     * This method also clears the internal ping timeout and increments the internal ID
+     * to ensure stale pings do not extend the lock after it has been released.
+     *
+     * @returns A promise that resolves once the lock has been released in the database.
+     */
+    unlock(): Promise<void>;
+    /**
+     * Periodically extends the lock's lifetime by updating the database record with a new expiration time.
+     * This method is called recursively using setTimeout. If the id passed to the ping method does not match
+     * the current lock instance's id, it means the lock has been released or acquired by another instance
+     * and the ping should not proceed further.
+     *
+     * @param id - The id of the current lock instance.
+     */
+    private ping;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mutex/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,cAAc,qBAAqB,CAAC;AAEpC;;;;;;;;;;;;;GAaG;AACH,qBAAa,KAAK;IAKd,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAR/B,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,WAAW,CAAkB;gBAGlB,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,SAAO,EACd,eAAe,SAAO,EACtB,YAAY,SAAO;IAGtC;;;;;;;OAOG;IACU,IAAI,CAAC,aAAa,UAAO;IAetC;;;;;;OAMG;IACU,MAAM;IAMnB;;;;;;;OAOG;YACW,IAAI;CAQnB"}

package/dest/mutex/index.js

@@ -0,0 +1,74 @@
+export * from './mutex_database.js';
+/**
+ * Mutex class provides a mutual exclusion mechanism for critical sections of code using a named lock.
+ * The lock is acquired and released via the `lock` and `unlock` methods. Locks can be optionally pinged
+ * to keep them alive when they are held for longer durations, avoiding unintended release due to timeouts.
+ *
+ * The underlying lock state is managed in a MutexDatabase instance which can be shared across multiple Mutex instances.
+ * This allows for synchronization between different parts of an application or even across different instances of an application.
+ *
+ * @example
+ * const mutex = new Mutex(mutexDatabase, 'myLock');
+ * await mutex.lock();
+ * // Critical section here
+ * await mutex.unlock();
+ */
+export class Mutex {
+    constructor(db, name, timeout = 5000, tryLockInterval = 2000, pingInterval = 2000) {
+        this.db = db;
+        this.name = name;
+        this.timeout = timeout;
+        this.tryLockInterval = tryLockInterval;
+        this.pingInterval = pingInterval;
+        this.id = 0;
+    }
+    /**
+     * Acquire a lock on the mutex. If 'untilAcquired' is true, the method will keep trying to acquire the lock until it
+     * successfully acquires it. If 'untilAcquired' is false, the method will try to acquire the lock once and return
+     * immediately with a boolean indicating if the lock has been acquired or not.
+     *
+     * @param untilAcquired - Optional parameter, set to true by default. If true, the method will keep trying to acquire the lock until success. If false, the method will try only once and return a boolean value.
+     * @returns A Promise that resolves to true if the lock has been acquired, or false when 'untilAcquired' is false and the lock could not be immediately acquired.
+     */
+    async lock(untilAcquired = true) {
+        while (true) {
+            if (await this.db.acquireLock(this.name, this.timeout)) {
+                const id = this.id;
+                this.pingTimeout = setTimeout(() => this.ping(id), this.pingInterval);
+                return true;
+            }
+            if (!untilAcquired) {
+                return false;
+            }
+            await new Promise(resolve => setTimeout(resolve, this.tryLockInterval));
+        }
+    }
+    /**
+     * Unlocks the mutex, allowing other instances to acquire the lock.
+     * This method also clears the internal ping timeout and increments the internal ID
+     * to ensure stale pings do not extend the lock after it has been released.
+     *
+     * @returns A promise that resolves once the lock has been released in the database.
+     */
+    async unlock() {
+        clearTimeout(this.pingTimeout);
+        this.id++;
+        await this.db.releaseLock(this.name);
+    }
+    /**
+     * Periodically extends the lock's lifetime by updating the database record with a new expiration time.
+     * This method is called recursively using setTimeout. If the id passed to the ping method does not match
+     * the current lock instance's id, it means the lock has been released or acquired by another instance
+     * and the ping should not proceed further.
+     *
+     * @param id - The id of the current lock instance.
+     */
+    async ping(id) {
+        if (id !== this.id) {
+            return;
+        }
+        await this.db.extendLock(this.name, this.timeout);
+        this.pingTimeout = setTimeout(() => this.ping(id), this.pingInterval);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXV0ZXgvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsY0FBYyxxQkFBcUIsQ0FBQztBQUVwQzs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsTUFBTSxPQUFPLEtBQUs7SUFJaEIsWUFDbUIsRUFBaUIsRUFDakIsSUFBWSxFQUNaLFVBQVUsSUFBSSxFQUNkLGtCQUFrQixJQUFJLEVBQ3RCLGVBQWUsSUFBSTtRQUpuQixPQUFFLEdBQUYsRUFBRSxDQUFlO1FBQ2pCLFNBQUksR0FBSixJQUFJLENBQVE7UUFDWixZQUFPLEdBQVAsT0FBTyxDQUFPO1FBQ2Qsb0JBQWUsR0FBZixlQUFlLENBQU87UUFDdEIsaUJBQVksR0FBWixZQUFZLENBQU87UUFSOUIsT0FBRSxHQUFHLENBQUMsQ0FBQztJQVNaLENBQUM7SUFFSjs7Ozs7OztPQU9HO0lBQ0ksS0FBSyxDQUFDLElBQUksQ0FBQyxhQUFhLEdBQUcsSUFBSTtRQUNwQyxPQUFPLElBQUksRUFBRTtZQUNYLElBQUksTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxPQUFPLENBQUMsRUFBRTtnQkFDdEQsTUFBTSxFQUFFLEdBQUcsSUFBSSxDQUFDLEVBQUUsQ0FBQztnQkFDbkIsSUFBSSxDQUFDLFdBQVcsR0FBRyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7Z0JBQ3RFLE9BQU8sSUFBSSxDQUFDO2FBQ2I7WUFFRCxJQUFJLENBQUMsYUFBYSxFQUFFO2dCQUNsQixPQUFPLEtBQUssQ0FBQzthQUNkO1lBQ0QsTUFBTSxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUM7U0FDekU7SUFDSCxDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0ksS0FBSyxDQUFDLE1BQU07UUFDakIsWUFBWSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUMvQixJQUFJLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDVixNQUFNLElBQUksQ0FBQyxFQUFFLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN2QyxDQUFDO0lBRUQ7Ozs7Ozs7T0FPRztJQUNLLEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBVTtRQUMzQixJQUFJLEVBQUUsS0FBSyxJQUFJLENBQUMsRUFBRSxFQUFFO1lBQ2xCLE9BQU87U0FDUjtRQUVELE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbEQsSUFBSSxDQUFDLFdBQVcsR0FBRyxVQUFVLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsRUFBRSxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7SUFDeEUsQ0FBQztDQUNGIn0=

package/dest/mutex/mutex.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sleep function for introducing a delay in the execution of code.
+ * Returns a Promise that resolves after the specified number of milliseconds.
+ *
+ * @param ms - The number of milliseconds to pause the execution.
+ * @returns A Promise that resolves after the specified delay.
+ */
+export declare function sleep(ms: number): Promise<unknown>;
+//# sourceMappingURL=mutex.test.d.ts.map

package/dest/mutex/mutex.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutex.test.d.ts","sourceRoot":"","sources":["../../src/mutex/mutex.test.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,oBAE/B"}

package/dest/mutex/mutex.test.js

@@ -0,0 +1,58 @@
+import { jest } from '@jest/globals';
+import { Mutex } from './index.js';
+/**
+ * Sleep function for introducing a delay in the execution of code.
+ * Returns a Promise that resolves after the specified number of milliseconds.
+ *
+ * @param ms - The number of milliseconds to pause the execution.
+ * @returns A Promise that resolves after the specified delay.
+ */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+describe('mutex', () => {
+    let db;
+    let mutex;
+    const mutexName = 'test-mutex';
+    const timeout = 500;
+    const tryLockInterval = 100;
+    const pingInterval = 200;
+    beforeEach(() => {
+        db = {
+            acquireLock: jest.fn().mockImplementation(() => false),
+            extendLock: jest.fn().mockImplementation(() => {
+                db.acquireLock.mockResolvedValueOnce(false);
+            }),
+            releaseLock: jest.fn().mockImplementation(() => {
+                db.acquireLock.mockResolvedValueOnce(true);
+            }),
+        };
+        db.acquireLock.mockResolvedValueOnce(true);
+        mutex = new Mutex(db, mutexName, timeout, tryLockInterval, pingInterval);
+    });
+    it('cannot lock if locked', async () => {
+        const result = [];
+        const fn1 = async (runAfterLocked) => {
+            await mutex.lock();
+            const pm = runAfterLocked();
+            await sleep(500);
+            result.push('fn1');
+            await mutex.unlock();
+            return pm;
+        };
+        const fn2 = async () => {
+            await mutex.lock();
+            result.push('fn2');
+            await mutex.unlock();
+        };
+        await fn1(fn2);
+        expect(result).toEqual(['fn1', 'fn2']);
+    });
+    it('automatically extend the expiry time of the lock', async () => {
+        await mutex.lock();
+        await sleep(1000);
+        await mutex.unlock();
+        expect(db.extendLock).toHaveBeenCalledWith(mutexName, timeout);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dest/mutex/mutex_database.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents a mutual exclusion (mutex) database interface.
+ * Provides functionality for acquiring, extending, and releasing locks on resources to ensure exclusive access and prevent conflicts in concurrent applications.
+ */
+export interface MutexDatabase {
+    acquireLock(name: string, timeout: number): Promise<boolean>;
+    extendLock(name: string, timeout: number): Promise<void>;
+    releaseLock(name: string): Promise<void>;
+}
+//# sourceMappingURL=mutex_database.d.ts.map

package/dest/mutex/mutex_database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutex_database.d.ts","sourceRoot":"","sources":["../../src/mutex/mutex_database.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAE5B,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAE7D,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C"}

package/dest/mutex/mutex_database.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXV0ZXhfZGF0YWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXV0ZXgvbXV0ZXhfZGF0YWJhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dest/retry/index.d.ts

@@ -0,0 +1,44 @@
+/** An error that indicates that the operation should not be retried. */
+export declare class NoRetryError extends Error {
+}
+/**
+ * Generates a backoff sequence for retrying operations with an increasing delay.
+ * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
+ * This generator can be used in combination with the `retry` function to perform
+ * retries with exponential backoff and capped at 64 seconds between attempts.
+ *
+ * @returns A generator that yields the next backoff value in seconds as an integer.
+ */
+export declare function backoffGenerator(): Generator<number, void, unknown>;
+/**
+ * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
+ * @param retries - Intervals to retry (in seconds).
+ * @returns A generator sequence.
+ */
+export declare function makeBackoff(retries: number[]): Generator<number, void, unknown>;
+/**
+ * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
+ * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
+ *
+ * @param fn - The asynchronous function to be retried.
+ * @param name - The optional name of the operation, used for logging purposes.
+ * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
+ * @param log - Logger to use for logging.
+ * @param failSilently - Do not log errors while retrying.
+ * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
+ * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
+ */
+export declare function retry<Result>(fn: () => Promise<Result>, name?: string, backoff?: Generator<number, void, unknown>, log?: import("../log/logger.js").DebugLogger, failSilently?: boolean): Promise<Result>;
+/**
+ * Retry an asynchronous function until it returns a truthy value or the specified timeout is exceeded.
+ * The function is retried periodically with a fixed interval between attempts. The operation can be named for better error messages.
+ * Will never timeout if the value is 0.
+ *
+ * @param fn - The asynchronous function to be retried, which should return a truthy value upon success or undefined otherwise.
+ * @param name - The optional name of the operation, used for generating timeout error message.
+ * @param timeout - The optional maximum time, in seconds, to keep retrying before throwing a timeout error. Defaults to 0 (never timeout).
+ * @param interval - The optional interval, in seconds, between retry attempts. Defaults to 1 second.
+ * @returns A Promise that resolves with the successful (truthy) result of the provided function, or rejects if timeout is exceeded.
+ */
+export declare function retryUntil<T>(fn: () => Promise<T | undefined>, name?: string, timeout?: number, interval?: number): Promise<NonNullable<Awaited<T>>>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/retry/index.ts"],"names":[],"mappings":"AAIA,wEAAwE;AACxE,qBAAa,YAAa,SAAQ,KAAK;CAAG;AAE1C;;;;;;;GAOG;AACH,wBAAiB,gBAAgB,qCAMhC;AAED;;;;GAIG;AACH,wBAAiB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,oCAI7C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,KAAK,CAAC,MAAM,EAChC,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EACzB,IAAI,SAAc,EAClB,OAAO,mCAAqB,EAC5B,GAAG,yCAA8C,EACjD,YAAY,UAAQ,mBAoBrB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,IAAI,SAAK,EAAE,OAAO,SAAI,EAAE,QAAQ,SAAI,oCAczG"}

package/dest/retry/index.js

@@ -0,0 +1,89 @@
+import { createDebugLogger } from '../log/index.js';
+import { sleep } from '../sleep/index.js';
+import { Timer } from '../timer/index.js';
+/** An error that indicates that the operation should not be retried. */
+export class NoRetryError extends Error {
+}
+/**
+ * Generates a backoff sequence for retrying operations with an increasing delay.
+ * The backoff sequence follows this pattern: 1, 1, 1, 2, 4, 8, 16, 32, 64, ...
+ * This generator can be used in combination with the `retry` function to perform
+ * retries with exponential backoff and capped at 64 seconds between attempts.
+ *
+ * @returns A generator that yields the next backoff value in seconds as an integer.
+ */
+export function* backoffGenerator() {
+    const v = [1, 1, 1, 2, 4, 8, 16, 32, 64];
+    let i = 0;
+    while (true) {
+        yield v[Math.min(i++, v.length - 1)];
+    }
+}
+/**
+ * Generates a backoff sequence based on the array of retry intervals to use with the `retry` function.
+ * @param retries - Intervals to retry (in seconds).
+ * @returns A generator sequence.
+ */
+export function* makeBackoff(retries) {
+    for (const retry of retries) {
+        yield retry;
+    }
+}
+/**
+ * Retry a given asynchronous function with a specific backoff strategy, until it succeeds or backoff generator ends.
+ * It logs the error and retry interval in case an error is caught. The function can be named for better log output.
+ *
+ * @param fn - The asynchronous function to be retried.
+ * @param name - The optional name of the operation, used for logging purposes.
+ * @param backoff - The optional backoff generator providing the intervals in seconds between retries. Defaults to a predefined series.
+ * @param log - Logger to use for logging.
+ * @param failSilently - Do not log errors while retrying.
+ * @returns A Promise that resolves with the successful result of the provided function, or rejects if backoff generator ends.
+ * @throws If `NoRetryError` is thrown by the `fn`, it is rethrown.
+ */
+export async function retry(fn, name = 'Operation', backoff = backoffGenerator(), log = createDebugLogger('aztec:foundation:retry'), failSilently = false) {
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (err instanceof NoRetryError) {
+                // A special error that indicates that the operation should not be retried. Rethrow it.
+                throw err;
+            }
+            const s = backoff.next().value;
+            if (s === undefined) {
+                throw err;
+            }
+            log(`${name} failed. Will retry in ${s}s...`);
+            !failSilently && log.error(err);
+            await sleep(s * 1000);
+            continue;
+        }
+    }
+}
+/**
+ * Retry an asynchronous function until it returns a truthy value or the specified timeout is exceeded.
+ * The function is retried periodically with a fixed interval between attempts. The operation can be named for better error messages.
+ * Will never timeout if the value is 0.
+ *
+ * @param fn - The asynchronous function to be retried, which should return a truthy value upon success or undefined otherwise.
+ * @param name - The optional name of the operation, used for generating timeout error message.
+ * @param timeout - The optional maximum time, in seconds, to keep retrying before throwing a timeout error. Defaults to 0 (never timeout).
+ * @param interval - The optional interval, in seconds, between retry attempts. Defaults to 1 second.
+ * @returns A Promise that resolves with the successful (truthy) result of the provided function, or rejects if timeout is exceeded.
+ */
+export async function retryUntil(fn, name = '', timeout = 0, interval = 1) {
+    const timer = new Timer();
+    while (true) {
+        const result = await fn();
+        if (result) {
+            return result;
+        }
+        await sleep(interval * 1000);
+        if (timeout && timer.s() > timeout) {
+            throw new Error(name ? `Timeout awaiting ${name}` : 'Timeout');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/running-promise/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * RunningPromise is a utility class that helps manage the execution of an asynchronous function
+ * at a specified polling interval. It allows starting, stopping, and checking the status of the
+ * internally managed promise. The class also supports interrupting the polling process when stopped.
+ */
+export declare class RunningPromise {
+    private fn;
+    private pollingInterval;
+    private running;
+    private runningPromise;
+    private interruptPromise;
+    private interruptResolve;
+    constructor(fn: () => Promise<void>, pollingInterval?: number);
+    /**
+     * Starts the running promise.
+     */
+    start(): void;
+    /**
+     * Stops the running promise, resolves any pending interruptable sleep,
+     * and waits for the currently executing function to complete.
+     */
+    stop(): Promise<void>;
+    /**
+     * A sleep function that can be interrupted before the specified time.
+     * The sleep duration is determined by 'timeInMs', and it can be terminated early if the 'interruptPromise' is resolved.
+     * @param timeInMs - The time in milliseconds.
+     */
+    private interruptableSleep;
+    /**
+     * Checks if the running promise is currently active.
+     * @returns True if the promise is running.
+     */
+    isRunning(): boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/dest/running-promise/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/running-promise/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,cAAc;IAKb,OAAO,CAAC,EAAE;IAAuB,OAAO,CAAC,eAAe;IAJpE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,gBAAgB,CAAY;gBAChB,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAU,eAAe,SAAQ;IAE5E;;OAEG;IACI,KAAK;IAaZ;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B;;;;OAIG;YACW,kBAAkB;IAShC;;;OAGG;IACI,SAAS;CAGjB"}

package/dest/running-promise/index.js

@@ -0,0 +1,59 @@
+/**
+ * RunningPromise is a utility class that helps manage the execution of an asynchronous function
+ * at a specified polling interval. It allows starting, stopping, and checking the status of the
+ * internally managed promise. The class also supports interrupting the polling process when stopped.
+ */
+export class RunningPromise {
+    constructor(fn, pollingInterval = 10000) {
+        this.fn = fn;
+        this.pollingInterval = pollingInterval;
+        this.running = false;
+        this.runningPromise = Promise.resolve();
+        this.interruptPromise = Promise.resolve();
+        this.interruptResolve = () => { };
+    }
+    /**
+     * Starts the running promise.
+     */
+    start() {
+        this.running = true;
+        this.interruptPromise = new Promise(resolve => (this.interruptResolve = resolve));
+        const poll = async () => {
+            while (this.running) {
+                await this.fn();
+                await this.interruptableSleep(this.pollingInterval);
+            }
+        };
+        this.runningPromise = poll();
+    }
+    /**
+     * Stops the running promise, resolves any pending interruptable sleep,
+     * and waits for the currently executing function to complete.
+     */
+    async stop() {
+        this.running = false;
+        this.interruptResolve();
+        await this.runningPromise;
+    }
+    /**
+     * A sleep function that can be interrupted before the specified time.
+     * The sleep duration is determined by 'timeInMs', and it can be terminated early if the 'interruptPromise' is resolved.
+     * @param timeInMs - The time in milliseconds.
+     */
+    async interruptableSleep(timeInMs) {
+        let timeout;
+        const sleepPromise = new Promise(resolve => {
+            timeout = setTimeout(resolve, timeInMs);
+        });
+        await Promise.race([sleepPromise, this.interruptPromise]);
+        clearTimeout(timeout);
+    }
+    /**
+     * Checks if the running promise is currently active.
+     * @returns True if the promise is running.
+     */
+    isRunning() {
+        return this.running;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnVubmluZy1wcm9taXNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8sY0FBYztJQUt6QixZQUFvQixFQUF1QixFQUFVLGtCQUFrQixLQUFLO1FBQXhELE9BQUUsR0FBRixFQUFFLENBQXFCO1FBQVUsb0JBQWUsR0FBZixlQUFlLENBQVE7UUFKcEUsWUFBTyxHQUFHLEtBQUssQ0FBQztRQUNoQixtQkFBYyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNuQyxxQkFBZ0IsR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDckMscUJBQWdCLEdBQUcsR0FBRyxFQUFFLEdBQUUsQ0FBQyxDQUFDO0lBQzJDLENBQUM7SUFFaEY7O09BRUc7SUFDSSxLQUFLO1FBQ1YsSUFBSSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUM7UUFDcEIsSUFBSSxDQUFDLGdCQUFnQixHQUFHLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLENBQUMsQ0FBQztRQUVsRixNQUFNLElBQUksR0FBRyxLQUFLLElBQUksRUFBRTtZQUN0QixPQUFPLElBQUksQ0FBQyxPQUFPLEVBQUU7Z0JBQ25CLE1BQU0sSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDO2dCQUNoQixNQUFNLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUM7YUFDckQ7UUFDSCxDQUFDLENBQUM7UUFDRixJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksRUFBRSxDQUFDO0lBQy9CLENBQUM7SUFFRDs7O09BR0c7SUFDSCxLQUFLLENBQUMsSUFBSTtRQUNSLElBQUksQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDO1FBQ3JCLElBQUksQ0FBQyxnQkFBZ0IsRUFBRSxDQUFDO1FBQ3hCLE1BQU0sSUFBSSxDQUFDLGNBQWMsQ0FBQztJQUM1QixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNLLEtBQUssQ0FBQyxrQkFBa0IsQ0FBQyxRQUFnQjtRQUMvQyxJQUFJLE9BQXdCLENBQUM7UUFDN0IsTUFBTSxZQUFZLEdBQUcsSUFBSSxPQUFPLENBQUMsT0FBTyxDQUFDLEVBQUU7WUFDekMsT0FBTyxHQUFHLFVBQVUsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDMUMsQ0FBQyxDQUFDLENBQUM7UUFDSCxNQUFNLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxZQUFZLEVBQUUsSUFBSSxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQztRQUMxRCxZQUFZLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDeEIsQ0FBQztJQUVEOzs7T0FHRztJQUNJLFNBQVM7UUFDZCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDdEIsQ0FBQztDQUNGIn0=