@aztec/foundation 0.34.0 → 0.35.0

package/src/fields/fields.ts

@@ -3,6 +3,7 @@ import { inspect } from 'util';
 import { toBigIntBE, toBufferBE } from '../bigint-buffer/index.js';
 import { randomBytes } from '../crypto/random/index.js';
 import { BufferReader } from '../serialize/buffer_reader.js';
+import { TypeRegistry } from '../serialize/type_registry.js';
 
 const ZERO_BUFFER = Buffer.alloc(32);
 
@@ -187,6 +188,7 @@ export interface Fr {
  */
 export class Fr extends BaseField {
   static ZERO = new Fr(0n);
+  static ONE = new Fr(1n);
   static MODULUS = 0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001n;
 
   constructor(value: number | bigint | boolean | Fr | Buffer) {
@@ -257,8 +259,18 @@ export class Fr extends BaseField {
 
     return new Fr(this.toBigInt() / rhs.toBigInt());
   }
+
+  toJSON() {
+    return {
+      type: 'Fr',
+      value: this.toString(),
+    };
+  }
 }
 
+// For deserializing JSON.
+TypeRegistry.register('Fr', Fr);
+
 /**
  * Branding to ensure fields are not interchangeable types.
  */
@@ -319,8 +331,18 @@ export class Fq extends BaseField {
   static fromHighLow(high: Fr, low: Fr): Fq {
     return new Fq((high.toBigInt() << Fq.HIGH_SHIFT) + low.toBigInt());
   }
+
+  toJSON() {
+    return {
+      type: 'Fq',
+      value: this.toString(),
+    };
+  }
 }
 
+// For deserializing JSON.
+TypeRegistry.register('Fq', Fq);
+
 // Beware: Performance bottleneck below
 
 /**
@@ -351,7 +373,7 @@ function extendedEuclidean(a: bigint, modulus: bigint): [bigint, bigint, bigint]
 /**
  * GrumpkinScalar is an Fq.
  * @remarks Called GrumpkinScalar because it is used to represent elements in Grumpkin's scalar field as defined in
- *          the Aztec Yellow Paper.
+ *          the Aztec Protocol Specs.
  */
 export type GrumpkinScalar = Fq;
 export const GrumpkinScalar = Fq;

package/src/log/logger.ts

@@ -97,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;

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;
+}