@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/rollup/private_tx_base_rollup_private_inputs.ts

@@ -0,0 +1,53 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_rollup_kernel_circuit_public_inputs.js';
+import { type ChonkProofData, ProofData } from '../proofs/proof_data.js';
+import { PrivateBaseRollupHints } from './base_rollup_hints.js';
+
+export class PrivateTxBaseRollupPrivateInputs {
+  constructor(
+    public hidingKernelProofData: ChonkProofData<PrivateToRollupKernelCircuitPublicInputs>,
+    public hints: PrivateBaseRollupHints,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateTxBaseRollupPrivateInputs>): PrivateTxBaseRollupPrivateInputs {
+    return new PrivateTxBaseRollupPrivateInputs(...PrivateTxBaseRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateTxBaseRollupPrivateInputs>) {
+    return [fields.hidingKernelProofData, fields.hints] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateTxBaseRollupPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateTxBaseRollupPrivateInputs(
+      ProofData.fromBuffer(reader, PrivateToRollupKernelCircuitPublicInputs),
+      reader.readObject(PrivateBaseRollupHints),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PrivateTxBaseRollupPrivateInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PrivateTxBaseRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a hex string. */
+  static get schema() {
+    return bufferSchemaFor(PrivateTxBaseRollupPrivateInputs);
+  }
+}

package/src/rollup/public_chonk_verifier_private_inputs.ts

@@ -0,0 +1,54 @@
+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 type { FieldsOf } from '@aztec/foundation/types';
+
+import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
+import { type ChonkProofData, ProofData } from '../proofs/proof_data.js';
+
+// CHONK_VERIFIER: Recursively verifies Chonk (Client Honk) proofs in circuits
+export class PublicChonkVerifierPrivateInputs {
+  constructor(
+    public hidingKernelProofData: ChonkProofData<PrivateToPublicKernelCircuitPublicInputs>,
+    public proverId: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<PublicChonkVerifierPrivateInputs>) {
+    return new PublicChonkVerifierPrivateInputs(...PublicChonkVerifierPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicChonkVerifierPrivateInputs>) {
+    return [fields.hidingKernelProofData, fields.proverId] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicChonkVerifierPrivateInputs(
+      ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicChonkVerifierPrivateInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PublicChonkVerifierPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(PublicChonkVerifierPrivateInputs);
+  }
+}

package/src/rollup/public_chonk_verifier_public_inputs.ts

@@ -0,0 +1,53 @@
+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 type { FieldsOf } from '@aztec/foundation/types';
+
+import { PrivateToPublicKernelCircuitPublicInputs } from '../kernel/private_to_public_kernel_circuit_public_inputs.js';
+
+// CHONK_VERIFIER: Recursively verifies Chonk (Client Honk) proofs in circuits
+export class PublicChonkVerifierPublicInputs {
+  constructor(
+    public privateTail: PrivateToPublicKernelCircuitPublicInputs,
+    public proverId: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<PublicChonkVerifierPublicInputs>) {
+    return new PublicChonkVerifierPublicInputs(...PublicChonkVerifierPublicInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicChonkVerifierPublicInputs>) {
+    return [fields.privateTail, fields.proverId] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicChonkVerifierPublicInputs(
+      reader.readObject(PrivateToPublicKernelCircuitPublicInputs),
+      reader.readObject(Fr),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicChonkVerifierPublicInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PublicChonkVerifierPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(PublicChonkVerifierPublicInputs);
+  }
+}

package/src/rollup/public_tx_base_rollup_private_inputs.ts

@@ -0,0 +1,57 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import type { AvmProofData } from './avm_proof_data.js';
+import { PublicBaseRollupHints } from './base_rollup_hints.js';
+import { PublicChonkVerifierPublicInputs } from './public_chonk_verifier_public_inputs.js';
+
+export class PublicTxBaseRollupPrivateInputs {
+  constructor(
+    public publicChonkVerifierProofData: RollupHonkProofData<PublicChonkVerifierPublicInputs>,
+    public avmProofData: AvmProofData,
+    public hints: PublicBaseRollupHints,
+  ) {}
+
+  static from(fields: FieldsOf<PublicTxBaseRollupPrivateInputs>): PublicTxBaseRollupPrivateInputs {
+    return new PublicTxBaseRollupPrivateInputs(...PublicTxBaseRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PublicTxBaseRollupPrivateInputs>) {
+    return [fields.publicChonkVerifierProofData, fields.avmProofData, fields.hints] as const;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PublicTxBaseRollupPrivateInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new PublicTxBaseRollupPrivateInputs(
+      ProofData.fromBuffer(reader, PublicChonkVerifierPublicInputs),
+      ProofData.fromBuffer(reader, AvmCircuitPublicInputs),
+      reader.readObject(PublicBaseRollupHints),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PublicTxBaseRollupPrivateInputs.getFields(this));
+  }
+
+  static fromString(str: string) {
+    return PublicTxBaseRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(PublicTxBaseRollupPrivateInputs);
+  }
+}

package/src/rollup/root_rollup_private_inputs.ts

@@ -0,0 +1,90 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { CheckpointRollupPublicInputs } from './checkpoint_rollup_public_inputs.js';
+
+/**
+ * Represents inputs of the root rollup circuit.
+ */
+export class RootRollupPrivateInputs {
+  constructor(
+    /**
+     * The previous rollup data.
+     * Note: Root rollup circuit is the latest circuit the chain of circuits and the previous rollup data is the data
+     * from 2 checkpoint root/merge/padding circuits.
+     */
+    public previousRollups: [
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+    ],
+  ) {}
+
+  /**
+   * Serializes the inputs to a buffer.
+   * @returns - The inputs serialized to a buffer.
+   */
+  toBuffer() {
+    return serializeToBuffer(...RootRollupPrivateInputs.getFields(this));
+  }
+
+  /**
+   * Serializes the inputs to a hex string.
+   * @returns The instance serialized to a hex string.
+   */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Creates a new instance from fields.
+   * @param fields - Fields to create the instance from.
+   * @returns A new RootRollupPrivateInputs instance.
+   */
+  static from(fields: FieldsOf<RootRollupPrivateInputs>) {
+    return new RootRollupPrivateInputs(...RootRollupPrivateInputs.getFields(fields));
+  }
+
+  /**
+   * Extracts fields from an instance.
+   * @param fields - Fields to create the instance from.
+   * @returns An array of fields.
+   */
+  static getFields(fields: FieldsOf<RootRollupPrivateInputs>) {
+    return [fields.previousRollups] as const;
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - A buffer to deserialize from.
+   * @returns A new RootRollupPrivateInputs instance.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new RootRollupPrivateInputs([
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+    ]);
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - A hex string to deserialize from.
+   * @returns A new RootRollupPrivateInputs instance.
+   */
+  static fromString(str: string) {
+    return RootRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(RootRollupPrivateInputs);
+  }
+}

package/src/rollup/root_rollup_public_inputs.ts

@@ -0,0 +1,99 @@
+import { FinalBlobAccumulator } from '@aztec/blob-lib/types';
+import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { FeeRecipient } from './checkpoint_rollup_public_inputs.js';
+import { EpochConstantData } from './epoch_constant_data.js';
+
+/**
+ * Represents public inputs of the root rollup circuit.
+ *
+ * NOTE: in practice, we'll hash all of this up into a single public input, for cheap onchain verification.
+ */
+export class RootRollupPublicInputs {
+  constructor(
+    /** Root of the archive tree before this rollup is processed */
+    public previousArchiveRoot: Fr,
+    /** Root of the archive tree after this rollup is processed */
+    public endArchiveRoot: Fr,
+    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public constants: EpochConstantData,
+    public blobPublicInputs: FinalBlobAccumulator,
+  ) {}
+
+  static getFields(fields: FieldsOf<RootRollupPublicInputs>) {
+    return [
+      fields.previousArchiveRoot,
+      fields.endArchiveRoot,
+      fields.checkpointHeaderHashes,
+      fields.fees,
+      fields.constants,
+      fields.blobPublicInputs,
+    ] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...RootRollupPublicInputs.getFields(this));
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...RootRollupPublicInputs.getFields(this));
+  }
+
+  static from(fields: FieldsOf<RootRollupPublicInputs>): RootRollupPublicInputs {
+    return new RootRollupPublicInputs(...RootRollupPublicInputs.getFields(fields));
+  }
+
+  /**
+   * Deserializes a buffer into a `RootRollupPublicInputs` object.
+   * @param buffer - The buffer to deserialize.
+   * @returns The deserialized `RootRollupPublicInputs` object.
+   */
+  public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new RootRollupPublicInputs(
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
+      reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
+      EpochConstantData.fromBuffer(reader),
+      reader.readObject(FinalBlobAccumulator),
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return RootRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  /** Creates an instance from a string. */
+  static get schema() {
+    return bufferSchemaFor(RootRollupPublicInputs);
+  }
+
+  /** Creates a random instance. Used for testing only - will not prove/verify. */
+  static random() {
+    return new RootRollupPublicInputs(
+      Fr.random(),
+      Fr.random(),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
+      makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
+      new EpochConstantData(Fr.random(), Fr.random(), Fr.random(), Fr.random(), Fr.random()),
+      FinalBlobAccumulator.random(),
+    );
+  }
+}

package/src/rollup/{state_diff_hints.ts → tree_snapshot_diff_hints.ts}

@@ -1,7 +1,7 @@
 import {
   MAX_NULLIFIERS_PER_TX,
-  NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH,
-  NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH,
+  NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
+  NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
@@ -11,13 +11,17 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s
 import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { NullifierLeafPreimage, PublicDataTreeLeafPreimage } from '../trees/index.js';
+import { NullifierLeafPreimage } from '../trees/index.js';
 
 /**
  * Hints used while proving state diff validity for the private base rollup.
  */
-export class PrivateBaseStateDiffHints {
+export class TreeSnapshotDiffHints {
   constructor(
+    /**
+     * Sibling path "pointing to" where the new note hash subtree should be inserted into the note hash tree.
+     */
+    public noteHashSubtreeRootSiblingPath: Tuple<Fr, typeof NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
      * The nullifiers which need to be updated to perform the batch insertion of the new nullifiers.
      * See `StandardIndexedTree.batchInsert` function for more details.
@@ -39,44 +43,29 @@ export class PrivateBaseStateDiffHints {
      * The indexes of the sorted nullifiers to the original ones.
      */
     public sortedNullifierIndexes: Tuple<number, typeof MAX_NULLIFIERS_PER_TX>,
-    /**
-     * Sibling path "pointing to" where the new note hash subtree should be inserted into the note hash tree.
-     */
-    public noteHashSubtreeSiblingPath: Tuple<Fr, typeof NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH>,
     /**
      * Sibling path "pointing to" where the new nullifiers subtree should be inserted into the nullifier tree.
      */
-    public nullifierSubtreeSiblingPath: Tuple<Fr, typeof NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH>,
-
-    /**
-     * Low leaf for the fee write in the public data tree.
-     */
-    public feeWriteLowLeafPreimage: PublicDataTreeLeafPreimage,
-    /**
-     * Membership witness for the low leaf for the fee write in the public data tree.
-     */
-    public feeWriteLowLeafMembershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
+    public nullifierSubtreeRootSiblingPath: Tuple<Fr, typeof NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
     /**
-     * Sibling path "pointing to" where the fee write should be inserted into the public data tree.
+     * Membership witness for the fee payer's balance leaf in the public data tree.
      */
-    public feeWriteSiblingPath: Tuple<Fr, typeof PUBLIC_DATA_TREE_HEIGHT>,
+    public feePayerBalanceMembershipWitness: MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
   ) {}
 
-  static from(fields: FieldsOf<PrivateBaseStateDiffHints>): PrivateBaseStateDiffHints {
-    return new PrivateBaseStateDiffHints(...PrivateBaseStateDiffHints.getFields(fields));
+  static from(fields: FieldsOf<TreeSnapshotDiffHints>): TreeSnapshotDiffHints {
+    return new TreeSnapshotDiffHints(...TreeSnapshotDiffHints.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<PrivateBaseStateDiffHints>) {
+  static getFields(fields: FieldsOf<TreeSnapshotDiffHints>) {
     return [
+      fields.noteHashSubtreeRootSiblingPath,
       fields.nullifierPredecessorPreimages,
       fields.nullifierPredecessorMembershipWitnesses,
       fields.sortedNullifiers,
       fields.sortedNullifierIndexes,
-      fields.noteHashSubtreeSiblingPath,
-      fields.nullifierSubtreeSiblingPath,
-      fields.feeWriteLowLeafPreimage,
-      fields.feeWriteLowLeafMembershipWitness,
-      fields.feeWriteSiblingPath,
+      fields.nullifierSubtreeRootSiblingPath,
+      fields.feePayerBalanceMembershipWitness,
     ] as const;
   }
 
@@ -85,42 +74,38 @@ export class PrivateBaseStateDiffHints {
    * @returns A buffer of the serialized state diff hints.
    */
   toBuffer(): Buffer {
-    return serializeToBuffer(...PrivateBaseStateDiffHints.getFields(this));
+    return serializeToBuffer(...TreeSnapshotDiffHints.getFields(this));
   }
 
   /**
    * Deserializes the state diff hints from a buffer.
    * @param buffer - A buffer to deserialize from.
-   * @returns A new PrivateBaseStateDiffHints instance.
+   * @returns A new TreeSnapshotDiffHints instance.
    */
-  static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseStateDiffHints {
+  static fromBuffer(buffer: Buffer | BufferReader): TreeSnapshotDiffHints {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateBaseStateDiffHints(
+    return new TreeSnapshotDiffHints(
+      reader.readArray(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       reader.readArray(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage),
       reader.readArray(MAX_NULLIFIERS_PER_TX, {
         fromBuffer: buffer => MembershipWitness.fromBuffer(buffer, NULLIFIER_TREE_HEIGHT),
       }),
       reader.readArray(MAX_NULLIFIERS_PER_TX, Fr),
       reader.readNumbers(MAX_NULLIFIERS_PER_TX),
-      reader.readArray(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, Fr),
-      reader.readArray(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, Fr),
-      reader.readObject(PublicDataTreeLeafPreimage),
+      reader.readArray(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
       MembershipWitness.fromBuffer(reader, PUBLIC_DATA_TREE_HEIGHT),
-      reader.readArray(PUBLIC_DATA_TREE_HEIGHT, Fr),
     );
   }
 
   static empty() {
-    return new PrivateBaseStateDiffHints(
+    return new TreeSnapshotDiffHints(
+      makeTuple(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, NullifierLeafPreimage.empty),
       makeTuple(MAX_NULLIFIERS_PER_TX, () => MembershipWitness.empty(NULLIFIER_TREE_HEIGHT)),
       makeTuple(MAX_NULLIFIERS_PER_TX, Fr.zero),
       makeTuple(MAX_NULLIFIERS_PER_TX, () => 0),
-      makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, Fr.zero),
-      makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, Fr.zero),
-      PublicDataTreeLeafPreimage.empty(),
+      makeTuple(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr.zero),
       MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT),
-      makeTuple(PUBLIC_DATA_TREE_HEIGHT, Fr.zero),
     );
   }
 }

package/src/rollup/{merge_rollup.ts → tx_merge_rollup_private_inputs.ts}

@@ -2,17 +2,18 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { PreviousRollupData } from './previous_rollup_data.js';
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { TxRollupPublicInputs } from './tx_rollup_public_inputs.js';
 
 /**
  * Represents inputs of the merge rollup circuit.
  */
-export class MergeRollupInputs {
+export class TxMergeRollupPrivateInputs {
   constructor(
     /**
      * Previous rollup data from the 2 merge or base rollup circuits that preceded this merge rollup circuit.
      */
-    public previousRollupData: [PreviousRollupData, PreviousRollupData],
+    public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
   ) {}
 
   /**
@@ -20,7 +21,7 @@ export class MergeRollupInputs {
    * @returns The inputs serialized to a buffer.
    */
   toBuffer() {
-    return serializeToBuffer(this.previousRollupData);
+    return serializeToBuffer(this.previousRollups);
   }
 
   /**
@@ -34,20 +35,23 @@ export class MergeRollupInputs {
   /**
    * Deserializes the inputs from a buffer.
    * @param buffer - The buffer to deserialize from.
-   * @returns A new MergeRollupInputs instance.
+   * @returns A new TxMergeRollupPrivateInputs instance.
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new MergeRollupInputs([reader.readObject(PreviousRollupData), reader.readObject(PreviousRollupData)]);
+    return new TxMergeRollupPrivateInputs([
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+    ]);
   }
 
   /**
    * Deserializes the inputs from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new MergeRollupInputs instance.
+   * @returns A new TxMergeRollupPrivateInputs instance.
    */
   static fromString(str: string) {
-    return MergeRollupInputs.fromBuffer(hexToBuffer(str));
+    return TxMergeRollupPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -57,6 +61,6 @@ export class MergeRollupInputs {
 
   /** Creates an instance from a string. */
   static get schema() {
-    return bufferSchemaFor(MergeRollupInputs);
+    return bufferSchemaFor(TxMergeRollupPrivateInputs);
   }
 }