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

package/dest/schemas/parse.js

@@ -1,14 +1,15 @@
 import { z } from 'zod';
 import { times } from '../collection/array.js';
 /** Parses the given arguments using a tuple from the provided schemas. */ export function parse(args, ...schemas) {
-    return z.tuple(schemas).parse(args);
+    return schemas.length === 0 ? z.tuple([]).parse(args) : z.tuple(schemas).parse(args);
 }
 /**
  * Parses the given arguments against a tuple, allowing empty for optional items.
- * @dev Zod doesn't like tuplues with optional items. See https://github.com/colinhacks/zod/discussions/949.
+ * @dev Zod doesn't like tuples with optional items. See https://github.com/colinhacks/zod/discussions/949.
  */ export function parseWithOptionals(args, schema) {
-    const missingCount = schema.items.length - args.length;
-    const optionalCount = schema.items.filter(isOptional).length;
+    const items = schema.def.items;
+    const missingCount = items.length - args.length;
+    const optionalCount = items.filter(isOptional).length;
     const toParse = missingCount > 0 && missingCount <= optionalCount ? args.concat(times(missingCount, ()=>undefined)) : args;
     return schema.parseAsync(toParse);
 }
@@ -17,6 +18,6 @@ function isOptional(schema) {
         return schema.isOptional();
     } catch  {
         // See https://github.com/colinhacks/zod/issues/1911
-        return schema._def.typeName === 'ZodOptional';
+        return schema.def.type === 'optional';
     }
 }

package/dest/schemas/schemas.d.ts

