@aztec/stdlib 3.0.0-nightly.20250918 → 3.0.0-nightly.20250920

package/src/logs/public_log.ts

@@ -1,28 +1,113 @@
-import { PUBLIC_LOG_LENGTH, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH, PUBLIC_LOG_HEADER_LENGTH } from '@aztec/constants';
+import type { FieldsOf } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
-import {
-  BufferReader,
-  FieldReader,
-  type Tuple,
-  serializeToBuffer,
-  serializeToFields,
-} from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
-export class PublicLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_LENGTH;
+function totalSizeInFields(logs: PublicLog[]) {
+  return logs.reduce((acc, log) => acc + log.sizeInFields(), 0);
+}
+
+// This class represents logs in the same format as noir does, with a bounded maximum length.
+export class FlatPublicLogs {
+  // We don't use tuple here because FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH is too large
+  constructor(
+    public length: number,
+    public payload: Fr[],
+  ) {
+    if (payload.length !== FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH) {
+      throw new Error('Invalid payload given to FlatPublicLogs');
+    }
+    if (length > payload.length) {
+      throw new Error('Invalid length given to FlatPublicLogs');
+    }
+  }
+
+  private static fromUnpaddedPayload(payload: Fr[]) {
+    const length = payload.length;
+    return new FlatPublicLogs(length, [...payload, ...Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH - length).fill(Fr.ZERO)]);
+  }
+
+  // In blobs, the actual nonempty length of the logs is encoded with the prefix, and then we have the non-padded payload.
+  static fromBlobFields(length: number, fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const payload = reader.readFieldArray(length);
+    return this.fromUnpaddedPayload(payload);
+  }
+
+  toBlobFields() {
+    return this.payload.slice(0, this.length);
+  }
+
+  static fromLogs(logs: PublicLog[]) {
+    return this.fromUnpaddedPayload(logs.flatMap(log => log.toFields()));
+  }
+
+  toLogs() {
+    const reader = FieldReader.asReader(this.payload);
+    const logs = [];
+    while (totalSizeInFields(logs) < this.length) {
+      logs.push(PublicLog.fromFields(reader));
+    }
+    if (totalSizeInFields(logs) !== this.length) {
+      throw new Error('Wrong length in FlatPublicLogs');
+    }
+    return logs;
+  }
+
+  static get schema(): ZodFor<FlatPublicLogs> {
+    return z
+      .object({
+        length: z.number(),
+        payload: z.array(schemas.Fr).min(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH).max(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH),
+      })
+      .transform(({ length, payload }) => new FlatPublicLogs(length, payload));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.length, this.payload.slice(0, this.length));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    const length = reader.readNumber();
+    return this.fromUnpaddedPayload(reader.readArray(length, Fr));
+  }
 
