@aztec/foundation 0.33.0 → 0.35.0

package/src/log/logger.ts

@@ -4,8 +4,7 @@ import { isatty } from 'tty';
 
 import { type LogData, type LogFn } from './log_fn.js';
 
-// Matches a subset of Winston log levels
-const LogLevels = ['silent', 'error', 'warn', 'info', 'verbose', 'debug', 'trace'] as const;
+const LogLevels = ['silent', 'error', 'warn', 'info', 'verbose', 'debug'] as const;
 const DefaultLogLevel = process.env.NODE_ENV === 'test' ? ('silent' as const) : ('info' as const);
 
 /**
@@ -28,7 +27,7 @@ export type Logger = { [K in LogLevel]: LogFn } & { /** Error log function */ er
  * 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.
  */
-export type DebugLogger = LogFn & Logger;
+export type DebugLogger = Logger;
 
 /**
  * Creates a new DebugLogger for the current module, defaulting to the LOG_LEVEL env var.
@@ -50,7 +49,6 @@ export function createDebugLogger(name: string): DebugLogger {
     info: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'info', msg, data),
     verbose: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'verbose', msg, data),
     debug: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'debug', msg, data),
-    trace: (msg: string, data?: LogData) => logWithDebug(debugLogger, 'trace', msg, data),
   };
   return Object.assign((msg: string, data?: LogData) => logWithDebug(debugLogger, 'debug', msg, data), logger);
 }
@@ -99,7 +97,7 @@ function logWithDebug(debug: debug.Debugger, level: LogLevel, msg: string, data?
 function getPrefix(debugLogger: debug.Debugger, level: LogLevel) {
   const levelLabel = currentLevel !== level ? ` ${level.toUpperCase()}` : '';
   const prefix = `${debugLogger.namespace.replace(/^aztec:/, '')}${levelLabel}`;
-  if (!isNode || !isatty(process.stderr.fd)) {
+  if ((!isNode || !isatty(process.stderr.fd)) && !process.env.DEBUG_COLORS) {
     return prefix;
   }
   const colorIndex = debug.selectColor(debugLogger.namespace) as number;
@@ -112,7 +110,8 @@ function getPrefix(debugLogger: debug.Debugger, level: LogLevel) {
  * @param msg - What to log.
  */
 function printLog(msg: string) {
-  process.stderr.write(msg + '\n');
+  // eslint-disable-next-line no-console
+  isNode ? process.stderr.write(msg + '\n') : console.error(msg);
 }
 
 /**

package/src/retry/index.ts

@@ -63,7 +63,7 @@ export async function retry<Result>(
       if (s === undefined) {
         throw err;
       }
-      log(`${name} failed. Will retry in ${s}s...`);
+      log.verbose(`${name} failed. Will retry in ${s}s...`);
       !failSilently && log.error(err);
       await sleep(s * 1000);
       continue;

package/src/serialize/index.ts

@@ -3,3 +3,4 @@ export * from './buffer_reader.js';
 export * from './field_reader.js';
 export * from './types.js';
 export * from './serialize.js';
+export * from './type_registry.js';

package/src/serialize/serialize.ts

@@ -121,11 +121,19 @@ export type Bufferable =
   | Bufferable[];
 
 /** A type that can be converted to a Field or a Field array. */
-export type Fieldeable =
+export type Fieldable =
   | Fr
   | boolean
   | number
   | bigint
+  | Buffer
+  | {
+      /**
+       * Serialize to a field.
+       * @dev Duplicate to `toField` but left as is as it is used in AVM codebase.
+       */
+      toFr: () => Fr;
+    }
   | {
       /** Serialize to a field. */
       toField: () => Fr;
@@ -134,7 +142,7 @@ export type Fieldeable =
       /** Serialize to an array of fields. */
       toFields: () => Fr[];
     }