@@ -8,37 +8,37 @@ import { Point } from '../curves/grumpkin/point.js';
 import { EthAddress } from '../eth-address/index.js';
 export declare const schemas: {
     /** Accepts a number, bigint, or string as an EpochNumber. */
-    EpochNumber: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodNumber>, EpochNumber, string | number | bigint>;
+    EpochNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<EpochNumber, number>>;
     /** Accepts a number, bigint, or string as a SlotNumber. */
-    SlotNumber: z.ZodEffects<z.ZodPipeline<z.ZodUnion<[z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodNumber>, SlotNumber, string | number | bigint>;
+    SlotNumber: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodBigInt, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>, z.ZodTransform<SlotNumber, number>>;
     /** Accepts a hex string. */
-    EthAddress: z.ZodType<EthAddress, any, string>;
+    EthAddress: z.ZodType<EthAddress, string, z.core.$ZodTypeInternals<EthAddress, string>>;
     /** Accepts a hex string. */
-    Fr: z.ZodType<Fr, any, string>;
+    Fr: z.ZodType<Fr, string, z.core.$ZodTypeInternals<Fr, string>>;
     /** Accepts a hex string. */
-    Fq: z.ZodType<Fq, any, string>;
+    Fq: z.ZodType<Fq, string, z.core.$ZodTypeInternals<Fq, string>>;
     /** Point. Serialized as a hex string. */
-    Point: z.ZodType<Point, any, string>;
+    Point: z.ZodType<Point, string, z.core.$ZodTypeInternals<Point, string>>;
     /** Coerces truthy-like string values to boolean. */
-    Boolean: z.ZodUnion<[z.ZodBoolean, z.ZodEffects<z.ZodEffects<z.ZodNumber, 0 | 1, number>, boolean, number>, z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, boolean, string>]>;
+    Boolean: z.ZodUnion<readonly [z.ZodBoolean, z.ZodPipe<z.ZodNumber & z.ZodType<0 | 1, number, z.core.$ZodTypeInternals<0 | 1, number>>, z.ZodTransform<boolean, 0 | 1>>, z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<boolean, string>>]>;
     /** Coerces any input to bigint. */
-    BigInt: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    BigInt: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
     /** Coerces any input to integer number. */
-    Integer: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    Integer: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
     /** Coerces input to UInt32. */
-    UInt32: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodNumber>;
+    UInt32: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number | bigint>>;
     /** Coerces input to UInt64. */
-    UInt64: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    UInt64: z.ZodPipe<z.ZodUnion<readonly [z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodCoercedBigInt<string | number | bigint>>;
     /** Accepts a hex string as a Buffer32 type. */
-    Buffer32: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, Buffer32, string>;
+    Buffer32: z.ZodPipe<z.ZodString, z.ZodTransform<Buffer32, string>>;
     /** Accepts a base64 string or an object `{ type: 'Buffer', data: [byte, byte...] }` as a buffer. */
     Buffer: import("./types.js").ZodFor<Buffer<ArrayBufferLike>>;
     /** Accepts a hex string as a buffer. */
-    BufferHex: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, Buffer<ArrayBuffer>, string>;
+    BufferHex: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodTransform<Buffer<ArrayBuffer>, string>>;
     /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */
-    HexString: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    HexString: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     /** Hex string with an optional 0x prefix which gets enforced as part of the parsing. */
-    HexStringWith0x: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, `0x${string}`, string>;
+    HexStringWith0x: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
     /** A secret config value */
     SecretValue: typeof SecretValue.schema;
 };

package/dest/schemas/types.d.ts

@@ -1,5 +1,5 @@
 import type { ZodType } from 'zod';
-export type ZodFor<T> = ZodType<T, any, any>;
+export type ZodFor<T> = ZodType<T, any>;
 /**
  * Creates a schema validator that enforces all properties of type T are present in the schema.
  * This provides compile-time safety to ensure schemas don't miss optional properties.
@@ -23,11 +23,11 @@ export type ZodFor<T> = ZodType<T, any, any>;
  * }));
  * ```
  */
-export declare function zodFor<T>(): <S extends ZodType<any, any, any>>(schema: keyof T extends keyof S["_output"] ? keyof S["_output"] extends keyof T ? S : S & {
+export declare function zodFor<T>(): <S extends ZodType<any, any, import("zod/v4/core").$ZodTypeInternals<any, any>>>(schema: keyof T extends keyof S["_output"] ? keyof S["_output"] extends keyof T ? S : S & {
     __error__: "Schema has extra keys not in type";
     __extra__: Exclude<keyof S["_output"], keyof T>;
 } : S & {
     __error__: "Schema is missing keys from type";
     __missing__: Exclude<keyof T, keyof S["_output"]>;
 }) => S;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zY2hlbWFzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLEtBQUssQ0FBQztBQUVuQyxNQUFNLE1BQU0sTUFBTSxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUMsQ0FBQyxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQztBQUU3Qzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUNILHdCQUFnQixNQUFNLENBQUMsQ0FBQyxNQUNRLENBQUM7Ozs7OztRQU9oQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zY2hlbWFzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLEtBQUssQ0FBQztBQUVuQyxNQUFNLE1BQU0sTUFBTSxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0FBRXhDOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBc0JHO0FBQ0gsd0JBQWdCLE1BQU0sQ0FBQyxDQUFDLE1BQ1EsQ0FBQzs7Ozs7O1FBT2hDIn0=

package/dest/schemas/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schemas/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,CAAC,MACQ,CAAC;;;;;;QAOhC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schemas/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,MAAM,CAAC,CAAC,MACQ,CAAC;;;;;;QAOhC"}

package/dest/schemas/utils.d.ts

@@ -1,19 +1,15 @@
-import { type ParseInput, type ParseReturnType, type ZodObject, ZodOptional, type ZodRawShape, type ZodType, type ZodTypeAny, z } from 'zod';
+import { type ZodObject, type ZodRawShape, type ZodType, type ZodTypeAny, z } from 'zod';
 import type { ZodFor } from './types.js';
-export declare const hexSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const hexSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
 /** Schema for a buffer represented as a base64 string or a Buffer object. */
 export declare const bufferSchema: ZodFor<Buffer>;
-export declare class ZodNullableOptional<T extends ZodTypeAny> extends ZodOptional<T> {
-    _isNullableOptional: boolean;
-    _parse(input: ParseInput): ParseReturnType<this['_output']>;
-    static create<T extends ZodTypeAny>(type: T): ZodNullableOptional<T>;
-}
+export type ZodNullableOptional<T extends ZodTypeAny> = ZodType<z.output<T> | undefined, z.input<T> | null | undefined>;
 /**
  * Declares a parameter as optional. Use this over z.optional in order to accept nulls as undefineds.
  * This is required as JSON does not have an undefined type, and null is used to represent it, so we
  * need to convert nulls to undefineds as we parse.
  */
-export declare function optional<T extends ZodTypeAny>(schema: T): ZodNullableOptional<T>;
+export declare function optional<T extends ZodTypeAny>(schema: T): z.ZodPipe<z.ZodOptional<z.ZodNullable<T>>, z.ZodTransform<Awaited<NonNullable<z.TypeOf<T>>> | undefined, z.TypeOf<T> | null | undefined>>;
 type ToJsonIs<T, TRet> = T extends {
     toJSON(): TRet;
 } ? T : never;
@@ -30,7 +26,7 @@ export declare function hexSchemaFor<TClass extends {
     fromString(str: string): infer TInstance;
 } | {
     fromBuffer(buf: Buffer): infer TInstance;
-} ? ToJsonIs<TInstance, string> : never, any, string>;
+} ? ToJsonIs<TInstance, string> : never, string>;
 /**
  * Creates a schema that accepts a base64 string and uses it to hydrate an instance.
  * @param klazz - Class that implements fromBuffer.
@@ -40,7 +36,7 @@ export declare function bufferSchemaFor<TClass extends {
     fromBuffer(buf: Buffer): any;
 }>(klazz: TClass, refinement?: (buf: Buffer) => boolean): ZodType<TClass extends {
     fromBuffer(buf: Buffer): infer TInstance;
-} ? ToJsonIs<TInstance, Buffer> : never, any, string>;
+} ? ToJsonIs<TInstance, Buffer> : never, string>;
 /** Creates a schema for a js Map type that matches the serialization used in jsonStringify. */
 export declare function mapSchema<TKey, TValue>(key: ZodFor<TKey>, value: ZodFor<TValue>): ZodFor<Map<TKey, TValue>>;
 /** Creates a schema for a js Set type that matches the serialization used in jsonStringify. */
@@ -48,4 +44,4 @@ export declare function setSchema<T>(value: ZodFor<T>): ZodFor<Set<T>>;
 /** Given an already parsed and validated object, extracts the keys defined in the given schema. Does not validate again. */
 export declare function pickFromSchema<T extends object, S extends ZodObject<ZodRawShape>>(obj: T, schema: S): Partial<T>;
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dest/schemas/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/schemas/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,eAAe,EAEpB,KAAK,SAAS,EACd,WAAW,EAEX,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,CAAC,EACF,MAAM,KAAK,CAAC;AAIb,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,SAAS,yEAAiF,CAAC;AAKxG,6EAA6E;AAC7E,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAiBtC,CAAC;AAEH,qBAAa,mBAAmB,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;IAC3E,mBAAmB,UAAQ;IAElB,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAMnE;IAED,OAAgB,MAAM,CAAC,CAAC,SAAS,UAAU,EAAE,IAAI,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAK5E;CACF;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC,0BAEvD;AAED,KAAK,QAAQ,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,SAAS;IAAE,MAAM,IAAI,IAAI,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAC;AAElE;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC7G,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GACtC,OAAO,CACR,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GACtG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,GAC3B,KAAK,EACT,GAAG,EACH,MAAM,CACP,CAMA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC7E,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GACpC,OAAO,CACR,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GAAG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,KAAK,EACjG,GAAG,EACH,MAAM,CACP,CAEA;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAE3G;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAE7D;AAED,4HAA4H;AAC5H,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,cAEnG"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/schemas/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,WAAW,EAAE,KAAK,OAAO,EAAE,KAAK,UAAU,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIzF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,eAAO,MAAM,SAAS,wDAAiF,CAAC;AAKxG,6EAA6E;AAC7E,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,CAiBtC,CAAC;AAEH,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,UAAU,IAAI,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAExH;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC,6IAEvD;AAED,KAAK,QAAQ,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,SAAS;IAAE,MAAM,IAAI,IAAI,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAC;AAElE;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC7G,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GACtC,OAAO,CACR,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GAAG;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GACtG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,GAC3B,KAAK,EACT,MAAM,CACP,CAMA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC7E,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GACpC,OAAO,CAAC,MAAM,SAAS;IAAE,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,SAAS,CAAA;CAAE,GAAG,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,CAAC,CAEpH;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAE3G;AAED,+FAA+F;AAC/F,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAE7D;AAED,4HAA4H;AAC5H,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,CAAC,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,cAEnG"}

package/dest/schemas/utils.js

@@ -1,4 +1,4 @@
-import { OK, ZodFirstPartyTypeKind, ZodOptional, ZodParsedType, z } from 'zod';
+import { z } from 'zod';
 import { pick } from '../collection/object.js';
 import { isHex, withoutHexPrefix } from '../string/index.js';
 export const hexSchema = z.string().refine(isHex, 'Not a valid hex string').transform(withoutHexPrefix);
@@ -17,28 +17,12 @@ const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}
     // Serialization from Buffer
     z.instanceof(Buffer)
 ]);
