@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/branded-types/block_number.js

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+/**
+ * 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) {
+    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;
+}
+/**
+ * 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) {
+    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);
+};
+/**
+ * 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) {
+    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) {
+    return value;
+};
+/**
+ * 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) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+};
+/** Increments a BlockNumber by a given value. */ BlockNumber.add = function(bn, increment) {
+    return BlockNumber(bn + increment);
+};
+/**
+ * The zero block value (genesis block).
+ */ BlockNumber.ZERO = BlockNumber(0);
+function makeBlockNumberSchema(minValue) {
+    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/dest/branded-types/buffer32_hash.d.ts

@@ -0,0 +1,27 @@
+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 declare function CheckpointProposalHash(s: `0x${string}`): CheckpointProposalHash;
+export declare namespace CheckpointProposalHash {
+    var fromBuffer: (buf: Buffer<ArrayBufferLike>) => 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 declare function BlockProposalHash(s: `0x${string}`): BlockProposalHash;
+export declare namespace BlockProposalHash {
+    var fromBuffer: (buf: Buffer<ArrayBufferLike>) => BlockProposalHash;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVmZmVyMzJfaGFzaC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2JyYW5kZWQtdHlwZXMvYnVmZmVyMzJfaGFzaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxPQUFPLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFMUM7Ozs7OztHQU1HO0FBQ0gsTUFBTSxNQUFNLHNCQUFzQixHQUFHLE9BQU8sQ0FBQyxLQUFLLE1BQU0sRUFBRSxFQUFFLHdCQUF3QixDQUFDLENBQUM7QUFFdEYscUVBQXFFO0FBQ3JFLHdCQUFnQixzQkFBc0IsQ0FBQyxDQUFDLEVBQUUsS0FBSyxNQUFNLEVBQUUsR0FBRyxzQkFBc0IsQ0FFL0U7Ozs7QUFPRDs7Ozs7R0FLRztBQUNILE1BQU0sTUFBTSxpQkFBaUIsR0FBRyxPQUFPLENBQUMsS0FBSyxNQUFNLEVBQUUsRUFBRSxtQkFBbUIsQ0FBQyxDQUFDO0FBRTVFLGdFQUFnRTtBQUNoRSx3QkFBZ0IsaUJBQWlCLENBQUMsQ0FBQyxFQUFFLEtBQUssTUFBTSxFQUFFLEdBQUcsaUJBQWlCLENBRXJFIn0=

package/dest/branded-types/buffer32_hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer32_hash.d.ts","sourceRoot":"","sources":["../../src/branded-types/buffer32_hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,EAAE,wBAAwB,CAAC,CAAC;AAEtF,qEAAqE;AACrE,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,KAAK,MAAM,EAAE,GAAG,sBAAsB,CAE/E;;;;AAOD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,EAAE,mBAAmB,CAAC,CAAC;AAE5E,gEAAgE;AAChE,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,MAAM,EAAE,GAAG,iBAAiB,CAErE"}

package/dest/branded-types/buffer32_hash.js

@@ -0,0 +1,12 @@
+/** Brands a `0x`-prefixed hex string as a CheckpointProposalHash. */ export function CheckpointProposalHash(s) {
+    return s;
+}
+/** Constructs a CheckpointProposalHash from a raw 32-byte hash buffer. */ CheckpointProposalHash.fromBuffer = function(buf) {
+    return `0x${buf.toString('hex')}`;
+};
+/** Brands a `0x`-prefixed hex string as a BlockProposalHash. */ export function BlockProposalHash(s) {
+    return s;
+}
+/** Constructs a BlockProposalHash from a raw 32-byte hash buffer. */ BlockProposalHash.fromBuffer = function(buf) {
+    return `0x${buf.toString('hex')}`;
+};

package/dest/branded-types/checkpoint_number.d.ts

@@ -0,0 +1,60 @@
+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 declare function CheckpointNumber(value: number): CheckpointNumber;
+export declare namespace CheckpointNumber {
+    var fromBlockNumber: (value: BlockNumber) => CheckpointNumber;
+}
+export declare namespace CheckpointNumber {
+    var fromBigInt: (value: bigint) => CheckpointNumber;
+}
+export declare namespace CheckpointNumber {
+    var fromString: (value: string) => CheckpointNumber;
+}
+export declare namespace CheckpointNumber {
+    var isValid: (value: unknown) => value is CheckpointNumber;
+}
+export declare namespace CheckpointNumber {
+    var add: (n: CheckpointNumber, increment: number) => CheckpointNumber;
+}
+export declare namespace CheckpointNumber {
+    var max: (...values: (CheckpointNumber | undefined)[]) => CheckpointNumber | undefined;
+}
+export declare namespace CheckpointNumber {
+    var ZERO: CheckpointNumber;
+}
+export declare namespace CheckpointNumber {
+    var INITIAL: CheckpointNumber;
+}
+/**
+ * Zod schema for parsing and validating Checkpoint values.
+ * Accepts numbers, bigints, or strings and coerces them to CheckpointNumber.
+ */
+export declare const CheckpointNumberSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<CheckpointNumber, number>>;
+/**
+ * Zod schema for parsing and validating CheckpointNumber values that are strictly positive.
+ * Accepts numbers, bigints, or strings and coerces them to CheckpointNumber.
+ */
+export declare const CheckpointNumberPositiveSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<CheckpointNumber, number>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2twb2ludF9udW1iZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9icmFuZGVkLXR5cGVzL2NoZWNrcG9pbnRfbnVtYmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFHeEIsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTFDOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLE1BQU0sZ0JBQWdCLEdBQUcsT0FBTyxDQUFDLE1BQU0sRUFBRSxrQkFBa0IsQ0FBQyxDQUFDO0FBRW5FOzs7OztHQUtHO0FBQ0gsd0JBQWdCLGdCQUFnQixDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsZ0JBQWdCLENBUWhFOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBbUZEOzs7R0FHRztBQUNILGVBQU8sTUFBTSxzQkFBc0IsNEtBQWdDLENBQUM7QUFFcEU7OztHQUdHO0FBQ0gsZUFBTyxNQUFNLDhCQUE4Qiw0S0FBZ0MsQ0FBQyJ9

package/dest/branded-types/checkpoint_number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint_number.d.ts","sourceRoot":"","sources":["../../src/branded-types/checkpoint_number.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAEnE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAQhE;;;;;;;;;;;;;;;;;;;;;;;;;AAmFD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,4KAAgC,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,4KAAgC,CAAC"}

package/dest/branded-types/checkpoint_number.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { isDefined } from '../types/index.js';
+/**
+ * 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) {
+    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;
+}
+/**
+ * @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) {
+    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) {
+    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);
+};
+/**
+ * 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) {
+    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) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+};
+/** Increments a CheckpointNumber by a given value. */ CheckpointNumber.add = function(n, increment) {
+    return CheckpointNumber(n + increment);
+};
+/** Computes max of a set of checkpoint numbers, ignoring undefined values. */ CheckpointNumber.max = function(...values) {
+    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) {
+    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/dest/branded-types/epoch.d.ts

@@ -0,0 +1,42 @@
+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 declare function EpochNumber(value: number): EpochNumber;
+export declare namespace EpochNumber {
+    var fromBigInt: (value: bigint) => EpochNumber;
+}
+export declare namespace EpochNumber {
+    var fromString: (value: string) => EpochNumber;
+}
+export declare namespace EpochNumber {
+    var isValid: (value: unknown) => value is EpochNumber;
+}
+export declare namespace EpochNumber {
+    var ZERO: EpochNumber;
+}
+/**
+ * Zod schema for parsing and validating EpochNumber values.
+ * Accepts numbers, bigints, or strings and coerces them to EpochNumber.
+ */
+export declare const EpochNumberSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<EpochNumber, number>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXBvY2guZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9icmFuZGVkLXR5cGVzL2Vwb2NoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTFDOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLE1BQU0sV0FBVyxHQUFHLE9BQU8sQ0FBQyxNQUFNLEVBQUUsYUFBYSxDQUFDLENBQUM7QUFFekQ7Ozs7O0dBS0c7QUFDSCx3QkFBZ0IsV0FBVyxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsV0FBVyxDQVF0RDs7Ozs7Ozs7Ozs7OztBQThDRDs7O0dBR0c7QUFDSCxlQUFPLE1BQU0saUJBQWlCLHVLQUdXLENBQUMifQ==

package/dest/branded-types/epoch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"epoch.d.ts","sourceRoot":"","sources":["../../src/branded-types/epoch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,CAQtD;;;;;;;;;;;;;AA8CD;;;GAGG;AACH,eAAO,MAAM,iBAAiB,uKAGW,CAAC"}

package/dest/branded-types/epoch.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+/**
+ * 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) {
+    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;
+}
+/**
+ * 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) {
+    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);
+};
+/**
+ * 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) {
+    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) {
+    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/dest/branded-types/index.d.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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9icmFuZGVkLXR5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsaUJBQWlCLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUM5RixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMvRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsc0JBQXNCLEVBQUUsOEJBQThCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNsSCxPQUFPLEVBQUUsV0FBVyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQzVELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSwyQkFBMkIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ2xHLE9BQU8sRUFBRSxVQUFVLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFekQsWUFBWSxFQUFFLE9BQU8sRUFBRSxNQUFNLFlBQVksQ0FBQyJ9

package/dest/branded-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/branded-types/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAC9F,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AAClH,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAClG,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAEzD,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC"}

package/dest/branded-types/index.js

@@ -0,0 +1,6 @@
+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';

package/dest/branded-types/index_within_checkpoint.d.ts

@@ -0,0 +1,42 @@
+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 declare function IndexWithinCheckpoint(value: number): IndexWithinCheckpoint;
+export declare namespace IndexWithinCheckpoint {
+    var fromBigInt: (value: bigint) => IndexWithinCheckpoint;
+}
+export declare namespace IndexWithinCheckpoint {
+    var fromString: (value: string) => IndexWithinCheckpoint;
+}
+export declare namespace IndexWithinCheckpoint {
+    var isValid: (value: unknown) => value is IndexWithinCheckpoint;
+}
+export declare namespace IndexWithinCheckpoint {
+    var ZERO: IndexWithinCheckpoint;
+}
+/**
+ * Zod schema for parsing and validating IndexWithinCheckpoint values.
+ * Accepts numbers, bigints, or strings and coerces them to IndexWithinCheckpoint.
+ */
+export declare const IndexWithinCheckpointSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<IndexWithinCheckpoint, number>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXhfd2l0aGluX2NoZWNrcG9pbnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9icmFuZGVkLXR5cGVzL2luZGV4X3dpdGhpbl9jaGVja3BvaW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxDQUFDLEVBQUUsTUFBTSxLQUFLLENBQUM7QUFFeEIsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTFDOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCxNQUFNLE1BQU0scUJBQXFCLEdBQUcsT0FBTyxDQUFDLE1BQU0sRUFBRSx1QkFBdUIsQ0FBQyxDQUFDO0FBRTdFOzs7OztHQUtHO0FBQ0gsd0JBQWdCLHFCQUFxQixDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcscUJBQXFCLENBUTFFOzs7Ozs7Ozs7Ozs7O0FBOENEOzs7R0FHRztBQUNILGVBQU8sTUFBTSwyQkFBMkIsaUxBR1csQ0FBQyJ9

package/dest/branded-types/index_within_checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index_within_checkpoint.d.ts","sourceRoot":"","sources":["../../src/branded-types/index_within_checkpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;AAE7E;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAQ1E;;;;;;;;;;;;;AA8CD;;;GAGG;AACH,eAAO,MAAM,2BAA2B,iLAGW,CAAC"}

package/dest/branded-types/index_within_checkpoint.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+/**
+ * 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) {
+    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;
+}
+/**
+ * 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) {
+    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);
+};
+/**
+ * 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) {
+    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) {
+    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().int().min(0)).transform((value)=>IndexWithinCheckpoint(value));

package/dest/branded-types/slot.d.ts

@@ -0,0 +1,45 @@
+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 declare function SlotNumber(value: number): SlotNumber;
+export declare namespace SlotNumber {
+    var fromBigInt: (value: bigint) => SlotNumber;
+}
+export declare namespace SlotNumber {
+    var fromString: (value: string) => SlotNumber;
+}
+export declare namespace SlotNumber {
+    var isValid: (value: unknown) => value is SlotNumber;
+}
+export declare namespace SlotNumber {
+    var add: (sn: SlotNumber, increment: number) => SlotNumber;
+}
+export declare namespace SlotNumber {
+    var ZERO: SlotNumber;
+}
+/**
+ * Zod schema for parsing and validating SlotNumber values.
+ * Accepts numbers, bigints, or strings and coerces them to SlotNumber.
+ */
+export declare const SlotNumberSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<SlotNumber, number>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xvdC5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2JyYW5kZWQtdHlwZXMvc2xvdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsQ0FBQyxFQUFFLE1BQU0sS0FBSyxDQUFDO0FBRXhCLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUxQzs7Ozs7Ozs7Ozs7OztHQWFHO0FBQ0gsTUFBTSxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsTUFBTSxFQUFFLFlBQVksQ0FBQyxDQUFDO0FBRXZEOzs7OztHQUtHO0FBQ0gsd0JBQWdCLFVBQVUsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLFVBQVUsQ0FRcEQ7Ozs7Ozs7Ozs7Ozs7Ozs7QUFtREQ7OztHQUdHO0FBQ0gsZUFBTyxNQUFNLGdCQUFnQixzS0FHVyxDQUFDIn0=

package/dest/branded-types/slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot.d.ts","sourceRoot":"","sources":["../../src/branded-types/slot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAQpD;;;;;;;;;;;;;;;;AAmDD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,sKAGW,CAAC"}

package/dest/branded-types/slot.js

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+/**
+ * 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) {
+    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;
+}
+/**
+ * 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) {
+    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);
+};
+/**
+ * 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) {
+    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) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0;
+};
+/** Increments a SlotNumber by a given value. */ SlotNumber.add = function(sn, increment) {
+    return SlotNumber(sn + increment);
+};
+/**
+ * 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/dest/branded-types/types.d.ts

@@ -0,0 +1,5 @@
+/** Adds a branding to a type for nominal typing. */
+export type Branded<T, Brand> = T & {
+    _branding: Brand;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9icmFuZGVkLXR5cGVzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9EQUFvRDtBQUNwRCxNQUFNLE1BQU0sT0FBTyxDQUFDLENBQUMsRUFBRSxLQUFLLElBQUksQ0FBQyxHQUFHO0lBQUUsU0FBUyxFQUFFLEtBQUssQ0FBQTtDQUFFLENBQUMifQ==

package/dest/branded-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/branded-types/types.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,GAAG;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,CAAC"}

package/dest/branded-types/types.js

@@ -0,0 +1 @@
+/** Adds a branding to a type for nominal typing. */ export { };