@aztec/foundation 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/async-pool/index.ts

@@ -29,6 +29,7 @@
 export function asyncPool<T, R>(poolLimit: number, iterable: T[], iteratorFn: (item: T, iterable: T[]) => Promise<R>) {
   let i = 0;
   const ret: Promise<R>[] = [];
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
   const executing: Set<Promise<R>> = new Set();
   const enqueue = (): Promise<any> => {
     if (i === iterable.length) {

package/src/bigint/index.ts

@@ -0,0 +1,20 @@
+/** Returns minimum value across a list of bigints. */
+export function minBigint(...values: bigint[]): bigint {
+  if (values.length === 0) {
+    throw new Error('Cannot get min of empty array');
+  }
+  return values.reduce((min, value) => (value < min ? value : min), values[0]);
+}
+
+/** Returns maximim value across a list of bigints. */
+export function maxBigint(...values: bigint[]): bigint {
+  if (values.length === 0) {
+    throw new Error('Cannot get max of empty array');
+  }
+  return values.reduce((max, value) => (value > max ? value : max), values[0]);
+}
+
+/** Sums an array of bigints */
+export function sumBigint(values: bigint[]): bigint {
+  return values.reduce((sum, value) => sum + value, 0n);
+}

package/src/branded-types/block_number.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+
+import type { CheckpointNumber } from './checkpoint_number.js';
+import type { Branded } from './types.js';
+
+/**
+ * A branded type representing an Aztec (L2) block number.
+ * Block numbers are sequential identifiers for blocks in the Aztec rollup chain.
+ *
+ * This is a nominal type backed by a number, but TypeScript will treat it as
+ * incompatible with plain numbers and other branded numeric types (like EpochNumber, SlotNumber, etc.).
+ *
+ * Note: This type should ONLY be used for Aztec L2 block numbers, NOT for Ethereum L1 block numbers.
+ *
+ * @example
+ * ```ts
+ * const blockNumber = BlockNumber(100);
+ * const plainNumber: number = blockNumber; // OK - BlockNumber is assignable to number
+ * const blockFromNumber: BlockNumber = 100;  // ERROR - number is not assignable to BlockNumber
+ * ```
+ */
+export type BlockNumber = Branded<number, 'BlockNumber'>;
+
+/**
+ * Creates a BlockNumber from a number.
+ * @param value - The block number (must be a non-negative integer)
+ * @returns The branded BlockNumber value
+ * @throws If the value is negative or not an integer
+ */
+export function BlockNumber(value: number): BlockNumber {
+  if (!Number.isInteger(value)) {
+    throw new Error(`BlockNumber must be an integer, got ${value}`);
+  }
+  if (value < 0) {
+    throw new Error(`BlockNumber must be non-negative, got ${value}`);
+  }
+  return value as BlockNumber;
+}
+
+/**
+ * Creates a BlockNumber from a bigint.
+ * @param value - The block number as bigint (must be a non-negative integer within safe integer range)
+ * @returns The branded BlockNumber value
+ * @throws If the value is negative or exceeds Number.MAX_SAFE_INTEGER
+ */
+BlockNumber.fromBigInt = function (value: bigint): BlockNumber {
+  if (value < 0n) {
+    throw new Error(`BlockNumber must be non-negative, got ${value}`);
+  }
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`BlockNumber ${value} exceeds MAX_SAFE_INTEGER`);
+  }
+  return Number(value) as BlockNumber;
+};
+
+/**
+ * Creates a BlockNumber from a string.
+ * @param value - The block number as a string
+ * @returns The branded BlockNumber value
+ * @throws If the string cannot be parsed as a valid block number
+ */
+BlockNumber.fromString = function (value: string): BlockNumber {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    throw new Error(`Cannot parse BlockNumber from string: ${value}`);
+  }
+  return BlockNumber(parsed);
+};
+
+/**
+ * Converts a CheckpointNumber to a BlockNumber.
+ * This is used in checkpoint-based systems where checkpoint numbers align with block numbers.
+ * WARNING: This should only be used when you know the checkpoint number corresponds to a block number.
+ * @param value - The checkpoint number to convert
+ * @returns The corresponding BlockNumber
+ */
+BlockNumber.fromCheckpointNumber = function (value: CheckpointNumber): BlockNumber {
+  return value as unknown as BlockNumber;
+};
+
+/**
+ * Type guard to check if a value is a valid BlockNumber.
+ * Note: At runtime, a BlockNumber is just a number, so this checks if the value
+ * is a non-negative integer.
+ */
+BlockNumber.isValid = function (value: unknown): value is BlockNumber {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+};
+
+/**
+ * The zero block value (genesis block).
+ */
+BlockNumber.ZERO = BlockNumber(0);
+
+function makeBlockNumberSchema(minValue: number) {
+  return z
+    .union([z.number(), z.bigint(), z.string()])
+    .pipe(z.coerce.number().int().min(minValue))
+    .transform(value => BlockNumber(value));
+}
+
+/**
+ * Zod schema for parsing and validating BlockNumber values.
+ * Accepts numbers, bigints, or strings and coerces them to BlockNumber.
+ */
+export const BlockNumberSchema = makeBlockNumberSchema(0);
+
+/**
+ * Zod schema for parsing and validating BlockNumber values that are strictly positive.
+ * Accepts numbers, bigints, or strings and coerces them to BlockNumber.
+ */
+export const BlockNumberPositiveSchema = makeBlockNumberSchema(1);