+  // ToFields and fromFields expect the noir style representation, with constant length payload.
+  toFields(): Fr[] {
+    return [new Fr(this.length), ...this.payload];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    // We need to do this because field reader returns tuples, which break the type system on these sizes.
+    const length = reader.readU32();
+    const payload: Fr[] = [];
+    for (let i = 0; i < FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH; ++i) {
+      payload.push(reader.readField());
+    }
+    return new FlatPublicLogs(length, payload);
+  }
+
+  static empty() {
+    return new FlatPublicLogs(0, Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH).fill(Fr.ZERO));
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+}
+
+export class PublicLog {
   constructor(
     public contractAddress: AztecAddress,
-    public fields: Tuple<Fr, typeof PUBLIC_LOG_SIZE_IN_FIELDS>,
-    public emittedLength: number,
+    public fields: Fr[],
   ) {}
 
   static from(fields: FieldsOf<PublicLog>) {
@@ -30,104 +115,81 @@ export class PublicLog {
   }
 
   static getFields(fields: FieldsOf<PublicLog>) {
-    return [fields.contractAddress, fields.fields, fields.emittedLength] as const;
+    return [fields.contractAddress, fields.fields] as const;
   }
 
   toFields(): Fr[] {
-    return serializeToFields(...PublicLog.getFields(this));
+    return [new Fr(this.fields.length), this.contractAddress.toField(), ...this.fields];
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PublicLog(
-      reader.readObject(AztecAddress),
-      reader.readFieldArray(PUBLIC_LOG_SIZE_IN_FIELDS),
-      reader.readU32(),
-    );
+    const fieldsLength = reader.readU32();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(fieldsLength));
   }
 
-  getEmittedFields() {
-    return this.fields.slice(0, this.emittedLength);
-  }
-
-  getEmittedFieldsWithoutTag() {
-    return this.fields.slice(1, this.emittedLength);
+  sizeInFields() {
+    return this.fields.length + PUBLIC_LOG_HEADER_LENGTH;
   }
 
-  toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  getEmittedFields() {
+    return this.fields.slice(0);
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
-    const contractAddress = reader.readObject(AztecAddress);
-    const emittedFields = reader.readFieldArray(emittedLength);
-    return new PublicLog(
-      contractAddress,
-      padArrayEnd(emittedFields, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS),
-      emittedLength,
-    );
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1);
   }
 
   isEmpty() {
-    return this.contractAddress.isZero() && this.fields.every(f => f.isZero()) && this.emittedLength === 0;
+    return this.contractAddress.isZero() && this.fields.length === 0;
   }
 
   static empty() {
-    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
+    return new PublicLog(AztecAddress.ZERO, []);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(...PublicLog.getFields(this));
+    return serializeToBuffer(this.fields.length, this.contractAddress, this.fields);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PublicLog(
-      reader.readObject(AztecAddress),
-      reader.readArray(PUBLIC_LOG_SIZE_IN_FIELDS, Fr),
-      reader.readNumber(),
-    );
+    const fieldsLength = reader.readNumber();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(fieldsLength, Fr));
   }
 
   static async random() {
     return new PublicLog(
       await AztecAddress.random(),
-      makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.random),
-      PUBLIC_LOG_SIZE_IN_FIELDS,
+      Array.from({ length: 10 }, () => Fr.random()),
     );
   }
 
   equals(other: this) {
     return (
+      this.fields.length === other.fields.length &&
       this.contractAddress.equals(other.contractAddress) &&
-      this.fields.every((field, i) => field.equals(other.fields[i])) &&
-      this.emittedLength === other.emittedLength
+      this.fields.every((field, i) => field.equals(other.fields[i]))
     );
   }
 
   toHumanReadable(): string {
-    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields}) emittedLength: ${this.emittedLength}`;
+    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields})`;
   }
 
   static get schema(): ZodFor<PublicLog> {
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        fields: z.array(schemas.Fr).refine(arr => arr.length === PUBLIC_LOG_SIZE_IN_FIELDS),
-        emittedLength: z.number(),
+        fields: z.array(schemas.Fr),
       })
