@aztec/stdlib 0.0.0-test.0

package/dest/proofs/proof.js

@@ -0,0 +1,91 @@
+import { AGGREGATION_OBJECT_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+const EMPTY_PROOF_SIZE = 42;
+/**
+ * The Proof class is a wrapper around the circuits proof.
+ * Underlying it is a buffer of proof data in a form a barretenberg prover understands.
+ * It provides methods to easily create, serialize, and deserialize the proof data for efficient
+ * communication and storage.
+ */ export class Proof {
+    buffer;
+    numPublicInputs;
+    // Make sure this type is not confused with other buffer wrappers
+    __proofBrand;
+    // Honk proofs start with a 4 byte length prefix
+    // the proof metadata starts immediately after
+    metadataOffset;
+    // the metadata is 3 Frs long
+    // the public inputs are after it
+    publicInputsOffset;
+    constructor(/**
+     * Holds the serialized proof data in a binary buffer format.
+     */ buffer, numPublicInputs){
+        this.buffer = buffer;
+        this.numPublicInputs = numPublicInputs;
+        this.metadataOffset = 4;
+        this.publicInputsOffset = 100;
+    }
+    /**
+   * Create a Proof from a Buffer or BufferReader.
+   * Expects a length-encoding.
+   *
+   * @param buffer - A Buffer or BufferReader containing the length-encoded proof data.
+   * @returns A Proof instance containing the decoded proof data.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const size = reader.readNumber();
+        const buf = reader.readBytes(size);
+        const numPublicInputs = reader.readNumber();
+        return new Proof(buf, numPublicInputs);
+    }
+    /**
+   * Convert the Proof instance to a custom Buffer format.
+   * This function serializes the Proof's buffer length and data sequentially into a new Buffer.
+   *
+   * @returns A Buffer containing the serialized proof data in custom format.
+   */ toBuffer() {
+        return serializeToBuffer(this.buffer.length, this.buffer, this.numPublicInputs);
+    }
+    /**
+   * Serialize the Proof instance to a hex string.
+   * @returns The hex string representation of the proof data.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    withoutPublicInputs() {
+        return Buffer.concat([
+            this.buffer.subarray(this.metadataOffset, this.publicInputsOffset),
+            this.buffer.subarray(this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs)
+        ]);
+    }
+    extractPublicInputs() {
+        const reader = BufferReader.asReader(this.buffer.subarray(this.publicInputsOffset, this.publicInputsOffset + Fr.SIZE_IN_BYTES * this.numPublicInputs));
+        return reader.readArray(this.numPublicInputs, Fr);
+    }
+    extractAggregationObject() {
+        const publicInputs = this.extractPublicInputs();
+        return publicInputs.slice(-1 * AGGREGATION_OBJECT_LENGTH);
+    }
+    /**
+   * Deserialize a Proof instance from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns - A new Proof instance.
+   */ static fromString(str) {
+        return Proof.fromBuffer(hexToBuffer(str));
+    }
+    /** Returns whether this proof is actually empty. */ isEmpty() {
+        return this.buffer.length === EMPTY_PROOF_SIZE && this.buffer.every((byte)=>byte === 0) && this.numPublicInputs === 0;
+    }
+    /** Returns an empty proof. */ static empty() {
+        return makeEmptyProof();
+    }
+}
+/**
+ * Makes an empty proof.
+ * Note: Used for local devnet milestone where we are not proving anything yet.
+ * @returns The empty "proof".
+ */ export function makeEmptyProof() {
+    return new Proof(Buffer.alloc(EMPTY_PROOF_SIZE, 0), 0);
+}

package/dest/proofs/proving_request_type.d.ts

@@ -0,0 +1,16 @@
+export declare enum ProvingRequestType {
+    PUBLIC_VM = 0,
+    PRIVATE_BASE_ROLLUP = 1,
+    PUBLIC_BASE_ROLLUP = 2,
+    MERGE_ROLLUP = 3,
+    EMPTY_BLOCK_ROOT_ROLLUP = 4,
+    BLOCK_ROOT_ROLLUP = 5,
+    SINGLE_TX_BLOCK_ROOT_ROLLUP = 6,
+    BLOCK_MERGE_ROLLUP = 7,
+    ROOT_ROLLUP = 8,
+    BASE_PARITY = 9,
+    ROOT_PARITY = 10,
+    /** Recursive Client IVC verification to connect private to public or rollup */
+    TUBE_PROOF = 11
+}
+//# sourceMappingURL=proving_request_type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proving_request_type.d.ts","sourceRoot":"","sources":["../../src/proofs/proving_request_type.ts"],"names":[],"mappings":"AAAA,oBAAY,kBAAkB;IAC5B,SAAS,IAAA;IAET,mBAAmB,IAAA;IACnB,kBAAkB,IAAA;IAClB,YAAY,IAAA;IACZ,uBAAuB,IAAA;IACvB,iBAAiB,IAAA;IACjB,2BAA2B,IAAA;IAC3B,kBAAkB,IAAA;IAClB,WAAW,IAAA;IAEX,WAAW,IAAA;IACX,WAAW,KAAA;IACX,+EAA+E;IAC/E,UAAU,KAAA;CACX"}

package/dest/proofs/proving_request_type.js

@@ -0,0 +1,15 @@
+export var ProvingRequestType = /*#__PURE__*/ function(ProvingRequestType) {
+    ProvingRequestType[ProvingRequestType["PUBLIC_VM"] = 0] = "PUBLIC_VM";
+    ProvingRequestType[ProvingRequestType["PRIVATE_BASE_ROLLUP"] = 1] = "PRIVATE_BASE_ROLLUP";
+    ProvingRequestType[ProvingRequestType["PUBLIC_BASE_ROLLUP"] = 2] = "PUBLIC_BASE_ROLLUP";
+    ProvingRequestType[ProvingRequestType["MERGE_ROLLUP"] = 3] = "MERGE_ROLLUP";
+    ProvingRequestType[ProvingRequestType["EMPTY_BLOCK_ROOT_ROLLUP"] = 4] = "EMPTY_BLOCK_ROOT_ROLLUP";
+    ProvingRequestType[ProvingRequestType["BLOCK_ROOT_ROLLUP"] = 5] = "BLOCK_ROOT_ROLLUP";
+    ProvingRequestType[ProvingRequestType["SINGLE_TX_BLOCK_ROOT_ROLLUP"] = 6] = "SINGLE_TX_BLOCK_ROOT_ROLLUP";
+    ProvingRequestType[ProvingRequestType["BLOCK_MERGE_ROLLUP"] = 7] = "BLOCK_MERGE_ROLLUP";
+    ProvingRequestType[ProvingRequestType["ROOT_ROLLUP"] = 8] = "ROOT_ROLLUP";
+    ProvingRequestType[ProvingRequestType["BASE_PARITY"] = 9] = "BASE_PARITY";
+    ProvingRequestType[ProvingRequestType["ROOT_PARITY"] = 10] = "ROOT_PARITY";
+    /** Recursive Client IVC verification to connect private to public or rollup */ ProvingRequestType[ProvingRequestType["TUBE_PROOF"] = 11] = "TUBE_PROOF";
+    return ProvingRequestType;
+}({});

package/dest/proofs/recursive_proof.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { Proof } from './proof.js';
+/**
+ * The Recursive proof class is a wrapper around the circuit's proof.
+ * We store the proof in 2 forms for convenience. The first is in the 'fields' format.
+ * This is a list of fields, for which there are distinct lengths based on the level of recursion.
+ * This 'fields' version does not contain the circuits public inputs
+ * We also store the raw binary proof which van be directly verified.
+ *
+ * The 'fieldsValid' member is set to false in the case where this object is constructed solely from the 'binary' proof
+ * This is usually when the proof has been received from clients and signals to provers that the 'fields' version needs to be generated
+ */
+export declare class RecursiveProof<N extends number> {
+    /**
+     * Holds the serialized proof data in an array of fields, this is without the public inputs
+     */
+    proof: Fr[];
+    /**
+     * Holds the serialized proof data in a binary buffer, this contains the public inputs
+     */
+    binaryProof: Proof;
+    /**
+     * This flag determines if the 'proof' member is valid, or if we need to generate it from the 'binaryProof' first
+     */
+    fieldsValid: boolean;
+    proofLength: N;
+    constructor(
+    /**
+     * Holds the serialized proof data in an array of fields, this is without the public inputs
+     */
+    proof: Fr[], 
+    /**
+     * Holds the serialized proof data in a binary buffer, this contains the public inputs
+     */
+    binaryProof: Proof, 
+    /**
+     * This flag determines if the 'proof' member is valid, or if we need to generate it from the 'binaryProof' first
+     */
+    fieldsValid: boolean, proofLength: N);
+    /**
+     * Create a Proof from a Buffer or BufferReader.
+     * Expects a length-encoding.
+     *
+     * @param buffer - A Buffer or BufferReader containing the length-encoded proof data.
+     * @returns A Proof instance containing the decoded proof data.
+     */
+    static fromBuffer<N extends number>(buffer: Buffer | BufferReader, expectedSize?: N): RecursiveProof<N>;
+    /**
+     * Convert the Proof instance to a custom Buffer format.
+     * This function serializes the Proof's buffer length and data sequentially into a new Buffer.
+     *
+     * @returns A Buffer containing the serialized proof data in custom format.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Serialize the Proof instance to a hex string.
+     * @returns The hex string representation of the proof data.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Deserialize a Proof instance from a hex string.
+     * @param str - A hex string to deserialize from.
+     * @returns - A new Proof instance.
+     */
+    static fromString<N extends number>(str: string, expectedSize?: N): RecursiveProof<N>;
+    /** Returns a buffer representation for JSON serialization. */
+    toJSON(): Buffer;
+    /** Creates an instance from a hex string with expected size. */
+    static schemaFor<N extends number>(expectedSize?: N): import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, Buffer, string>, import("zod").ZodEffects<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"Buffer">;
+        data: import("zod").ZodArray<import("zod").ZodNumber, "many">;
+    }, "strip", import("zod").ZodTypeAny, {
+        type: "Buffer";
+        data: number[];
+    }, {
+        type: "Buffer";
+        data: number[];
+    }>, Buffer, {
+        type: "Buffer";
+        data: number[];
+    }>]>, RecursiveProof<N>, string | {
+        type: "Buffer";
+        data: number[];
+    }>;
+}
+/**
+ * Makes an empty proof.
+ * Note: Used for local devnet milestone where we are not proving anything yet.
+ * @returns The empty "proof".
+ */
+export declare function makeEmptyRecursiveProof<N extends number>(size: N): RecursiveProof<N>;
+export declare function makeRecursiveProof<PROOF_LENGTH extends number>(size: PROOF_LENGTH, seed?: number): RecursiveProof<PROOF_LENGTH>;
+/**
+ * Makes an instance of the recursive proof from a binary only proof
+ * @returns The proof object
+ */
+export declare function makeRecursiveProofFromBinary<PROOF_LENGTH extends number>(proof: Proof, size: PROOF_LENGTH): RecursiveProof<PROOF_LENGTH>;
+//# sourceMappingURL=recursive_proof.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recursive_proof.d.ts","sourceRoot":"","sources":["../../src/proofs/recursive_proof.ts"],"names":[],"mappings":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,EAAE,KAAK,EAAkB,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;GASG;AACH,qBAAa,cAAc,CAAC,CAAC,SAAS,MAAM;IAExC;;OAEG;IACI,KAAK,EAAE,EAAE,EAAE;IAElB;;OAEG;IACI,WAAW,EAAE,KAAK;IACzB;;OAEG;IACI,WAAW,EAAE,OAAO;IACpB,WAAW,EAAE,CAAC;;IAbrB;;OAEG;IACI,KAAK,EAAE,EAAE,EAAE;IAElB;;OAEG;IACI,WAAW,EAAE,KAAK;IACzB;;OAEG;IACI,WAAW,EAAE,OAAO,EACpB,WAAW,EAAE,CAAC;IAOvB;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;IAcvG;;;;;OAKG;IACI,QAAQ;IAIf;;;OAGG;IACI,QAAQ;IAIf;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;IAIrF,8DAA8D;IAC9D,MAAM;IAIN,gEAAgE;IAChE,MAAM,CAAC,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,YAAY,CAAC,EAAE,CAAC;;;;;;;;;;;;;;;;CAGpD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,qBAEhE;AAED,wBAAgB,kBAAkB,CAAC,YAAY,SAAS,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,SAAI,gCAO3F;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,YAAY,SAAS,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,YAAY,gCAEzG"}