package/src/branded-types/checkpoint_number.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+
+import type { BlockNumber } from './block_number.js';
+import type { Branded } from './types.js';
+
+/**
+ * A branded type representing an checkpoint number.
+ * Checkpoints are used in the Aztec protocol to group L2 blocks.
+ *
+ * This is a nominal type backed by a number, but TypeScript will treat it as
+ * incompatible with plain numbers and other branded numeric types (like Slot, BlockNumber, etc.).
+ *
+ * @example
+ * ```ts
+ * const checkpoint = CheckpointNumber(5);
+ * const plainNumber: number = checkpoint; // OK - CheckpointNumber is assignable to number
+ * const checkpointFromNumber: CheckpointNumber = 5;  // ERROR - number is not assignable to CheckpointNumber
+ * ```
+ */
+export type CheckpointNumber = Branded<number, 'CheckpointNumber'>;
+
+/**
+ * Creates an CheckpointNumber from a number.
+ * @param value - The checkpoint number (must be a non-negative integer)
+ * @returns The branded CheckpointNumber value
+ * @throws If the value is negative or not an integer
+ */
+export function CheckpointNumber(value: number): CheckpointNumber {
+  if (!Number.isInteger(value)) {
+    throw new Error(`CheckpointNumber must be an integer, got ${value}`);
+  }
+  if (value < 0) {
+    throw new Error(`CheckpointNumber must be non-negative, got ${value}`);
+  }
+  return value as CheckpointNumber;
+}
+
+/**
+ * @param value - The block number
+ * @returns The branded CheckpointNumber value
+ *
+ * @deprecated Checkpoint number and block number should no longer convert to each other once we support multiple blocks
+ * per checkpoint everywhere.
+ */
+CheckpointNumber.fromBlockNumber = function (value: BlockNumber): CheckpointNumber {
+  return CheckpointNumber(value);
+};
+
+/**
+ * Creates an CheckpointNumber from a bigint.
+ * @param value - The checkpoint number as bigint (must be a non-negative integer within safe integer range)
+ * @returns The branded CheckpointNumber value
+ * @throws If the value is negative or exceeds Number.MAX_SAFE_INTEGER
+ */
+CheckpointNumber.fromBigInt = function (value: bigint): CheckpointNumber {
+  if (value < 0n) {
+    throw new Error(`CheckpointNumber must be non-negative, got ${value}`);
+  }
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`CheckpointNumber ${value} exceeds MAX_SAFE_INTEGER`);
+  }
+  return Number(value) as CheckpointNumber;
+};
+
+/**
+ * Creates an CheckpointNumber from a string.
+ * @param value - The checkpoint number as a string
+ * @returns The branded CheckpointNumber value
+ * @throws If the string cannot be parsed as a valid checkpoint
+ */
+CheckpointNumber.fromString = function (value: string): CheckpointNumber {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    throw new Error(`Cannot parse CheckpointNumber from string: ${value}`);
+  }
+  return CheckpointNumber(parsed);
+};
+
+/**
+ * Type guard to check if a value is a valid CheckpointNumber.
+ * Note: At runtime, an CheckpointNumber is just a number, so this checks if the value
+ * is a non-negative integer.
+ */
+CheckpointNumber.isValid = function (value: unknown): value is CheckpointNumber {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+};
+
+/** The zero checkpoint value. */
+CheckpointNumber.ZERO = CheckpointNumber(0);
+
+/** Initial checkpoint. */
+CheckpointNumber.INITIAL = CheckpointNumber(1);
+
+/**
+ * Zod schema for parsing and validating CheckpointNumber values.
+ * Accepts numbers, bigints, or strings and coerces them to CheckpointNumber.
+ */
+function makeCheckpointNumberSchema(minValue: number) {
+  return z
+    .union([z.number(), z.bigint(), z.string()])
+    .pipe(z.coerce.number().int().min(minValue))
+    .transform(value => CheckpointNumber(value));
+}
+
+/**
+ * Zod schema for parsing and validating Checkpoint values.
+ * Accepts numbers, bigints, or strings and coerces them to CheckpointNumber.
+ */
+export const CheckpointNumberSchema = makeCheckpointNumberSchema(0);
+
+/**
+ * Zod schema for parsing and validating CheckpointNumber values that are strictly positive.
+ * Accepts numbers, bigints, or strings and coerces them to CheckpointNumber.
+ */
+export const CheckpointNumberPositiveSchema = makeCheckpointNumberSchema(1);

