@aztec/foundation 0.66.0 → 0.67.1-devnet

package/src/log/pino-logger.ts

@@ -1,7 +1,6 @@
 import { createColors } from 'colorette';
 import isNode from 'detect-node';
 import { pino, symbols } from 'pino';
-import pretty from 'pino-pretty';
 import { type Writable } from 'stream';
 import { inspect } from 'util';
 
@@ -10,38 +9,37 @@ import { getLogLevelFromFilters, parseEnv } from './log-filters.js';
 import { type LogLevel } from './log-levels.js';
 import { type LogData, type LogFn } from './log_fn.js';
 
-// TODO(palla/log): Rename to createLogger
-export function createDebugLogger(module: string): DebugLogger {
-  // TODO(palla/log): Rename all module names to remove the aztec prefix
-  const pinoLogger = logger.child(
-    { module: module.replace(/^aztec:/, '') },
-    { level: getLogLevelFromFilters(logFilters, module) },
-  );
+export function createLogger(module: string): Logger {
+  module = module.replace(/^aztec:/, '');
+  const pinoLogger = logger.child({ module }, { 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: LogLevel, msg: string, data?: LogData) =>
-    isLevelEnabled(pinoLogger, level) && pinoLogger[level](processLogData(data ?? {}), msg);
+  const logFn = (level: LogLevel, msg: string, data?: unknown) =>
+    isLevelEnabled(pinoLogger, level) && pinoLogger[level](processLogData((data as LogData) ?? {}), 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: string, err?: unknown, data?: LogData) => logFn('fatal', formatErr(msg, err), data),
+    fatal: (msg: string, err?: unknown, data?: unknown) => logFn('fatal', formatErr(msg, err), data),
     /** Log as error. Use for errors in general. */
-    error: (msg: string, err?: unknown, data?: LogData) => logFn('error', formatErr(msg, err), data),
+    error: (msg: string, err?: unknown, data?: unknown) => logFn('error', formatErr(msg, err), data),
     /** Log as warn. Use for when we stray from the happy path. */
-    warn: (msg: string, data?: LogData) => logFn('warn', msg, data),
+    warn: (msg: string, data?: unknown) => logFn('warn', msg, data),
     /** Log as info. Use for providing an operator with info on what the system is doing. */
-    info: (msg: string, data?: LogData) => logFn('info', msg, data),
+    info: (msg: string, data?: unknown) => logFn('info', msg, data),
     /** Log as verbose. Use for when we need additional insight on what a subsystem is doing. */
-    verbose: (msg: string, data?: LogData) => logFn('verbose', msg, data),
+    verbose: (msg: string, data?: unknown) => logFn('verbose', msg, data),
     /** Log as debug. Use for when we need debugging info to troubleshoot an issue on a specific component. */
-    debug: (msg: string, data?: LogData) => logFn('debug', msg, data),
+    debug: (msg: string, data?: unknown) => logFn('debug', msg, data),
     /** Log as trace. Use for when we want to denial-of-service any recipient of the logs. */
-    trace: (msg: string, data?: LogData) => logFn('trace', msg, data),
+    trace: (msg: string, data?: unknown) => logFn('trace', msg, data),
     level: pinoLogger.level as LogLevel,
+    /** Whether the given level is enabled for this logger. */
     isLevelEnabled: (level: LogLevel) => isLevelEnabled(pinoLogger, level),
+    /** Module name for the logger. */
+    module,
   };
 }
 
@@ -69,10 +67,58 @@ function isLevelEnabled(logger: pino.Logger<'verbose', boolean>, level: LogLevel
 const defaultLogLevel = process.env.NODE_ENV === 'test' ? 'silent' : 'info';
 const [logLevel, logFilters] = parseEnv(process.env.LOG_LEVEL, defaultLogLevel);
 
+// Define custom logging levels for pino.
+const customLevels = { verbose: 25 };
+
+// inspired by https://github.com/pinojs/pino/issues/726#issuecomment-605814879
+const levelToSeverityFormatter = (label: string, level: number): object => {
+  // Severity labels https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
+  let severity: string;
+
+  switch (label as pino.Level | keyof typeof customLevels) {
+    case 'trace':
+    case 'debug':
+      severity = 'DEBUG';
+      break;
+    case 'verbose':
+    case 'info':
+      severity = 'INFO';
+      break;
+    case 'warn':
+      severity = 'WARNING';
+      break;
+    case 'error':
+      severity = 'ERROR';
+      break;
+    case 'fatal':
+      severity = 'CRITICAL';
+      break;
+    default:
+      severity = 'DEFAULT';
+      break;
+  }
+
+  return { severity, level };
+};
+
+const pinoOpts: pino.LoggerOptions<keyof typeof customLevels> = {
+  customLevels,
+  useOnlyCustomLevels: false,
+  level: logLevel,
+  formatters: {
+    level: levelToSeverityFormatter,
+  },
+};
+
+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 useColor = true;
 const { bold, reset } = createColors({ useColor });
-const pinoPrettyOpts = {
+export const pinoPrettyOpts = {
   destination: 2,
   sync: true,
   colorize: useColor,
@@ -81,25 +127,20 @@ const pinoPrettyOpts = {
   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' as const,
+  singleLine: !['1', 'true'].includes(process.env.LOG_MULTILINE ?? ''),
 };
-const prettyTransport: pino.TransportSingleOptions = {
+
+const prettyTransport: pino.TransportTargetOptions = {
   target: 'pino-pretty',
   options: pinoPrettyOpts,
+  level: 'trace',
 };
 
 // Transport for vanilla stdio logging as JSON.
-const stdioTransport: pino.TransportSingleOptions = {
+const stdioTransport: pino.TransportTargetOptions = {
   target: 'pino/file',
   options: { destination: 2 },
-};
-
-// Define custom logging levels for pino.
-const customLevels = { verbose: 25 };
-const pinoOpts = { customLevels, useOnlyCustomLevels: false, level: logLevel };
-
-export const levels = {
-  labels: { ...pino.levels.labels, ...Object.fromEntries(Object.entries(customLevels).map(e => e.reverse())) },
-  values: { ...pino.levels.values, ...customLevels },
+  level: 'trace',
 };
 
 // Transport for OpenTelemetry logging. While defining this here is an abstraction leakage since this
@@ -110,18 +151,21 @@ export const levels = {
 // 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 otelOpts = { levels };
-const otelTransport: pino.TransportSingleOptions = {
+const otelTransport: pino.TransportTargetOptions = {
   target: '@aztec/telemetry-client/otel-pino-stream',
   options: otelOpts,
+  level: 'trace',
 };
 
 function makeLogger() {
   if (!isNode) {
-    // We are on the browser
+    // 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. We stream to stderr with pretty.
-    return pino(pinoOpts, pretty(pinoPrettyOpts));
+    // 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 provided.
@@ -129,7 +173,7 @@ function makeLogger() {
       ['1', 'true', 'TRUE'].includes(process.env.LOG_JSON ?? '') ? stdioTransport : prettyTransport,
       otlpEndpoint ? otelTransport : undefined,
     ]);
-    return pino(pinoOpts, pino.transport({ targets }));
+    return pino(pinoOpts, pino.transport({ targets, levels: levels.values }));
   }
 }
 
@@ -146,6 +190,14 @@ logger.verbose(
     : `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: Writable): void {
+  (logger as any)[symbols.streamSym] = stream;
+}
+
 /**
  * Registers an additional destination to the pino logger.
  * Use only when working with destinations, not worker transports.
@@ -176,15 +228,9 @@ type ErrorLogFn = (msg: string, err?: Error | unknown, data?: LogData) => void;
 export type Logger = { [K in LogLevel]: LogFn } & { /** Error log function */ error: ErrorLogFn } & {
   level: LogLevel;
   isLevelEnabled: (level: LogLevel) => boolean;
+  module: string;
 };
 
-/**
- * Logger that supports multiple severity levels and can be called directly to issue a debug statement.
- * Intended as a drop-in replacement for the debug module.
- * TODO(palla/log): Remove this alias
- */
-export type DebugLogger = Logger;
-
 /**
  * Concatenates a log message and an exception.
  * @param msg - Log message

package/src/promise/running-promise.ts

@@ -1,3 +1,4 @@
+import { createLogger } from '../log/pino-logger.js';
 import { InterruptibleSleep } from '../sleep/index.js';
 import { type PromiseWithResolvers, promiseWithResolvers } from './utils.js';
 
@@ -12,7 +13,11 @@ export class RunningPromise {
   private interruptibleSleep = new InterruptibleSleep();
   private requested: PromiseWithResolvers<void> | undefined = undefined;
 
-  constructor(private fn: () => void | Promise<void>, private pollingIntervalMS = 10000) {}
+  constructor(
+    private fn: () => void | Promise<void>,
+    private logger = createLogger('running-promise'),
+    private pollingIntervalMS = 10000,
+  ) {}
 
   /**
    * Starts the running promise.
@@ -23,7 +28,11 @@ export class RunningPromise {
     const poll = async () => {
       while (this.running) {
         const hasRequested = this.requested !== undefined;
-        await this.fn();
+        try {
+          await this.fn();
+        } catch (err) {
+          this.logger.error('Error in running promise', err);
+        }
 
         // If an immediate run had been requested *before* the function started running, resolve the request.
         if (hasRequested) {

package/src/queue/base_memory_queue.ts

@@ -1,11 +1,11 @@
 import { TimeoutError } from '../error/index.js';
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 
 export abstract class BaseMemoryQueue<T> {
   private waiting: ((item: T | null) => void)[] = [];
   private flushing = false;
 
-  constructor(private log = createDebugLogger('aztec:foundation:memory_fifo')) {}
+  constructor(private log = createLogger('foundation:memory_fifo')) {}
 
   protected abstract get items(): {
     length: number;

package/src/queue/bounded_serial_queue.ts

@@ -1,4 +1,4 @@
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { Semaphore } from './semaphore.js';
 import { SerialQueue } from './serial_queue.js';
 
@@ -10,7 +10,7 @@ export class BoundedSerialQueue {
   private readonly queue = new SerialQueue();
   private semaphore: Semaphore;
 
-  constructor(maxQueueSize: number, private log = createDebugLogger('aztec:foundation:bounded_serial_queue')) {
+  constructor(maxQueueSize: number, private log = createLogger('foundation:bounded_serial_queue')) {
     this.semaphore = new Semaphore(maxQueueSize);
   }
 

package/src/queue/fifo_memory_queue.ts

@@ -1,4 +1,4 @@
-import { type DebugLogger } from '../log/index.js';
+import { type Logger } from '../log/index.js';
 import { BaseMemoryQueue } from './base_memory_queue.js';
 
 /**
@@ -9,7 +9,7 @@ import { BaseMemoryQueue } from './base_memory_queue.js';
 export class FifoMemoryQueue<T> extends BaseMemoryQueue<T> {
   private container = new FifoQueue<T>();
 
-  constructor(log?: DebugLogger) {
+  constructor(log?: Logger) {
     super(log);
   }
 

package/src/retry/index.ts

@@ -1,4 +1,4 @@
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { sleep } from '../sleep/index.js';
 import { Timer } from '../timer/index.js';
 
@@ -48,7 +48,7 @@ export async function retry<Result>(
   fn: () => Promise<Result>,
   name = 'Operation',
   backoff = backoffGenerator(),
-  log = createDebugLogger('aztec:foundation:retry'),
+  log = createLogger('foundation:retry'),
   failSilently = false,
 ) {
   while (true) {
@@ -64,7 +64,7 @@ export async function retry<Result>(
         throw err;
       }
       log.verbose(`${name} failed. Will retry in ${s}s...`);
-      !failSilently && log.error(err);
+      !failSilently && log.error(`Error while retrying ${name}`, err);
       await sleep(s * 1000);
       continue;
     }

package/src/schemas/utils.ts

@@ -3,13 +3,16 @@ import {
   type ParseInput,
   type ParseReturnType,
   ZodFirstPartyTypeKind,
+  type ZodObject,
   ZodOptional,
   ZodParsedType,
+  type ZodRawShape,
   type ZodType,
   type ZodTypeAny,
   z,
 } from 'zod';
 
+import { pick } from '../collection/object.js';
 import { isHex, withoutHexPrefix } from '../string/index.js';
 import { type ZodFor } from './types.js';
 
@@ -72,10 +75,10 @@ export function hexSchemaFor<TClass extends { fromString(str: string): any } | {
   string
 > {
   const stringSchema = refinement ? z.string().refine(refinement, `Not a valid instance`) : z.string();
-  const hexSchema = stringSchema.refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
+  const hexSchema = stringSchema.refine(isHex, 'Not a valid hex string');
   return 'fromString' in klazz
     ? hexSchema.transform(klazz.fromString.bind(klazz))
-    : hexSchema.transform(str => Buffer.from(str, 'hex')).transform(klazz.fromBuffer.bind(klazz));
+    : hexSchema.transform(str => Buffer.from(withoutHexPrefix(str), 'hex')).transform(klazz.fromBuffer.bind(klazz));
 }
 
 /**
@@ -102,3 +105,8 @@ export function mapSchema<TKey, TValue>(key: ZodFor<TKey>, value: ZodFor<TValue>
 export function setSchema<T>(value: ZodFor<T>): ZodFor<Set<T>> {
   return z.array(value).transform(entries => new Set(entries));
 }
+
+/** Given an already parsed and validated object, extracts the keys defined in the given schema. Does not validate again. */
+export function pickFromSchema<T extends object, S extends ZodObject<ZodRawShape>>(obj: T, schema: S) {
+  return pick(obj, ...Object.keys(schema.shape));
+}

package/src/serialize/field_reader.ts

@@ -140,4 +140,12 @@ export class FieldReader {
   }): T {
     return deserializer.fromFields(this);
   }
+
+  /**
+   * Returns whether the reader has finished reading all fields.
+   * @returns A bool.
+   */
+  public isFinished(): boolean {
+    return this.index === this.length;
+  }
 }

package/src/string/index.ts

@@ -25,3 +25,7 @@ export function pluralize(str: string, count: number | bigint, plural?: string):
 export function count(count: number | bigint, str: string, plural?: string): string {
   return `${count} ${pluralize(str, count, plural)}`;
 }
+
+export function truncate(str: string, length: number = 64): string {
+  return str.length > length ? str.slice(0, length) + '...' : str;
+}

package/src/testing/files/index.ts

@@ -0,0 +1,76 @@
+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';
+
+let generateProtocolCircuitTestData = false;
+
+/**
+ * This is separate so Prover.tomls don't get edited everytime any test is run,
+ * Only full.test updates prover tomls, then switches this off.
+ */
+export function switchGenerateProtocolCircuitTestData() {
+  generateProtocolCircuitTestData = !generateProtocolCircuitTestData;
+}
+
+/** Writes the contents specified to the target file if test data generation is enabled. */
+export function writeTestData(targetFileFromRepoRoot: string, contents: string | Buffer) {
+  if (!isGenerateTestDataEnabled()) {
+    return;
+  }
+  const targetFile = getPathToFile(targetFileFromRepoRoot);
+  const toWrite = typeof contents === 'string' ? contents : contents.toString('hex');
+  writeFileSync(targetFile, toWrite);
+  const logger = createConsoleLogger('aztec:testing:test_data');
+  logger(`Wrote test data to ${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: string, itemName: string, value: string) {
+  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 & generateProtocolCircuitTestData=true to be set
+ * To re-gen, run 'AZTEC_GENERATE_TEST_DATA=1 FAKE_PROOFS=1 yarn workspace @aztec/end-to-end test full.test'
+ */
+export function updateProtocolCircuitSampleInputs(circuitName: string, value: string) {
+  if (!isGenerateTestDataEnabled() || !generateProtocolCircuitTestData) {
+    return;
+  }
+  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: string) {
+  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/src/testing/index.ts

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

package/src/testing/test_data.ts

@@ -1,9 +1,3 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-
-import { createConsoleLogger } from '../log/console.js';
-import { fileURLToPath } from '../url/index.js';
-
 const testData: { [key: string]: unknown[] } = {};
 
 /** Returns whether test data generation is enabled */
@@ -40,47 +34,3 @@ export function getTestData(itemName: string): unknown[] {
   const fullItemName = `${testName} ${itemName}`;
   return testData[fullItemName];
 }
-
-/** Writes the contents specified to the target file if test data generation is enabled. */
-export function writeTestData(targetFileFromRepoRoot: string, contents: string | Buffer) {
-  if (!isGenerateTestDataEnabled()) {
-    return;
-  }
-  const targetFile = getPathToFile(targetFileFromRepoRoot);
-  const toWrite = typeof contents === 'string' ? contents : contents.toString('hex');
-  writeFileSync(targetFile, toWrite);
-  const logger = createConsoleLogger('aztec:testing:test_data');
-  logger(`Wrote test data to ${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: string, itemName: string, value: string) {
-  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}`);
-}
-
-function getPathToFile(targetFileFromRepoRoot: string) {
-  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/src/timer/date.ts

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

package/src/timer/index.ts

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

package/src/transport/dispatch/create_dispatch_fn.ts

@@ -1,6 +1,6 @@
 import { format } from 'util';
 
-import { createDebugLogger } from '../../log/index.js';
+import { createLogger } from '../../log/index.js';
 
 /**
  * Represents a message object for dispatching function calls.
@@ -26,7 +26,7 @@ export interface DispatchMsg {
  * @param log - Optional logging function for debugging purposes.
  * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
  */
-export function createDispatchFn(targetFn: () => any, log = createDebugLogger('aztec:foundation:dispatch')) {
+export function createDispatchFn(targetFn: () => any, log = createLogger('foundation:dispatch')) {
   return async ({ fn, args }: DispatchMsg) => {
     const target = targetFn();
     log.debug(format(`dispatching to ${target}: ${fn}`, args));

package/src/transport/transport_client.ts

@@ -1,12 +1,12 @@
 import EventEmitter from 'events';
 import { format } from 'util';
 
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { type EventMessage, type ResponseMessage, isEventMessage } from './dispatch/messages.js';
 import { type Connector } from './interface/connector.js';
 import { type Socket } from './interface/socket.js';
 
-const log = createDebugLogger('aztec:transport_client');
+const log = createLogger('foundation:transport_client');
 
 /**
  * Represents a pending request in the TransportClient.

package/src/wasm/wasm_module.ts

@@ -59,7 +59,7 @@ export class WasmModule implements IWasmModule {
   constructor(
     private module: WebAssembly.Module | Buffer,
     private importFn: (module: WasmModule) => any,
-    loggerName = 'aztec:wasm',
+    loggerName = 'wasm',
   ) {
     this.debug = createDebugOnlyLogger(loggerName);
     this.mutexQ.put(true);

package/src/worker/worker_pool.ts

@@ -1,7 +1,7 @@
-import { createDebugLogger } from '../log/index.js';
+import { createLogger } from '../log/index.js';
 import { type WasmWorker } from './wasm_worker.js';
 
-const log = createDebugLogger('bb:worker_pool');
+const log = createLogger('foundation:worker_pool');
 
 /**
  * Type of a worker factory.