@aztec/foundation 0.0.1-commit.2ed92850 → 0.0.1-commit.3100065

package/package.json

@@ -1,9 +1,29 @@
 {
   "name": "@aztec/foundation",
-  "version": "0.0.1-commit.2ed92850",
+  "version": "0.0.1-commit.3100065",
   "type": "module",
   "main": "./dest/index.js",
   "types": "./dest/index.d.ts",
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/buffer/index.ts",
+      "./src/collection/index.ts",
+      "./src/config/index.ts",
+      "./src/crypto/random/index.ts",
+      "./src/error/index.ts",
+      "./src/eth-address/index.ts",
+      "./src/json-rpc/index.ts",
+      "./src/log/index.ts",
+      "./src/retry/index.ts",
+      "./src/schemas/index.ts",
+      "./src/serialize/index.ts",
+      "./src/sleep/index.ts",
+      "./src/timer/index.ts",
+      "./src/types/index.ts"
+    ],
+    "name": "Foundation",
+    "tsconfig": "./tsconfig.json"
+  },
   "exports": {
     "./eslint": "./eslint.config.js",
     "./eslint.docs": "./eslint.config.docs.js",
@@ -41,6 +61,8 @@
     "./eth-address": "./dest/eth-address/index.js",
     "./eth-signature": "./dest/eth-signature/index.js",
     "./queue": "./dest/queue/index.js",
+    "./fifo": "./dest/fifo/index.js",
+    "./fifo-set": "./dest/fifo_set/index.js",
     "./fs": "./dest/fs/index.js",
     "./buffer": "./dest/buffer/index.js",
     "./json-rpc": "./dest/json-rpc/index.js",
@@ -51,6 +73,7 @@
     "./iterable": "./dest/iterable/index.js",
     "./iterator": "./dest/iterator/index.js",
     "./log": "./dest/log/index.js",
+    "./log/server": "./dest/log/pino-logger-server.js",
     "./mutex": "./dest/mutex/index.js",
     "./retry": "./dest/retry/index.js",
     "./running-promise": "./dest/running-promise/index.js",
@@ -123,12 +146,12 @@
     "testEnvironment": "../../foundation/src/jest/env.mjs"
   },
   "dependencies": {
-    "@aztec/bb.js": "0.0.1-commit.2ed92850",
+    "@aztec/bb.js": "0.0.1-commit.3100065",
     "@koa/cors": "^5.0.0",
     "@noble/curves": "=1.7.0",
     "@noble/hashes": "^1.6.1",
     "@scure/bip39": "^2.0.1",
-    "bn.js": "^5.2.1",
+    "bn.js": "^5.2.3",
     "colorette": "^2.0.20",
     "detect-node": "^2.1.0",
     "hash.js": "^1.1.7",
@@ -144,7 +167,7 @@
     "pino-pretty": "^13.0.0",
     "sha3": "^2.1.4",
     "undici": "^5.28.5",
-    "zod": "^3.23.8"
+    "zod": "^4"
   },
   "devDependencies": {
     "@jest/globals": "^30.0.0",

package/src/array/sorted_array.ts

@@ -21,34 +21,39 @@ export function dedupeSortedArray<T>(arr: T[], cmp: Cmp<T>): void {
 }
 
 export function insertIntoSortedArray<T>(arr: T[], item: T, cmp: Cmp<T>, allowDuplicates = true): boolean {
+  const index = findInsertionIndexInSortedArray(arr, item, cmp);
+
+  if (!allowDuplicates) {
+    // Check element before insertion point (upper bound returns index after equal elements)
+    if (index > 0 && cmp(arr[index - 1], item) === 0) {
+      return false;
+    }
+  }
+
+  arr.splice(index, 0, item);
+  return true;
+}
+
+/**
+ * Finds the index where needle would be inserted to maintain sorted order.
+ * Returns the count of elements less than or equal to needle.
+ */
+export function findInsertionIndexInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): number {
   let start = 0;
-  let end = arr.length;
+  let end = values.length;
 
   while (start < end) {
     const mid = start + (((end - start) / 2) | 0);
-    const comparison = cmp(arr[mid], item);
+    const comparison = cmp(values[mid], needle);
 
-    if (comparison < 0) {
+    if (comparison <= 0) {
       start = mid + 1;
     } else {
       end = mid;
     }
   }
 
-  if (!allowDuplicates) {
-    // Check element at insertion point
-    if (start < arr.length && cmp(arr[start], item) === 0) {
-      return false;
-    }
-
-    // Check element before insertion point (in case we landed after duplicates)
-    if (start > 0 && cmp(arr[start - 1], item) === 0) {
-      return false;
-    }
-  }
-
-  arr.splice(start, 0, item);
-  return true;
+  return start;
 }
 
 export function findIndexInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): number {

package/src/bigint-buffer/index.ts

@@ -49,9 +49,14 @@ export function toBufferLE(num: bigint, width: number): Buffer {
  * @returns A big-endian buffer representation of num.
  */
 export function toBufferBE(num: bigint, width: number): Buffer {
-  if (num < BigInt(0)) {
+  if (num < 0n) {
     throw new Error(`Cannot convert negative bigint ${num.toString()} to buffer with toBufferBE.`);
   }
+  // The values serialized in the hot paths are overwhelmingly zero (field elements are mostly
+  // zero-padding in protocol structs), and the hex round-trip is wasteful for them.
+  if (num === 0n) {
+    return Buffer.alloc(width);
+  }
   const hex = num.toString(16);
   const buffer = Buffer.from(hex.padStart(width * 2, '0').slice(0, width * 2), 'hex');
   if (buffer.length > width) {

package/src/branded-types/block_number.ts

@@ -98,9 +98,27 @@ BlockNumber.add = function (bn: BlockNumber, increment: number): BlockNumber {
 BlockNumber.ZERO = BlockNumber(0);
 
 function makeBlockNumberSchema(minValue: number) {
+  const max = Number.MAX_SAFE_INTEGER;
   return z
-    .union([z.number(), z.bigint(), z.string()])
-    .pipe(z.coerce.number().int().min(minValue))
+    .union([
+      z.number().int().min(minValue).max(max),
+      z
+        .bigint()
+        .min(BigInt(minValue))
+        .max(BigInt(max))
+        .transform(v => Number(v)),
+      z
+        .string()
+        .regex(/^\d+$/, 'BlockNumber string must be a non-negative decimal integer')
+        .transform((v, ctx) => {
+          const parsed = Number(v);
+          if (!Number.isInteger(parsed) || parsed > max || parsed < minValue) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: `BlockNumber out of range: ${v}` });
+            return z.NEVER;
+          }
+          return parsed;
+        }),
+    ])
     .transform(value => BlockNumber(value));
 }
 

package/src/branded-types/buffer32_hash.ts

@@ -0,0 +1,38 @@
+import type { Branded } from './types.js';
+
+/**
+ * A branded `0x`-prefixed hex string representing a checkpoint proposal payload hash.
+ *
+ * A `CheckpointProposal` and the matching `CheckpointAttestation` sign the same
+ * `ConsensusPayload`, so they share this hash type. Used by the p2p attestation
+ * pool to dedup signed payloads and detect equivocations.
+ */
+export type CheckpointProposalHash = Branded<`0x${string}`, 'CheckpointProposalHash'>;
+
+/** Brands a `0x`-prefixed hex string as a CheckpointProposalHash. */
+export function CheckpointProposalHash(s: `0x${string}`): CheckpointProposalHash {
+  return s as CheckpointProposalHash;
+}
+
+/** Constructs a CheckpointProposalHash from a raw 32-byte hash buffer. */
+CheckpointProposalHash.fromBuffer = function (buf: Buffer): CheckpointProposalHash {
+  return `0x${buf.toString('hex')}` as CheckpointProposalHash;
+};
+
+/**
+ * A branded `0x`-prefixed hex string representing a block proposal payload hash.
+ *
+ * Used by the p2p attestation pool to dedup signed payloads at a given
+ * `(slot, indexWithinCheckpoint)` and detect equivocations.
+ */
+export type BlockProposalHash = Branded<`0x${string}`, 'BlockProposalHash'>;
+
+/** Brands a `0x`-prefixed hex string as a BlockProposalHash. */
+export function BlockProposalHash(s: `0x${string}`): BlockProposalHash {
+  return s as BlockProposalHash;
+}
+
+/** Constructs a BlockProposalHash from a raw 32-byte hash buffer. */
+BlockProposalHash.fromBuffer = function (buf: Buffer): BlockProposalHash {
+  return `0x${buf.toString('hex')}` as BlockProposalHash;
+};

package/src/branded-types/checkpoint_number.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 
+import { isDefined } from '../types/index.js';
 import type { BlockNumber } from './block_number.js';
 import type { Branded } from './types.js';
 
@@ -85,6 +86,20 @@ CheckpointNumber.isValid = function (value: unknown): value is CheckpointNumber
   return typeof value === 'number' && Number.isInteger(value) && value >= 0;
 };
 
+/** Increments a CheckpointNumber by a given value. */
+CheckpointNumber.add = function (n: CheckpointNumber, increment: number): CheckpointNumber {
+  return CheckpointNumber(n + increment);
+};
+
+/** Computes max of a set of checkpoint numbers, ignoring undefined values. */
+CheckpointNumber.max = function (...values: (CheckpointNumber | undefined)[]): CheckpointNumber | undefined {
+  const filtered = values.filter(isDefined);
+  if (filtered.length === 0) {
+    return undefined;
+  }
+  return CheckpointNumber(Math.max(...filtered));
+};
+
 /** The zero checkpoint value. */
 CheckpointNumber.ZERO = CheckpointNumber(0);
 
@@ -98,7 +113,7 @@ CheckpointNumber.INITIAL = CheckpointNumber(1);
 function makeCheckpointNumberSchema(minValue: number) {
   return z
     .union([z.number(), z.bigint(), z.string()])
-    .pipe(z.coerce.number().int().min(minValue))
+    .pipe(z.coerce.number<string | number | bigint>().int().min(minValue))
     .transform(value => CheckpointNumber(value));
 }
 

package/src/branded-types/epoch.ts

@@ -84,5 +84,5 @@ EpochNumber.ZERO = EpochNumber(0);
  */
 export const EpochNumberSchema = z
   .union([z.number(), z.bigint(), z.string()])
-  .pipe(z.coerce.number().int().min(0))
+  .pipe(z.coerce.number<string | number | bigint>().int().min(0))
   .transform(value => EpochNumber(value));

package/src/branded-types/index.ts

@@ -1,4 +1,5 @@
 export { BlockNumber, BlockNumberSchema, BlockNumberPositiveSchema } from './block_number.js';
+export { BlockProposalHash, CheckpointProposalHash } from './buffer32_hash.js';
 export { CheckpointNumber, CheckpointNumberSchema, CheckpointNumberPositiveSchema } from './checkpoint_number.js';
 export { EpochNumber, EpochNumberSchema } from './epoch.js';
 export { IndexWithinCheckpoint, IndexWithinCheckpointSchema } from './index_within_checkpoint.js';

package/src/branded-types/index_within_checkpoint.ts

@@ -84,5 +84,5 @@ IndexWithinCheckpoint.ZERO = IndexWithinCheckpoint(0);
  */
 export const IndexWithinCheckpointSchema = z
   .union([z.number(), z.bigint(), z.string()])
-  .pipe(z.coerce.number().int().min(0))
+  .pipe(z.coerce.number<string | number | bigint>().int().min(0))
   .transform(value => IndexWithinCheckpoint(value));

package/src/branded-types/slot.ts

@@ -73,6 +73,11 @@ SlotNumber.isValid = function (value: unknown): value is SlotNumber {
   return typeof value === 'number' && Number.isInteger(value) && value >= 0;
 };
 
+/** Increments a SlotNumber by a given value. */
+SlotNumber.add = function (sn: SlotNumber, increment: number): SlotNumber {
+  return SlotNumber(sn + increment);
+};
+
 /**
  * The zero slot value.
  */
@@ -84,5 +89,5 @@ SlotNumber.ZERO = SlotNumber(0);
  */
 export const SlotNumberSchema = z
   .union([z.number(), z.bigint(), z.string()])
-  .pipe(z.coerce.number().int().min(0))
+  .pipe(z.coerce.number<string | number | bigint>().int().min(0))
   .transform(value => SlotNumber(value));

package/src/buffer/buffer16.ts

@@ -10,6 +10,9 @@ import { bufferToHex } from '../string/index.js';
  * A class representing a 16 byte Buffer.
  */
 export class Buffer16 {
+  /** Branding for nominal typing. */
+  declare private readonly _branding: 'Buffer16';
+
   /**
    * The size of the hash in bytes.
    */

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/buffer/index.ts

@@ -1,2 +1,3 @@
 export * from './buffer32.js';
 export * from './buffer16.js';
+export * from './utils.js';

package/src/buffer/utils.ts

@@ -0,0 +1,8 @@
+/** Returns the number of bytes in the buffer, excluding any trailing zero bytes. */
+export function trimmedBytesLength(buf: Uint8Array): number {
+  let end = buf.length;
+  while (end > 0 && buf[end - 1] === 0) {
+    end--;
+  }
+  return end;
+}

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.
@@ -250,6 +270,27 @@ export function chunk<T>(items: T[], chunkSize: number): T[][] {
   return chunks;
 }
 
+/**
+ * Splits the given array into chunks of the given size, wrapping around to the beginning
+ * if the last chunk would be smaller than the requested size.
+ * Returns empty array for empty input. Returns single chunk with all items if chunkSize <= 0.
+ */
+export function chunkWrapAround<T>(items: T[], chunkSize: number): T[][] {
+  if (items.length === 0) {
+    return [];
+  }
+  if (chunkSize <= 0 || items.length <= chunkSize) {
+    return [items];
+  }
+  const remainder = items.length % chunkSize;
+  if (remainder === 0) {
+    return chunk(items, chunkSize);
+  }
+  const wrapAroundCount = chunkSize - remainder;
+  const wrappedItems = [...items, ...items.slice(0, wrapAroundCount)];
+  return chunk(wrappedItems, chunkSize);
+}
+
 const UNINITIALIZED = Symbol('uninitialized');
 
 /**
@@ -294,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';