package/dest/proofs/recursive_proof.js

@@ -0,0 +1,93 @@
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { Proof, makeEmptyProof } from './proof.js';
+/**
+ * The Recursive proof class is a wrapper around the circuit's proof.
+ * We store the proof in 2 forms for convenience. The first is in the 'fields' format.
+ * This is a list of fields, for which there are distinct lengths based on the level of recursion.
+ * This 'fields' version does not contain the circuits public inputs
+ * We also store the raw binary proof which van be directly verified.
+ *
+ * The 'fieldsValid' member is set to false in the case where this object is constructed solely from the 'binary' proof
+ * This is usually when the proof has been received from clients and signals to provers that the 'fields' version needs to be generated
+ */ export class RecursiveProof {
+    proof;
+    binaryProof;
+    fieldsValid;
+    proofLength;
+    constructor(/**
+     * Holds the serialized proof data in an array of fields, this is without the public inputs
+     */ proof, /**
+     * Holds the serialized proof data in a binary buffer, this contains the public inputs
+     */ binaryProof, /**
+     * This flag determines if the 'proof' member is valid, or if we need to generate it from the 'binaryProof' first
+     */ fieldsValid, proofLength){
+        this.proof = proof;
+        this.binaryProof = binaryProof;
+        this.fieldsValid = fieldsValid;
+        this.proofLength = proofLength;
+        if (proof.length !== proofLength) {
+            throw new Error(`Proof length ${proof.length} does not match expected length ${proofLength}.`);
+        }
+    }
+    /**
+   * Create a Proof from a Buffer or BufferReader.
+   * Expects a length-encoding.
+   *
+   * @param buffer - A Buffer or BufferReader containing the length-encoded proof data.
+   * @returns A Proof instance containing the decoded proof data.
+   */ static fromBuffer(buffer, expectedSize) {
+        const reader = BufferReader.asReader(buffer);
+        const size = reader.readNumber();
+        if (typeof expectedSize === 'number' && expectedSize !== size) {
+            throw new Error(`Expected proof length ${expectedSize}, got ${size}`);
+        }
+        return new RecursiveProof(reader.readArray(size, Fr), Proof.fromBuffer(reader), reader.readBoolean(), size);
+    }
+    /**
+   * Convert the Proof instance to a custom Buffer format.
+   * This function serializes the Proof's buffer length and data sequentially into a new Buffer.
+   *
+   * @returns A Buffer containing the serialized proof data in custom format.
+   */ toBuffer() {
+        return serializeToBuffer(this.proof.length, this.proof, this.binaryProof, this.fieldsValid);
+    }
+    /**
+   * Serialize the Proof instance to a hex string.
+   * @returns The hex string representation of the proof data.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Deserialize a Proof instance from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns - A new Proof instance.
+   */ static fromString(str, expectedSize) {
+        return RecursiveProof.fromBuffer(hexToBuffer(str), expectedSize);
+    }
+    /** Returns a buffer representation for JSON serialization. */ toJSON() {
+        return this.toBuffer();
+    }
+    /** Creates an instance from a hex string with expected size. */ static schemaFor(expectedSize) {
+        return schemas.Buffer.transform((b)=>RecursiveProof.fromBuffer(b, expectedSize));
+    }
+}
+/**
+ * Makes an empty proof.
+ * Note: Used for local devnet milestone where we are not proving anything yet.
+ * @returns The empty "proof".
+ */ export function makeEmptyRecursiveProof(size) {
+    return new RecursiveProof(makeTuple(size, Fr.zero), makeEmptyProof(), true, size);
+}
+export function makeRecursiveProof(size, seed = 1) {
+    return new RecursiveProof(makeTuple(size, (i)=>new Fr(i), seed), makeEmptyProof(), true, size);
+}
+/**
+ * Makes an instance of the recursive proof from a binary only proof
+ * @returns The proof object
+ */ export function makeRecursiveProofFromBinary(proof, size) {
+    return new RecursiveProof(makeTuple(size, Fr.zero), proof, false, size);
+}