-export class ZodNullableOptional extends ZodOptional {
-    _isNullableOptional = true;
-    _parse(input) {
-        const parsedType = this._getType(input);
-        if (parsedType === ZodParsedType.undefined || parsedType === ZodParsedType.null) {
-            return OK(undefined);
-        }
-        return this._def.innerType._parse(input);
-    }
-    static create(type) {
-        return new ZodNullableOptional({
-            innerType: type,
-            typeName: ZodFirstPartyTypeKind.ZodOptional
-        });
-    }
-}
 /**
  * Declares a parameter as optional. Use this over z.optional in order to accept nulls as undefineds.
  * This is required as JSON does not have an undefined type, and null is used to represent it, so we
  * need to convert nulls to undefineds as we parse.
  */ export function optional(schema) {
-    return ZodNullableOptional.create(schema);
+    return schema.nullish().transform((value)=>value ?? undefined);
 }
 /**
  * Creates a schema that accepts a hex string and uses it to hydrate an instance.

package/dest/serialize/buffer_sink.d.ts

@@ -0,0 +1,134 @@
+/**
+ * A value that can be appended to a {@link BufferSink}. Mirrors `Bufferable`, but the object arm allows the
+ * optional-sink overload of `toBuffer` so a legacy `toBuffer(): Buffer` and a migrated `toBuffer(sink?)` both fit.
+ */
+export type Sinkable = boolean | Buffer | Uint8Array | number | bigint | string | {
+    toBuffer(sink?: BufferSink): Buffer | void;
+} | Sinkable[];
+/**
+ * A growable, append-only binary sink backed by a single `ArrayBuffer`.
+ *
+ * It exists to replace the recursive `toBuffer()` chain — which allocates a `Buffer` at every node and
+ * `Buffer.concat`s at every level — with one buffer that the whole object graph streams into and that is sliced
+ * exactly once at the root. Encodings are big-endian, matching `serializeToBuffer` byte-for-byte.
+ *
+ * The migration contract is the optional-sink `toBuffer`:
+ *
+ * ```ts
+ * toBuffer(): Buffer;
+ * toBuffer(sink: BufferSink): void;
+ * toBuffer(sink?: BufferSink): Buffer | void {
+ *   if (!sink) return BufferSink.serialize(this); // own a sink, fill it, slice once
+ *   serializeToSink(sink, this.a, this.b, this.c); // stream into the caller's sink
+ * }
+ * ```
+ *
+ * When a sink is passed it writes and returns `undefined`; otherwise it returns its own buffer. Nodes that have
+ * not been migrated keep their plain `toBuffer(): Buffer` and are folded in via the return-value fallback in
+ * {@link serializeToSink}, so the tree stays valid at every step of an incremental migration.
+ *
+ * Performance note: bigints are written via `DataView.setBigUint64` limbs ({@link writeBigInt},
+ * {@link writeField}), NOT a per-byte shift loop. The limb form is ~16x faster than the legacy hex round-trip
+ * on field-heavy structures, and faster than the legacy path at every width — a naive per-byte shift loop is
+ * actually the slowest option, since each byte allocates a fresh BigInt. See the spike benchmark.
+ */
+export declare class BufferSink {
+    private buffer;
+    private view;
+    private offset;
+    constructor(initialCapacity?: number);
+    /** Number of bytes written so far. */
+    get length(): number;
+    /**
+     * Serialize a migrated value into a fresh sink and return the single resulting buffer. This is the no-sink
+     * branch of every migrated `toBuffer`: one allocation, one slice, only at the root.
+     *
+     * @param obj - The value to serialize via its sink-aware `toBuffer`.
+     * @param initialCapacity - Optional size hint (e.g. from `getSize()`) to skip reallocations on hot paths.
+     */
+    static serialize(obj: {
+        toBuffer(sink: BufferSink): void;
+    }, initialCapacity?: number): Buffer;
+    private ensure;
+    /** Append a single byte (0/1) for a boolean, matching `boolToBuffer`. */
+    writeBool(value: boolean): void;
+    /** Append an unsigned 8-bit integer. */
+    writeUInt8(value: number): void;
+    /** Append a big-endian unsigned 16-bit integer. */
+    writeUInt16(value: number): void;
+    /** Append a big-endian unsigned 32-bit integer, matching `numToUInt32BE`. */
+    writeNumber(value: number): void;
+    /** Append a big-endian unsigned 64-bit integer, matching `bigintToUInt64BE`. */
+    writeUInt64(value: bigint): void;
+    /**
+     * Append a non-negative bigint as a big-endian unsigned integer of `width` bytes (default 32), matching
+     * `serializeBigInt` / `toBufferBE`. Every width is written limb-wise via `setBigUint64` rather than the
+     * legacy per-byte BigInt shift loop — that loop allocated a fresh BigInt per byte and benchmarked as the
+     * *slowest* option (slower even than the legacy hex round-trip); the limb form is faster at every width.
+     *
+     * The bulk of the value is written as 64-bit big-endian limbs from the least-significant tail upward, and
+     * a final `width % 8` (at most 7) high bytes that don't fill a whole limb are written individually. The
+     * common widths (8/16/32) are exact multiples of 8, so they take the pure-limb path with no remainder.
+     * `width === 32` keeps its own straight-line four-limb form (shared with {@link writeField}) since it is
+     * the `Fr`/`Fq`/Chonk-proof hot path and the unrolled body is marginally faster than the loop.
+     *
+     * @param value - The non-negative bigint to serialize.
+     * @param width - Output width in bytes.
+     */
+    writeBigInt(value: bigint, width?: number): void;
+    /**
+     * Append a 32-byte (256-bit) big-endian non-negative bigint. Specialized form of {@link writeBigInt}
+     * with no width parameter and no width-branch, so V8 can inline the four `setBigUint64` limb writes
+     * without the wider branchy form's instability. This is the Fr/Fq leaf hot path; prefer it over
+     * `writeBigInt(value, 32)` in callers that always serialize 32-byte fields.
+     */
+    writeField(value: bigint): void;
+    /**
+     * Append an array of field elements (or any objects exposing `toBigInt(): bigint`) as a contiguous
+     * sequence of 32-byte big-endian limbs. Iterates inline — no per-element `toBuffer` dispatch and no
+     * per-element function-call indirection through the generic sinkable dispatcher. Use this in classes
+     * that hold large flat field arrays (e.g. the 1632-element ChonkProof field list).
+     */
+    writeFields(fields: ReadonlyArray<{
+        toBigInt(): bigint;
+    }>): void;
+    /** Append raw bytes verbatim (no length prefix), matching how a `Buffer`/`Uint8Array` is serialized inline. */
+    writeBytes(bytes: Uint8Array): void;
+    /** Append a string as a 4-byte big-endian length prefix followed by its UTF-8 bytes, matching the string case. */
+    writeString(value: string): void;
+    /**
+     * Reset the write cursor without releasing the backing buffer. Lets the same sink be reused across many
+     * serializations without reallocating — the per-call cost drops to the bytes written (no `new ArrayBuffer`).
+     * Any `Buffer` previously returned by {@link toBuffer} is a fresh copy and remains valid; any view from
+     * {@link asUint8Array} aliases the buffer and is invalidated.
+     */
+    reset(): void;
+    /** Copy the written region into a freshly allocated `Buffer`. The single allocation of the whole serialization. */
+    toBuffer(): Buffer;
+    /** A zero-copy view of the written region. Valid only until the next write (which may reallocate). */
+    asUint8Array(): Uint8Array;
+}
+/**
+ * Streaming counterpart to `serializeToBufferArray`: walk a list of {@link Sinkable}s and append each to the sink.
+ * Dispatch matches `serializeToBufferArray` byte-for-byte. An object is serialized via `obj.toBuffer(sink)`; a
+ * migrated node writes into the sink and returns `undefined`, while a not-yet-migrated node ignores the argument
+ * and returns its `Buffer`, which we copy in. That return-value fallback is what makes the migration incremental.
+ *
+ * Dispatch is hot-pathed for the common case of objects exposing `toBuffer` (Fr/Fq and every other migrated leaf),
+ * and arrays recurse via an inner-array helper to avoid the per-call rest-args allocation that a spread-recurse
+ * would force on large flat arrays like the 1632-element ChonkProof field list.
+ *
+ * @param sink - The destination sink.
+ * @param objs - The values to serialize, in order.
+ */
+export declare function serializeToSink(sink: BufferSink, ...objs: Sinkable[]): void;
+/**
+ * Streaming counterpart to `serializeArrayOfBufferableToVector`: write a length prefix (1 or 4 bytes) giving the
+ * number of serialized elements, then each element. Byte-identical to the buffer version.
+ *
+ * @param sink - The destination sink.
+ * @param objs - The vector elements.
+ * @param prefixLength - Width of the count prefix in bytes (1 or 4).
+ */
+export declare function serializeArrayToSink(sink: BufferSink, objs: Sinkable[], prefixLength?: number): void;
+//# sourceMappingURL=data:application/json;base64,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

