@aztec/stdlib 3.0.0-nightly.20250917 → 3.0.0-nightly.20250919

package/src/rollup/checkpoint_root_rollup_private_inputs.ts

@@ -0,0 +1,218 @@
+import { BlobAccumulatorPublicInputs, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
+import { ARCHIVE_HEIGHT, BLOBS_PER_BLOCK, FIELDS_PER_BLOB } from '@aztec/constants';
+import { BLS12Point, Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, 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 { BlockHeader } from '../tx/block_header.js';
+import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
+
+export class CheckpointRootRollupHints {
+  constructor(
+    /**
+     * The header of the previous block before this checkpoint.
+     */
+    public previousBlockHeader: BlockHeader,
+    /**
+     * Hint for checking the hash of previous_block_header is the last leaf of the previous archive.
+     */
+    public previousArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+    /**
+     * The current blob accumulation state across the epoch.
+     */
+    public startBlobAccumulator: BlobAccumulatorPublicInputs,
+    /**
+     * Finalized challenges z and gamma for performing blob batching. Shared value across the epoch.
+     */
+    public finalBlobChallenges: FinalBlobBatchingChallenges,
+    /**
+     * Flat list of all tx effects which will be added to the blob.
+     * Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+     * Tuple<Fr, FIELDS_PER_BLOB * BLOBS_PER_BLOCK>
+     */
+    public blobFields: Fr[],
+    /**
+     * KZG commitments representing the blob (precomputed in ts, injected to use inside circuit).
+     */
+    public blobCommitments: Tuple<BLS12Point, typeof BLOBS_PER_BLOCK>,
+    /**
+     * The hash of eth blob hashes for this block
+     * See yarn-project/foundation/src/blob/index.ts or body.ts for calculation
+     */
+    public blobsHash: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<CheckpointRootRollupHints>) {
+    return new CheckpointRootRollupHints(...CheckpointRootRollupHints.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<CheckpointRootRollupHints>) {
+    return [
+      fields.previousBlockHeader,
+      fields.previousArchiveSiblingPath,
+      fields.startBlobAccumulator,
+      fields.finalBlobChallenges,
+      fields.blobFields,
+      fields.blobCommitments,
+      fields.blobsHash,
+    ] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...CheckpointRootRollupHints.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CheckpointRootRollupHints(
+      BlockHeader.fromBuffer(reader),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
+      reader.readObject(BlobAccumulatorPublicInputs),
+      reader.readObject(FinalBlobBatchingChallenges),
+      // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+      // reader.readArray(FIELDS_PER_BLOB, Fr),
+      Array.from({ length: FIELDS_PER_BLOB * BLOBS_PER_BLOCK }, () => Fr.fromBuffer(reader)),
+      reader.readArray(BLOBS_PER_BLOCK, BLS12Point),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return CheckpointRootRollupHints.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(CheckpointRootRollupHints);
+  }
+}
+
+export class CheckpointRootRollupPrivateInputs {
+  constructor(
+    public previousRollups: [
+      RollupHonkProofData<BlockRollupPublicInputs>,
+      RollupHonkProofData<BlockRollupPublicInputs>,
+    ],
+    public hints: CheckpointRootRollupHints,
+  ) {}
+
+  static from(fields: FieldsOf<CheckpointRootRollupPrivateInputs>) {
+    return new CheckpointRootRollupPrivateInputs(...CheckpointRootRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<CheckpointRootRollupPrivateInputs>) {
+    return [fields.previousRollups, fields.hints] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...CheckpointRootRollupPrivateInputs.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CheckpointRootRollupPrivateInputs(
+      [ProofData.fromBuffer(reader, BlockRollupPublicInputs), ProofData.fromBuffer(reader, BlockRollupPublicInputs)],
+      CheckpointRootRollupHints.fromBuffer(reader),
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return CheckpointRootRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(CheckpointRootRollupPrivateInputs);
+  }
+}
+
+export class CheckpointRootSingleBlockRollupPrivateInputs {
+  constructor(
+    public previousRollup: RollupHonkProofData<BlockRollupPublicInputs>,
+    public hints: CheckpointRootRollupHints,
+  ) {}
+
+  static from(fields: FieldsOf<CheckpointRootSingleBlockRollupPrivateInputs>) {
+    return new CheckpointRootSingleBlockRollupPrivateInputs(
+      ...CheckpointRootSingleBlockRollupPrivateInputs.getFields(fields),
+    );
+  }
+
+  static getFields(fields: FieldsOf<CheckpointRootSingleBlockRollupPrivateInputs>) {
+    return [fields.previousRollup, fields.hints] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...CheckpointRootSingleBlockRollupPrivateInputs.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CheckpointRootSingleBlockRollupPrivateInputs(
+      ProofData.fromBuffer(reader, BlockRollupPublicInputs),
+      CheckpointRootRollupHints.fromBuffer(reader),
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return CheckpointRootSingleBlockRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(CheckpointRootSingleBlockRollupPrivateInputs);
+  }
+}
+
+// Checkpoint padding circuit does not have any private inputs.
+export class CheckpointPaddingRollupPrivateInputs {
+  constructor() {}
+
+  toBuffer() {
+    return Buffer.alloc(0);
+  }
+
+  static fromBuffer(_buffer: Buffer | BufferReader) {
+    return new CheckpointPaddingRollupPrivateInputs();
+  }
+
+  toString(): `0x${string}` {
+    return '0x';
+  }
+
+  static fromString(_str: string) {
+    return new CheckpointPaddingRollupPrivateInputs();
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(CheckpointPaddingRollupPrivateInputs);
+  }
+}

package/src/rollup/epoch_constant_data.ts

@@ -1,5 +1,5 @@
 import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { BufferReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 /**
@@ -7,6 +7,14 @@ import type { FieldsOf } from '@aztec/foundation/types';
  */
 export class EpochConstantData {
   constructor(
+    /**
+     * ChainId of the rollup.
+     */
+    public chainId: Fr,
+    /**
+     * Version of the rollup.
+     */
+    public version: Fr,
     /**
      * Root of the verification key tree.
      */
@@ -25,20 +33,36 @@ export class EpochConstantData {
     return new EpochConstantData(...EpochConstantData.getFields(fields));
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): EpochConstantData {
-    const reader = BufferReader.asReader(buffer);
-    return new EpochConstantData(Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader));
+  static getFields(fields: FieldsOf<EpochConstantData>) {
+    return [
+      fields.chainId,
+      fields.version,
+      fields.vkTreeRoot,
+      fields.protocolContractTreeRoot,
+      fields.proverId,
+    ] as const;
   }
 
-  static getFields(fields: FieldsOf<EpochConstantData>) {
-    return [fields.vkTreeRoot, fields.protocolContractTreeRoot, fields.proverId] as const;
+  toFields(): Fr[] {
+    return serializeToFields(...EpochConstantData.getFields(this));
   }
 
-  static empty() {
-    return new EpochConstantData(Fr.ZERO, Fr.ZERO, Fr.ZERO);
+  static fromBuffer(buffer: Buffer | BufferReader): EpochConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new EpochConstantData(
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
   }
 
   toBuffer() {
     return serializeToBuffer(...EpochConstantData.getFields(this));
   }
+
+  static empty() {
+    return new EpochConstantData(Fr.ZERO, Fr.ZERO, Fr.ZERO, Fr.ZERO, Fr.ZERO);
+  }
 }

package/src/rollup/index.ts

@@ -1,18 +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_root_or_block_merge_public_inputs.js';
-export * from './empty_block_root_rollup_inputs.js';
+export * from './block_merge_rollup_private_inputs.js';
+export * from './block_rollup_public_inputs.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_private_inputs.js';
+export * from './checkpoint_rollup_public_inputs.js';
+export * from './checkpoint_root_rollup_private_inputs.js';
 export * from './epoch_constant_data.js';
-export * from './block_root_rollup.js';
-export * from './merge_rollup.js';
-export * from './padding_block_root_rollup_inputs.js';
-export * from './previous_rollup_block_data.js';
-export * from './previous_rollup_data.js';
-export * from './private_base_rollup_inputs.js';
-export * from './public_base_rollup_inputs.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';

package/src/rollup/{private_base_rollup_inputs.ts → private_tx_base_rollup_private_inputs.ts}

@@ -7,34 +7,34 @@ import { PrivateToRollupKernelCircuitPublicInputs } from '../kernel/private_to_r
 import { type CivcProofData, ProofData } from '../proofs/proof_data.js';
 import { PrivateBaseRollupHints } from './base_rollup_hints.js';
 
-export class PrivateBaseRollupInputs {
+export class PrivateTxBaseRollupPrivateInputs {
   constructor(
     public hidingKernelProofData: CivcProofData<PrivateToRollupKernelCircuitPublicInputs>,
     public hints: PrivateBaseRollupHints,
   ) {}
 
-  static from(fields: FieldsOf<PrivateBaseRollupInputs>): PrivateBaseRollupInputs {
-    return new PrivateBaseRollupInputs(...PrivateBaseRollupInputs.getFields(fields));
+  static from(fields: FieldsOf<PrivateTxBaseRollupPrivateInputs>): PrivateTxBaseRollupPrivateInputs {
+    return new PrivateTxBaseRollupPrivateInputs(...PrivateTxBaseRollupPrivateInputs.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<PrivateBaseRollupInputs>) {
+  static getFields(fields: FieldsOf<PrivateTxBaseRollupPrivateInputs>) {
     return [fields.hidingKernelProofData, fields.hints] as const;
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): PrivateBaseRollupInputs {
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateTxBaseRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
-    return new PrivateBaseRollupInputs(
+    return new PrivateTxBaseRollupPrivateInputs(
       ProofData.fromBuffer(reader, PrivateToRollupKernelCircuitPublicInputs),
       reader.readObject(PrivateBaseRollupHints),
     );
   }
 
   toBuffer() {
-    return serializeToBuffer(...PrivateBaseRollupInputs.getFields(this));
+    return serializeToBuffer(...PrivateTxBaseRollupPrivateInputs.getFields(this));
   }
 
   static fromString(str: string) {
-    return PrivateBaseRollupInputs.fromBuffer(hexToBuffer(str));
+    return PrivateTxBaseRollupPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   toString() {
@@ -48,6 +48,6 @@ export class PrivateBaseRollupInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(PrivateBaseRollupInputs);
+    return bufferSchemaFor(PrivateTxBaseRollupPrivateInputs);
   }
 }

package/src/rollup/{public_base_rollup_inputs.ts → public_tx_base_rollup_private_inputs.ts}

@@ -8,24 +8,24 @@ import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
 import { AvmProofData } from './avm_proof_data.js';
 import { PublicBaseRollupHints } from './base_rollup_hints.js';
 
-export class PublicBaseRollupInputs {
+export class PublicTxBaseRollupPrivateInputs {
   constructor(
     public publicTubeProofData: RollupHonkProofData<PrivateToPublicKernelCircuitPublicInputs>,
     public avmProofData: AvmProofData,
     public hints: PublicBaseRollupHints,
   ) {}
 
-  static from(fields: FieldsOf<PublicBaseRollupInputs>): PublicBaseRollupInputs {
-    return new PublicBaseRollupInputs(...PublicBaseRollupInputs.getFields(fields));
+  static from(fields: FieldsOf<PublicTxBaseRollupPrivateInputs>): PublicTxBaseRollupPrivateInputs {
+    return new PublicTxBaseRollupPrivateInputs(...PublicTxBaseRollupPrivateInputs.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<PublicBaseRollupInputs>) {
+  static getFields(fields: FieldsOf<PublicTxBaseRollupPrivateInputs>) {
     return [fields.publicTubeProofData, fields.avmProofData, fields.hints] as const;
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): PublicBaseRollupInputs {
+  static fromBuffer(buffer: Buffer | BufferReader): PublicTxBaseRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
-    return new PublicBaseRollupInputs(
+    return new PublicTxBaseRollupPrivateInputs(
       ProofData.fromBuffer(reader, PrivateToPublicKernelCircuitPublicInputs),
       reader.readObject(AvmProofData),
       reader.readObject(PublicBaseRollupHints),
@@ -33,11 +33,11 @@ export class PublicBaseRollupInputs {
   }
 
   toBuffer() {
-    return serializeToBuffer(...PublicBaseRollupInputs.getFields(this));
+    return serializeToBuffer(...PublicTxBaseRollupPrivateInputs.getFields(this));
   }
 
   static fromString(str: string) {
-    return PublicBaseRollupInputs.fromBuffer(hexToBuffer(str));
+    return PublicTxBaseRollupPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   toString() {
@@ -51,6 +51,6 @@ export class PublicBaseRollupInputs {
 
   /** Creates an instance from a string. */
   static get schema() {
-    return bufferSchemaFor(PublicBaseRollupInputs);
+    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.ts → root_rollup_public_inputs.ts}

@@ -7,88 +7,8 @@ import { BufferReader, type Tuple, serializeToBuffer, serializeToFields } from '
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { FeeRecipient } from './block_root_or_block_merge_public_inputs.js';
-import { PreviousRollupBlockData } from './previous_rollup_block_data.js';
-
-/**
- * Represents inputs of the root rollup circuit.
- */
-export class RootRollupInputs {
-  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 block merge circuits.
-     */
-    public previousRollupData: [PreviousRollupBlockData, PreviousRollupBlockData],
-  ) {}
-
-  /**
-   * Serializes the inputs to a buffer.
-   * @returns - The inputs serialized to a buffer.
-   */
-  toBuffer() {
-    return serializeToBuffer(...RootRollupInputs.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 RootRollupInputs instance.
-   */
-  static from(fields: FieldsOf<RootRollupInputs>): RootRollupInputs {
-    return new RootRollupInputs(...RootRollupInputs.getFields(fields));
-  }
-
-  /**
-   * Extracts fields from an instance.
-   * @param fields - Fields to create the instance from.
-   * @returns An array of fields.
-   */
-  static getFields(fields: FieldsOf<RootRollupInputs>) {
-    return [fields.previousRollupData] as const;
-  }
-
-  /**
-   * Deserializes the inputs from a buffer.
-   * @param buffer - A buffer to deserialize from.
-   * @returns A new RootRollupInputs instance.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader): RootRollupInputs {
-    const reader = BufferReader.asReader(buffer);
-    return new RootRollupInputs([
-      reader.readObject(PreviousRollupBlockData),
-      reader.readObject(PreviousRollupBlockData),
-    ]);
-  }
-
-  /**
-   * Deserializes the inputs from a hex string.
-   * @param str - A hex string to deserialize from.
-   * @returns A new RootRollupInputs instance.
-   */
-  static fromString(str: string) {
-    return RootRollupInputs.fromBuffer(hexToBuffer(str));
-  }
-
-  /** Returns a representation for JSON serialization. */
-  toJSON() {
-    return this.toBuffer();
-  }
-
-  /** Creates an instance from a string. */
-  static get schema() {
-    return bufferSchemaFor(RootRollupInputs);
-  }
-}
+import { FeeRecipient } from './checkpoint_rollup_public_inputs.js';
+import { EpochConstantData } from './epoch_constant_data.js';
 
 /**
  * Represents public inputs of the root rollup circuit.
@@ -101,13 +21,9 @@ export class RootRollupPublicInputs {
     public previousArchiveRoot: Fr,
     /** Root of the archive tree after this rollup is processed */
     public endArchiveRoot: Fr,
-    public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
-    public chainId: Fr,
-    public version: Fr,
-    public vkTreeRoot: Fr,
-    public protocolContractTreeRoot: Fr,
-    public proverId: Fr,
+    public constants: EpochConstantData,
     public blobPublicInputs: FinalBlobAccumulatorPublicInputs,
   ) {}
 
@@ -115,13 +31,9 @@ export class RootRollupPublicInputs {
     return [
       fields.previousArchiveRoot,
       fields.endArchiveRoot,
-      fields.proposedBlockHeaderHashes,
+      fields.checkpointHeaderHashes,
       fields.fees,
-      fields.chainId,
-      fields.version,
-      fields.vkTreeRoot,
-      fields.protocolContractTreeRoot,
-      fields.proverId,
+      fields.constants,
       fields.blobPublicInputs,
     ] as const;
   }
@@ -150,11 +62,7 @@ export class RootRollupPublicInputs {
       Fr.fromBuffer(reader),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      EpochConstantData.fromBuffer(reader),
       reader.readObject(FinalBlobAccumulatorPublicInputs),
     );
   }
@@ -184,11 +92,7 @@ export class RootRollupPublicInputs {
       Fr.random(),
       makeTuple(AZTEC_MAX_EPOCH_DURATION, Fr.random),
       makeTuple(AZTEC_MAX_EPOCH_DURATION, FeeRecipient.random),
-      Fr.random(),
-      Fr.random(),
-      Fr.random(),
-      Fr.random(),
-      Fr.random(),
+      new EpochConstantData(Fr.random(), Fr.random(), Fr.random(), Fr.random(), Fr.random()),
       FinalBlobAccumulatorPublicInputs.random(),
     );
   }