package/dest/rollup/avm_proof_data.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { AVM_PROOF_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VkWitnessData } from '../vks/vk_witness_data.js';
+export declare class AvmProofData {
+    publicInputs: AvmCircuitPublicInputs;
+    proof: RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>;
+    vkData: VkWitnessData;
+    constructor(publicInputs: AvmCircuitPublicInputs, proof: RecursiveProof<typeof AVM_PROOF_LENGTH_IN_FIELDS>, vkData: VkWitnessData);
+    static fromBuffer(buffer: Buffer | BufferReader): AvmProofData;
+    toBuffer(): Buffer;
+    static empty(): AvmProofData;
+}
+//# sourceMappingURL=avm_proof_data.d.ts.map

package/dest/rollup/avm_proof_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_proof_data.d.ts","sourceRoot":"","sources":["../../src/rollup/avm_proof_data.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,cAAc,EAA2B,MAAM,8BAA8B,CAAC;AACvF,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D,qBAAa,YAAY;IAEd,YAAY,EAAE,sBAAsB;IACpC,KAAK,EAAE,cAAc,CAAC,OAAO,0BAA0B,CAAC;IACxD,MAAM,EAAE,aAAa;gBAFrB,YAAY,EAAE,sBAAsB,EACpC,KAAK,EAAE,cAAc,CAAC,OAAO,0BAA0B,CAAC,EACxD,MAAM,EAAE,aAAa;IAG9B,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAS/C,QAAQ;IAIR,MAAM,CAAC,KAAK;CAOb"}

