@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/parity/inbox_parity_private_inputs.d.ts

@@ -0,0 +1,61 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+/** The InboxParity size ladder, ascending. One VK per size; the prover proves the smallest that fits. */
+export declare const INBOX_PARITY_SIZES: readonly [64, 256, 1024];
+/** A valid InboxParity ladder size. */
+export type InboxParitySize = (typeof INBOX_PARITY_SIZES)[number];
+/**
+ * Picks the smallest ladder size that can hold `numMessages` messages.
+ * @throws if `numMessages` exceeds the largest rung.
+ */
+export declare function pickInboxParitySize(numMessages: number): InboxParitySize;
+/**
+ * Private inputs for one `InboxParity<S>` proof (S = `size`). The prover produces exactly one per checkpoint, sized
+ * by the checkpoint's message count via {@link pickInboxParitySize}.
+ */
+export declare class InboxParityPrivateInputs {
+    /** Ladder size S: the length of `messages` and the circuit variant to prove ({@link INBOX_PARITY_SIZES}). */
+    readonly size: InboxParitySize;
+    /** The checkpoint's L1-to-L2 messages, padded with zeros to `size`; the first `numMessages` are real. */
+    readonly messages: Fr[];
+    /** Number of real (non-padding) messages in `messages`. */
+    readonly numMessages: number;
+    /** Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end; genesis is zero). */
+    readonly startRollingHash: Fr;
+    /** Prover identity committed to by the circuit, for sybil protection. */
+    readonly proverId: Fr;
+    constructor(
+    /** Ladder size S: the length of `messages` and the circuit variant to prove ({@link INBOX_PARITY_SIZES}). */
+    size: InboxParitySize, 
+    /** The checkpoint's L1-to-L2 messages, padded with zeros to `size`; the first `numMessages` are real. */
+    messages: Fr[], 
+    /** Number of real (non-padding) messages in `messages`. */
+    numMessages: number, 
+    /** Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end; genesis is zero). */
+    startRollingHash: Fr, 
+    /** Prover identity committed to by the circuit, for sybil protection. */
+    proverId: Fr);
+    /**
+     * Builds the inputs from a checkpoint's real messages, sizing the circuit by the message count and padding the
+     * message array out to that size.
+     */
+    static fromMessages(messages: Fr[], startRollingHash: Fr, proverId: Fr): InboxParityPrivateInputs;
+    /** Serializes the inputs to a buffer. */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /** Serializes the inputs to a hex string. */
+    toString(): `0x${string}`;
+    /**
+     * Deserializes the inputs from a buffer.
+     * @param buffer - The buffer to deserialize from.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): InboxParityPrivateInputs;
+    /**
+     * Deserializes the inputs from a hex string.
+     * @param str - The hex string to deserialize from.
+     */
+    static fromString(str: string): InboxParityPrivateInputs;
+    /** Returns a buffer representation for JSON serialization. */
+    toJSON(): Buffer<ArrayBufferLike>;
+    static get schema(): import("zod").ZodType<InboxParityPrivateInputs, string, import("zod/v4/core").$ZodTypeInternals<InboxParityPrivateInputs, string>>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5ib3hfcGFyaXR5X3ByaXZhdGVfaW5wdXRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcGFyaXR5L2luYm94X3Bhcml0eV9wcml2YXRlX2lucHV0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFFekQsT0FBTyxFQUFFLFlBQVksRUFBcUIsTUFBTSxrQ0FBa0MsQ0FBQztBQUduRix5R0FBeUc7QUFDekcsZUFBTyxNQUFNLGtCQUFrQiwwQkFBd0YsQ0FBQztBQUV4SCx1Q0FBdUM7QUFDdkMsTUFBTSxNQUFNLGVBQWUsR0FBRyxDQUFDLE9BQU8sa0JBQWtCLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUVsRTs7O0dBR0c7QUFDSCx3QkFBZ0IsbUJBQW1CLENBQUMsV0FBVyxFQUFFLE1BQU0sR0FBRyxlQUFlLENBUXhFO0FBRUQ7OztHQUdHO0FBQ0gscUJBQWEsd0JBQXdCO0lBRWpDLDZHQUE2RzthQUM3RixJQUFJLEVBQUUsZUFBZTtJQUNyQyx5R0FBeUc7YUFDekYsUUFBUSxFQUFFLEVBQUUsRUFBRTtJQUM5QiwyREFBMkQ7YUFDM0MsV0FBVyxFQUFFLE1BQU07SUFDbkMsNkdBQTZHO2FBQzdGLGdCQUFnQixFQUFFLEVBQUU7SUFDcEMseUVBQXlFO2FBQ3pELFFBQVEsRUFBRSxFQUFFO0lBVjlCO0lBQ0UsNkdBQTZHO0lBQzdGLElBQUksRUFBRSxlQUFlO0lBQ3JDLHlHQUF5RztJQUN6RixRQUFRLEVBQUUsRUFBRSxFQUFFO0lBQzlCLDJEQUEyRDtJQUMzQyxXQUFXLEVBQUUsTUFBTTtJQUNuQyw2R0FBNkc7SUFDN0YsZ0JBQWdCLEVBQUUsRUFBRTtJQUNwQyx5RUFBeUU7SUFDekQsUUFBUSxFQUFFLEVBQUUsRUFLN0I7SUFFRDs7O09BR0c7SUFDSCxNQUFNLENBQUMsWUFBWSxDQUFDLFFBQVEsRUFBRSxFQUFFLEVBQUUsRUFBRSxnQkFBZ0IsRUFBRSxFQUFFLEVBQUUsUUFBUSxFQUFFLEVBQUUsR0FBRyx3QkFBd0IsQ0FVaEc7SUFFRCx5Q0FBeUM7SUFDekMsUUFBUSw0QkFRUDtJQUVELDZDQUE2QztJQUM3QyxRQUFRLGtCQUVQO0lBRUQ7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksNEJBWTlDO0lBRUQ7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSw0QkFFNUI7SUFFRCw4REFBOEQ7SUFDOUQsTUFBTSw0QkFFTDtJQUVELE1BQU0sS0FBSyxNQUFNLHVJQUVoQjtDQUNGIn0=

package/dest/parity/inbox_parity_private_inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox_parity_private_inputs.d.ts","sourceRoot":"","sources":["../../src/parity/inbox_parity_private_inputs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAGnF,yGAAyG;AACzG,eAAO,MAAM,kBAAkB,0BAAwF,CAAC;AAExH,uCAAuC;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAElE;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe,CAQxE;AAED;;;GAGG;AACH,qBAAa,wBAAwB;IAEjC,6GAA6G;aAC7F,IAAI,EAAE,eAAe;IACrC,yGAAyG;aACzF,QAAQ,EAAE,EAAE,EAAE;IAC9B,2DAA2D;aAC3C,WAAW,EAAE,MAAM;IACnC,6GAA6G;aAC7F,gBAAgB,EAAE,EAAE;IACpC,yEAAyE;aACzD,QAAQ,EAAE,EAAE;IAV9B;IACE,6GAA6G;IAC7F,IAAI,EAAE,eAAe;IACrC,yGAAyG;IACzF,QAAQ,EAAE,EAAE,EAAE;IAC9B,2DAA2D;IAC3C,WAAW,EAAE,MAAM;IACnC,6GAA6G;IAC7F,gBAAgB,EAAE,EAAE;IACpC,yEAAyE;IACzD,QAAQ,EAAE,EAAE,EAK7B;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,GAAG,wBAAwB,CAUhG;IAED,yCAAyC;IACzC,QAAQ,4BAQP;IAED,6CAA6C;IAC7C,QAAQ,kBAEP;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,4BAY9C;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,4BAE5B;IAED,8DAA8D;IAC9D,MAAM,4BAEL;IAED,MAAM,KAAK,MAAM,uIAEhB;CACF"}

package/dest/parity/inbox_parity_private_inputs.js

@@ -0,0 +1,79 @@
+import { INBOX_PARITY_SIZE_LARGE, INBOX_PARITY_SIZE_MEDIUM, INBOX_PARITY_SIZE_SMALL } from '@aztec-labs/constants';
+import { padArrayEnd } from '@aztec-labs/foundation/collection';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+/** The InboxParity size ladder, ascending. One VK per size; the prover proves the smallest that fits. */ export const INBOX_PARITY_SIZES = [
+    INBOX_PARITY_SIZE_SMALL,
+    INBOX_PARITY_SIZE_MEDIUM,
+    INBOX_PARITY_SIZE_LARGE
+];
+/**
+ * Picks the smallest ladder size that can hold `numMessages` messages.
+ * @throws if `numMessages` exceeds the largest rung.
+ */ export function pickInboxParitySize(numMessages) {
+    const size = INBOX_PARITY_SIZES.find((s)=>numMessages <= s);
+    if (size === undefined) {
+        throw new Error(`Cannot fit ${numMessages} L1-to-L2 messages into any InboxParity size (max ${INBOX_PARITY_SIZE_LARGE})`);
+    }
+    return size;
+}
+/**
+ * Private inputs for one `InboxParity<S>` proof (S = `size`). The prover produces exactly one per checkpoint, sized
+ * by the checkpoint's message count via {@link pickInboxParitySize}.
+ */ export class InboxParityPrivateInputs {
+    size;
+    messages;
+    numMessages;
+    startRollingHash;
+    proverId;
+    constructor(/** Ladder size S: the length of `messages` and the circuit variant to prove ({@link INBOX_PARITY_SIZES}). */ size, /** The checkpoint's L1-to-L2 messages, padded with zeros to `size`; the first `numMessages` are real. */ messages, /** Number of real (non-padding) messages in `messages`. */ numMessages, /** Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end; genesis is zero). */ startRollingHash, /** Prover identity committed to by the circuit, for sybil protection. */ proverId){
+        this.size = size;
+        this.messages = messages;
+        this.numMessages = numMessages;
+        this.startRollingHash = startRollingHash;
+        this.proverId = proverId;
+        if (messages.length !== size) {
+            throw new Error(`InboxParity messages length (${messages.length}) must equal size (${size})`);
+        }
+    }
+    /**
+   * Builds the inputs from a checkpoint's real messages, sizing the circuit by the message count and padding the
+   * message array out to that size.
+   */ static fromMessages(messages, startRollingHash, proverId) {
+        const size = pickInboxParitySize(messages.length);
+        // Explicit `<Fr, number>` keeps the result `Fr[]`; padding to the union-literal `size` would infer a deep tuple.
+        return new InboxParityPrivateInputs(size, padArrayEnd(messages, Fr.ZERO, size), messages.length, startRollingHash, proverId);
+    }
+    /** Serializes the inputs to a buffer. */ toBuffer() {
+        return serializeToBuffer(new Fr(this.size), this.messages, new Fr(this.numMessages), this.startRollingHash, this.proverId);
+    }
+    /** Serializes the inputs to a hex string. */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const size = Fr.fromBuffer(reader).toNumber();
+        // Array.from keeps the type `Fr[]`; readArray with the union-literal `size` would infer a deep tuple.
+        const messages = Array.from({
+            length: size
+        }, ()=>Fr.fromBuffer(reader));
+        return new InboxParityPrivateInputs(size, messages, Fr.fromBuffer(reader).toNumber(), Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+    }
+    /**
+   * Deserializes the inputs from a hex string.
+   * @param str - The hex string to deserialize from.
+   */ static fromString(str) {
+        return InboxParityPrivateInputs.fromBuffer(hexToBuffer(str));
+    }
+    /** Returns a buffer representation for JSON serialization. */ toJSON() {
+        return this.toBuffer();
+    }
+    static get schema() {
+        return bufferSchemaFor(InboxParityPrivateInputs);
+    }
+}

package/dest/parity/index.d.ts

@@ -0,0 +1,3 @@
+export * from './inbox_parity_private_inputs.js';
+export * from './parity_public_inputs.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wYXJpdHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDJCQUEyQixDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parity/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC"}

package/dest/parity/index.js

@@ -0,0 +1,2 @@
+export * from './inbox_parity_private_inputs.js';
+export * from './parity_public_inputs.js';

package/dest/parity/parity_public_inputs.d.ts

@@ -0,0 +1,61 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader } from '@aztec-labs/foundation/serialize';
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js';
+export declare class ParityPublicInputs {
+    /** Inbox rolling hash before absorbing this checkpoint's messages. */
+    startRollingHash: Fr;
+    /** Inbox rolling hash after absorbing the checkpoint's real messages. */
+    endRollingHash: Fr;
+    /** Message-bundle sponge after absorbing the same real messages into the empty per-checkpoint sponge. */
+    endSponge: L1ToL2MessageSponge;
+    /** Prover identity committed to by the circuit, for sybil protection. */
+    proverId: Fr;
+    constructor(
+    /** Inbox rolling hash before absorbing this checkpoint's messages. */
+    startRollingHash: Fr, 
+    /** Inbox rolling hash after absorbing the checkpoint's real messages. */
+    endRollingHash: Fr, 
+    /** Message-bundle sponge after absorbing the same real messages into the empty per-checkpoint sponge. */
+    endSponge: L1ToL2MessageSponge, 
+    /** Prover identity committed to by the circuit, for sybil protection. */
+    proverId: Fr);
+    /**
+     * Serializes the inputs to a buffer.
+     * @returns The inputs serialized to a buffer.
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Serializes the inputs to a hex string.
+     * @returns The inputs serialized to a hex string.
+     */
+    toString(): `0x${string}`;
+    /** Returns a representation for JSON serialization. */
+    toJSON(): Buffer<ArrayBufferLike>;
+    /**
+     * Creates a new ParityPublicInputs instance from the given fields.
+     * @param fields - The fields to create the instance from.
+     * @returns The instance.
+     */
+    static from(fields: FieldsOf<ParityPublicInputs>): ParityPublicInputs;
+    /**
+     * Extracts the fields from the given instance.
+     * @param fields - The instance to get the fields from.
+     * @returns The instance fields.
+     */
+    static getFields(fields: FieldsOf<ParityPublicInputs>): readonly [Fr, Fr, L1ToL2MessageSponge, Fr];
+    /**
+     * Deserializes the inputs from a buffer.
+     * @param buffer - The buffer to deserialize from.
+     * @returns A new ParityPublicInputs instance.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): ParityPublicInputs;
+    /**
+     * Deserializes the inputs from a hex string.
+     * @param str - The hex string to deserialize from.
+     * @returns A new ParityPublicInputs instance.
+     */
+    static fromString(str: string): ParityPublicInputs;
+    static get schema(): import("zod").ZodType<ParityPublicInputs, string, import("zod/v4/core").$ZodTypeInternals<ParityPublicInputs, string>>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyaXR5X3B1YmxpY19pbnB1dHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wYXJpdHkvcGFyaXR5X3B1YmxpY19pbnB1dHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXpELE9BQU8sRUFBRSxZQUFZLEVBQXFCLE1BQU0sa0NBQWtDLENBQUM7QUFFbkYsT0FBTyxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFN0QsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFOUUscUJBQWEsa0JBQWtCO0lBRTNCLHNFQUFzRTtJQUMvRCxnQkFBZ0IsRUFBRSxFQUFFO0lBQzNCLHlFQUF5RTtJQUNsRSxjQUFjLEVBQUUsRUFBRTtJQUN6Qix5R0FBeUc7SUFDbEcsU0FBUyxFQUFFLG1CQUFtQjtJQUNyQyx5RUFBeUU7SUFDbEUsUUFBUSxFQUFFLEVBQUU7SUFSckI7SUFDRSxzRUFBc0U7SUFDL0QsZ0JBQWdCLEVBQUUsRUFBRTtJQUMzQix5RUFBeUU7SUFDbEUsY0FBYyxFQUFFLEVBQUU7SUFDekIseUdBQXlHO0lBQ2xHLFNBQVMsRUFBRSxtQkFBbUI7SUFDckMseUVBQXlFO0lBQ2xFLFFBQVEsRUFBRSxFQUFFLEVBQ2pCO0lBRUo7OztPQUdHO0lBQ0gsUUFBUSw0QkFFUDtJQUVEOzs7T0FHRztJQUNILFFBQVEsa0JBRVA7SUFFRCx1REFBdUQ7SUFDdkQsTUFBTSw0QkFFTDtJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxRQUFRLENBQUMsa0JBQWtCLENBQUMsR0FBRyxrQkFBa0IsQ0FFcEU7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGtCQUFrQixDQUFDLDhDQUVwRDtJQUVEOzs7O09BSUc7SUFDSCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxzQkFROUM7SUFFRDs7OztPQUlHO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxHQUFHLEVBQUUsTUFBTSxzQkFFNUI7SUFFRCxNQUFNLEtBQUssTUFBTSwySEFFaEI7Q0FDRiJ9

package/dest/parity/parity_public_inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parity_public_inputs.d.ts","sourceRoot":"","sources":["../../src/parity/parity_public_inputs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAqB,MAAM,kCAAkC,CAAC;AAEnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAE7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAE9E,qBAAa,kBAAkB;IAE3B,sEAAsE;IAC/D,gBAAgB,EAAE,EAAE;IAC3B,yEAAyE;IAClE,cAAc,EAAE,EAAE;IACzB,yGAAyG;IAClG,SAAS,EAAE,mBAAmB;IACrC,yEAAyE;IAClE,QAAQ,EAAE,EAAE;IARrB;IACE,sEAAsE;IAC/D,gBAAgB,EAAE,EAAE;IAC3B,yEAAyE;IAClE,cAAc,EAAE,EAAE;IACzB,yGAAyG;IAClG,SAAS,EAAE,mBAAmB;IACrC,yEAAyE;IAClE,QAAQ,EAAE,EAAE,EACjB;IAEJ;;;OAGG;IACH,QAAQ,4BAEP;IAED;;;OAGG;IACH,QAAQ,kBAEP;IAED,uDAAuD;IACvD,MAAM,4BAEL;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GAAG,kBAAkB,CAEpE;IAED;;;;OAIG;IACH,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,kBAAkB,CAAC,8CAEpD;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,sBAQ9C;IAED;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,sBAE5B;IAED,MAAM,KAAK,MAAM,2HAEhB;CACF"}

package/dest/parity/parity_public_inputs.js

@@ -0,0 +1,69 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js';
+export class ParityPublicInputs {
+    startRollingHash;
+    endRollingHash;
+    endSponge;
+    proverId;
+    constructor(/** Inbox rolling hash before absorbing this checkpoint's messages. */ startRollingHash, /** Inbox rolling hash after absorbing the checkpoint's real messages. */ endRollingHash, /** Message-bundle sponge after absorbing the same real messages into the empty per-checkpoint sponge. */ endSponge, /** Prover identity committed to by the circuit, for sybil protection. */ proverId){
+        this.startRollingHash = startRollingHash;
+        this.endRollingHash = endRollingHash;
+        this.endSponge = endSponge;
+        this.proverId = proverId;
+    }
+    /**
+   * Serializes the inputs to a buffer.
+   * @returns The inputs serialized to a buffer.
+   */ toBuffer() {
+        return serializeToBuffer(this.startRollingHash, this.endRollingHash, this.endSponge, this.proverId);
+    }
+    /**
+   * Serializes the inputs to a hex string.
+   * @returns The inputs serialized to a hex string.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /** Returns a representation for JSON serialization. */ toJSON() {
+        return this.toBuffer();
+    }
+    /**
+   * Creates a new ParityPublicInputs instance from the given fields.
+   * @param fields - The fields to create the instance from.
+   * @returns The instance.
+   */ static from(fields) {
+        return new ParityPublicInputs(...ParityPublicInputs.getFields(fields));
+    }
+    /**
+   * Extracts the fields from the given instance.
+   * @param fields - The instance to get the fields from.
+   * @returns The instance fields.
+   */ static getFields(fields) {
+        return [
+            fields.startRollingHash,
+            fields.endRollingHash,
+            fields.endSponge,
+            fields.proverId
+        ];
+    }
+    /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   * @returns A new ParityPublicInputs instance.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new ParityPublicInputs(reader.readObject(Fr), reader.readObject(Fr), reader.readObject(L1ToL2MessageSponge), Fr.fromBuffer(reader));
+    }
+    /**
+   * Deserializes the inputs from a hex string.
+   * @param str - The hex string to deserialize from.
+   * @returns A new ParityPublicInputs instance.
+   */ static fromString(str) {
+        return ParityPublicInputs.fromBuffer(hexToBuffer(str));
+    }
+    static get schema() {
+        return bufferSchemaFor(ParityPublicInputs);
+    }
+}

