@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/log/pino-logger.js

@@ -0,0 +1,347 @@
+import { createColors, isColorSupported } from 'colorette';
+import isNode from 'detect-node';
+import { pino, symbols } from 'pino';
+import { inspect } from 'util';
+import { compactArray } from '../collection/array.js';
+import { parseBooleanEnv } from '../config/parse-env.js';
+import { AWSCloudLoggerConfig } from './aws-logger-config.js';
+import { convertBigintsToStrings } from './bigint-utils.js';
+import { GoogleCloudLoggerConfig } from './gcloud-logger-config.js';
+import { getLogLevelFromFilters, parseLogLevelEnvVar } from './log-filters.js';
+const MAX_MODULE_NAME_LENGTH = 256;
+const logBindingsHandlers = [];
+export function addLogBindingsHandler(handler) {
+    logBindingsHandlers.push(handler);
+}
+export function removeLogBindingsHandler(handler) {
+    const index = logBindingsHandlers.indexOf(handler);
+    if (index !== -1) {
+        logBindingsHandlers.splice(index, 1);
+    }
+}
+function getBindingsFromHandlers() {
+    for (const handler of logBindingsHandlers){
+        const bindings = handler();
+        if (bindings) {
+            return bindings;
+        }
+    }
+    return undefined;
+}
+export function createLogger(module, bindings) {
+    module = module.slice(0, MAX_MODULE_NAME_LENGTH).replace(/^aztec:/, '');
+    const resolvedBindings = {
+        ...getBindingsFromHandlers(),
+        ...bindings
+    };
+    const actor = resolvedBindings?.actor;
+    const instanceId = resolvedBindings?.instanceId;
+    const pinoLogger = logger.child({
+        module,
+        ...actor && {
+            actor
+        },
+        ...instanceId && {
+            instanceId
+        }
+    }, {
+        level: getLogLevelFromFilters(logFilters, module)
+    });
+    // We check manually for isLevelEnabled to avoid calling processLogData unnecessarily.
+    // Note that isLevelEnabled is missing from the browser version of pino.
+    const logFn = (level, msg, data)=>isLevelEnabled(pinoLogger, level) && pinoLogger[level](processLogData(data ?? {}), msg);
+    return {
+        silent: ()=>{},
+        // TODO(palla/log): Should we move err to data instead of the text message?
+        /** Log as fatal. Use when an error has brought down the system. */ fatal: (msg, err, data)=>logFn('fatal', formatErr(msg, err), data),
+        /** Log as error. Use for errors in general. */ error: (msg, err, data)=>logFn('error', formatErr(msg, err), data),
+        /** Log as warn. Use for when we stray from the happy path. */ warn: (msg, data)=>logFn('warn', msg, data),
+        /** Log as info. Use for providing an operator with info on what the system is doing. */ info: (msg, data)=>logFn('info', msg, data),
+        /** Log as verbose. Use for when we need additional insight on what a subsystem is doing. */ verbose: (msg, data)=>logFn('verbose', msg, data),
+        /** Log as debug. Use for when we need debugging info to troubleshoot an issue on a specific component. */ debug: (msg, data)=>logFn('debug', msg, data),
+        /** Log as trace. Use for when we want to denial-of-service any recipient of the logs. */ trace: (msg, data)=>logFn('trace', msg, data),
+        /** Level of the logger */ level: pinoLogger.level,
+        /** Whether the given level is enabled for this logger. */ isLevelEnabled: (level)=>isLevelEnabled(pinoLogger, level),
+        /** Module name for the logger. */ module,
+        /** Creates another logger by extending this logger module name and preserving bindings. */ createChild: (childModule)=>createLogger(`${module}:${childModule}`, {
+                actor,
+                instanceId
+            }),
+        /** Returns the bindings (actor, instanceId) for this logger. */ getBindings: ()=>({
+                actor,
+                instanceId
+            })
+    };
+}
+/**
+ * Returns a logger for the given module. If loggerOrBindings is already a Logger, returns it directly.
+ * Otherwise, creates a new logger with the given module name and bindings.
+ */ export function resolveLogger(module, loggerOrBindings) {
+    if (loggerOrBindings && 'info' in loggerOrBindings) {
+        return loggerOrBindings;
+    }
+    return createLogger(module, loggerOrBindings);
+}
+const logDataHandlers = [];
+export function addLogDataHandler(handler) {
+    logDataHandlers.push(handler);
+}
+function processLogData(data) {
+    return logDataHandlers.reduce((accum, handler)=>handler(accum), data);
+}
+// Patch isLevelEnabled missing from pino/browser.
+function isLevelEnabled(logger, level) {
+    return typeof logger.isLevelEnabled === 'function' ? logger.isLevelEnabled(level) : logger.levels.values[level] >= logger.levels.values[logger.level];
+}
+// Load log levels from environment variables.
+const defaultLogLevel = process.env.NODE_ENV === 'test' ? 'silent' : 'info';
+export const [logLevel, logFilters] = parseLogLevelEnvVar(process.env.LOG_LEVEL, defaultLogLevel);
+// Define custom logging levels for pino.
+const customLevels = {
+    verbose: 25
+};
+// Global pino options, tweaked for the active cloud logging backend.
+const useGcloudLogging = parseBooleanEnv(process.env['USE_GCLOUD_LOGGING']);
+const useAwsLogging = parseBooleanEnv(process.env['USE_AWS_LOGGING']);
+const loggingConfig = useGcloudLogging ? GoogleCloudLoggerConfig : useAwsLogging ? AWSCloudLoggerConfig : {
+    formatters: {},
+    messageKey: 'msg'
+};
+const redactedPaths = [
+    'validatorPrivateKeys',
+    // for both the validator and the prover
+    'publisherPrivateKeys',
+    'peerIdPrivateKey',
+    // bot keys
+    'l1PrivateKey',
+    'senderPrivateKey',
+    // blob sink
+    'l1ConsensusHostApiKeys',
+    // sensitive options used in the CLI
+    'privateKey',
+    'mnemonic',
+    'l1Mnemonic',
+    'l1PrivateKey'
+];
+const pinoOpts = {
+    customLevels,
+    messageKey: loggingConfig.messageKey,
+    useOnlyCustomLevels: false,
+    level: logLevel,
+    redact: {
+        paths: [
+            ...redactedPaths,
+            ...redactedPaths.map((p)=>`config.${p}`),
+            ...redactedPaths.map((p)=>`cfg.${p}`),
+            ...redactedPaths.map((p)=>`options.${p}`),
+            ...redactedPaths.map((p)=>`opts.${p}`)
+        ]
+    },
+    formatters: {
+        log: (obj)=>convertBigintsToStrings(obj),
+        ...loggingConfig.formatters
+    }
+};
+export const levels = {
+    labels: {
+        ...pino.levels.labels,
+        ...Object.fromEntries(Object.entries(customLevels).map((e)=>e.reverse()))
+    },
+    values: {
+        ...pino.levels.values,
+        ...customLevels
+    }
+};
+// Transport options for pretty logging to stderr via pino-pretty.
+const colorEnv = process.env['FORCE_COLOR'];
+const useColor = colorEnv === undefined ? isColorSupported : parseBooleanEnv(colorEnv);
+const { bold, reset, cyan, magenta, yellow, blue, green, magentaBright, yellowBright, blueBright, greenBright } = createColors({
+    useColor
+});
+// Per-actor coloring: each unique actor gets a different color for easier visual distinction.
+// Disabled when LOG_NO_COLOR_PER_ACTOR is set to a truthy value.
+const useColorPerActor = useColor && !parseBooleanEnv(process.env['LOG_NO_COLOR_PER_ACTOR']);
+const actorColors = [
+    yellow,
+    magenta,
+    blue,
+    green,
+    magentaBright,
+    yellowBright,
+    blueBright,
+    greenBright
+];
+const actorColorMap = new Map();
+let nextColorIndex = 0;
+/** Returns the color function assigned to a given actor, assigning a new one if needed. */ export function getActorColor(actor) {
+    let color = actorColorMap.get(actor);
+    if (!color) {
+        color = actorColors[nextColorIndex % actorColors.length];
+        actorColorMap.set(actor, color);
+        nextColorIndex++;
+    }
+    return color;
+}
+/** Resets the actor-to-color mapping. Useful for testing. */ export function resetActorColors() {
+    actorColorMap.clear();
+    nextColorIndex = 0;
+}
+// String template for messageFormat (used in worker threads and when per-actor coloring is disabled).
+const messageFormatString = `${bold('{module}')}{if actor} ${cyan('{actor}')}{end}{if instanceId} ${reset(cyan('{instanceId}'))}{end} ${reset('{msg}')}`;
+/** Formats a log message with per-actor coloring. Actor, module, and instanceId share the same color. */ export function formatLogMessage(log, messageKey) {
+    const actor = log.actor;
+    const module = log.module ?? '';
+    const instanceId = log.instanceId;
+    const msg = log[messageKey] ?? '';
+    // Use actor color for actor, module, and instanceId when actor is present
+    const color = actor ? getActorColor(actor) : cyan;
+    let result = bold(color(module));
+    if (actor) {
+        result += ' ' + color(actor);
+    }
+    if (instanceId) {
+        result += ' ' + reset(color(instanceId));
+    }
+    result += ' ' + reset(String(msg));
+    return result;
+}
+// Base options for pino-pretty (shared between transport and direct use).
+const pinoPrettyBaseOpts = {
+    destination: 2,
+    sync: true,
+    colorize: useColor,
+    ignore: 'module,actor,instanceId,pid,hostname,trace_id,span_id,trace_flags,severity,severityText,severityNumber',
+    customLevels: 'fatal:60,error:50,warn:40,info:30,verbose:25,debug:20,trace:10',
+    customColors: 'fatal:bgRed,error:red,warn:yellow,info:green,verbose:magenta,debug:blue,trace:gray',
+    minimumLevel: 'trace',
+    singleLine: !parseBooleanEnv(process.env['LOG_MULTILINE'])
+};
+/**
+ * Pino-pretty options for direct use (e.g., jest/setup.mjs).
+ * Includes function-based messageFormat for per-actor coloring when enabled.
+ */ export const pinoPrettyOpts = {
+    ...pinoPrettyBaseOpts,
+    messageFormat: useColorPerActor ? formatLogMessage : messageFormatString
+};
+// Transport options use string template only (functions can't be serialized to worker threads).
+const prettyTransportOpts = {
+    ...pinoPrettyBaseOpts,
+    messageFormat: messageFormatString
+};
+const prettyTransport = {
+    target: 'pino-pretty',
+    options: prettyTransportOpts,
+    level: 'trace'
+};
+// Transport for vanilla stdio logging as JSON.
+const stdioTransport = {
+    target: 'pino/file',
+    options: {
+        destination: 2
+    },
+    level: 'trace'
+};
+// Transport for OpenTelemetry logging. While defining this here is an abstraction leakage since this
+// should live in the telemetry-client, it is necessary to ensure that the logger is initialized with
+// the correct transport. Tweaking transports of a live pino instance is tricky, and creating a new instance
+// would mean that all child loggers created before the telemetry-client is initialized would not have
+// this transport configured. Note that the target is defined as the export in the telemetry-client,
+// since pino will load this transport separately on a worker thread, to minimize disruption to the main loop.
+const otlpEndpoint = process.env['OTEL_EXPORTER_OTLP_LOGS_ENDPOINT'];
+const otlpEnabled = !!otlpEndpoint && !useGcloudLogging;
+const otelOpts = {
+    levels
+};
+const otelTransport = {
+    target: '@aztec-labs/telemetry-client/otel-pino-stream',
+    options: otelOpts,
+    level: 'trace'
+};
+function makeLogger() {
+    if (!isNode) {
+        // We are on the browser.
+        return pino({
+            ...pinoOpts,
+            browser: {
+                asObject: false
+            }
+        });
+    } else if (process.env.JEST_WORKER_ID) {
+        // We are on jest, so we need sync logging and stream to stderr.
+        // We expect jest/setup.mjs to kick in later and replace set up a pretty logger,
+        // but if for some reason it doesn't, at least we're covered with a default logger.
+        return pino(pinoOpts, pino.destination(2));
+    } else {
+        // Regular nodejs with transports on worker thread, using pino-pretty for console logging if LOG_JSON
+        // is not set, and an optional OTLP transport if the OTLP endpoint is set.
+        const targets = compactArray([
+            parseBooleanEnv(process.env.LOG_JSON) ? stdioTransport : prettyTransport,
+            otlpEnabled ? otelTransport : undefined
+        ]);
+        return pino(pinoOpts, pino.transport({
+            targets,
+            levels: levels.values
+        }));
+    }
+}
+export const logger = makeLogger();
+// Log the logger configuration.
+logger.verbose({
+    module: 'logger',
+    ...logFilters.reduce((accum, [module, level])=>({
+            ...accum,
+            [`log.${module}`]: level
+        }), {})
+}, isNode ? `Logger initialized with level ${logLevel}` + (otlpEnabled ? ` with OTLP exporter to ${otlpEndpoint}` : '') : `Browser console logger initialized with level ${logLevel}`);
+/**
+ * Overwrites the logging stream with a different destination.
+ * Used by jest/setup.mjs to set up a pretty logger.
+ */ export function overwriteLoggingStream(stream) {
+    logger[symbols.streamSym] = stream;
+}
+/**
+ * Registers an additional destination to the pino logger.
+ * Use only when working with destinations, not worker transports.
+ */ export function registerLoggingStream(stream) {
+    logger.verbose({
+        module: 'logger'
+    }, `Registering additional logging stream`);
+    const original = logger[symbols.streamSym];
+    const destination = original ? pino.multistream([
+        // Set streams to lowest logging level, and control actual logging from the parent logger
+        // otherwise streams default to info and refuse to log anything below that.
+        {
+            level: 'trace',
+            stream: original
+        },
+        {
+            level: 'trace',
+            stream
+        }
+    ], {
+        levels: levels.values
+    }) : stream;
+    logger[symbols.streamSym] = destination;
+}
+/**
+ * Concatenates a log message and an exception.
+ * @param msg - Log message
+ * @param err - Error to log
+ * @returns A string with both the log message and the error message.
+ */ function formatErr(msg, err) {
+    if (!err) {
+        return msg;
+    }
+    try {
+        return `${msg}: ${inspect(err)}`;
+    } catch  {
+        // inspect can crash on error objects with broken property descriptors
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            return `${msg}: ${err instanceof Error ? `${err.name}: ${err.message}` : String(err)}`;
+        } catch  {
+            // if even String(err) fails, return the original message with a note about the error
+            return `${msg}: [unserializable error]`;
+        }
+    }
+}