package/dest/rollup/avm_proof_data.js

@@ -0,0 +1,25 @@
+import { AVM_PROOF_LENGTH_IN_FIELDS } from '@aztec/constants';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
+import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
+import { VkWitnessData } from '../vks/vk_witness_data.js';
+export class AvmProofData {
+    publicInputs;
+    proof;
+    vkData;
+    constructor(publicInputs, proof, vkData){
+        this.publicInputs = publicInputs;
+        this.proof = proof;
+        this.vkData = vkData;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new AvmProofData(reader.readObject(AvmCircuitPublicInputs), RecursiveProof.fromBuffer(reader), reader.readObject(VkWitnessData));
+    }
+    toBuffer() {
+        return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+    }
+    static empty() {
+        return new AvmProofData(AvmCircuitPublicInputs.empty(), makeEmptyRecursiveProof(AVM_PROOF_LENGTH_IN_FIELDS), VkWitnessData.empty());
+    }
+}

package/dest/rollup/base_or_merge_rollup_public_inputs.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { SpongeBlob } from '@aztec/blob-lib';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { RollupTypes } from '../types/shared.js';
+import { ConstantRollupData } from './constant_rollup_data.js';
+/**
+ * Output of the base and merge rollup circuits.
+ */
+export declare class BaseOrMergeRollupPublicInputs {
+    /**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */
+    rollupType: RollupTypes;
+    /**
+     * Number of txs in this rollup.
+     */
+    numTxs: number;
+    /**
+     * Data which is forwarded through the rollup circuits unchanged.
+     */
+    constants: ConstantRollupData;
+    /**
+     * Partial state reference at the start of the rollup circuit.
+     */
+    start: PartialStateReference;
+    /**
+     * Partial state reference at the end of the rollup circuit.
+     */
+    end: PartialStateReference;
+    /**
+     * Sponge state to absorb blob inputs at the start of the rollup circuit.
+     */
+    startSpongeBlob: SpongeBlob;
+    /**
+     * Sponge state to absorb blob inputs at the end of the rollup circuit.
+     */
+    endSpongeBlob: SpongeBlob;
+    /**
+     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
+     * Note: Truncated to 31 bytes to fit in Fr.
+     */
+    outHash: Fr;
+    /**
+     * The summed `transaction_fee` of the constituent transactions.
+     */
+    accumulatedFees: Fr;
+    /**
+     * The summed `mana_used` of the constituent transactions.
+     */
+    accumulatedManaUsed: Fr;
+    constructor(
+    /**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */
+    rollupType: RollupTypes, 
+    /**
+     * Number of txs in this rollup.
+     */
+    numTxs: number, 
+    /**
+     * Data which is forwarded through the rollup circuits unchanged.
+     */
+    constants: ConstantRollupData, 
+    /**
+     * Partial state reference at the start of the rollup circuit.
+     */
+    start: PartialStateReference, 
+    /**
+     * Partial state reference at the end of the rollup circuit.
+     */
+    end: PartialStateReference, 
+    /**
+     * Sponge state to absorb blob inputs at the start of the rollup circuit.
+     */
+    startSpongeBlob: SpongeBlob, 
+    /**
+     * Sponge state to absorb blob inputs at the end of the rollup circuit.
+     */
+    endSpongeBlob: SpongeBlob, 
+    /**
+     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
+     * Note: Truncated to 31 bytes to fit in Fr.
+     */
+    outHash: Fr, 
+    /**
+     * The summed `transaction_fee` of the constituent transactions.
+     */
+    accumulatedFees: Fr, 
+    /**
+     * The summed `mana_used` of the constituent transactions.
+     */
+    accumulatedManaUsed: Fr);
+    /** Returns an empty instance. */
+    static empty(): BaseOrMergeRollupPublicInputs;
+    /**
+     * Deserializes from a buffer or reader.
+     * Note: Corresponds to a write in cpp.
+     * @param buffer - Buffer or reader to read from.
+     * @returns The deserialized public inputs.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): BaseOrMergeRollupPublicInputs;
+    /**
+     * Serialize this as a buffer.
+     * @returns The buffer.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Serialize this as a hex string.
+     * @returns - The hex string.
+     */
+    toString(): `0x${string}`;
+    /**
+     * Deserializes from a hex string.
+     * @param str - A hex string to deserialize from.
+     * @returns A new BaseOrMergeRollupPublicInputs instance.
+     */
+    static fromString(str: string): BaseOrMergeRollupPublicInputs;
+    /** Returns a buffer representation for JSON serialization. */
+    toJSON(): Buffer;
+    /** Creates an instance from a hex string. */
+    static get schema(): import("zod").ZodType<BaseOrMergeRollupPublicInputs, any, string>;
+}
+//# sourceMappingURL=base_or_merge_rollup_public_inputs.d.ts.map

