@aztec/foundation 0.42.0 → 0.44.0

package/src/fields/fields.ts

@@ -25,9 +25,6 @@ type DerivedField<T extends BaseField> = {
  * Conversions from Buffer to BigInt and vice-versa are not cheap.
  * We allow construction with either form and lazily convert to other as needed.
  * We only check we are within the field modulus when initializing with bigint.
- * If NODE_ENV === 'test', we will always initialize both types to check the modulus.
- * This is also necessary in test environment as a lot of tests just use deep equality to check equality.
- * WARNING: This could lead to a bugs in production that don't reveal in tests, but it's low risk.
  */
 abstract class BaseField {
   static SIZE_IN_BYTES = 32;
@@ -42,6 +39,11 @@ abstract class BaseField {
     return this.toBigInt();
   }
 
+  /** Returns the size in bytes. */
+  get size(): number {
+    return BaseField.SIZE_IN_BYTES;
+  }
+
   protected constructor(value: number | bigint | boolean | BaseField | Buffer) {
     if (value instanceof Buffer) {
       if (value.length > BaseField.SIZE_IN_BYTES) {
@@ -62,14 +64,6 @@ abstract class BaseField {
     } else {
       throw new Error(`Type '${typeof value}' with value '${value}' passed to BaseField ctor.`);
     }
-
-    // Loads of our tests are just doing deep equality rather than calling e.g. toBigInt() first.
-    // This ensures the deep equality passes regardless of the internal representation.
-    // It also ensures the value range is checked even when initializing as a buffer.
-    if (process.env.NODE_ENV === 'test') {
-      this.toBuffer();
-      this.toBigInt();
-    }
   }
 
   protected abstract modulus(): bigint;
@@ -243,6 +237,14 @@ export class Fr extends BaseField {
     return new Fr((this.toBigInt() + rhs.toBigInt()) % Fr.MODULUS);
   }
 
+  square() {
+    return new Fr((this.toBigInt() * this.toBigInt()) % Fr.MODULUS);
+  }
+
+  negate() {
+    return new Fr(Fr.MODULUS - this.toBigInt());
+  }
+
   sub(rhs: Fr) {
     const result = this.toBigInt() - rhs.toBigInt();
     return new Fr(result < 0 ? result + Fr.MODULUS : result);
@@ -392,3 +394,22 @@ export const GrumpkinScalar = Fq;
 export function reduceFn<TInput, TField extends BaseField>(fn: (input: TInput) => Buffer, field: DerivedField<TField>) {
   return (input: TInput) => fromBufferReduce(fn(input), field);
 }
+
+/** If we are in test mode, we register a special equality for fields. */
+if (process.env.NODE_ENV === 'test') {
+  const areFieldsEqual = (a: unknown, b: unknown): boolean | undefined => {
+    const isAField = a instanceof BaseField;
+    const isBField = b instanceof BaseField;
+
+    if (isAField && isBField) {
+      return a.equals(b);
+    } else if (isAField === isBField) {
+      return undefined;
+    } else {
+      return false;
+    }
+  };
+
+  // `addEqualityTesters` doesn't seem to be in the types yet.
+  (expect as any).addEqualityTesters([areFieldsEqual]);
+}

package/src/fields/point.ts

@@ -23,7 +23,9 @@ export class Point {
      * The point's y coordinate
      */
     public readonly y: Fr,
-  ) {}
+  ) {
+    // TODO: Do we want to check if the point is on the curve here?
+  }
 
   /**
    * Generate a random Point instance.
@@ -44,7 +46,7 @@ export class Point {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new this(Fr.fromBuffer(reader.readBytes(32)), Fr.fromBuffer(reader.readBytes(32)));
+    return new this(Fr.fromBuffer(reader), Fr.fromBuffer(reader));
   }
 
   /**
@@ -134,6 +136,30 @@ export class Point {
   hash() {
     return poseidon2Hash(this.toFields());
   }
+
+  /**
+   * Check if this is point at infinity.
+   * Check this is consistent with how bb is encoding the point at infinity
+   */
+  public get inf() {
+    return this.x == Fr.ZERO;
+  }
+  public toFieldsWithInf() {
+    return [this.x, this.y, new Fr(this.inf)];
+  }
+
+  isOnGrumpkin() {
+    // TODO: Check this against how bb handles curve check and infinity point check
+    if (this.inf) {
+      return true;
+    }
+
+    // p.y * p.y == p.x * p.x * p.x - 17
+    const A = new Fr(17);
+    const lhs = this.y.square();
+    const rhs = this.x.square().mul(this.x).sub(A);
+    return lhs.equals(rhs);
+  }
 }
 
 /**

package/src/fs/run_in_dir.ts

@@ -1,18 +1,23 @@
-import { randomBytes } from 'crypto';
 import * as fs from 'fs/promises';
+import * as path from 'path';
 
 // Create a random directory underneath a 'base' directory
 // Calls a provided method, ensures the random directory is cleaned up afterwards
-export async function runInDirectory<T>(workingDirBase: string, fn: (dir: string) => Promise<T>): Promise<T> {
+export async function runInDirectory<T>(
+  workingDirBase: string,
+  fn: (dir: string) => Promise<T>,
+  cleanup: boolean = true,
+): Promise<T> {
   // Create random directory to be used for temp files
-  const workingDirectory = `${workingDirBase}/${randomBytes(8).toString('hex')}`;
-  await fs.mkdir(workingDirectory, { recursive: true });
+  const workingDirectory = await fs.mkdtemp(path.join(workingDirBase, 'tmp-'));
 
   await fs.access(workingDirectory);
 
   try {
     return await fn(workingDirectory);
   } finally {
-    await fs.rm(workingDirectory, { recursive: true, force: true });
+    if (cleanup) {
+      await fs.rm(workingDirectory, { recursive: true, force: true });
+    }
   }
 }

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

@@ -25,7 +25,7 @@ export class JsonRpcServer {
     private objectClassMap: JsonClassConverterInput,
     /** List of methods to disallow from calling remotely */
     public readonly disallowedMethods: string[] = [],
-    private log = createDebugLogger('aztec:foundation:json-rpc:server'),
+    private log = createDebugLogger('json-rpc:server'),
   ) {
     this.proxy = new JsonProxy(handler, stringClassMap, objectClassMap);
   }
@@ -226,7 +226,7 @@ export type ServerList = {
  */
 export function createNamespacedJsonRpcServer(
   servers: ServerList,
-  log = createDebugLogger('aztec:foundation:json-rpc:multi-server'),
+  log = createDebugLogger('json-rpc:multi-server'),
 ): JsonRpcServer {
   const handler = {} as any;
   const disallowedMethods: string[] = [];

package/src/log/logger.ts

@@ -1,6 +1,4 @@
 import debug from 'debug';
-import isNode from 'detect-node';
-import { isatty } from 'tty';
 
 import { type LogData, type LogFn } from './log_fn.js';
 
@@ -15,6 +13,9 @@ export type LogLevel = (typeof LogLevels)[number];
 const envLogLevel = process.env.LOG_LEVEL?.toLowerCase() as LogLevel;
 const currentLevel = LogLevels.includes(envLogLevel) ? envLogLevel : DefaultLogLevel;
 
+const namespaces = process.env.DEBUG ?? 'aztec:*';
+debug.enable(namespaces);
+
 /** Log function that accepts an exception object */
 type ErrorLogFn = (msg: string, err?: Error | unknown, data?: LogData) => void;
 
@@ -38,9 +39,6 @@ export type DebugLogger = Logger;
  */
 export function createDebugLogger(name: string): DebugLogger {
   const debugLogger = debug(name);
-  if (currentLevel === 'debug') {
-    debugLogger.enabled = true;
-  }
 
   const logger = {
     silent: () => {},
@@ -78,42 +76,11 @@ function logWithDebug(debug: debug.Debugger, level: LogLevel, msg: string, data?
   }
 
   msg = data ? `${msg} ${fmtLogData(data)}` : msg;
-  if (debug.enabled) {
-    if (level !== 'debug') {
-      msg = `${level.toUpperCase()} ${msg}`;
-    }
-    debug(msg);
-  } else if (LogLevels.indexOf(level) <= LogLevels.indexOf(currentLevel)) {
-    printLog(`${getPrefix(debug, level)} ${msg}`);
+  if (debug.enabled && LogLevels.indexOf(level) <= LogLevels.indexOf(currentLevel)) {
+    debug('[%s] %s', level.toUpperCase(), msg);
   }
 }
 
-/**
- * Returns a log prefix that emulates that of npm debug. Uses colors if in node and in a tty.
- * @param debugLogger - Instance of npm debug logger.
- * @param level - Intended log level (printed out if strictly above current log level).
- * @returns Log prefix.
- */
-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)) && !process.env.DEBUG_COLORS) {
-    return prefix;
-  }
-  const colorIndex = debug.selectColor(debugLogger.namespace) as number;
-  const colorCode = '\u001B[3' + (colorIndex < 8 ? colorIndex : '8;5;' + colorIndex);
-  return `  ${colorCode};1m${prefix}\u001B[0m`;
-}
-
-/**
- * Outputs to console error.
- * @param msg - What to log.
- */
-function printLog(msg: string) {
-  // eslint-disable-next-line no-console
-  isNode ? process.stderr.write(msg + '\n') : console.error(msg);
-}
-
 /**
  * Concatenates a log message and an exception.
  * @param msg - Log message

package/src/promise/running-promise.ts

@@ -10,7 +10,7 @@ export class RunningPromise {
   private runningPromise = Promise.resolve();
   private interruptibleSleep = new InterruptibleSleep();
 
-  constructor(private fn: () => Promise<void>, private pollingIntervalMS = 10000) {}
+  constructor(private fn: () => void | Promise<void>, private pollingIntervalMS = 10000) {}
 
   /**
    * Starts the running promise.

package/src/serialize/buffer_reader.ts

@@ -55,6 +55,7 @@ export class BufferReader {
    * @returns The read 32-bit unsigned integer value.
    */
   public readNumber(): number {
+    this.#rangeCheck(4);
     this.index += 4;
     return this.buffer.readUint32BE(this.index - 4);
   }
@@ -76,6 +77,7 @@ export class BufferReader {
    * @returns The read 16 bit value.
    */
   public readUInt16(): number {
+    this.#rangeCheck(2);
     this.index += 2;
     return this.buffer.readUInt16BE(this.index - 2);
   }
@@ -87,6 +89,7 @@ export class BufferReader {
    * @returns The read 8 bit value.
    */
   public readUInt8(): number {
+    this.#rangeCheck(1);
     this.index += 1;
     return this.buffer.readUInt8(this.index - 1);
   }
@@ -99,6 +102,7 @@ export class BufferReader {
    * @returns A boolean value representing the byte at the current index.
    */
   public readBoolean(): boolean {
+    this.#rangeCheck(1);
     this.index += 1;
     return Boolean(this.buffer.at(this.index - 1));
   }
@@ -112,6 +116,7 @@ export class BufferReader {
    * @returns A new Buffer containing the read bytes.
    */
   public readBytes(n: number): Buffer {
+    this.#rangeCheck(n);
     this.index += n;
     return Buffer.from(this.buffer.subarray(this.index - n, this.index));
   }
@@ -215,6 +220,7 @@ export class BufferReader {
   public readBufferArray(size = -1): Buffer[] {
     const result: Buffer[] = [];
     const end = size >= 0 ? this.index + size : this.buffer.length;
+    this.#rangeCheck(end - this.index);
     while (this.index < end) {
       const item = this.readBuffer();
       result.push(item);
@@ -252,6 +258,7 @@ export class BufferReader {
    * @returns A Buffer with the next n bytes or the remaining bytes if n is not provided or exceeds the buffer length.
    */
   public peekBytes(n?: number): Buffer {
+    this.#rangeCheck(n || 0);
     return this.buffer.subarray(this.index, n ? this.index + n : undefined);
   }
 
@@ -276,6 +283,7 @@ export class BufferReader {
    */
   public readBuffer(): Buffer {
     const size = this.readNumber();
+    this.#rangeCheck(size);
     return this.readBytes(size);
   }
 
@@ -311,6 +319,14 @@ export class BufferReader {
   public getLength(): number {
     return this.buffer.length;
   }
+
+  #rangeCheck(numBytes: number) {
+    if (this.index + numBytes > this.buffer.length) {
+      throw new Error(
+        `Attempted to read beyond buffer length. Start index: ${this.index}, Num bytes to read: ${numBytes}, Buffer length: ${this.buffer.length}`,
+      );
+    }
+  }
 }
 
 /**

package/src/serialize/free_funcs.ts

@@ -194,3 +194,11 @@ export function fromTruncField(field: Fr): Buffer {
 export function fromFieldsTuple(fields: Tuple<Fr, 2>): Buffer {
   return from2Fields(fields[0], fields[1]);
 }
+
+export function toHumanReadable(buf: Buffer, maxLen?: number): string {
+  const result = buf.every(byte => byte >= 32 && byte <= 126) ? buf.toString('ascii') : `0x${buf.toString('hex')}`;
+  if (maxLen && result.length > maxLen) {
+    return result.slice(0, maxLen) + '...';
+  }
+  return result;
+}