@aztec/foundation 0.0.1-commit.a072138 → 0.0.1-commit.a4600f49

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_reader.d.ts

@@ -72,6 +72,13 @@ export declare class BufferReader {
      * @returns The read 256 bit value as a bigint.
      */
     readUInt256(): bigint;
+    /**
+     * Reads a 256-bit signed integer (two's complement) from the buffer at the current index position.
+     * Updates the index position by 32 bytes after reading the number.
+     *
+     * @returns The read 256 bit signed value as a bigint.
+     */
+    readInt256(): bigint;
     /** Alias for readUInt256 */
     readBigInt(): bigint;
     /**
@@ -264,4 +271,4 @@ export interface FromBuffer<T> {
      */
     fromBuffer(buffer: Buffer): T;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"buffer_reader.d.ts","sourceRoot":"","sources":["../../src/serialize/buffer_reader.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"buffer_reader.d.ts","sourceRoot":"","sources":["../../src/serialize/buffer_reader.ts"],"names":[],"mappings":"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"}

package/dest/serialize/buffer_reader.js

@@ -1,3 +1,4 @@
+import { toBigIntBE } from '../bigint-buffer/index.js';
 /**
  * The BufferReader class provides a utility for reading various data types from a buffer.
  * It supports reading numbers, booleans, byte arrays, Fr and Fq field elements,
@@ -103,6 +104,18 @@
         this.index += 32;
         return result;
     }
+    /**
+   * Reads a 256-bit signed integer (two's complement) from the buffer at the current index position.
+   * Updates the index position by 32 bytes after reading the number.
+   *
+   * @returns The read 256 bit signed value as a bigint.
+   */ readInt256() {
+        this.#rangeCheck(32);
+        const unsigned = toBigIntBE(this.buffer.subarray(this.index, this.index + 32));
+        this.index += 32;
+        const signBit = 1n << 255n;
+        return unsigned >= signBit ? unsigned - (1n << 256n) : unsigned;
+    }
     /** Alias for readUInt256 */ readBigInt() {
         return this.readUInt256();
     }

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"}

package/dest/serialize/buffer_sink.js

@@ -0,0 +1,297 @@
+/**
+ * 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.
+ */ const DEFAULT_INITIAL_CAPACITY = 1024;
+const MASK_64 = (1n << 64n) - 1n;
+/**
+ * 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 class BufferSink {
+    buffer;
+    view;
+    offset = 0;
+    constructor(initialCapacity = DEFAULT_INITIAL_CAPACITY){
+        const ab = new ArrayBuffer(initialCapacity);
+        this.buffer = new Uint8Array(ab);
+        this.view = new DataView(ab);
+    }
+    /** Number of bytes written so far. */ get length() {
+        return this.offset;
+    }
+    /**
+   * 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, initialCapacity) {
+        const sink = new BufferSink(initialCapacity);
+        obj.toBuffer(sink);
+        return sink.toBuffer();
+    }
+    ensure(extra) {
+        const required = this.offset + extra;
+        if (required <= this.buffer.length) {
+            return;
+        }
+        let next = this.buffer.length * 2;
+        while(next < required){
+            next *= 2;
+        }
+        const grown = new Uint8Array(next);
+        grown.set(this.buffer.subarray(0, this.offset));
+        this.buffer = grown;
+        this.view = new DataView(grown.buffer);
+    }
+    /** Append a single byte (0/1) for a boolean, matching `boolToBuffer`. */ writeBool(value) {
+        this.ensure(1);
+        this.buffer[this.offset++] = value ? 1 : 0;
+    }
+    /** Append an unsigned 8-bit integer. */ writeUInt8(value) {
+        this.ensure(1);
+        this.buffer[this.offset++] = value & 0xff;
+    }
+    /** Append a big-endian unsigned 16-bit integer. */ writeUInt16(value) {
+        this.ensure(2);
+        this.view.setUint16(this.offset, value, false);
+        this.offset += 2;
+    }
+    /** Append a big-endian unsigned 32-bit integer, matching `numToUInt32BE`. */ writeNumber(value) {
+        this.ensure(4);
+        this.view.setUint32(this.offset, value, false);
+        this.offset += 4;
+    }
+    /** Append a big-endian unsigned 64-bit integer, matching `bigintToUInt64BE`. */ writeUInt64(value) {
+        this.ensure(8);
+        this.view.setBigUint64(this.offset, value, false);
+        this.offset += 8;
+    }
+    /**
+   * 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, width = 32) {
+        if (value < 0n) {
+            throw new Error(`Cannot serialize negative bigint ${value}`);
+        }
+        this.ensure(width);
+        const o = this.offset;
+        if (width === 32) {
+            let x = value;
+            this.view.setBigUint64(o + 24, x & MASK_64, false);
+            x >>= 64n;
+            this.view.setBigUint64(o + 16, x & MASK_64, false);
+            x >>= 64n;
+            this.view.setBigUint64(o + 8, x & MASK_64, false);
+            x >>= 64n;
+            this.view.setBigUint64(o, x & MASK_64, false);
+            x >>= 64n;
+            if (x !== 0n) {
+                throw new Error(`BigInt ${value} does not fit into 32 bytes`);
+            }
+            this.offset += 32;
+            return;
+        }
+        let x = value;
+        let pos = o + width;
+        while(pos - 8 >= o){
+            pos -= 8;
+            this.view.setBigUint64(pos, x & MASK_64, false);
+            x >>= 64n;
+        }
+        for(let i = pos - 1; i >= o; i--){
+            this.buffer[i] = Number(x & 0xffn);
+            x >>= 8n;
+        }
+        if (x !== 0n) {
+            throw new Error(`BigInt ${value} does not fit into ${width} bytes`);
+        }
+        this.offset += width;
+    }
+    /**
+   * 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) {
+        if (value < 0n) {
+            throw new Error(`Cannot serialize negative bigint ${value}`);
+        }
+        this.ensure(32);
+        const o = this.offset;
+        let x = value;
+        this.view.setBigUint64(o + 24, x & MASK_64, false);
+        x >>= 64n;
+        this.view.setBigUint64(o + 16, x & MASK_64, false);
+        x >>= 64n;
+        this.view.setBigUint64(o + 8, x & MASK_64, false);
+        x >>= 64n;
+        this.view.setBigUint64(o, x & MASK_64, false);
+        if (x >> 64n !== 0n) {
+            throw new Error(`BigInt ${value} does not fit into 32 bytes`);
+        }
+        this.offset = o + 32;
+    }
+    /**
+   * 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) {
+        this.ensure(32 * fields.length);
+        for(let i = 0, n = fields.length; i < n; i++){
+            const value = fields[i].toBigInt();
+            if (value < 0n) {
+                throw new Error(`Cannot serialize negative bigint ${value}`);
+            }
+            const o = this.offset;
+            let x = value;
+            this.view.setBigUint64(o + 24, x & MASK_64, false);
+            x >>= 64n;
+            this.view.setBigUint64(o + 16, x & MASK_64, false);
+            x >>= 64n;
+            this.view.setBigUint64(o + 8, x & MASK_64, false);
+            x >>= 64n;
+            this.view.setBigUint64(o, x & MASK_64, false);
+            if (x >> 64n !== 0n) {
+                throw new Error(`BigInt ${value} does not fit into 32 bytes`);
+            }
+            this.offset = o + 32;
+        }
+    }
+    /** Append raw bytes verbatim (no length prefix), matching how a `Buffer`/`Uint8Array` is serialized inline. */ writeBytes(bytes) {
+        this.ensure(bytes.length);
+        this.buffer.set(bytes, this.offset);
+        this.offset += bytes.length;
+    }
+    /** Append a string as a 4-byte big-endian length prefix followed by its UTF-8 bytes, matching the string case. */ writeString(value) {
+        const bytes = Buffer.from(value);
+        this.writeNumber(bytes.length);
+        this.writeBytes(bytes);
+    }
+    /**
+   * 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() {
+        this.offset = 0;
+    }
+    /** Copy the written region into a freshly allocated `Buffer`. The single allocation of the whole serialization. */ toBuffer() {
+        return Buffer.from(this.buffer.subarray(0, this.offset));
+    }
+    /** A zero-copy view of the written region. Valid only until the next write (which may reallocate). */ asUint8Array() {
+        return this.buffer.subarray(0, this.offset);
+    }
+}
+/**
+ * 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 function serializeToSink(sink, ...objs) {
+    serializeArrayToSinkInner(sink, objs);
+}
+function serializeArrayToSinkInner(sink, objs) {
+    for(let i = 0, n = objs.length; i < n; i++){
+        serializeOneToSink(sink, objs[i]);
+    }
+}
+function serializeOneToSink(sink, obj) {
+    if (typeof obj === 'object' && obj !== null) {
+        // Hot path: migrated nodes (anything implementing toBuffer, including Fr/Fq via BaseField). This branch
+        // is taken for the vast majority of recursive serialization, so it is checked before the typeof primitives.
+        if (obj.toBuffer !== undefined) {
+            const ret = obj.toBuffer(sink);
+            if (ret !== undefined) {
+                sink.writeBytes(ret);
+            }
+            return;
+        }
+        if (Array.isArray(obj)) {
+            serializeArrayToSinkInner(sink, obj);
+            return;
+        }
+        if (Buffer.isBuffer(obj) || obj instanceof Uint8Array) {
+            sink.writeBytes(obj);
+            return;
+        }
+        throw new Error(`Cannot serialize input to sink: ${typeof obj} ${obj.constructor?.name}`);
+    }
+    if (typeof obj === 'boolean') {
+        sink.writeBool(obj);
+    } else if (typeof obj === 'bigint') {
+        sink.writeBigInt(obj);
+    } else if (typeof obj === 'number') {
+        sink.writeNumber(obj);
+    } else if (typeof obj === 'string') {
+        sink.writeString(obj);
+    } else {
+        throw new Error(`Cannot serialize input to sink: ${typeof obj}`);
+    }
+}
+/**
+ * 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 function serializeArrayToSink(sink, objs, prefixLength = 4) {
+    const count = countSinkables(objs);
+    if (prefixLength === 1) {
+        sink.writeUInt8(count);
+    } else if (prefixLength === 4) {
+        sink.writeNumber(count);
+    } else {
+        throw new Error(`Unsupported prefix length. Got ${prefixLength}, expected 1 or 4`);
+    }
+    serializeArrayToSinkInner(sink, objs);
+}
+/** Count how many top-level buffers `serializeToBufferArray` would emit, flattening nested arrays as it does. */ function countSinkables(objs) {
+    let count = 0;
+    for (const obj of objs){
+        count += Array.isArray(obj) ? countSinkables(obj) : 1;
+    }
+    return count;
+}

package/dest/serialize/index.d.ts

@@ -1,7 +1,8 @@
 export * from './free_funcs.js';
 export * from './buffer_reader.js';
+export * from './buffer_sink.js';
 export * from './field_reader.js';
 export * from './types.js';
 export * from './serialize.js';
 export * from './type_registry.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJpYWxpemUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLG9CQUFvQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zZXJpYWxpemUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsb0JBQW9CLENBQUMifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serialize/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serialize/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/dest/serialize/index.js

@@ -1,5 +1,6 @@
 export * from './free_funcs.js';
 export * from './buffer_reader.js';
+export * from './buffer_sink.js';
 export * from './field_reader.js';
 export * from './types.js';
 export * from './serialize.js';

package/dest/serialize/serialize.d.ts

@@ -115,6 +115,13 @@ export declare function toFriendlyJSON(obj: object): string;
  * @returns A Buffer containing the serialized BigInt value in big-endian format.
  */
 export declare function serializeBigInt(n: bigint, width?: number): Buffer<ArrayBufferLike>;
+/**
+ * Serialize a signed BigInt value into a Buffer of specified width using two's complement.
+ * @param n - The signed BigInt value to be serialized.
+ * @param width - The width (in bytes) of the output Buffer, optional with default value 32.
+ * @returns A Buffer containing the serialized signed BigInt value in big-endian format.
+ */
+export declare function serializeSignedBigInt(n: bigint, width?: number): Buffer<ArrayBufferLike>;
 /**
  * Deserialize a big integer from a buffer, given an offset and width.
  * Reads the specified number of bytes from the buffer starting at the offset, converts it to a big integer, and returns the deserialized result along with the number of bytes read (advanced).
@@ -128,6 +135,17 @@ export declare function deserializeBigInt(buf: Buffer, offset?: number, width?:
     elem: bigint;
     adv: number;
 };
+/**
+ * Deserialize a signed BigInt from a buffer (two's complement).
+ * @param buf - The buffer containing the signed big integer to be deserialized.
+ * @param offset - The position in the buffer where the integer starts. Defaults to 0.
+ * @param width - The number of bytes to read from the buffer for the integer. Defaults to 32.
+ * @returns An object containing the deserialized signed bigint value ('elem') and bytes advanced ('adv').
+ */
+export declare function deserializeSignedBigInt(buf: Buffer, offset?: number, width?: number): {
+    elem: bigint;
+    adv: number;
+};
 /**
  * Serializes a Date object into a Buffer containing its timestamp as a big integer value.
  * The resulting Buffer has a fixed width of 8 bytes, representing a 64-bit big-endian integer.
@@ -178,4 +196,4 @@ export declare function deserializeInt32(buf: Buffer, offset?: number): {
     adv: number;
 };
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/serialize/serialize.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C;;;;;GAKG;AACH,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,YAAY,SAAI,GAAG,MAAM,CAa/F;AAED;;GAEG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,KACX;IACH;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IACR;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACT;IACD;;OAEG;IACH,IAAI,EAAE,CAAC,EAAE,CAAC;IACV;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAWA;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAGzD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,SAAI,GAAG,MAAM,CAInE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGvD;AAED,8CAA8C;AAC9C,MAAM,MAAM,UAAU,GAClB,OAAO,GACP,MAAM,GACN,UAAU,GACV,MAAM,GACN,MAAM,GACN,MAAM,GACN;IACE;;OAEG;IACH,QAAQ,EAAE,MAAM,MAAM,CAAC;CACxB,GACD,UAAU,EAAE,CAAC;AAEjB,gEAAgE;AAChE,MAAM,MAAM,SAAS,GACjB,EAAE,GACF,OAAO,GACP,MAAM,GACN,MAAM,GACN,MAAM,GACN;IACE;;;OAGG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,GACD;IACE,4BAA4B;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,GACD;IACE,uCAAuC;IACvC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;CACtB,GACD,SAAS,EAAE,CAAC;AAEhB,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,IAAI,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE,CA4BtE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,CAsB5D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,IAAI,EAAE,UAAU,EAAE,GAAG,MAAM,CAE/D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CA4BlD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,SAAK,2BAEpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI,EAAE,KAAK,SAAK;;;EAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,2BAEvC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGvD"}
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/serialize/serialize.ts"],"names":[],"mappings":"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"}