@aztec-labs/stdlib 6.0.0-nightly.20260829

package/src/proofs/chonk_proof.ts

@@ -0,0 +1,243 @@
+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 {
+  /**
+   * 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.
+   */
+  public compressedProof?: Buffer;
+
+  constructor(
+    // The proof fields.
+    // For native verification, attach public inputs via `attachPublicInputs(publicInputs)`.
+    // Not using Tuple here due to the length being too high.
+    public fields: Fr[],
+    compressedProof?: Buffer,
+  ) {
+    // 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;
+  }
+
+  public attachPublicInputs(publicInputs: Fr[]) {
+    return new ChonkProofWithPublicInputs([...publicInputs, ...this.fields]);
+  }
+
+  public 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: Buffer | BufferReader): ChonkProof {
+    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: number = 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: Buffer): ChonkProof {
+    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);
+  }
+
+  /**
+   * 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.
+   */
+  public toBuffer(): Buffer;
+  public toBuffer(sink: BufferSink): void;
+  public toBuffer(sink?: BufferSink): Buffer | void {
+    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 {
+  /**
+   * 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.
+   */
+  public compressedProof?: Buffer;
+
+  constructor(
+    // The proof fields with public inputs.
+    // For recursive verification, use without public inputs via `removePublicInputs()`.
+    public fieldsWithPublicInputs: Fr[],
+  ) {
+    // 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}`);
+    }
+  }
+
+  public getPublicInputs() {
+    if (this.fieldsWithPublicInputs.length === 0) {
+      return [];
+    }
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+    return this.fieldsWithPublicInputs.slice(0, numPublicInputs);
+  }
+
+  public 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);
+  }
+
+  public 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: Buffer | BufferReader): ChonkProofWithPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ChonkProofWithPublicInputs(proof);
+  }
+
+  public toBuffer(): Buffer;
+  public toBuffer(sink: BufferSink): void;
+  public toBuffer(sink?: BufferSink): Buffer | void {
+    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: Uint8Array[]): ChonkProofWithPublicInputs {
+    const proof = fields.map(field => Fr.fromBuffer(Buffer.from(field)));
+    return new ChonkProofWithPublicInputs(proof);
+  }
+}

package/src/proofs/index.ts

@@ -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';

package/src/proofs/proof.ts

@@ -0,0 +1,122 @@
+import { PAIRING_POINTS_SIZE } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/foundation/string';
+import { strict as assert } from 'assert';
+
+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 {
+  // Make sure this type is not confused with other buffer wrappers
+  readonly __proofBrand: any;
+
+  constructor(
+    /**
+     * Holds the serialized proof data in a binary buffer format.
+     */
+    public buffer: Buffer,
+
+    public numPublicInputs: number,
+  ) {}
+
+  /**
+   * 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: Buffer | BufferReader): Proof {
+    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.
+   */
+  public 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.
+   */
+  public toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Returns the proof without the public inputs, but includes the pairing point object as part of the proof.
+   * @returns Proof in bytes form, including the pairing point object at the start.
+   */
+  public withoutPublicInputs(): Buffer {
+    if (this.isEmpty()) {
+      return this.buffer;
+    }
+    // We are indexing to this particular size because we are assuming the proof buffer looks like:
+    // [binary public inputs, binary proof]
+    // Here, we are assuming the pairing point object is the last 16 fields of the public inputs.
+    assert(this.numPublicInputs >= PAIRING_POINTS_SIZE, 'Proof does not contain an aggregation object');
+    const proofStart = Fr.SIZE_IN_BYTES * (this.numPublicInputs - PAIRING_POINTS_SIZE);
+    assert(this.buffer.length >= proofStart, 'Proof buffer is not appropriately sized to call withoutPublicInputs()');
+    return this.buffer.subarray(proofStart);
+  }
+
+  // This function assumes that the proof will contain an aggregation object and look something like:
+  // [binary public inputs, aggregation object, rest of proof]
+  // We are extracting the binary public inputs and reading them as Frs.
+  public extractPublicInputs(): Fr[] {
+    if (this.isEmpty()) {
+      // return array of this.numPublicInputs 0s
+      return new Array(this.numPublicInputs).fill(Fr.zero());
+    }
+    assert(this.numPublicInputs >= PAIRING_POINTS_SIZE, 'Proof does not contain an aggregation object');
+    const numInnerPublicInputs = this.numPublicInputs - PAIRING_POINTS_SIZE;
+    const reader = BufferReader.asReader(this.buffer.subarray(0, Fr.SIZE_IN_BYTES * numInnerPublicInputs));
+    const publicInputs = reader.readArray(numInnerPublicInputs, Fr);
+    return publicInputs;
+  }
+
+  /**
+   * Deserialize a Proof instance from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns - A new Proof instance.
+   */
+  static fromString(str: string) {
+    return Proof.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns whether this proof is actually empty. */
+  public 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/src/proofs/proof_data.ts

@@ -0,0 +1,64 @@
+import type {
+  CHONK_PROOF_LENGTH,
+  RECURSIVE_PROOF_LENGTH,
+  RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
+} from '@aztec-labs/constants';
+import { BufferReader, type Bufferable, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VkData } from '../vks/index.js';
+
+/**
+ * Represents the data of a recursive proof.
+ */
+export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
+  constructor(
+    public publicInputs: T,
+    public proof: RecursiveProof<PROOF_LENGTH>,
+    public vkData: VkData,
+  ) {}
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+  }
+
+  public static fromBuffer<T extends Bufferable, PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    publicInputs: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): ProofData<T, PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new ProofData(reader.readObject(publicInputs), RecursiveProof.fromBuffer(reader), reader.readObject(VkData));
+  }
+}
+
+/**
+ * Represents the data of a recursive proof for a circuit with a fixed verification key.
+ */
+export class ProofDataForFixedVk<T extends Bufferable, PROOF_LENGTH extends number> {
+  constructor(
+    public publicInputs: T,
+    public proof: RecursiveProof<PROOF_LENGTH>,
+  ) {}
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.publicInputs, this.proof);
+  }
+
+  public static fromBuffer<T extends Bufferable, PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    publicInputs: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): ProofDataForFixedVk<T, PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new ProofDataForFixedVk(reader.readObject(publicInputs), RecursiveProof.fromBuffer(reader));
+  }
+}
+
+export type ChonkProofData<T extends Bufferable> = ProofData<T, typeof CHONK_PROOF_LENGTH>;
+
+export type UltraHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_PROOF_LENGTH>;
+
+export type RollupHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;

