@aztec/foundation 5.0.0-private.20260319 → 5.0.0-rc.2

package/src/buffer/buffer32.ts

@@ -7,69 +7,39 @@ import { inspect } from 'util';
 import { bufferToHex } from '../string/index.js';
 
 /**
- * A class representing a 32 byte Buffer.
+ * Abstract unbranded base class for 32-byte buffers.
+ * Extend this instead of Buffer32 when defining a branded subtype
+ * to avoid inheriting Buffer32's `_branding`.
  */
-export class Buffer32 {
-  /**
-   * The size of the hash in bytes.
-   */
+export abstract class BaseBuffer32 {
+  /** The size of the buffer in bytes. */
   public static SIZE = 32;
 
-  /**
-   * Buffer32 with value zero.
-   */
-  public static ZERO = new Buffer32(Buffer.alloc(Buffer32.SIZE));
-
   constructor(
-    /**
-     * The buffer containing the hash.
-     */
+    /** The buffer containing the data. */
     public buffer: Buffer,
   ) {
-    if (buffer.length !== Buffer32.SIZE) {
-      throw new Error(`Expected buffer to have length ${Buffer32.SIZE} but was ${buffer.length}`);
+    if (buffer.length !== BaseBuffer32.SIZE) {
+      throw new Error(`Expected buffer to have length ${BaseBuffer32.SIZE} but was ${buffer.length}`);
     }
   }
 
-  /**
-   * Returns the raw buffer of the hash.
-   * @returns The buffer containing the hash.
-   */
+  /** Returns the raw buffer. */
   public toBuffer() {
     return this.buffer;
   }
 
-  /**
-   * Creates a Buffer32 from a buffer.
-   * @param buffer - The buffer to create from.
-   * @returns A new Buffer32 object.
-   */
-  public static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new Buffer32(reader.readBytes(Buffer32.SIZE));
-  }
-
-  /**
-   * Checks if this hash and another hash are equal.
-   * @param hash - A hash to compare with.
-   * @returns True if the hashes are equal, false otherwise.
-   */
-  public equals(hash: Buffer32): boolean {
+  /** Checks if this and another buffer are equal. */
+  public equals(hash: BaseBuffer32): boolean {
     return this.buffer.equals(hash.buffer);
   }
 
-  /**
-   * Returns true if this hash is zero.
-   * @returns True if this hash is zero.
-   */
+  /** Returns true if all bytes are zero. */
   public isZero(): boolean {
     return this.buffer.equals(Buffer.alloc(32, 0));
   }
 
-  /**
-   * Convert this hash to a hex string.
-   * @returns The hex string.
-   */
+  /** Convert to a hex string. */
   public toString() {
     return bufferToHex(this.buffer);
   }
@@ -82,16 +52,27 @@ export class Buffer32 {
     return this.toString();
   }
 
-  /**
-   * Convert this hash to a big int.
-   * @returns The big int.
-   */
+  /** Convert to a big int. */
   public toBigInt() {
-    return deserializeBigInt(this.buffer, 0, Buffer32.SIZE).elem;
+    return deserializeBigInt(this.buffer, 0, BaseBuffer32.SIZE).elem;
   }
-  /**
-   * Creates a Buffer32 from a bigint.
-   */
+}
+
+/** A branded 32-byte buffer. */
+export class Buffer32 extends BaseBuffer32 {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'Buffer32';
+
+  /** Buffer32 with value zero. */
+  public static ZERO = new Buffer32(Buffer.alloc(Buffer32.SIZE));
+
+  /** Creates a Buffer32 from a buffer. */
+  public static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new Buffer32(reader.readBytes(Buffer32.SIZE));
+  }
+
+  /** Creates a Buffer32 from a bigint. */
   public static fromBigInt(hash: bigint) {
     return new Buffer32(serializeBigInt(hash, Buffer32.SIZE));
   }
@@ -101,8 +82,7 @@ export class Buffer32 {
   }
 
   /**
-   * Converts this hash from a buffer of 28 bytes.
-   * Verifies the input is 28 bytes.
+   * Converts from a buffer of 28 bytes.
    * @param buffer - The 28 byte buffer to construct from.
    * @returns A Buffer32 created from the input buffer with 4 bytes 0 padding at the front.
    */
@@ -110,36 +90,27 @@ export class Buffer32 {
     if (buffer.length != 28) {
       throw new Error(`Expected Buffer32 input buffer to be 28 bytes`);
     }
-    const padded = Buffer.concat([Buffer.alloc(this.SIZE - 28), buffer]);
+    const padded = Buffer.concat([Buffer.alloc(Buffer32.SIZE - 28), buffer]);
     return new Buffer32(padded);
   }
 
-  /**
-   * Converts a string into a Buffer32 object.
-   */
+  /** Converts a string into a Buffer32 object. */
   public static fromString(str: string): Buffer32 {
     if (str.startsWith('0x')) {
       str = str.slice(2);
     }
-    if (str.length !== this.SIZE * 2) {
-      throw new Error(`Expected string to be ${this.SIZE * 2} characters long, but was ${str.length}`);
+    if (str.length !== Buffer32.SIZE * 2) {
+      throw new Error(`Expected string to be ${Buffer32.SIZE * 2} characters long, but was ${str.length}`);
     }
     return new Buffer32(Buffer.from(str, 'hex'));
   }
 
-  /**
-   * Converts a number into a Buffer32 object.
-   * @param num - The number to convert.
-   * @returns A new Buffer32 object.
-   */
+  /** Converts a number into a Buffer32 object. */
   public static fromNumber(num: number): Buffer32 {
     return new Buffer32(serializeBigInt(BigInt(num), Buffer32.SIZE));
   }
 
-  /**
-   * Generates a random Buffer32.
-   * @returns A new Buffer32 object.
-   */
+  /** Generates a random Buffer32. */
   public static random(): Buffer32 {
     return new Buffer32(Buffer.from(randomBytes(Buffer32.SIZE)));
   }

package/src/collection/array.ts

@@ -138,6 +138,26 @@ export function unique<T>(arr: T[]): T[] {
   return [...new Set(arr)];
 }
 
+/**
+ * Removes duplicates from the given array using a key function. The first occurrence of each key is kept.
+ * @param arr - The array.
+ * @param keyFn - A function that returns a primitive key for each element. Elements with the same key are
+ *               considered duplicates.
+ * @returns A new array.
+ */
+export function uniqueBy<T, K extends string | number | bigint>(arr: T[], keyFn: (item: T) => K): T[] {
+  const seen = new Set<K>();
+  const result: T[] = [];
+  for (const item of arr) {
+    const key = keyFn(item);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(item);
+    }
+  }
+  return result;
+}
+
 /**
  * Removes all undefined elements from the array.
  * @param arr - The array.
@@ -315,3 +335,17 @@ export function partition<T>(items: T[], predicate: (item: T) => boolean): [T[],
   }
   return [pass, fail];
 }
+
+/** Partitions the given iterable into two arrays based on the predicate. */
+export async function partitionAsync<T>(items: T[], predicate: (item: T) => Promise<boolean>): Promise<[T[], T[]]> {
+  const pass: T[] = [];
+  const fail: T[] = [];
+  for (const item of items) {
+    if (await predicate(item)) {
+      pass.push(item);
+    } else {
+      fail.push(item);
+    }
+  }
+  return [pass, fail];
+}

package/src/collection/index.ts

@@ -1,2 +1,4 @@
 export * from './array.js';
+export * from './lru_map.js';
+export * from './lru_set.js';
 export * from './object.js';

package/src/collection/lru_map.ts

@@ -0,0 +1,143 @@
+/** Node in a doubly-linked list used by {@link LruMap}. */
+type LruNode<K, V> = {
+  key: K;
+  value: V;
+  prev: LruNode<K, V> | undefined;
+  next: LruNode<K, V> | undefined;
+};
+
+/**
+ * A bounded key-value map with Least Recently Used (LRU) eviction.
+ * Both {@link get} and {@link set} count as an access and refresh the entry's
+ * recency, so entries that are actively used stay in the map longest.
+ *
+ * Uses a doubly-linked list for O(1) ordering and a Map for O(1) lookup.
+ * Head = least recent, tail = most recent.
+ */
+export class LruMap<K, V> {
+  /** Map from key to its linked-list node for O(1) lookup. */
+  private readonly map = new Map<K, LruNode<K, V>>();
+  private head: LruNode<K, V> | undefined;
+  private tail: LruNode<K, V> | undefined;
+
+  constructor(private readonly maxSize: number) {
+    if (maxSize < 1) {
+      throw new Error('LruMap maxSize must be at least 1');
+    }
+  }
+
+  /** Number of entries in the map. */
+  get size(): number {
+    return this.map.size;
+  }
+
+  /** Returns true if the key is present, without refreshing its recency. */
+  has(key: K): boolean {
+    return this.map.has(key);
+  }
+
+  /**
+   * Returns the value for the key, or undefined if absent.
+   * Refreshes the entry's recency so it becomes the most recently used.
+   */
+  get(key: K): V | undefined {
+    const node = this.map.get(key);
+    if (!node) {
+      return undefined;
+    }
+    this.moveToTail(node);
+    return node.value;
+  }
+
+  /**
+   * Stores a value for the key, refreshing its recency. If the key already exists, overwrites the value.
+   * If the map is at capacity, evicts the least recently used entry.
+   */
+  set(key: K, value: V): void {
+    const existing = this.map.get(key);
+    if (existing) {
+      existing.value = value;
+      this.moveToTail(existing);
+      return;
+    }
+
+    if (this.map.size >= this.maxSize) {
+      this.evictHead();
+    }
+
+    const node: LruNode<K, V> = { key, value, prev: this.tail, next: undefined };
+    if (this.tail) {
+      this.tail.next = node;
+    } else {
+      this.head = node;
+    }
+    this.tail = node;
+    this.map.set(key, node);
+  }
+
+  /** Removes the entry for the key, returning true if it was present. */
+  delete(key: K): boolean {
+    const node = this.map.get(key);
+    if (!node) {
+      return false;
+    }
+    this.unlink(node);
+    this.map.delete(key);
+    return true;
+  }
+
+  /** Removes all entries from the map. */
+  clear(): void {
+    this.map.clear();
+    this.head = undefined;
+    this.tail = undefined;
+  }
+
+  /** Unlinks a node from its current position and relinks it at the tail. */
+  private moveToTail(node: LruNode<K, V>): void {
+    if (node === this.tail) {
+      return;
+    }
+    this.unlink(node);
+
+    node.prev = this.tail;
+    node.next = undefined;
+    if (this.tail) {
+      this.tail.next = node;
+    } else {
+      this.head = node;
+    }
+    this.tail = node;
+  }
+
+  /** Detaches a node from the linked list, fixing up its neighbours and the head/tail pointers. */
+  private unlink(node: LruNode<K, V>): void {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+    node.prev = undefined;
+    node.next = undefined;
+  }
+
+  /** Evicts the head (least recently used) node. */
+  private evictHead(): void {
+    const oldHead = this.head;
+    if (!oldHead) {
+      return;
+    }
+    this.head = oldHead.next;
+    if (this.head) {
+      this.head.prev = undefined;
+    } else {
+      this.tail = undefined;
+    }
+    this.map.delete(oldHead.key);
+  }
+}

package/src/collection/lru_set.ts

@@ -0,0 +1,115 @@
+/** Node in a doubly-linked list used by {@link LruSet}. */
+type LruNode<T> = {
+  value: T;
+  prev: LruNode<T> | undefined;
+  next: LruNode<T> | undefined;
+};
+
+/**
+ * A bounded set with Least Recently Used (LRU) eviction.
+ * Both {@link has} and {@link add} count as an access and refresh the entry's
+ * recency, so items that are actively checked stay in the set longest.
+ *
+ * Uses a doubly-linked list for O(1) ordering and a Map for O(1) lookup.
+ * Head = least recent, tail = most recent.
+ */
+export class LruSet<T> {
+  /** Map from value to its linked-list node for O(1) lookup. */
+  private readonly map = new Map<T, LruNode<T>>();
+  private head: LruNode<T> | undefined;
+  private tail: LruNode<T> | undefined;
+
+  constructor(private readonly maxSize: number) {
+    if (maxSize < 1) {
+      throw new Error('LruSet maxSize must be at least 1');
+    }
+  }
+
+  /** Number of entries in the set. */
+  get size(): number {
+    return this.map.size;
+  }
+
+  /**
+   * Returns true if the item is in the set.
+   * Refreshes the item's recency so it becomes the most recently used.
+   */
+  has(item: T): boolean {
+    const node = this.map.get(item);
+    if (!node) {
+      return false;
+    }
+    this.moveToTail(node);
+    return true;
+  }
+
+  /**
+   * Adds an item to the set. If the item already exists, refreshes its recency.
+   * If the set is at capacity, evicts the least recently used item.
+   */
+  add(item: T): void {
+    const existing = this.map.get(item);
+    if (existing) {
+      this.moveToTail(existing);
+      return;
+    }
+
+    if (this.map.size >= this.maxSize) {
+      this.evictHead();
+    }
+
+    const node: LruNode<T> = { value: item, prev: this.tail, next: undefined };
+    if (this.tail) {
+      this.tail.next = node;
+    } else {
+      this.head = node;
+    }
+    this.tail = node;
+    this.map.set(item, node);
+  }
+
+  /** Removes all entries from the set. */
+  clear(): void {
+    this.map.clear();
+    this.head = undefined;
+    this.tail = undefined;
+  }
+
+  /** Unlinks a node from its current position and relinks it at the tail. */
+  private moveToTail(node: LruNode<T>): void {
+    if (node === this.tail) {
+      return;
+    }
+
+    // Unlink
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+    if (node.next) {
+      node.next.prev = node.prev;
+    }
+
+    // Relink at tail
+    node.prev = this.tail;
+    node.next = undefined;
+    if (this.tail) {
+      this.tail.next = node;
+    }
+    this.tail = node;
+  }
+
+  /** Evicts the head (least recently used) node. */
+  private evictHead(): void {
+    const oldHead = this.head!;
+    this.map.delete(oldHead.value);
+
+    this.head = oldHead.next;
+    if (this.head) {
+      this.head.prev = undefined;
+    } else {
+      this.tail = undefined;
+    }
+  }
+}

package/src/committable/committable.ts

@@ -24,7 +24,7 @@ export class Committable<T> {
    * Rolls back the uncommitted value.
    */
   public rollback() {
-    this.nextValue === undefined;
+    this.nextValue = undefined;
   }
 
   /**