@aztec/foundation 0.0.1-commit.ffe5b04ea → 0.0.1-commit.fff30aa

package/src/jest/setup.mjs

@@ -10,30 +10,3 @@ import pretty from 'pino-pretty';
 if (!parseBooleanEnv(process.env.LOG_JSON)) {
   overwriteLoggingStream(pretty(pinoPrettyOpts));
 }
-
-// Prevent timers from keeping the process alive after tests complete.
-// Libraries like viem create internal polling loops (via setTimeout) that
-// reschedule themselves indefinitely. In test environments we never want a
-// timer to be the reason the process can't exit. We also unref stdout/stderr
-// which, when they are pipes (as in Jest workers), remain ref'd by default.
-{
-  const origSetTimeout = globalThis.setTimeout;
-  const origSetInterval = globalThis.setInterval;
-  globalThis.setTimeout = function unrefSetTimeout(...args) {
-    const id = origSetTimeout.apply(this, args);
-    id?.unref?.();
-    return id;
-  };
-  // Preserve .unref, .__promisify__ etc. that may exist on the original
-  Object.setPrototypeOf(globalThis.setTimeout, origSetTimeout);
-
-  globalThis.setInterval = function unrefSetInterval(...args) {
-    const id = origSetInterval.apply(this, args);
-    id?.unref?.();
-    return id;
-  };
-  Object.setPrototypeOf(globalThis.setInterval, origSetInterval);
-
-  if (process.stdout?._handle?.unref) process.stdout._handle.unref();
-  if (process.stderr?._handle?.unref) process.stderr._handle.unref();
-}

package/src/schemas/api.ts

@@ -37,7 +37,10 @@ export type ApiSchema = {
 };
 
 /** Return whether an API schema defines a valid function schema for a given method name. */