package/dest/rollup/base_or_merge_rollup_public_inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_or_merge_rollup_public_inputs.d.ts","sourceRoot":"","sources":["../../src/rollup/base_or_merge_rollup_public_inputs.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAE/D;;GAEG;AACH,qBAAa,6BAA6B;IAEtC;;OAEG;IACI,UAAU,EAAE,WAAW;IAC9B;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;OAEG;IACI,SAAS,EAAE,kBAAkB;IACpC;;OAEG;IACI,KAAK,EAAE,qBAAqB;IACnC;;OAEG;IACI,GAAG,EAAE,qBAAqB;IACjC;;OAEG;IACI,eAAe,EAAE,UAAU;IAClC;;OAEG;IACI,aAAa,EAAE,UAAU;IAChC;;;OAGG;IACI,OAAO,EAAE,EAAE;IAClB;;OAEG;IACI,eAAe,EAAE,EAAE;IAC1B;;OAEG;IACI,mBAAmB,EAAE,EAAE;;IAxC9B;;OAEG;IACI,UAAU,EAAE,WAAW;IAC9B;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;OAEG;IACI,SAAS,EAAE,kBAAkB;IACpC;;OAEG;IACI,KAAK,EAAE,qBAAqB;IACnC;;OAEG;IACI,GAAG,EAAE,qBAAqB;IACjC;;OAEG;IACI,eAAe,EAAE,UAAU;IAClC;;OAEG;IACI,aAAa,EAAE,UAAU;IAChC;;;OAGG;IACI,OAAO,EAAE,EAAE;IAClB;;OAEG;IACI,eAAe,EAAE,EAAE;IAC1B;;OAEG;IACI,mBAAmB,EAAE,EAAE;IAGhC,iCAAiC;IACjC,MAAM,CAAC,KAAK;IAeZ;;;;;OAKG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,6BAA6B;IAgB/E;;;OAGG;IACH,QAAQ;IAmBR;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM;IAI7B,8DAA8D;IAC9D,MAAM;IAIN,6CAA6C;IAC7C,MAAM,KAAK,MAAM,sEAEhB;CACF"}