package/dest/proofs/chonk_proof.d.ts

@@ -0,0 +1,78 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, BufferSink } from '@aztec-labs/foundation/serialize';
+/**
+ * Serialization format detection for ChonkProof is value-based on the leading uint32:
+ *   - EMPTY:                 [0: uint32]                              → total = 4 bytes
+ *   - UNCOMPRESSED (legacy): [field_count=1632: uint32] [fields...]  → total ≈ 52KB (>= 40KB)
+ *   - COMPRESSED:            [byte_count: uint32] [compressed_bytes] → total ≈ 35KB (< 40KB)
+ *
+ * Detection from the first uint32: 0 means an empty proof (no fields); CHONK_PROOF_LENGTH
+ * (1632) means legacy format (field count); any other value is the compressed byte count.
+ * A real compressed proof always has a non-zero byte count, so 0 is an unambiguous sentinel
+ * for the empty case. The old uncompressed format is never smaller than 40KB; compressed
+ * proofs are always smaller than 40KB.
+ */
+export declare class ChonkProof {
+    fields: Fr[];
+    /**
+     * Optional compressed proof bytes from chonk compression (point compression + u256 encoding).
+     * When set, toBuffer() will serialize in compressed format (~1.7x smaller).
+     * When reading from compressed format, this is populated and fields are decompressed on demand.
+     */
+    compressedProof?: Buffer;
+    constructor(fields: Fr[], compressedProof?: Buffer);
+    attachPublicInputs(publicInputs: Fr[]): ChonkProofWithPublicInputs;
+    isEmpty(): boolean;
+    static empty(): ChonkProof;
+    static random(): ChonkProof;
+    static get schema(): import("zod").ZodType<ChonkProof, string, import("zod/v4/core").$ZodTypeInternals<ChonkProof, string>>;
+    toJSON(): Buffer<ArrayBufferLike>;
+    /**
+     * Deserialize a ChonkProof from a buffer.
+     * Supports both legacy (field elements) and compressed (chonk compression) formats.
+     *
+     * Value-based format detection on the leading uint32:
+     *   - First uint32 == 0: empty proof (no fields), total = 4 bytes
+     *   - First uint32 == CHONK_PROOF_LENGTH (1632): legacy format, read field elements
+     *     Total proof data ≈ 52KB (always >= 40KB)
+     *   - Otherwise: compressed format, first uint32 is byte count of compressed data
+     *     Total proof data ≈ 35KB (always < 40KB)
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): ChonkProof;
+    /**
+     * Create a ChonkProof from compressed bytes by decompressing via the BarretenbergSync API.
+     * The compressed format uses point compression and u256 encoding (from PR #20645).
+     *
+     * @param compressed - Compressed proof bytes from chonk compression
+     * @returns ChonkProof with both fields and compressed bytes populated
+     */
+    static fromCompressedBytes(compressed: Buffer): ChonkProof;
+    /**
+     * Serialize the proof to a buffer.
+     * If compressed bytes are available, uses the compressed format (~1.7x smaller).
+     * Otherwise falls back to legacy field element format.
+     */
+    toBuffer(): Buffer;
+    toBuffer(sink: BufferSink): void;
+}
+export declare class ChonkProofWithPublicInputs {
+    fieldsWithPublicInputs: Fr[];
+    /**
+     * Optional compressed proof bytes (covers the full proof WITH public inputs).
+     * Set by the prover when using chonk compression. Flows through to ChonkProof
+     * via removePublicInputs() so the Tx can serialize in compressed format.
+     */
+    compressedProof?: Buffer;
+    constructor(fieldsWithPublicInputs: Fr[]);
+    getPublicInputs(): Fr[];
+    removePublicInputs(): ChonkProof;
+    isEmpty(): boolean;
+    static empty(): ChonkProofWithPublicInputs;
+    static get schema(): import("zod").ZodType<ChonkProofWithPublicInputs, string, import("zod/v4/core").$ZodTypeInternals<ChonkProofWithPublicInputs, string>>;
+    toJSON(): Buffer<ArrayBufferLike>;
+    static fromBuffer(buffer: Buffer | BufferReader): ChonkProofWithPublicInputs;
+    toBuffer(): Buffer;
+    toBuffer(sink: BufferSink): void;
+    static fromBufferArray(fields: Uint8Array[]): ChonkProofWithPublicInputs;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hvbmtfcHJvb2YuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm9vZnMvY2hvbmtfcHJvb2YudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0EsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXpELE9BQU8sRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFNUU7Ozs7Ozs7Ozs7O0dBV0c7QUFHSCxxQkFBYSxVQUFVO0lBWVosTUFBTSxFQUFFLEVBQUUsRUFBRTtJQVhyQjs7OztPQUlHO0lBQ0ksZUFBZSxDQUFDLEVBQUUsTUFBTSxDQUFDO0lBRWhDLFlBSVMsTUFBTSxFQUFFLEVBQUUsRUFBRSxFQUNuQixlQUFlLENBQUMsRUFBRSxNQUFNLEVBT3pCO0lBRU0sa0JBQWtCLENBQUMsWUFBWSxFQUFFLEVBQUUsRUFBRSw4QkFFM0M7SUFFTSxPQUFPLFlBRWI7SUFFRCxNQUFNLENBQUMsS0FBSyxlQUVYO0lBRUQsTUFBTSxDQUFDLE1BQU0sZUFZWjtJQUVELE1BQU0sS0FBSyxNQUFNLDJHQUVoQjtJQUdELE1BQU0sNEJBRUw7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0gsTUFBTSxDQUFDLFVBQVUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksR0FBRyxVQUFVLENBcUIzRDtJQUVEOzs7Ozs7T0FNRztJQUNILE1BQU0sQ0FBQyxtQkFBbUIsQ0FBQyxVQUFVLEVBQUUsTUFBTSxHQUFHLFVBQVUsQ0FrQnpEO0lBRUQ7Ozs7T0FJRztJQUNJLFFBQVEsSUFBSSxNQUFNLENBQUM7SUFDbkIsUUFBUSxDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsSUFBSSxDQUFDO0NBa0J6QztBQUVELHFCQUFhLDBCQUEwQjtJQVc1QixzQkFBc0IsRUFBRSxFQUFFLEVBQUU7SUFWckM7Ozs7T0FJRztJQUNJLGVBQWUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUVoQyxZQUdTLHNCQUFzQixFQUFFLEVBQUUsRUFBRSxFQU1wQztJQUVNLGVBQWUsU0FNckI7SUFFTSxrQkFBa0IsZUFPeEI7SUFFTSxPQUFPLFlBRWI7SUFFRCxNQUFNLENBQUMsS0FBSywrQkFFWDtJQUVELE1BQU0sS0FBSyxNQUFNLDJJQUVoQjtJQUdELE1BQU0sNEJBRUw7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsWUFBWSxHQUFHLDBCQUEwQixDQUszRTtJQUVNLFFBQVEsSUFBSSxNQUFNLENBQUM7SUFDbkIsUUFBUSxDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsSUFBSSxDQUFDO0lBVXhDLE1BQU0sQ0FBQyxlQUFlLENBQUMsTUFBTSxFQUFFLFVBQVUsRUFBRSxHQUFHLDBCQUEwQixDQUd2RTtDQUNGIn0=

package/dest/proofs/chonk_proof.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chonk_proof.d.ts","sourceRoot":"","sources":["../../src/proofs/chonk_proof.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAE5E;;;;;;;;;;;GAWG;AAGH,qBAAa,UAAU;IAYZ,MAAM,EAAE,EAAE,EAAE;IAXrB;;;;OAIG;IACI,eAAe,CAAC,EAAE,MAAM,CAAC;IAEhC,YAIS,MAAM,EAAE,EAAE,EAAE,EACnB,eAAe,CAAC,EAAE,MAAM,EAOzB;IAEM,kBAAkB,CAAC,YAAY,EAAE,EAAE,EAAE,8BAE3C;IAEM,OAAO,YAEb;IAED,MAAM,CAAC,KAAK,eAEX;IAED,MAAM,CAAC,MAAM,eAYZ;IAED,MAAM,KAAK,MAAM,2GAEhB;IAGD,MAAM,4BAEL;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU,CAqB3D;IAED;;;;;;OAMG;IACH,MAAM,CAAC,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAkBzD;IAED;;;;OAIG;IACI,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CAkBzC;AAED,qBAAa,0BAA0B;IAW5B,sBAAsB,EAAE,EAAE,EAAE;IAVrC;;;;OAIG;IACI,eAAe,CAAC,EAAE,MAAM,CAAC;IAEhC,YAGS,sBAAsB,EAAE,EAAE,EAAE,EAMpC;IAEM,eAAe,SAMrB;IAEM,kBAAkB,eAOxB;IAEM,OAAO,YAEb;IAED,MAAM,CAAC,KAAK,+BAEX;IAED,MAAM,KAAK,MAAM,2IAEhB;IAGD,MAAM,4BAEL;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,0BAA0B,CAK3E;IAEM,QAAQ,IAAI,MAAM,CAAC;IACnB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IAUxC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,0BAA0B,CAGvE;CACF"}

package/dest/proofs/chonk_proof.js

@@ -0,0 +1,203 @@
+import { BarretenbergSync, flattenChonkProofFields } from '@aztec/bb.js';
+import { CHONK_PROOF_LENGTH } from '@aztec-labs/constants';
+import { times } from '@aztec-labs/foundation/collection';
+import { randomBytes } from '@aztec-labs/foundation/crypto/random';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec-labs/foundation/schemas';
+import { BufferReader, BufferSink } from '@aztec-labs/foundation/serialize';
+/**
+ * Serialization format detection for ChonkProof is value-based on the leading uint32:
+ *   - EMPTY:                 [0: uint32]                              → total = 4 bytes
+ *   - UNCOMPRESSED (legacy): [field_count=1632: uint32] [fields...]  → total ≈ 52KB (>= 40KB)
+ *   - COMPRESSED:            [byte_count: uint32] [compressed_bytes] → total ≈ 35KB (< 40KB)
+ *
+ * Detection from the first uint32: 0 means an empty proof (no fields); CHONK_PROOF_LENGTH
+ * (1632) means legacy format (field count); any other value is the compressed byte count.
+ * A real compressed proof always has a non-zero byte count, so 0 is an unambiguous sentinel
+ * for the empty case. The old uncompressed format is never smaller than 40KB; compressed
+ * proofs are always smaller than 40KB.
+ */ // CHONK: "Client Honk" - An UltraHonk variant with incremental folding and delayed non-native arithmetic.
+export class ChonkProof {
+    fields;
+    /**
+   * Optional compressed proof bytes from chonk compression (point compression + u256 encoding).
+   * When set, toBuffer() will serialize in compressed format (~1.7x smaller).
+   * When reading from compressed format, this is populated and fields are decompressed on demand.
+   */ compressedProof;
+    constructor(// The proof fields.
+    // For native verification, attach public inputs via `attachPublicInputs(publicInputs)`.
+    // Not using Tuple here due to the length being too high.
+    fields, compressedProof){
+        this.fields = fields;
+        // An empty proof (no fields) is a valid placeholder; see ChonkProof.empty().
+        if (fields.length !== 0 && fields.length !== CHONK_PROOF_LENGTH) {
+            throw new Error(`Invalid ChonkProof length: ${fields.length}`);
+        }
+        this.compressedProof = compressedProof;
+    }
+    attachPublicInputs(publicInputs) {
+        return new ChonkProofWithPublicInputs([
+            ...publicInputs,
+            ...this.fields
+        ]);
+    }
+    isEmpty() {
+        return this.fields.every((field)=>field.isZero());
+    }
+    static empty() {
+        return new ChonkProof([]);
+    }
+    static random() {
+        // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+        // NB2: generate one fewer random bytes to not have to deal with buffers representing numbers greater than the field modulus
+        // NB3: a chonk proof can be compressed. Simulate this by filling 1/4 of the proof with zero data
+        const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
+        const nonZeroFields = Math.floor(3 * CHONK_PROOF_LENGTH / 4);
+        const randomFields = randomBytes(nonZeroFields * Fr.SIZE_IN_BYTES);
+        const proof = [
+            ...times(nonZeroFields, (i)=>new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize))),
+            ...times(CHONK_PROOF_LENGTH - nonZeroFields, ()=>Fr.ZERO)
+        ];
+        return new ChonkProof(proof);
+    }
+    static get schema() {
+        return bufferSchemaFor(ChonkProof);
+    }
+    // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
+    toJSON() {
+        return this.toBuffer();
+    }
+    /**
+   * Deserialize a ChonkProof from a buffer.
+   * Supports both legacy (field elements) and compressed (chonk compression) formats.
+   *
+   * Value-based format detection on the leading uint32:
+   *   - First uint32 == 0: empty proof (no fields), total = 4 bytes
+   *   - First uint32 == CHONK_PROOF_LENGTH (1632): legacy format, read field elements
+   *     Total proof data ≈ 52KB (always >= 40KB)
+   *   - Otherwise: compressed format, first uint32 is byte count of compressed data
+   *     Total proof data ≈ 35KB (always < 40KB)
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const firstUint32 = reader.readNumber();
+        if (firstUint32 === 0) {
+            // Empty format: a zero length encodes an empty proof.
+            return ChonkProof.empty();
+        }
+        if (firstUint32 === CHONK_PROOF_LENGTH) {
+            // Legacy format: firstUint32 is the field count (1632)
+            // Widen to `number` to prevent TS from narrowing to literal 1632,
+            // which would cause Tuple<Fr, 1632> to exceed the recursion limit.
+            const fieldCount = firstUint32;
+            const proof = reader.readArray(fieldCount, Fr);
+            return new ChonkProof(proof);
+        }
+        // Compressed format: firstUint32 is the compressed byte count
+        const compressedBytes = reader.readBytes(firstUint32);
+        return ChonkProof.fromCompressedBytes(Buffer.from(compressedBytes));
+    }
+    /**
+   * Create a ChonkProof from compressed bytes by decompressing via the BarretenbergSync API.
+   * The compressed format uses point compression and u256 encoding (from PR #20645).
+   *
+   * @param compressed - Compressed proof bytes from chonk compression
+   * @returns ChonkProof with both fields and compressed bytes populated
+   */ static fromCompressedBytes(compressed) {
+        const api = BarretenbergSync.getSingleton();
+        const result = api.chonkDecompressProof({
+            compressedProof: new Uint8Array(compressed)
+        });
+        // Flatten the structured bb.js ChonkProof into flat Fr[] field elements
+        const flatFields = flattenChonkProofFields(result.proof);
+        const fields = flatFields.map((f)=>Fr.fromBuffer(Buffer.from(f)));
+        // The decompressed proof includes public inputs in hidingOinkProof.
+        // Since ChonkProof stores fields WITHOUT public inputs, strip them.
+        // The number of public inputs = total fields - CHONK_PROOF_LENGTH
+        if (fields.length > CHONK_PROOF_LENGTH) {
+            const numPubInputs = fields.length - CHONK_PROOF_LENGTH;
+            const proofFields = fields.slice(numPubInputs);
+            return new ChonkProof(proofFields, compressed);
+        }
+        return new ChonkProof(fields, compressed);
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        if (this.compressedProof) {
+            // Compressed format: [compressed_byte_count: uint32] [compressed_bytes]
+            sink.writeNumber(this.compressedProof.length);
+            sink.writeBytes(this.compressedProof);
+            return;
+        }
+        // Legacy / empty format: [field_count: uint32] [fields...]. fields.length === 0 emits the empty
+        // sentinel (a lone zero uint32) that ChonkProof.fromBuffer detects; fields.length === CHONK_PROOF_LENGTH
+        // is the full legacy form. The writeFields fast path skips per-element sinkable dispatch on the 1632
+        // leaves and is a no-op when the array is empty.
+        sink.writeNumber(this.fields.length);
+        sink.writeFields(this.fields);
+    }
+}
+export class ChonkProofWithPublicInputs {
+    fieldsWithPublicInputs;
+    /**
+   * Optional compressed proof bytes (covers the full proof WITH public inputs).
+   * Set by the prover when using chonk compression. Flows through to ChonkProof
+   * via removePublicInputs() so the Tx can serialize in compressed format.
+   */ compressedProof;
+    constructor(// The proof fields with public inputs.
+    // For recursive verification, use without public inputs via `removePublicInputs()`.
+    fieldsWithPublicInputs){
+        this.fieldsWithPublicInputs = fieldsWithPublicInputs;
+        // An empty proof (no fields) is a valid placeholder; see ChonkProofWithPublicInputs.empty().
+        if (fieldsWithPublicInputs.length !== 0 && fieldsWithPublicInputs.length < CHONK_PROOF_LENGTH) {
+            throw new Error(`Invalid ChonkProofWithPublicInputs length: ${fieldsWithPublicInputs.length}`);
+        }
+    }
+    getPublicInputs() {
+        if (this.fieldsWithPublicInputs.length === 0) {
+            return [];
+        }
+        const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+        return this.fieldsWithPublicInputs.slice(0, numPublicInputs);
+    }
+    removePublicInputs() {
+        if (this.fieldsWithPublicInputs.length === 0) {
+            return new ChonkProof([], this.compressedProof);
+        }
+        const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+        // Flow compressed proof bytes through so the ChonkProof can serialize efficiently
+        return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs), this.compressedProof);
+    }
+    isEmpty() {
+        return this.fieldsWithPublicInputs.every((field)=>field.isZero());
+    }
+    static empty() {
+        return ChonkProof.empty().attachPublicInputs([]);
+    }
+    static get schema() {
+        return bufferSchemaFor(ChonkProofWithPublicInputs);
+    }
+    // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
+    toJSON() {
+        return this.toBuffer();
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const proofLength = reader.readNumber();
+        const proof = reader.readArray(proofLength, Fr);
+        return new ChonkProofWithPublicInputs(proof);
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        sink.writeNumber(this.fieldsWithPublicInputs.length);
+        sink.writeFields(this.fieldsWithPublicInputs);
+    }
+    // Called when constructing from bb proving results.
+    static fromBufferArray(fields) {
+        const proof = fields.map((field)=>Fr.fromBuffer(Buffer.from(field)));
+        return new ChonkProofWithPublicInputs(proof);
+    }
+}

package/dest/proofs/index.d.ts

@@ -0,0 +1,6 @@
+export * from './recursive_proof.js';
+export * from './chonk_proof.js';
+export * from './proof.js';
+export * from './proof_data.js';
+export * from './proving_request_type.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wcm9vZnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYywyQkFBMkIsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/proofs/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC"}

package/dest/proofs/index.js

@@ -0,0 +1,5 @@
+export * from './recursive_proof.js';
+export * from './chonk_proof.js';
+export * from './proof.js';
+export * from './proof_data.js';
+export * from './proving_request_type.js';