package/src/branded-types/epoch.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+
+import type { Branded } from './types.js';
+
+/**
+ * A branded type representing an epoch number.
+ * Epochs are used in the Aztec protocol to group slots and manage validator committees.
+ *
+ * This is a nominal type backed by a number, but TypeScript will treat it as
+ * incompatible with plain numbers and other branded numeric types (like Slot, BlockNumber, etc.).
+ *
+ * @example
+ * ```ts
+ * const epoch = EpochNumber(5);
+ * const plainNumber: number = epoch; // OK - EpochNumber is assignable to number
+ * const epochFromNumber: EpochNumber = 5;  // ERROR - number is not assignable to EpochNumber
+ * ```
+ */
+export type EpochNumber = Branded<number, 'EpochNumber'>;
+
+/**
+ * Creates an EpochNumber from a number.
+ * @param value - The epoch number (must be a non-negative integer)
+ * @returns The branded EpochNumber value
+ * @throws If the value is negative or not an integer
+ */
+export function EpochNumber(value: number): EpochNumber {
+  if (!Number.isInteger(value)) {
+    throw new Error(`EpochNumber must be an integer, got ${value}`);
+  }
+  if (value < 0) {
+    throw new Error(`EpochNumber must be non-negative, got ${value}`);
+  }
+  return value as EpochNumber;
+}
+
+/**
+ * Creates an EpochNumber from a bigint.
+ * @param value - The epoch number as bigint (must be a non-negative integer within safe integer range)
+ * @returns The branded EpochNumber value
+ * @throws If the value is negative or exceeds Number.MAX_SAFE_INTEGER
+ */
+EpochNumber.fromBigInt = function (value: bigint): EpochNumber {
+  if (value < 0n) {
+    throw new Error(`EpochNumber must be non-negative, got ${value}`);
+  }
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`EpochNumber ${value} exceeds MAX_SAFE_INTEGER`);
+  }
+  return Number(value) as EpochNumber;
+};
+
+/**
+ * Creates an EpochNumber from a string.
+ * @param value - The epoch number as a string
+ * @returns The branded EpochNumber value
+ * @throws If the string cannot be parsed as a valid epoch
+ */
+EpochNumber.fromString = function (value: string): EpochNumber {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    throw new Error(`Cannot parse EpochNumber from string: ${value}`);
+  }
+  return EpochNumber(parsed);
+};
+
+/**
+ * Type guard to check if a value is a valid EpochNumber.
+ * Note: At runtime, an EpochNumber is just a number, so this checks if the value
+ * is a non-negative integer.
+ */
+EpochNumber.isValid = function (value: unknown): value is EpochNumber {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+};
+
+/**
+ * The zero epoch value.
+ */
+EpochNumber.ZERO = EpochNumber(0);
+
+/**
+ * Zod schema for parsing and validating EpochNumber values.
+ * Accepts numbers, bigints, or strings and coerces them to EpochNumber.
+ */
+export const EpochNumberSchema = z
+  .union([z.number(), z.bigint(), z.string()])
+  .pipe(z.coerce.number().int().min(0))
+  .transform(value => EpochNumber(value));

package/src/branded-types/index.ts