package/src/proofs/proving_request_type.ts

@@ -0,0 +1,19 @@
+export enum ProvingRequestType {
+  PUBLIC_VM,
+  PUBLIC_CHONK_VERIFIER,
+
+  PRIVATE_TX_BASE_ROLLUP,
+  PUBLIC_TX_BASE_ROLLUP,
+  TX_MERGE_ROLLUP,
+  BLOCK_ROOT_ROLLUP,
+  BLOCK_ROOT_SINGLE_TX_ROLLUP,
+  BLOCK_ROOT_NO_TXS_ROLLUP,
+  BLOCK_MERGE_ROLLUP,
+  CHECKPOINT_ROOT_ROLLUP,
+  CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
+  CHECKPOINT_PADDING_ROLLUP,
+  CHECKPOINT_MERGE_ROLLUP,
+  ROOT_ROLLUP,
+
+  INBOX_PARITY,
+}

package/src/proofs/recursive_proof.ts

@@ -0,0 +1,124 @@
+import { makeTuple } from '@aztec-labs/foundation/array';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec-labs/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<N extends number> {
+  constructor(
+    /**
+     * Holds the serialized proof data in an array of fields, this is without the public inputs
+     */
+    public proof: Fr[],
+
+    /**
+     * Holds the serialized proof data in a binary buffer, this contains the public inputs
+     */
+    public binaryProof: Proof,
+    /**
+     * This flag determines if the 'proof' member is valid, or if we need to generate it from the 'binaryProof' first
+     */
+    public fieldsValid: boolean,
+    public proofLength: N,
+  ) {
+    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<N extends number>(buffer: Buffer | BufferReader, expectedSize?: N): RecursiveProof<N> {
+    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) as any,
+      Proof.fromBuffer(reader),
+      reader.readBoolean(),
+      size as 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.
+   */
+  public 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.
+   */
+  public 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<N extends number>(str: string, expectedSize?: N): RecursiveProof<N> {
+    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<N extends number>(expectedSize?: N) {
+    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<N extends number>(size: N) {
+  return new RecursiveProof(makeTuple<Fr, N>(size, Fr.zero), makeEmptyProof(), true, size);
+}
+
+export function makeRecursiveProof<PROOF_LENGTH extends number>(size: PROOF_LENGTH, seed = 1) {
+  return new RecursiveProof<PROOF_LENGTH>(
+    makeTuple<Fr, PROOF_LENGTH>(size, (i: number) => 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_LENGTH extends number>(proof: Proof, size: PROOF_LENGTH) {
+  return new RecursiveProof<PROOF_LENGTH>(makeTuple<Fr, PROOF_LENGTH>(size, Fr.zero), proof, false, size);
+}

package/src/rollup/avm_proof_data.ts

@@ -0,0 +1,6 @@
+import { AVM_V2_PROOF_LENGTH_IN_FIELDS } from '@aztec-labs/constants';
+
+import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
+import type { ProofDataForFixedVk } from '../proofs/proof_data.js';
+
+export type AvmProofData = ProofDataForFixedVk<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS>;