@aztec/foundation 0.66.0 → 0.67.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/foundation",
-  "version": "0.66.0",
+  "version": "0.67.1",
   "packageManager": "yarn@3.4.1",
   "type": "module",
   "main": "./dest/index.js",
@@ -96,10 +96,17 @@
           "summaryThreshold": 9999
         }
       ]
+    ],
+    "testTimeout": 30000,
+    "setupFilesAfterEnv": [
+      "../../foundation/src/jest/setup.mjs"
+    ],
+    "setupFiles": [
+      "../../foundation/src/jest/setup.mjs"
     ]
   },
   "dependencies": {
-    "@aztec/bb.js": "0.66.0",
+    "@aztec/bb.js": "0.67.1",
     "@koa/cors": "^5.0.0",
     "@noble/curves": "^1.2.0",
     "bn.js": "^5.2.1",
@@ -133,7 +140,6 @@
     "@types/koa": "^2.13.5",
     "@types/koa-bodyparser": "^4.3.10",
     "@types/koa-compress": "^4.0.3",
-    "@types/koa-cors": "^0.0.2",
     "@types/koa-router": "^7.4.4",
     "@types/koa__cors": "^4.0.0",
     "@types/leveldown": "^4.0.3",

package/src/abi/abi.ts

@@ -3,6 +3,7 @@ import { inflate } from 'pako';
 import { z } from 'zod';
 
 import { type Fr } from '../fields/fields.js';
+import { createLogger } from '../log/index.js';
 import { schemas } from '../schemas/schemas.js';
 import { type ZodFor } from '../schemas/types.js';
 import { type FunctionSelector } from './function_selector.js';
@@ -15,6 +16,8 @@ export interface BasicValue<T extends string, V> {
   value: V;
 }
 
+const logger = createLogger('aztec:foundation:abi');
+
 /** An exported value. */
 export type AbiValue =
   | BasicValue<'boolean', boolean>
@@ -390,7 +393,9 @@ export function getFunctionArtifact(
   if (!functionArtifact) {
     throw new Error(`Unknown function ${functionNameOrSelector}`);
   }
+
   const debugMetadata = getFunctionDebugMetadata(artifact, functionArtifact);
+
   return { ...functionArtifact, debug: debugMetadata };
 }
 
@@ -404,18 +409,32 @@ export function getFunctionDebugMetadata(
   contractArtifact: ContractArtifact,
   functionArtifact: FunctionArtifact,
 ): FunctionDebugMetadata | undefined {
-  if (functionArtifact.debugSymbols && contractArtifact.fileMap) {
-    const programDebugSymbols = JSON.parse(
-      inflate(Buffer.from(functionArtifact.debugSymbols, 'base64'), { to: 'string', raw: true }),
-    );
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
-    // We only support handling debug info for the contract function entry point.
-    // So for now we simply index into the first debug info.
-    return {
-      debugSymbols: programDebugSymbols.debug_infos[0],
-      files: contractArtifact.fileMap,
-    };
+  try {
+    if (functionArtifact.debugSymbols && contractArtifact.fileMap) {
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/10546) investigate why debugMetadata is so big for some tests.
+      const programDebugSymbols = JSON.parse(
+        inflate(Buffer.from(functionArtifact.debugSymbols, 'base64'), { to: 'string', raw: true }),
+      );
+      // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5813)
+      // We only support handling debug info for the contract function entry point.
+      // So for now we simply index into the first debug info.
+      return {
+        debugSymbols: programDebugSymbols.debug_infos[0],
+        files: contractArtifact.fileMap,
+      };
+    }
+  } catch (err: any) {
+    if (err instanceof RangeError && err.message.includes('Invalid string length')) {
+      logger.warn(
+        `Caught RangeError: Invalid string length. This suggests the debug_symbols field of the contract ${contractArtifact.name} and function ${functionArtifact.name} is huge; too big to parse. We'll skip returning this info until this issue is resolved. Here's the error:\n${err.message}`,
+      );
+      // We'll return undefined.
+    } else {
+      // Rethrow unexpected errors
+      throw err;
+    }
   }
+
   return undefined;
 }
 

package/src/abi/encoder.ts

@@ -49,7 +49,7 @@ class ArgumentEncoder {
         } else if (typeof arg === 'bigint') {
           this.flattened.push(new Fr(arg));
         } else if (typeof arg === 'string') {
-          this.flattened.push(Fr.fromString(arg));
+          this.flattened.push(Fr.fromHexString(arg));
         } else if (typeof arg === 'boolean') {
           this.flattened.push(new Fr(arg ? 1n : 0n));
         } else if (typeof arg === 'object') {
@@ -58,7 +58,7 @@ class ArgumentEncoder {
           } else if (typeof arg.toField === 'function') {
             this.flattened.push(arg.toField());
           } else if (typeof arg.value === 'string') {
-            this.flattened.push(Fr.fromString(arg.value));
+            this.flattened.push(Fr.fromHexString(arg.value));
           } else {
             throw new Error(`Argument for ${name} cannot be serialized to a field`);
           }

package/src/abi/event_selector.ts

@@ -62,7 +62,7 @@ export class EventSelector extends Selector {
   static fromString(selector: string) {
     const buf = fromHex(selector);
     if (buf.length !== Selector.SIZE) {
-      throw new Error(`Invalid Selector length ${buf.length} (expected ${Selector.SIZE}).`);
+      throw new Error(`Invalid EventSelector length ${buf.length} (expected ${Selector.SIZE}).`);
     }
     return EventSelector.fromBuffer(buf);
   }

package/src/abi/function_selector.ts

@@ -91,7 +91,7 @@ export class FunctionSelector extends Selector {
   static fromString(selector: string) {
     const buf = fromHex(selector);
     if (buf.length !== Selector.SIZE) {
-      throw new Error(`Invalid Selector length ${buf.length} (expected ${Selector.SIZE}).`);
+      throw new Error(`Invalid FunctionSelector length ${buf.length} (expected ${Selector.SIZE}).`);
     }
     return FunctionSelector.fromBuffer(buf);
   }

package/src/collection/array.ts

@@ -145,3 +145,13 @@ export function areArraysEqual<T>(a: T[], b: T[], eq: (a: T, b: T) => boolean =
 export function maxBy<T>(arr: T[], fn: (x: T) => number): T | undefined {
   return arr.reduce((max, x) => (fn(x) > fn(max) ? x : max), arr[0]);
 }
+
+/** Computes the median of a numeric array. Returns undefined if array is empty. */
+export function median(arr: number[]) {
+  if (arr.length === 0) {
+    return undefined;
+  }
+  const sorted = [...arr].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}

package/src/collection/object.ts

@@ -28,3 +28,25 @@ export function compact<T extends object>(obj: T): { [P in keyof T]+?: Exclude<T
   }
   return result;
 }
+
+/** Returns a new object by picking the given keys. */
+export function pick<T extends object, U extends keyof T>(object: T, ...props: U[]): Pick<T, U>;
+export function pick<T extends object>(object: T, ...props: string[]): Partial<T>;
+export function pick<T extends object>(object: T, ...props: string[]): Partial<T> {
+  const obj: any = {};
+  for (const prop of props) {
+    obj[prop] = (object as any)[prop];
+  }
+  return obj;
+}
+
+/** Returns a new object by omitting the given keys. */
+export function omit<T extends object, K extends keyof T>(object: T, ...props: K[]): Omit<T, K>;
+export function omit<T extends object>(object: T, ...props: string[]): Partial<T>;
+export function omit<T extends object>(object: T, ...props: string[]): Partial<T> {
+  const obj: any = { ...object };
+  for (const prop of props) {
+    delete obj[prop];
+  }
+  return obj;
+}

package/src/config/env_var.ts

@@ -56,10 +56,12 @@ export type EnvVar =
   | 'L2_QUEUE_SIZE'
   | 'LOG_ELAPSED_TIME'
   | 'LOG_JSON'
+  | 'LOG_MULTILINE'
   | 'LOG_LEVEL'
   | 'MNEMONIC'
   | 'NETWORK_NAME'
   | 'NETWORK'
+  | 'NO_PXE'
   | 'COIN_ISSUER_CONTRACT_ADDRESS'
   | 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT'
   | 'OTEL_EXPORTER_OTLP_TRACES_ENDPOINT'
@@ -124,7 +126,6 @@ export type EnvVar =
   | 'PROVER_REQUIRED_CONFIRMATIONS'
   | 'PROVER_TEST_DELAY_MS'
   | 'PROVER_CACHE_DIR'
-  | 'PXE_BLOCK_POLLING_INTERVAL_MS'
   | 'PXE_L2_STARTING_BLOCK'
   | 'PXE_PROVER_ENABLED'
   | 'QUOTE_PROVIDER_BASIS_POINT_FEE'
@@ -182,4 +183,10 @@ export type EnvVar =
   | 'L1_TX_MONITOR_MAX_ATTEMPTS'
   | 'L1_TX_MONITOR_CHECK_INTERVAL_MS'
   | 'L1_TX_MONITOR_STALL_TIME_MS'
-  | 'L1_TX_MONITOR_TX_TIMEOUT_MS';
+  | 'L1_TX_MONITOR_TX_TIMEOUT_MS'
+  | 'FAUCET_MNEMONIC_ACCOUNT_INDEX'
+  | 'FAUCET_ETH_AMOUNT'
+  | 'FAUCET_INTERVAL_MS'
+  | 'FAUCET_L1_ASSETS'
+  | 'K8S_POD_NAME'
+  | 'K8S_POD_UID';

package/src/crypto/random/randomness_singleton.ts

@@ -1,4 +1,4 @@
-import { createDebugLogger } from '../../log/pino-logger.js';
+import { createLogger } from '../../log/pino-logger.js';
 
 /**
  * A number generator which is used as a source of randomness in the system. If the SEED env variable is set, the
@@ -15,7 +15,7 @@ export class RandomnessSingleton {
 
   private constructor(
     private readonly seed?: number,
-    private readonly log = createDebugLogger('aztec:randomness_singleton'),
+    private readonly log = createLogger('foundation:randomness_singleton'),
   ) {
     if (seed !== undefined) {
       this.log.debug(`Using pseudo-randomness with seed: ${seed}`);

package/src/fields/fields.ts

@@ -232,12 +232,31 @@ export class Fr extends BaseField {
     return fromBufferReduce(buffer, Fr);
   }
 
+  /**
+   * Creates a Fr instance from a string.
+   * @param buf - the string to create a Fr from.
+   * @returns the Fr instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */
+  static fromString(buf: string) {
+    if (buf.match(/^\d+$/) !== null) {
+      return new Fr(toBufferBE(BigInt(buf), 32));
+    }
+    if (buf.match(/^0x/i) !== null) {
+      return fromHexString(buf, Fr);
+    }
+
+    throw new Error('Tried to create a Fr from an invalid string');
+  }
+
   /**
    * Creates a Fr instance from a hex string.
    * @param buf - a hex encoded string.
    * @returns the Fr instance
    */
-  static fromString(buf: string) {
+  static fromHexString(buf: string) {
     return fromHexString(buf, Fr);
   }
 
@@ -368,12 +387,31 @@ export class Fq extends BaseField {
     return fromBufferReduce(buffer, Fq);
   }
 
+  /**
+   * Creates a Fq instance from a string.
+   * @param buf - the string to create a Fq from.
+   * @returns the Fq instance
+   * @remarks if the string only consists of numbers, we assume we are parsing a bigint,
+   * otherwise we require the hex string to be prepended with "0x", to ensure there is no misunderstanding
+   * as to what is being parsed.
+   */
+  static fromString(buf: string) {
+    if (buf.match(/^\d+$/) !== null) {
+      return new Fq(toBufferBE(BigInt(buf), 32));
+    }
+    if (buf.match(/^0x/i) !== null) {
+      return fromHexString(buf, Fq);
+    }
+
+    throw new Error('Tried to create a Fq from an invalid string');
+  }
+
   /**
    * Creates a Fq instance from a hex string.
    * @param buf - a hex encoded string.
    * @returns the Fq instance
    */
-  static fromString(buf: string) {
+  static fromHexString(buf: string) {
     return fromHexString(buf, Fq);
   }
 

package/src/fs/run_in_dir.ts

@@ -1,4 +1,4 @@
-import * as fs from 'fs/promises';
+import { promises as fs } from 'fs';
 import * as path from 'path';
 
 // Create a random directory underneath a 'base' directory

package/src/iterable/index.ts

@@ -4,3 +4,4 @@ export * from './sort.js';
 export * from './take.js';
 export * from './all.js';
 export * from './peek.js';
+export * from './toArray.js';

package/src/iterable/toArray.ts

@@ -0,0 +1,7 @@
+export async function toArray<T>(iterator: AsyncIterableIterator<T> | IterableIterator<T>): Promise<T[]> {
+  const arr = [];
+  for await (const i of iterator) {
+    arr.push(i);
+  }
+  return arr;
+}

package/src/jest/setup.mjs

@@ -0,0 +1,9 @@
+import { overwriteLoggingStream, pinoPrettyOpts } from '@aztec/foundation/log';
+
+import pretty from 'pino-pretty';
+
+// Overwrite logging stream with pino-pretty. We define this as a separate
+// file so we don't mess up with dependencies in non-testing environments,
+// since pino-pretty messes up with browser bundles.
+// See also https://www.npmjs.com/package/pino-pretty?activeTab=readme#user-content-usage-with-jest
+overwriteLoggingStream(pretty(pinoPrettyOpts));

package/src/json-rpc/client/fetch.ts

@@ -1,10 +1,10 @@
 import { format, inspect } from 'util';
 
-import { type DebugLogger, createDebugLogger } from '../../log/index.js';
+import { type Logger, createLogger } from '../../log/index.js';
 import { NoRetryError, makeBackoff, retry } from '../../retry/index.js';
 import { jsonStringify } from '../convert.js';
 
-const log = createDebugLogger('json-rpc:json_rpc_client');
+const log = createLogger('json-rpc:json_rpc_client');
 
 /**
  * A normal fetch function that does not retry.
@@ -73,7 +73,7 @@ export async function defaultFetch(
  * @param log - Optional logger for logging attempts.
  * @returns A fetch function.
  */
-export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: DebugLogger) {
+export function makeFetch(retries: number[], defaultNoRetry: boolean, log?: Logger) {
   return async (host: string, rpcMethod: string, body: any, useApiEndpoints: boolean, noRetry?: boolean) => {
     return await retry(
       () => defaultFetch(host, rpcMethod, body, useApiEndpoints, noRetry ?? defaultNoRetry),

package/src/json-rpc/client/safe_json_rpc_client.ts

@@ -1,6 +1,6 @@
 import { format } from 'util';
 
-import { createDebugLogger } from '../../log/pino-logger.js';
+import { createLogger } from '../../log/pino-logger.js';
 import { type ApiSchema, type ApiSchemaFor, schemaHasMethod } from '../../schemas/api.js';
 import { defaultFetch } from './fetch.js';
 
@@ -19,7 +19,7 @@ export function createSafeJsonRpcClient<T extends object>(
   useApiEndpoints: boolean = false,
   namespaceMethods?: string | false,
   fetch = defaultFetch,
-  log = createDebugLogger('json-rpc:client'),
+  log = createLogger('json-rpc:client'),
 ): T {
   let id = 0;
   const request = async (methodName: string, params: any[]): Promise<any> => {
@@ -44,18 +44,10 @@ export function createSafeJsonRpcClient<T extends object>(
     return (schema as ApiSchema)[methodName].returnType().parse(res.result);
   };
 
-  // Intercept any RPC methods with a proxy
-  const proxy = new Proxy(
-    {},
-    {
-      get: (target, method: string) => {
-        if (['then', 'catch'].includes(method)) {
-          return Reflect.get(target, method);
-        }
-        return (...params: any[]) => request(method, params);
-      },
-    },
-  ) as T;
+  const proxy: any = {};
+  for (const method of Object.keys(schema)) {
+    proxy[method] = (...params: any[]) => request(method, params);
+  }
 
-  return proxy;
+  return proxy as T;
 }

package/src/json-rpc/server/safe_json_rpc_server.ts

@@ -8,7 +8,7 @@ import { type AddressInfo } from 'net';
 import { format, inspect } from 'util';
 import { ZodError } from 'zod';
 
-import { type DebugLogger, createDebugLogger } from '../../log/index.js';
+import { type Logger, createLogger } from '../../log/index.js';
 import { promiseWithResolvers } from '../../promise/utils.js';
 import { type ApiSchema, type ApiSchemaFor, parseWithOptionals, schemaHasMethod } from '../../schemas/index.js';
 import { jsonStringify } from '../convert.js';
@@ -27,7 +27,7 @@ export class SafeJsonRpcServer {
     /** Health check function */
     private readonly healthCheck: StatusCheckFn = () => true,
     /** Logger */
-    private log = createDebugLogger('json-rpc:server'),
+    private log = createLogger('json-rpc:server'),
   ) {}
 
   public isHealthy(): boolean | Promise<boolean> {
@@ -170,7 +170,7 @@ interface Proxy {
  * before forwarding calls, and then converts outputs into JSON using default conversions.
  */
 export class SafeJsonProxy<T extends object = any> implements Proxy {
-  private log = createDebugLogger('json-rpc:proxy');
+  private log = createLogger('json-rpc:proxy');
   private schema: ApiSchema;
 
   constructor(private handler: T, schema: ApiSchemaFor<T>) {
@@ -233,7 +233,7 @@ export function makeHandler<T extends object>(handler: T, schema: ApiSchemaFor<T
   return [handler, schema];
 }
 
-function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: DebugLogger): StatusCheckFn {
+function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: Logger): StatusCheckFn {
   return async () => {
     try {
       const results = await Promise.all(
@@ -259,7 +259,7 @@ function makeAggregateHealthcheck(namedHandlers: NamespacedApiHandlers, log?: De
  */
 export function createNamespacedSafeJsonRpcServer(
   handlers: NamespacedApiHandlers,
-  log = createDebugLogger('json-rpc:server'),
+  log = createLogger('json-rpc:server'),
 ): SafeJsonRpcServer {
   const proxy = new NamespacedSafeJsonProxy(handlers);
   const healthCheck = makeAggregateHealthcheck(handlers, log);

package/src/log/log-filters.ts

@@ -42,7 +42,13 @@ export function parseFilters(definition: string | undefined): LogFilters {
     const sanitizedLevel = level.trim().toLowerCase();
     assertLogLevel(sanitizedLevel);
     for (const module of modules.split(',')) {
-      filters.push([module.trim().toLowerCase(), sanitizedLevel as LogLevel | 'silent']);
+      filters.push([
+        module
+          .trim()
+          .toLowerCase()
+          .replace(/^aztec:/, ''),
+        sanitizedLevel as LogLevel | 'silent',
+      ]);
     }
   }
   return filters.reverse();

package/src/log/log_fn.ts

@@ -2,4 +2,4 @@
 export type LogData = Record<string, string | number | bigint | boolean | { toString(): string } | undefined>;
 
 /** A callable logger instance. */
-export type LogFn = (msg: string, data?: LogData) => void;
+export type LogFn = (msg: string, data?: unknown) => void;

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,19 @@ 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 };
+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 },
+};
+
 // 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 +88,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 +112,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 +134,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 +151,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 +189,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