package/dest/serialize/buffer_sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer_sink.d.ts","sourceRoot":"","sources":["../../src/serialize/buffer_sink.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAChB,OAAO,GACP,MAAM,GACN,UAAU,GACV,MAAM,GACN,MAAM,GACN,MAAM,GACN;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAAA;CAAE,GAC9C,QAAQ,EAAE,CAAC;AAKf;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,IAAI,CAAW;IACvB,OAAO,CAAC,MAAM,CAAK;IAEnB,YAAY,eAAe,GAAE,MAAiC,EAI7D;IAED,sCAAsC;IACtC,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;;;;;OAMG;IACH,OAAc,SAAS,CAAC,GAAG,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;KAAE,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAInG;IAED,OAAO,CAAC,MAAM;IAed,yEAAyE;IAClE,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAGrC;IAED,wCAAwC;IACjC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAGrC;IAED,mDAAmD;IAC5C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAItC;IAED,6EAA6E;IACtE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAItC;IAED,gFAAgF;IACzE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAItC;IAED;;;;;;;;;;;;;;OAcG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,IAAI,CAqClD;IAED;;;;;OAKG;IACI,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAkBrC;IAED;;;;;OAKG;IACI,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC;QAAE,QAAQ,IAAI,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI,CAqBtE;IAED,+GAA+G;IACxG,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAIzC;IAED,kHAAkH;IAC3G,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAItC;IAED;;;;;OAKG;IACI,KAAK,IAAI,IAAI,CAEnB;IAED,mHAAmH;IAC5G,QAAQ,IAAI,MAAM,CAExB;IAED,sGAAsG;IAC/F,YAAY,IAAI,UAAU,CAEhC;CACF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI,CAE3E;AA0CD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,YAAY,SAAI,GAAG,IAAI,CAU/F"}