@@ -0,0 +1,6 @@
+export { BlockNumber, BlockNumberSchema, BlockNumberPositiveSchema } from './block_number.js';
+export { CheckpointNumber, CheckpointNumberSchema, CheckpointNumberPositiveSchema } from './checkpoint_number.js';
+export { EpochNumber, EpochNumberSchema } from './epoch.js';
+export { SlotNumber, SlotNumberSchema } from './slot.js';
+
+export type { Branded } from './types.js';

package/src/branded-types/slot.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+
+import type { Branded } from './types.js';
+
+/**
+ * A branded type representing a slot number.
+ * Slots are the fundamental time unit in the Aztec protocol, with multiple slots comprising an epoch.
+ *
+ * This is a nominal type backed by a number, but TypeScript will treat it as
+ * incompatible with plain numbers and other branded numeric types (like EpochNumber, BlockNumber, etc.).
+ *
+ * @example
+ * ```ts
+ * const slot = SlotNumber(5);
+ * const plainNumber: number = slot; // OK - SlotNumber is assignable to number
+ * const slotFromNumber: SlotNumber = 5;  // ERROR - number is not assignable to SlotNumber
+ * ```
+ */
+export type SlotNumber = Branded<number, 'SlotNumber'>;
+
+/**
+ * Creates a SlotNumber from a number.
+ * @param value - The slot number (must be a non-negative integer)
+ * @returns The branded SlotNumber value
+ * @throws If the value is negative or not an integer
+ */
+export function SlotNumber(value: number): SlotNumber {
+  if (!Number.isInteger(value)) {
+    throw new Error(`SlotNumber must be an integer, got ${value}`);
+  }
+  if (value < 0) {
+    throw new Error(`SlotNumber must be non-negative, got ${value}`);
+  }
+  return value as SlotNumber;
+}
+
+/**
+ * Creates a SlotNumber from a bigint.
+ * @param value - The slot number as bigint (must be a non-negative integer within safe integer range)
+ * @returns The branded SlotNumber value
+ * @throws If the value is negative or exceeds Number.MAX_SAFE_INTEGER
+ */
+SlotNumber.fromBigInt = function (value: bigint): SlotNumber {
+  if (value < 0n) {
+    throw new Error(`SlotNumber must be non-negative, got ${value}`);
+  }
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(`SlotNumber ${value} exceeds MAX_SAFE_INTEGER`);
+  }
+  return Number(value) as SlotNumber;
+};
+
+/**
+ * Creates a SlotNumber from a string.
+ * @param value - The slot number as a string
+ * @returns The branded SlotNumber value
+ * @throws If the string cannot be parsed as a valid slot
+ */
+SlotNumber.fromString = function (value: string): SlotNumber {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    throw new Error(`Cannot parse SlotNumber from string: ${value}`);
+  }
+  return SlotNumber(parsed);
+};
+
+/**
+ * Type guard to check if a value is a valid SlotNumber.
+ * Note: At runtime, a SlotNumber is just a number, so this checks if the value
+ * is a non-negative integer.
+ */
+SlotNumber.isValid = function (value: unknown): value is SlotNumber {
+  return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+};
+
+/**
+ * The zero slot value.
+ */
+SlotNumber.ZERO = SlotNumber(0);
+
+/**
+ * Zod schema for parsing and validating SlotNumber values.
+ * Accepts numbers, bigints, or strings and coerces them to SlotNumber.
+ */
+export const SlotNumberSchema = z
+  .union([z.number(), z.bigint(), z.string()])
+  .pipe(z.coerce.number().int().min(0))
+  .transform(value => SlotNumber(value));

package/src/branded-types/types.ts

@@ -0,0 +1,2 @@
+/** Adds a branding to a type for nominal typing. */
+export type Branded<T, Brand> = T & { _branding: Brand };

package/src/buffer/buffer16.ts

