@aztec/foundation 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/array/sorted_array.ts

@@ -0,0 +1,138 @@
+type Cmp<T> = (a: T, b: T) => -1 | 0 | 1;
+
+export function dedupeSortedArray<T>(arr: T[], cmp: Cmp<T>): void {
+  for (let i = 0; i < arr.length; i++) {
+    let j = i + 1;
+    for (; j < arr.length; j++) {
+      const res = cmp(arr[i], arr[j]);
+      if (res === 0) {
+        continue;
+      } else if (res < 0) {
+        break;
+      } else {
+        throw new Error('Array not sorted');
+      }
+    }
+
+    if (j - i > 1) {
+      arr.splice(i + 1, j - i - 1);
+    }
+  }
+}
+
+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 = values.length;
+
+  while (start < end) {
+    const mid = start + (((end - start) / 2) | 0);
+    const comparison = cmp(values[mid], needle);
+
+    if (comparison <= 0) {
+      start = mid + 1;
+    } else {
+      end = mid;
+    }
+  }
+
+  return start;
+}
+
+export function findIndexInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): number {
+  let start = 0;
+  let end = values.length - 1;
+
+  while (start <= end) {
+    const mid = start + (((end - start) / 2) | 0);
+    const comparison = cmp(values[mid], needle);
+
+    if (comparison === 0) {
+      return mid;
+    }
+
+    if (comparison > 0) {
+      end = mid - 1;
+    } else {
+      start = mid + 1;
+    }
+  }
+
+  return -1;
+}
+
+export function findInSortedArray<T, N>(values: T[], needle: N, cmp: (a: T, b: N) => number): T | undefined {
+  const idx = findIndexInSortedArray(values, needle, cmp);
+  return idx > -1 ? values[idx] : undefined;
+}
+
+export function removeAnyOf<T, N>(arr: T[], vals: N[], cmp: (a: T, b: N) => -1 | 0 | 1): void {
+  let writeIdx = 0;
+  let readIdx = 0;
+  let valIdx = 0;
+
+  while (readIdx < arr.length && valIdx < vals.length) {
+    const comparison = cmp(arr[readIdx], vals[valIdx]);
+
+    if (comparison < 0) {
+      arr[writeIdx++] = arr[readIdx++];
+    } else if (comparison > 0) {
+      valIdx++;
+    } else {
+      readIdx++;
+    }
+  }
+
+  while (readIdx < arr.length) {
+    arr[writeIdx++] = arr[readIdx++];
+  }
+
+  arr.length = writeIdx;
+}
+
+export function removeFromSortedArray<T, N>(arr: T[], val: N, cmp: (a: T, b: N) => -1 | 0 | 1) {
+  const idx = findIndexInSortedArray(arr, val, cmp);
+  if (idx > -1) {
+    arr.splice(idx, 1);
+  }
+}
+
+export function merge<T>(arr: T[], toInsert: T[], cmp: (a: T, b: T) => -1 | 0 | 1): void {
+  const result = new Array<T>(arr.length + toInsert.length);
+  let i = 0,
+    j = 0,
+    k = 0;
+
+  while (i < arr.length && j < toInsert.length) {
+    result[k++] = cmp(arr[i], toInsert[j]) <= 0 ? arr[i++] : toInsert[j++];
+  }
+
+  while (i < arr.length) {
+    result[k++] = arr[i++];
+  }
+  while (j < toInsert.length) {
+    result[k++] = toInsert[j++];
+  }
+
+  for (i = 0; i < result.length; i++) {
+    arr[i] = result[i];
+  }
+  arr.length = result.length;
+}

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

@@ -0,0 +1,135 @@
+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;
+};
+
+/** Increments a BlockNumber by a given value. */
+BlockNumber.add = function (bn: BlockNumber, increment: number): BlockNumber {
+  return BlockNumber(bn + increment);
+};
+
+/**
+ * The zero block value (genesis block).
+ */
+BlockNumber.ZERO = BlockNumber(0);
+
+function makeBlockNumberSchema(minValue: number) {
+  const max = Number.MAX_SAFE_INTEGER;
+  return z
+    .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));
+}
+
+/**
+ * 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/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

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+
+import { isDefined } from '../types/index.js';
+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;
+};
+
+/** 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);
+
+/** 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<string | number | bigint>().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<string | number | bigint>().int().min(0))
+  .transform(value => EpochNumber(value));

package/src/branded-types/index.ts

@@ -0,0 +1,8 @@
+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';
+export { SlotNumber, SlotNumberSchema } from './slot.js';
+
+export type { Branded } from './types.js';

package/src/branded-types/index_within_checkpoint.ts

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