package/dest/message/index.d.ts

@@ -0,0 +1,32 @@
+export type MessageHeaderInit = {
+    /** The message ID. Optional, if not set defaults to 0 */
+    messageId?: number;
+    /** Identifies the original request. Optional */
+    requestId?: number;
+};
+export declare class MessageHeader {
+    /** An number to identify this message */
+    readonly messageId: number;
+    /** If this message is a response to a request, the messageId of the request */
+    readonly requestId: number;
+    constructor({ messageId, requestId }: MessageHeaderInit);
+    static fromMessagePack(data: object): MessageHeader;
+}
+interface TypedMessageLike {
+    msgType: number;
+    header: {
+        messageId?: number;
+        requestId?: number;
+    };
+    value: any;
+}
+export declare class TypedMessage<T, B> {
+    readonly msgType: T;
+    readonly header: MessageHeader;
+    readonly value: B;
+    constructor(msgType: T, header: MessageHeader, value: B);
+    static fromMessagePack<T, B>(data: TypedMessageLike): TypedMessage<T, B>;
+    static isTypedMessageLike(obj: any): obj is TypedMessageLike;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZXNzYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sTUFBTSxpQkFBaUIsR0FBRztJQUM5Qix5REFBeUQ7SUFDekQsU0FBUyxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBQ25CLGdEQUFnRDtJQUNoRCxTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDcEIsQ0FBQztBQUVGLHFCQUFhLGFBQWE7SUFDeEIseUNBQXlDO0lBQ3pDLFNBQWdCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEMsK0VBQStFO0lBQy9FLFNBQWdCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFFbEMsWUFBWSxFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQUUsRUFBRSxpQkFBaUIsRUFHdEQ7SUFFRCxNQUFNLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRSxNQUFNLEdBQUcsYUFBYSxDQUVsRDtDQUNGO0FBRUQsVUFBVSxnQkFBZ0I7SUFDeEIsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixNQUFNLEVBQUU7UUFDTixTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7UUFDbkIsU0FBUyxDQUFDLEVBQUUsTUFBTSxDQUFDO0tBQ3BCLENBQUM7SUFDRixLQUFLLEVBQUUsR0FBRyxDQUFDO0NBQ1o7QUFFRCxxQkFBYSxZQUFZLENBQUMsQ0FBQyxFQUFFLENBQUM7YUFFVixPQUFPLEVBQUUsQ0FBQzthQUNWLE1BQU0sRUFBRSxhQUFhO2FBQ3JCLEtBQUssRUFBRSxDQUFDO0lBSDFCLFlBQ2tCLE9BQU8sRUFBRSxDQUFDLEVBQ1YsTUFBTSxFQUFFLGFBQWEsRUFDckIsS0FBSyxFQUFFLENBQUMsRUFDdEI7SUFFSixNQUFNLENBQUMsZUFBZSxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixHQUFHLFlBQVksQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBRXZFO0lBRUQsTUFBTSxDQUFDLGtCQUFrQixDQUFDLEdBQUcsRUFBRSxHQUFHLEdBQUcsR0FBRyxJQUFJLGdCQUFnQixDQUUzRDtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/message/index.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,qBAAa,aAAa;IACxB,yCAAyC;IACzC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,+EAA+E;IAC/E,SAAgB,SAAS,EAAE,MAAM,CAAC;IAElC,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,iBAAiB,EAGtD;IAED,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAElD;CACF;AAED,UAAU,gBAAgB;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE;QACN,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC;CACZ;AAED,qBAAa,YAAY,CAAC,CAAC,EAAE,CAAC;aAEV,OAAO,EAAE,CAAC;aACV,MAAM,EAAE,aAAa;aACrB,KAAK,EAAE,CAAC;IAH1B,YACkB,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,CAAC,EACtB;IAEJ,MAAM,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAEvE;IAED,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,gBAAgB,CAE3D;CACF"}

package/dest/message/index.js

@@ -0,0 +1,27 @@
+export class MessageHeader {
+    /** An number to identify this message */ messageId;
+    /** If this message is a response to a request, the messageId of the request */ requestId;
+    constructor({ messageId, requestId }){
+        this.messageId = messageId ?? 0;
+        this.requestId = requestId ?? 0;
+    }
+    static fromMessagePack(data) {
+        return new MessageHeader(data);
+    }
+}
+export class TypedMessage {
+    msgType;
+    header;
+    value;
+    constructor(msgType, header, value){
+        this.msgType = msgType;
+        this.header = header;
+        this.value = value;
+    }
+    static fromMessagePack(data) {
+        return new TypedMessage(data['msgType'], MessageHeader.fromMessagePack(data['header']), data['value']);
+    }
+    static isTypedMessageLike(obj) {
+        return typeof obj === 'object' && obj !== null && 'msgType' in obj && 'header' in obj && 'value' in obj;
+    }
+}

package/dest/mutex/index.d.ts

@@ -0,0 +1,53 @@
+import type { 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tdXRleC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV6RCxjQUFjLHFCQUFxQixDQUFDO0FBRXBDOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxxQkFBYSxLQUFLO0lBS2QsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFO0lBQ25CLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSTtJQUNyQixPQUFPLENBQUMsUUFBUSxDQUFDLE9BQU87SUFDeEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxlQUFlO0lBQ2hDLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWTtJQVIvQixPQUFPLENBQUMsRUFBRSxDQUFLO0lBQ2YsT0FBTyxDQUFDLFdBQVcsQ0FBa0I7SUFFckMsWUFDbUIsRUFBRSxFQUFFLGFBQWEsRUFDakIsSUFBSSxFQUFFLE1BQU0sRUFDWixPQUFPLFNBQU8sRUFDZCxlQUFlLFNBQU8sRUFDdEIsWUFBWSxTQUFPLEVBQ2xDO0lBRUo7Ozs7Ozs7T0FPRztJQUNVLElBQUksQ0FBQyxhQUFhLFVBQU8sb0JBYXJDO0lBRUQ7Ozs7OztPQU1HO0lBQ1UsTUFBTSxrQkFJbEI7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsT0FBTyxDQUFDLElBQUk7Q0FTYiJ9

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,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,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;IAErC,YACmB,EAAE,EAAE,aAAa,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,SAAO,EACd,eAAe,SAAO,EACtB,YAAY,SAAO,EAClC;IAEJ;;;;;;;OAOG;IACU,IAAI,CAAC,aAAa,UAAO,oBAarC;IAED;;;;;;OAMG;IACU,MAAM,kBAIlB;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,IAAI;CASb"}

package/dest/mutex/index.js

@@ -0,0 +1,78 @@
+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 {
+    db;
+    name;
+    timeout;
+    tryLockInterval;
+    pingInterval;
+    id;
+    pingTimeout;
+    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.
+   */ ping(id) {
+        if (id !== this.id) {
+            return;
+        }
+        void (async ()=>{
+            await this.db.extendLock(this.name, this.timeout);
+            this.pingTimeout = setTimeout(()=>this.ping(id), this.pingInterval);
+        })();
+    }
+}

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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXV0ZXhfZGF0YWJhc2UuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tdXRleC9tdXRleF9kYXRhYmFzZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFDSCxNQUFNLFdBQVcsYUFBYTtJQUM1QixXQUFXLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUU3RCxVQUFVLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUV6RCxXQUFXLENBQUMsSUFBSSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUM7Q0FDMUMifQ==

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;IAC5B,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,4 @@
+/**
+ * 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 { };

package/dest/noir/index.d.ts

@@ -0,0 +1,2 @@
+export * from './noir_package_config.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9ub2lyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUMifQ==

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

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

package/dest/noir/index.js

@@ -0,0 +1 @@
+export * from './noir_package_config.js';

package/dest/noir/noir_package_config.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+declare const noirGitDependencySchema: z.ZodObject<{
+    git: z.ZodString;
+    tag: z.ZodString;
+    directory: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const noirLocalDependencySchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+/**
+ * A remote package dependency.
+ */
+export type NoirGitDependencyConfig = z.infer<typeof noirGitDependencySchema>;
+/**
+ * A local package dependency.
+ */
+export type NoirLocalDependencyConfig = z.infer<typeof noirLocalDependencySchema>;
+/**
+ * A package dependency.
+ */
+export type NoirDependencyConfig = NoirGitDependencyConfig | NoirLocalDependencyConfig;
+/**
+ * Noir package configuration.
+ */
+export type NoirPackageConfig = {
+    package: {
+        name: string;
+        type: 'lib' | 'contract' | 'bin';
+        entry?: string | undefined;
+        description?: string | undefined;
+        authors?: string[] | undefined;
+        compiler_version?: string | undefined;
+        backend?: string | undefined;
+        license?: string | undefined;
+    };
+    dependencies: Record<string, NoirDependencyConfig>;
+};
+/**
+ * Checks that an object is a package configuration.
+ * @param config - Config to check
+ */
+export declare function parseNoirPackageConfig(config: any): NoirPackageConfig;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9pcl9wYWNrYWdlX2NvbmZpZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL25vaXIvbm9pcl9wYWNrYWdlX2NvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLFFBQUEsTUFBTSx1QkFBdUI7Ozs7aUJBSTNCLENBQUM7QUFFSCxRQUFBLE1BQU0seUJBQXlCOztpQkFFN0IsQ0FBQztBQUVIOztHQUVHO0FBQ0gsTUFBTSxNQUFNLHVCQUF1QixHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyx1QkFBdUIsQ0FBQyxDQUFDO0FBRTlFOztHQUVHO0FBQ0gsTUFBTSxNQUFNLHlCQUF5QixHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyx5QkFBeUIsQ0FBQyxDQUFDO0FBRWxGOztHQUVHO0FBQ0gsTUFBTSxNQUFNLG9CQUFvQixHQUFHLHVCQUF1QixHQUFHLHlCQUF5QixDQUFDO0FBRXZGOztHQUVHO0FBQ0gsTUFBTSxNQUFNLGlCQUFpQixHQUFHO0lBQzlCLE9BQU8sRUFBRTtRQUNQLElBQUksRUFBRSxNQUFNLENBQUM7UUFDYixJQUFJLEVBQUUsS0FBSyxHQUFHLFVBQVUsR0FBRyxLQUFLLENBQUM7UUFDakMsS0FBSyxDQUFDLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztRQUMzQixXQUFXLENBQUMsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO1FBQ2pDLE9BQU8sQ0FBQyxFQUFFLE1BQU0sRUFBRSxHQUFHLFNBQVMsQ0FBQztRQUMvQixnQkFBZ0IsQ0FBQyxFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUM7UUFDdEMsT0FBTyxDQUFDLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztRQUM3QixPQUFPLENBQUMsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDO0tBQzlCLENBQUM7SUFDRixZQUFZLEVBQUUsTUFBTSxDQUFDLE1BQU0sRUFBRSxvQkFBb0IsQ0FBQyxDQUFDO0NBQ3BELENBQUM7QUFpQkY7OztHQUdHO0FBQ0gsd0JBQWdCLHNCQUFzQixDQUFDLE1BQU0sRUFBRSxHQUFHLEdBQUcsaUJBQWlCLENBRXJFIn0=

package/dest/noir/noir_package_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noir_package_config.d.ts","sourceRoot":"","sources":["../../src/noir/noir_package_config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,QAAA,MAAM,uBAAuB;;;;iBAI3B,CAAC;AAEH,QAAA,MAAM,yBAAyB;;iBAE7B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,GAAG,yBAAyB,CAAC;AAEvF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,KAAK,GAAG,UAAU,GAAG,KAAK,CAAC;QACjC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QACjC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;QAC/B,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QACtC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC7B,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KAC9B,CAAC;IACF,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;CACpD,CAAC;AAiBF;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,GAAG,GAAG,iBAAiB,CAErE"}