-  | Fieldeable[];
+  | Fieldable[];
 
 /**
  * Serializes a list of objects contiguously.
@@ -142,10 +150,10 @@ export type Fieldeable =
  * @returns A buffer list with the concatenation of all fields.
  */
 export function serializeToBufferArray(...objs: Bufferable[]): Buffer[] {
-  let ret: Buffer[] = [];
+  const ret: Buffer[] = [];
   for (const obj of objs) {
     if (Array.isArray(obj)) {
-      ret = [...ret, ...serializeToBufferArray(...obj)];
+      ret.push(...serializeToBufferArray(...obj));
     } else if (Buffer.isBuffer(obj)) {
       ret.push(obj);
     } else if (typeof obj === 'boolean') {
@@ -176,19 +184,25 @@ export function serializeToBufferArray(...objs: Bufferable[]): Buffer[] {
  * @param objs - Objects to serialize.
  * @returns An array of fields with the concatenation of all fields.
  */
-export function serializeToFields(...objs: Fieldeable[]): Fr[] {
-  let ret: Fr[] = [];
+export function serializeToFields(...objs: Fieldable[]): Fr[] {
+  const ret: Fr[] = [];
   for (const obj of objs) {
     if (Array.isArray(obj)) {
-      ret = [...ret, ...serializeToFields(...obj)];
+      ret.push(...serializeToFields(...obj));
     } else if (obj instanceof Fr) {
       ret.push(obj);
     } else if (typeof obj === 'boolean' || typeof obj === 'number' || typeof obj === 'bigint') {
       ret.push(new Fr(obj));
     } else if ('toFields' in obj) {
-      ret = [...ret, ...obj.toFields()];
-    } else {
+      ret.push(...obj.toFields());
+    } else if ('toFr' in obj) {
+      ret.push(obj.toFr());
+    } else if ('toField' in obj) {
       ret.push(obj.toField());
+    } else if (Buffer.isBuffer(obj)) {
+      ret.push(Fr.fromBuffer(obj));
+    } else {
+      throw new Error(`Cannot serialize input to field: ${typeof obj} ${(obj as any).constructor?.name}`);
     }
   }
   return ret;

package/src/serialize/type_registry.ts

@@ -0,0 +1,43 @@
+type Deserializable = { fromString(str: string): object };
+
+/**
+ * Register a class here that has a toJSON method that returns:
+ * ```
+ * {
+ *   "type": "ExampleClassName",
+ *   "value": <result of ExampleClassName.toString()>
+ * }
+ * ```
+ * and has an e.g. ExampleClassName.fromString(string) method.
+ * This means you can then easily serialize/deserialize the type using JSON.stringify and JSON.parse.
+ */
+export class TypeRegistry {
+  private static registry: Map<string, Deserializable> = new Map();
+
+  public static register(typeName: string, constructor: Deserializable): void {
+    this.registry.set(typeName, constructor);
+  }
+
+  public static getConstructor(typeName: string): Deserializable | undefined {
+    return this.registry.get(typeName);
+  }
+}
+
+// Resolver function that enables JSON serialization of BigInts.
+export function resolver(_: any, value: any) {
+  return typeof value === 'bigint' ? value.toString() + 'n' : value;
+}
+
+// Reviver function that uses TypeRegistry to instantiate objects.
+export function reviver(key: string, value: any) {
+  if (typeof value === 'string' && /^\d+n$/.test(value)) {
+    return BigInt(value.slice(0, -1));
+  }
+  if (value && typeof value === 'object' && 'type' in value && 'value' in value) {
+    const Constructor = TypeRegistry.getConstructor(value.type);
+    if (Constructor) {
+      return Constructor.fromString(value.value);
+    }
+  }
+  return value;
+}

package/src/transport/dispatch/create_dispatch_fn.ts

@@ -23,13 +23,13 @@ export interface DispatchMsg {
  * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
  *
  * @param targetFn - A function that returns the target object containing the methods to be dispatched.
- * @param debug - Optional logging function for debugging purposes.
+ * @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, debug = createDebugLogger('aztec:foundation:dispatch')) {
+export function createDispatchFn(targetFn: () => any, log = createDebugLogger('aztec:foundation:dispatch')) {
   return async ({ fn, args }: DispatchMsg) => {
     const target = targetFn();
-    debug(format(`dispatching to ${target}: ${fn}`, args));
+    log.debug(format(`dispatching to ${target}: ${fn}`, args));
     return await target[fn](...args);
   };
 }

package/src/transport/transport_client.ts

@@ -6,7 +6,7 @@ import { type EventMessage, type ResponseMessage, isEventMessage } from './dispa
 import { type Connector } from './interface/connector.js';
 import { type Socket } from './interface/socket.js';
 
-const debug = createDebugLogger('aztec:transport_client');
+const log = createDebugLogger('aztec:transport_client');
 
 /**
  * Represents a pending request in the TransportClient.
@@ -92,7 +92,7 @@ export class TransportClient<Payload> extends EventEmitter {
     }
     const msgId = this.msgId++;
     const msg = { msgId, payload };
-    debug(format(`->`, msg));
+    log.debug(format(`->`, msg));
     return new Promise<any>((resolve, reject) => {
       this.pendingRequests.push({ resolve, reject, msgId });
       this.socket!.send(msg, transfer).catch(reject);
@@ -112,7 +112,7 @@ export class TransportClient<Payload> extends EventEmitter {
       this.close();
       return;
     }
-    debug(format(`<-`, msg));
+    log.debug(format(`<-`, msg));
     if (isEventMessage(msg)) {
       this.emit('event_msg', msg.payload);
       return;

package/src/worker/worker_pool.ts

@@ -1,7 +1,7 @@
 import { createDebugLogger } from '../log/index.js';
 import { type WasmWorker } from './wasm_worker.js';
 
-const debug = createDebugLogger('bb:worker_pool');
+const log = createDebugLogger('bb:worker_pool');
 
 /**
  * Type of a worker factory.
@@ -53,7 +53,7 @@ export class WorkerPool {
    * @param maxMem - Max memory pages.
    */
   public async init(createWorker: CreateWorker, poolSize: number, maxMem = WorkerPool.MAX_PAGES) {
-    debug(`creating ${poolSize} workers...`);
+    log.debug(`creating ${poolSize} workers...`);
     const start = new Date().getTime();
     this.workers = await Promise.all(
       Array(poolSize)
@@ -61,7 +61,7 @@ export class WorkerPool {
         .map((_, i) => createWorker(`${i}`, i === 0 ? Math.min(WorkerPool.MAX_PAGES, maxMem) : 768, maxMem)),
     );
 
-    debug(`created workers: ${new Date().getTime() - start}ms`);
+    log.debug(`created workers: ${new Date().getTime() - start}ms`);
   }
 
   /**