-export function schemaHasMethod(schema: ApiSchema, methodName: string) {
+export function schemaHasMethod<T extends ApiSchema>(
+  schema: T,
+  methodName: string,
+): methodName is Extract<keyof T, string> {
   return (
     typeof methodName === 'string' &&
     Object.hasOwn(schema, methodName) &&

package/src/serialize/buffer_reader.ts

@@ -286,16 +286,39 @@ export class BufferReader {
   }
 
   /**
-   * Read an array of a fixed size with elements of type T from the buffer.
-   * The 'itemDeserializer' object should have a 'fromBuffer' method that takes a BufferReader instance as input,
-   * and returns an instance of the desired deserialized data type T.
-   * This method will call the 'fromBuffer' method for each element in the array and return the resulting array.
+   * Read an array from the buffer using lazy allocation (new Array + loop).
+   * Safe for use with untrusted sizes — does not pre-allocate memory proportional to size.
    *
-   * @param size - The fixed number of elements in the array.
+   * @param size - The number of elements to read.
    * @param itemDeserializer - An object with a 'fromBuffer' method to deserialize individual elements of type T.
    * @returns An array of instances of type T.
    */
-  public readArray<T, N extends number>(
+  public readArray<T>(
+    size: number,
+    itemDeserializer: {
+      /**
+       * A function for deserializing data from a BufferReader instance.
+       */
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): T[] {
+    const result = new Array<T>(size);
+    for (let i = 0; i < size; i++) {
+      result[i] = itemDeserializer.fromBuffer(this);
+    }
+    return result;
+  }
+
+  /**
+   * Read a fixed-size tuple from the buffer using dense allocation (Array.from).
+   * Only use with compile-time constant sizes — the size parameter MUST NOT come from untrusted input
+   * as Array.from pre-allocates memory proportional to size.
+   *
+   * @param size - The fixed number of elements (must be a compile-time constant).
+   * @param itemDeserializer - An object with a 'fromBuffer' method to deserialize individual elements of type T.
+   * @returns A densely-allocated tuple of instances of type T.
+   */
+  public readTuple<T, N extends number>(
     size: N,
     itemDeserializer: {
       /**

package/src/serialize/field_reader.ts

@@ -169,12 +169,30 @@ export class FieldReader {
    * @param itemDeserializer - An object with a 'fromFields' method to deserialize individual elements of type T.
    * @returns An array of instances of type T.
    */
-  public readArray<T, N extends number>(
+  /**
+   * Read an array from the field array using lazy allocation (new Array + loop).
+   * Safe for use with untrusted sizes.
+   */
+  public readArray<T>(
+    size: number,
+    itemDeserializer: {
+      fromFields: (reader: FieldReader) => T;
+    },
+  ): T[] {
+    const result = new Array<T>(size);
+    for (let i = 0; i < size; i++) {
+      result[i] = itemDeserializer.fromFields(this);
+    }
+    return result;
+  }
+
+  /**
+   * Read a fixed-size tuple from the field array using dense allocation (Array.from).
+   * Only use with compile-time constant sizes — the size parameter MUST NOT come from untrusted input.
+   */
+  public readTuple<T, N extends number>(
     size: N,
     itemDeserializer: {
-      /**
-       * A function for deserializing data from a FieldReader instance.
-       */
       fromFields: (reader: FieldReader) => T;
     },
   ): Tuple<T, N> {

package/src/sleep/index.ts

@@ -22,7 +22,6 @@ import { InterruptError } from '../error/index.js';
  */
 export class InterruptibleSleep {
   private interrupts: Array<(shouldThrow: boolean) => void> = [];
-  private timeoutIds: NodeJS.Timeout[] = [];
 
   /**
    * Sleep for a specified amount of time in milliseconds.
@@ -39,15 +38,9 @@ export class InterruptibleSleep {
       this.interrupts.push(resolve);
     });
 
-    let timeoutId: NodeJS.Timeout;
-    const timeoutPromise = new Promise<boolean>(resolve => {
-      timeoutId = setTimeout(() => resolve(false), ms);
-      this.timeoutIds.push(timeoutId);
-    });
+    const timeoutPromise = new Promise<boolean>(resolve => setTimeout(() => resolve(false), ms));
     const shouldThrow = await Promise.race([interruptPromise, timeoutPromise]);
 
-    clearTimeout(timeoutId!);
-    this.timeoutIds = this.timeoutIds.filter(id => id !== timeoutId);
     this.interrupts = this.interrupts.filter(res => res !== interruptResolve);
 
     if (shouldThrow) {
@@ -65,8 +58,6 @@ export class InterruptibleSleep {
   public interrupt(sleepShouldThrow = false): void {
     this.interrupts.forEach(resolve => resolve(sleepShouldThrow));
     this.interrupts = [];
-    this.timeoutIds.forEach(id => clearTimeout(id));
-    this.timeoutIds = [];
   }
 }
 

package/src/timer/date.ts

@@ -32,12 +32,6 @@ export class TestDateProvider extends DateProvider {
     this.logger.warn(`Time set to ${new Date(timeMs).toISOString()}`, { offset: this.offset, timeMs });
   }
 
-  /** Resets the time back to real time (offset = 0). */
-  public reset() {
-    this.offset = 0;
-    this.logger.warn('Time reset to real time');
-  }
-
   /** Advances the time by the given number of seconds. */
   public advanceTime(seconds: number) {
     this.offset += seconds * 1000;

package/src/trees/membership_witness.ts

@@ -94,7 +94,7 @@ export class MembershipWitness<N extends number> {
   static fromBuffer<N extends number>(buffer: Buffer | BufferReader, size: N): MembershipWitness<N> {
     const reader = BufferReader.asReader(buffer);
     const leafIndex = toBigIntBE(reader.readBytes(32));
-    const siblingPath = reader.readArray(size, Fr);
+    const siblingPath = reader.readArray(size, Fr) as Tuple<Fr, N>;
     return new MembershipWitness(size, leafIndex, siblingPath);
   }
 
@@ -108,7 +108,7 @@ export class MembershipWitness<N extends number> {
       fromBuffer: (buffer: Buffer | BufferReader) => {
         const reader = BufferReader.asReader(buffer);
         const leafIndex = toBigIntBE(reader.readBytes(32));
-        const siblingPath = reader.readArray(size, Fr);
+        const siblingPath = reader.readArray(size, Fr) as Tuple<Fr, N>;
         return new MembershipWitness(size, leafIndex, siblingPath);
       },
     };