package/dest/rollup/base_or_merge_rollup_public_inputs.js

@@ -0,0 +1,92 @@
+import { SpongeBlob } from '@aztec/blob-lib';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import { PartialStateReference } from '../tx/partial_state_reference.js';
+import { RollupTypes } from '../types/shared.js';
+import { ConstantRollupData } from './constant_rollup_data.js';
+/**
+ * Output of the base and merge rollup circuits.
+ */ export class BaseOrMergeRollupPublicInputs {
+    rollupType;
+    numTxs;
+    constants;
+    start;
+    end;
+    startSpongeBlob;
+    endSpongeBlob;
+    outHash;
+    accumulatedFees;
+    accumulatedManaUsed;
+    constructor(/**
+     * Specifies from which type of rollup circuit these inputs are from.
+     */ rollupType, /**
+     * Number of txs in this rollup.
+     */ numTxs, /**
+     * Data which is forwarded through the rollup circuits unchanged.
+     */ constants, /**
+     * Partial state reference at the start of the rollup circuit.
+     */ start, /**
+     * Partial state reference at the end of the rollup circuit.
+     */ end, /**
+     * Sponge state to absorb blob inputs at the start of the rollup circuit.
+     */ startSpongeBlob, /**
+     * Sponge state to absorb blob inputs at the end of the rollup circuit.
+     */ endSpongeBlob, /**
+     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
+     * Note: Truncated to 31 bytes to fit in Fr.
+     */ outHash, /**
+     * The summed `transaction_fee` of the constituent transactions.
+     */ accumulatedFees, /**
+     * The summed `mana_used` of the constituent transactions.
+     */ accumulatedManaUsed){
+        this.rollupType = rollupType;
+        this.numTxs = numTxs;
+        this.constants = constants;
+        this.start = start;
+        this.end = end;
+        this.startSpongeBlob = startSpongeBlob;
+        this.endSpongeBlob = endSpongeBlob;
+        this.outHash = outHash;
+        this.accumulatedFees = accumulatedFees;
+        this.accumulatedManaUsed = accumulatedManaUsed;
+    }
+    /** Returns an empty instance. */ static empty() {
+        return new BaseOrMergeRollupPublicInputs(RollupTypes.Base, 0, ConstantRollupData.empty(), PartialStateReference.empty(), PartialStateReference.empty(), SpongeBlob.empty(), SpongeBlob.empty(), Fr.zero(), Fr.zero(), Fr.zero());
+    }
+    /**
+   * Deserializes from a buffer or reader.
+   * Note: Corresponds to a write in cpp.
+   * @param buffer - Buffer or reader to read from.
+   * @returns The deserialized public inputs.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new BaseOrMergeRollupPublicInputs(reader.readNumber(), reader.readNumber(), reader.readObject(ConstantRollupData), reader.readObject(PartialStateReference), reader.readObject(PartialStateReference), reader.readObject(SpongeBlob), reader.readObject(SpongeBlob), Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+    }
+    /**
+   * Serialize this as a buffer.
+   * @returns The buffer.
+   */ toBuffer() {
+        return serializeToBuffer(this.rollupType, this.numTxs, this.constants, this.start, this.end, this.startSpongeBlob, this.endSpongeBlob, this.outHash, this.accumulatedFees, this.accumulatedManaUsed);
+    }
+    /**
+   * Serialize this as a hex string.
+   * @returns - The hex string.
+   */ toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    /**
+   * Deserializes from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new BaseOrMergeRollupPublicInputs instance.
+   */ static fromString(str) {
+        return BaseOrMergeRollupPublicInputs.fromBuffer(hexToBuffer(str));
+    }
+    /** Returns a buffer representation for JSON serialization. */ toJSON() {
+        return this.toBuffer();
+    }
+    /** Creates an instance from a hex string. */ static get schema() {
+        return bufferSchemaFor(BaseOrMergeRollupPublicInputs);
+    }
+}