-      .transform(({ contractAddress, fields, emittedLength }) =>
-        PublicLog.fromFields([contractAddress.toField(), ...fields, new Fr(emittedLength)]),
-      );
+      .transform(({ contractAddress, fields }) => PublicLog.from({ contractAddress, fields }));
   }
 
   [inspect.custom](): string {
     return `PublicLog {
       contractAddress: ${inspect(this.contractAddress)},
       fields: [${this.fields.map(x => inspect(x)).join(', ')}],
-      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/parity/index.ts

@@ -1,4 +1,3 @@
-export * from './base_parity_inputs.js';
+export * from './parity_base_private_inputs.js';
 export * from './parity_public_inputs.js';
-export * from './root_parity_input.js';
-export * from './root_parity_inputs.js';
+export * from './parity_root_private_inputs.js';

package/src/parity/{base_parity_inputs.ts → parity_base_private_inputs.ts}

@@ -4,7 +4,7 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-export class BaseParityInputs {
+export class ParityBasePrivateInputs {
   constructor(
     /** Aggregated proof of all the parity circuit iterations. */
     public readonly msgs: Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>,
@@ -16,11 +16,11 @@ export class BaseParityInputs {
     array: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
     index: number,
     vkTreeRoot: Fr,
-  ): BaseParityInputs {
+  ): ParityBasePrivateInputs {
     const start = index * NUM_MSGS_PER_BASE_PARITY;
     const end = start + NUM_MSGS_PER_BASE_PARITY;
     const msgs = array.slice(start, end);
-    return new BaseParityInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
+    return new ParityBasePrivateInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
   }
 
   /** Serializes the inputs to a buffer. */
@@ -39,7 +39,7 @@ export class BaseParityInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new BaseParityInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
+    return new ParityBasePrivateInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
   }
 
   /**
@@ -48,7 +48,7 @@ export class BaseParityInputs {
    * @returns - The deserialized inputs.
    */
   static fromString(str: string) {
-    return BaseParityInputs.fromBuffer(hexToBuffer(str));
+    return ParityBasePrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -58,6 +58,6 @@ export class BaseParityInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BaseParityInputs);
+    return bufferSchemaFor(ParityBasePrivateInputs);
   }
 }

package/src/parity/{root_parity_inputs.ts → parity_root_private_inputs.ts}

@@ -1,17 +1,18 @@
-import { NUM_BASE_PARITY_PER_ROOT_PARITY, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
+import { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { RootParityInput } from './root_parity_input.js';
+import { ProofData, type UltraHonkProofData } from '../proofs/proof_data.js';
+import { ParityPublicInputs } from './parity_public_inputs.js';
 
-export class RootParityInputs {
+export type ParityBaseProofData = UltraHonkProofData<ParityPublicInputs>;
+
+export class ParityRootPrivateInputs {
   constructor(
-    /** Public inputs of children and their proofs. */
-    public readonly children: Tuple<
-      RootParityInput<typeof RECURSIVE_PROOF_LENGTH>,
-      typeof NUM_BASE_PARITY_PER_ROOT_PARITY
-    >,
+    /** Public inputs of the parity base circuits and their proofs and vk data. */
+    public readonly children: Tuple<ParityBaseProofData, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
   ) {}
 
   /**
@@ -19,7 +20,7 @@ export class RootParityInputs {
    * @returns The inputs serialized to a buffer.
    */
   toBuffer() {
-    return serializeToBuffer(...this.children);
+    return serializeToBuffer(this.children);
   }
 
   /**
@@ -33,25 +34,22 @@ export class RootParityInputs {
   /**
    * Deserializes the inputs from a buffer.
    * @param buffer - The buffer to deserialize from.
-   * @returns A new RootParityInputs instance.
+   * @returns A new ParityRootPrivateInputs instance.
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    const tuple = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, () =>
-      RootParityInput.fromBuffer(reader, RECURSIVE_PROOF_LENGTH),
-    );
-    return new RootParityInputs(
-      tuple as Tuple<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
+    return new ParityRootPrivateInputs(
+      makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, () => ProofData.fromBuffer(reader, ParityPublicInputs)),
     );
   }
 
   /**
    * Deserializes the inputs from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new RootParityInputs instance.
+   * @returns A new ParityRootPrivateInputs instance.
    */
   static fromString(str: string) {
-    return RootParityInputs.fromBuffer(hexToBuffer(str));
+    return ParityRootPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -61,6 +59,6 @@ export class RootParityInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(RootParityInputs);
+    return bufferSchemaFor(ParityRootPrivateInputs);
   }
 }

package/src/proofs/proof_data.ts

@@ -1,4 +1,4 @@
-import type { CIVC_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { CIVC_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
 import { BufferReader, type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { RecursiveProof } from '../proofs/recursive_proof.js';
@@ -31,4 +31,6 @@ export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
 
 export type CivcProofData<T extends Bufferable> = ProofData<T, typeof CIVC_PROOF_LENGTH>;
 
-export type RollupHonkProofData<T extends Bufferable> = ProofData<T, typeof NESTED_RECURSIVE_ROLLUP_HONK_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

@@ -1,9 +1,10 @@
 export enum ProvingRequestType {
   PUBLIC_VM,
   PUBLIC_TUBE,
-  PRIVATE_BASE_ROLLUP,
-  PUBLIC_BASE_ROLLUP,
-  MERGE_ROLLUP,
+
+  PRIVATE_TX_BASE_ROLLUP,
+  PUBLIC_TX_BASE_ROLLUP,
+  TX_MERGE_ROLLUP,
   BLOCK_ROOT_FIRST_ROLLUP,
   BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
   BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
@@ -16,6 +17,6 @@ export enum ProvingRequestType {
   CHECKPOINT_MERGE_ROLLUP,
   ROOT_ROLLUP,
 
-  BASE_PARITY,
-  ROOT_PARITY,
+  PARITY_BASE,
+  PARITY_ROOT,
 }

package/src/rollup/{block_merge_rollup.ts → block_merge_rollup_private_inputs.ts}

@@ -2,9 +2,8 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { ProofData } from '../proofs/index.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
 import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
-import type { RollupProofData } from './rollup_proof_data.js';
 
 /**
  * Represents inputs of the block merge rollup circuit.
@@ -14,7 +13,10 @@ export class BlockMergeRollupPrivateInputs {
     /**
      * Previous rollup data from the 2 block merge or block root rollup circuits that preceded this merge rollup circuit.
      */
-    public previousRollups: [RollupProofData<BlockRollupPublicInputs>, RollupProofData<BlockRollupPublicInputs>],
+    public previousRollups: [
+      RollupHonkProofData<BlockRollupPublicInputs>,
+      RollupHonkProofData<BlockRollupPublicInputs>,
+    ],
   ) {}
 
   /**

package/src/rollup/{block_root_rollup.ts → block_root_rollup_private_inputs.ts}

@@ -6,27 +6,23 @@ import { BufferReader, type Tuple, bigintToUInt64BE, serializeToBuffer } from '@
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
-import { ProofData } from '../proofs/proof_data.js';
+import { ProofData, type RollupHonkProofData, type UltraHonkProofData } from '../proofs/proof_data.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { StateReference } from '../tx/state_reference.js';
 import type { UInt64 } from '../types/shared.js';
-import { BaseOrMergeRollupPublicInputs } from './base_or_merge_rollup_public_inputs.js';
 import { CheckpointConstantData } from './checkpoint_constant_data.js';
-import type { RollupProofData, RootParityProofData } from './rollup_proof_data.js';
+import { TxRollupPublicInputs } from './tx_rollup_public_inputs.js';
 
 export class BlockRootFirstRollupPrivateInputs {
   constructor(
     /**
      * The original and converted roots of the L1 to L2 messages subtrees.
      */
-    public l1ToL2Roots: RootParityProofData,
+    public l1ToL2Roots: UltraHonkProofData<ParityPublicInputs>,
     /**
      * The previous rollup proof data from base or merge rollup circuits.
      */
-    public previousRollups: [
-      RollupProofData<BaseOrMergeRollupPublicInputs>,
-      RollupProofData<BaseOrMergeRollupPublicInputs>,
-    ],
+    public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
     /**
      * The l1 to l2 message tree snapshot immediately before this block.
      */
@@ -63,10 +59,7 @@ export class BlockRootFirstRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootFirstRollupPrivateInputs(
       ProofData.fromBuffer(reader, ParityPublicInputs),
-      [
-        ProofData.fromBuffer(reader, BaseOrMergeRollupPublicInputs),
-        ProofData.fromBuffer(reader, BaseOrMergeRollupPublicInputs),
-      ],
+      [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
       AppendOnlyTreeSnapshot.fromBuffer(reader),
       reader.readArray(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
@@ -87,11 +80,11 @@ export class BlockRootSingleTxFirstRollupPrivateInputs {
     /**
      * The original and converted roots of the L1 to L2 messages subtrees.
      */
-    public l1ToL2Roots: RootParityProofData,
+    public l1ToL2Roots: UltraHonkProofData<ParityPublicInputs>,
     /**
      * The previous rollup proof data from base or merge rollup circuits.
      */
-    public previousRollup: RollupProofData<BaseOrMergeRollupPublicInputs>,
+    public previousRollup: RollupHonkProofData<TxRollupPublicInputs>,
     /**
      * The l1 to l2 message tree snapshot immediately before this block.
      */
@@ -130,7 +123,7 @@ export class BlockRootSingleTxFirstRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootSingleTxFirstRollupPrivateInputs(
       ProofData.fromBuffer(reader, ParityPublicInputs),
-      ProofData.fromBuffer(reader, BaseOrMergeRollupPublicInputs),
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
       AppendOnlyTreeSnapshot.fromBuffer(reader),
       reader.readArray(L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
@@ -151,7 +144,7 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
     /**
      * The original and converted roots of the L1 to L2 messages subtrees.
      */
-    public l1ToL2Roots: RootParityProofData,
+    public l1ToL2Roots: UltraHonkProofData<ParityPublicInputs>,
     /**
      * The archive after applying the previous block.
      */
@@ -241,10 +234,7 @@ export class BlockRootRollupPrivateInputs {
     /**
      * The previous rollup proof data from base or merge rollup circuits.
      */
-    public previousRollups: [
-      RollupProofData<BaseOrMergeRollupPublicInputs>,
-      RollupProofData<BaseOrMergeRollupPublicInputs>,
-    ],
+    public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -266,10 +256,7 @@ export class BlockRootRollupPrivateInputs {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootRollupPrivateInputs(
-      [
-        ProofData.fromBuffer(reader, BaseOrMergeRollupPublicInputs),
-        ProofData.fromBuffer(reader, BaseOrMergeRollupPublicInputs),
-      ],
+      [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
@@ -288,7 +275,7 @@ export class BlockRootSingleTxRollupPrivateInputs {
     /**
      * The previous rollup proof data from base or merge rollup circuits.
      */
-    public previousRollup: RollupProofData<BaseOrMergeRollupPublicInputs>,
+    public previousRollup: RollupHonkProofData<TxRollupPublicInputs>,
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -310,7 +297,7 @@ export class BlockRootSingleTxRollupPrivateInputs {
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootSingleTxRollupPrivateInputs(
-      ProofData.fromBuffer(reader, BaseOrMergeRollupPublicInputs),
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }

package/src/rollup/{checkpoint_merge_rollup.ts → checkpoint_merge_rollup_private_inputs.ts}

@@ -2,9 +2,8 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { ProofData } from '../proofs/proof_data.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
 import { CheckpointRollupPublicInputs } from './checkpoint_rollup_public_inputs.js';
-import type { RollupProofData } from './rollup_proof_data.js';
 
 /**
  * Represents inputs of the checkpoint merge rollup circuit.
@@ -15,8 +14,8 @@ export class CheckpointMergeRollupPrivateInputs {
      * Previous rollup data from the 2 checkpoint root or merge rollup circuits that preceded this checkpoint merge rollup circuit.
      */
     public previousRollups: [
-      RollupProofData<CheckpointRollupPublicInputs>,
-      RollupProofData<CheckpointRollupPublicInputs>,
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
     ],
   ) {}
 

package/src/rollup/{checkpoint_root_rollup.ts → checkpoint_root_rollup_private_inputs.ts}

@@ -6,10 +6,9 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { ProofData } from '../proofs/proof_data.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
-import type { RollupProofData } from './rollup_proof_data.js';
 
 export class CheckpointRootRollupHints {
   constructor(
@@ -100,7 +99,10 @@ export class CheckpointRootRollupHints {
 
 export class CheckpointRootRollupPrivateInputs {
   constructor(
-    public previousRollups: [RollupProofData<BlockRollupPublicInputs>, RollupProofData<BlockRollupPublicInputs>],
+    public previousRollups: [
+      RollupHonkProofData<BlockRollupPublicInputs>,
+      RollupHonkProofData<BlockRollupPublicInputs>,
+    ],
     public hints: CheckpointRootRollupHints,
   ) {}
 
@@ -143,7 +145,7 @@ export class CheckpointRootRollupPrivateInputs {
 
 export class CheckpointRootSingleBlockRollupPrivateInputs {
   constructor(
-    public previousRollup: RollupProofData<BlockRollupPublicInputs>,
+    public previousRollup: RollupHonkProofData<BlockRollupPublicInputs>,
     public hints: CheckpointRootRollupHints,
   ) {}
 

package/src/rollup/index.ts

@@ -1,21 +1,20 @@
 export * from './avm_proof_data.js';
-export * from './base_or_merge_rollup_public_inputs.js';
 export * from './base_rollup_hints.js';
 export * from './block_constant_data.js';
-export * from './block_merge_rollup.js';
+export * from './block_merge_rollup_private_inputs.js';
 export * from './block_rollup_public_inputs.js';
-export * from './block_root_rollup.js';
+export * from './block_root_rollup_private_inputs.js';
 export * from './checkpoint_constant_data.js';
 export * from './checkpoint_header.js';
-export * from './checkpoint_merge_rollup.js';
+export * from './checkpoint_merge_rollup_private_inputs.js';
 export * from './checkpoint_rollup_public_inputs.js';
-export * from './checkpoint_root_rollup.js';
+export * from './checkpoint_root_rollup_private_inputs.js';
 export * from './epoch_constant_data.js';
-export * from './merge_rollup.js';
-export * from './previous_rollup_data.js';
-export * from './private_base_rollup_inputs.js';
-export * from './public_base_rollup_inputs.js';
-export * from './rollup_proof_data.js';
+export * from './private_tx_base_rollup_private_inputs.js';
+export * from './public_tx_base_rollup_private_inputs.js';
 export * from './public_tube_private_inputs.js';
-export * from './root_rollup.js';
+export * from './root_rollup_private_inputs.js';
+export * from './root_rollup_public_inputs.js';
 export * from './state_diff_hints.js';
+export * from './tx_merge_rollup_private_inputs.js';
+export * from './tx_rollup_public_inputs.js';