@@ -0,0 +1,133 @@
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, deserializeBigInt, serializeBigInt } from '@aztec/foundation/serialize';
+
+import { inspect } from 'util';
+
+import { bufferToHex } from '../string/index.js';
+
+/**
+ * A class representing a 16 byte Buffer.
+ */
+export class Buffer16 {
+  /**
+   * The size of the hash in bytes.
+   */
+  public static SIZE = 16;
+
+  /**
+   * Buffer16 with value zero.
+   */
+  public static ZERO = new Buffer16(Buffer.alloc(Buffer16.SIZE));
+
+  constructor(
+    /**
+     * The buffer containing the hash.
+     */
+    public buffer: Buffer,
+  ) {
+    if (buffer.length !== Buffer16.SIZE) {
+      throw new Error(`Expected buffer to have length ${Buffer16.SIZE} but was ${buffer.length}`);
+    }
+  }
+
+  /**
+   * Returns the raw buffer of the hash.
+   * @returns The buffer containing the hash.
+   */
+  public toBuffer() {
+    return this.buffer;
+  }
+
+  /**
+   * Creates a Buffer16 from a buffer.
+   * @param buffer - The buffer to create from.
+   * @returns A new Buffer16 object.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new Buffer16(reader.readBytes(Buffer16.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: Buffer16): boolean {
+    return this.buffer.equals(hash.buffer);
+  }
+
+  /**
+   * Returns true if this hash is zero.
+   * @returns True if this hash is zero.
+   */
+  public isZero(): boolean {
+    return this.buffer.equals(Buffer.alloc(16, 0));
+  }
+
+  /**
+   * Convert this hash to a hex string.
+   * @returns The hex string.
+   */
+  public toString() {
+    return bufferToHex(this.buffer);
+  }
+
+  [inspect.custom]() {
+    return `Buffer16<${this.toString()}>`;
+  }
+
+  toJSON() {
+    return this.toString();
+  }
+
+  /**
+   * Convert this hash to a big int.
+   * @returns The big int.
+   */
+  public toBigInt() {
+    return deserializeBigInt(this.buffer, 0, Buffer16.SIZE).elem;
+  }
+
+  /**
+   * Creates a Buffer16 from a bigint.
+   */
+  public static fromBigInt(hash: bigint) {
+    return new Buffer16(serializeBigInt(hash, Buffer16.SIZE));
+  }
+
+  public static fromField(hash: Fr) {
+    return new Buffer16(serializeBigInt(hash.toBigInt()));
+  }
+
+  /**
+   * Converts a hex string into a Buffer16 object.
+   */
+  public static fromString(str: string): Buffer16 {
+    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}`);
+    }
+    return new Buffer16(Buffer.from(str, 'hex'));
+  }
+
+  /**
+   * Converts a number into a Buffer16 object.
+   * @param num - The number to convert.
+   * @returns A new Buffer16 object.
+   */
+  public static fromNumber(num: number): Buffer16 {
+    return new Buffer16(serializeBigInt(BigInt(num), Buffer16.SIZE));
+  }
+
+  /**
+   * Generates a random Buffer16.
+   * @returns A new Buffer16 object.
+   */
+  public static random(): Buffer16 {
+    return new Buffer16(Buffer.from(randomBytes(Buffer16.SIZE)));
+  }
+}

package/src/buffer/buffer32.ts

@@ -1,7 +1,9 @@
-import { randomBytes } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, deserializeBigInt, serializeBigInt } from '@aztec/foundation/serialize';
 
+import { inspect } from 'util';
+
 import { bufferToHex } from '../string/index.js';
 
 /**
@@ -72,6 +74,10 @@ export class Buffer32 {
     return bufferToHex(this.buffer);
   }
 
+  [inspect.custom]() {
+    return `Buffer32<${this.toString()}>`;
+  }
+
   toJSON() {
     return this.toString();
   }
@@ -85,8 +91,6 @@ export class Buffer32 {
   }
   /**
    * Creates a Buffer32 from a bigint.
-   * @param hash - The tx hash as a big int.
-   * @returns The Buffer32.
    */
   public static fromBigInt(hash: bigint) {
     return new Buffer32(serializeBigInt(hash, Buffer32.SIZE));
@@ -112,15 +116,13 @@ export class Buffer32 {
 
   /**
    * Converts a string into a Buffer32 object.
-   * @param str - The TX hash in string format.
-   * @returns A new Buffer32 object.
    */
   public static fromString(str: string): Buffer32 {
     if (str.startsWith('0x')) {
       str = str.slice(2);
     }
-    if (str.length !== 64) {
-      throw new Error(`Expected string to be 64 characters long, but was ${str.length}`);
+    if (str.length !== this.SIZE * 2) {
+      throw new Error(`Expected string to be ${this.SIZE * 2} characters long, but was ${str.length}`);
     }
     return new Buffer32(Buffer.from(str, 'hex'));
   }

package/src/buffer/index.ts

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