@aztec/stdlib 1.0.0-nightly.20250606 → 1.0.0-nightly.20250607

package/src/fees/transaction_fee.ts

@@ -10,15 +10,15 @@ import type { GasSettings } from '../gas/gas_settings.js';
  */
 export function computeEffectiveGasFees(gasFees: GasFees, gasSettings: GasSettings): GasFees {
   const { maxFeesPerGas, maxPriorityFeesPerGas } = gasSettings;
-  const minField = (f1: Fr, f2: Fr) => (f1.lt(f2) ? f1 : f2);
+  const minBigInt = (f1: bigint, f2: bigint) => (f1 < f2 ? f1 : f2);
   const priorityFees = new GasFees(
-    minField(maxPriorityFeesPerGas.feePerDaGas, maxFeesPerGas.feePerDaGas.sub(gasFees.feePerDaGas)),
-    minField(maxPriorityFeesPerGas.feePerL2Gas, maxFeesPerGas.feePerL2Gas.sub(gasFees.feePerL2Gas)),
+    minBigInt(maxPriorityFeesPerGas.feePerDaGas, maxFeesPerGas.feePerDaGas - gasFees.feePerDaGas),
+    minBigInt(maxPriorityFeesPerGas.feePerL2Gas, maxFeesPerGas.feePerL2Gas - gasFees.feePerL2Gas),
   );
 
   const effectiveFees = new GasFees(
-    gasFees.feePerDaGas.add(priorityFees.feePerDaGas),
-    gasFees.feePerL2Gas.add(priorityFees.feePerL2Gas),
+    gasFees.feePerDaGas + priorityFees.feePerDaGas,
+    gasFees.feePerL2Gas + priorityFees.feePerL2Gas,
   );
 
   return effectiveFees;

package/src/gas/gas.ts

@@ -88,7 +88,7 @@ export class Gas {
 
   computeFee(gasFees: GasFees) {
     return GasDimensions.reduce(
-      (acc, dimension) => acc.add(gasFees.get(dimension).mul(new Fr(this.get(dimension)))),
+      (acc, dimension) => acc.add(new Fr(gasFees.get(dimension)).mul(new Fr(this.get(dimension)))),
       Fr.ZERO,
     );
   }

package/src/gas/gas_fees.ts

@@ -1,28 +1,35 @@
 import { Fr } from '@aztec/foundation/fields';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import {
+  BufferReader,
+  FieldReader,
+  bigintToUInt128BE,
+  serializeToBuffer,
+  serializeToFields,
+} from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import type { UInt128 } from '../types/shared.js';
 import type { GasDimensions } from './gas.js';
 
 /** Gas prices for each dimension. */
 export class GasFees {
-  public readonly feePerDaGas: Fr;
-  public readonly feePerL2Gas: Fr;
+  public readonly feePerDaGas: UInt128;
+  public readonly feePerL2Gas: UInt128;
 
-  constructor(feePerDaGas: Fr | number | bigint, feePerL2Gas: Fr | number | bigint) {
-    this.feePerDaGas = new Fr(feePerDaGas);
-    this.feePerL2Gas = new Fr(feePerL2Gas);
+  constructor(feePerDaGas: number | bigint, feePerL2Gas: number | bigint) {
+    this.feePerDaGas = BigInt(feePerDaGas);
+    this.feePerL2Gas = BigInt(feePerL2Gas);
   }
 
   static get schema() {
     return z
       .object({
-        feePerDaGas: schemas.Fr,
-        feePerL2Gas: schemas.Fr,
+        feePerDaGas: schemas.BigInt,
+        feePerL2Gas: schemas.BigInt,
       })
       .transform(GasFees.from);
   }
@@ -32,7 +39,7 @@ export class GasFees {
   }
 
   equals(other: GasFees) {
-    return this.feePerDaGas.equals(other.feePerDaGas) && this.feePerL2Gas.equals(other.feePerL2Gas);
+    return this.feePerDaGas === other.feePerDaGas && this.feePerL2Gas === other.feePerL2Gas;
   }
 
   get(dimension: GasDimensions) {
@@ -48,12 +55,9 @@ export class GasFees {
     if (scalar === 1 || scalar === 1n) {
       return this.clone();
     } else if (typeof scalar === 'bigint') {
-      return new GasFees(new Fr(this.feePerDaGas.toBigInt() * scalar), new Fr(this.feePerL2Gas.toBigInt() * scalar));
+      return new GasFees(this.feePerDaGas * scalar, this.feePerL2Gas * scalar);
     } else {
-      return new GasFees(
-        new Fr(this.feePerDaGas.toNumberUnsafe() * scalar),
-        new Fr(this.feePerL2Gas.toNumberUnsafe() * scalar),
-      );
+      return new GasFees(Number(this.feePerDaGas) * scalar, Number(this.feePerL2Gas) * scalar);
     }
   }
 
@@ -62,29 +66,29 @@ export class GasFees {
   }
 
   static random() {
-    return new GasFees(Fr.random(), Fr.random());
+    return new GasFees(Math.floor(Math.random() * 1e9), Math.floor(Math.random() * 1e9));
   }
 
   static empty() {
-    return new GasFees(Fr.ZERO, Fr.ZERO);
+    return new GasFees(0, 0);
   }
 
   isEmpty() {
-    return this.feePerDaGas.isZero() && this.feePerL2Gas.isZero();
+    return this.feePerDaGas === 0n && this.feePerL2Gas === 0n;
   }
 
   static fromBuffer(buffer: Buffer | BufferReader): GasFees {
     const reader = BufferReader.asReader(buffer);
-    return new GasFees(reader.readObject(Fr), reader.readObject(Fr));
+    return new GasFees(reader.readUInt128(), reader.readUInt128());
   }
 
   toBuffer() {
-    return serializeToBuffer(this.feePerDaGas, this.feePerL2Gas);
+    return serializeToBuffer(bigintToUInt128BE(this.feePerDaGas), bigintToUInt128BE(this.feePerL2Gas));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new GasFees(reader.readField(), reader.readField());
+    return new GasFees(reader.readField().toBigInt(), reader.readField().toBigInt());
   }
 
   toFields() {
@@ -93,12 +97,12 @@ export class GasFees {
 
   toInspect() {
     return {
-      feePerDaGas: this.feePerDaGas.toNumberUnsafe(),
-      feePerL2Gas: this.feePerL2Gas.toNumberUnsafe(),
+      feePerDaGas: this.feePerDaGas,
+      feePerL2Gas: this.feePerL2Gas,
     };
   }
 
   [inspect.custom]() {
-    return `GasFees { feePerDaGas=${this.feePerDaGas.toBigInt()} feePerL2Gas=${this.feePerL2Gas.toBigInt()} }`;
+    return `GasFees { feePerDaGas=${this.feePerDaGas} feePerL2Gas=${this.feePerL2Gas} }`;
   }
 }

package/src/gas/gas_settings.ts

@@ -60,11 +60,7 @@ export class GasSettings {
   /** Returns the maximum fee to be paid according to gas limits and max fees set. */
   getFeeLimit() {
     return GasDimensions.reduce(
-      (acc, dimension) =>
-        this.maxFeesPerGas
-          .get(dimension)
-          .mul(new Fr(this.gasLimits.get(dimension)))
-          .add(acc),
+      (acc, dimension) => new Fr(this.maxFeesPerGas.get(dimension)).mul(new Fr(this.gasLimits.get(dimension))).add(acc),
       Fr.ZERO,
     );
   }

package/src/interfaces/archiver.ts

@@ -73,5 +73,6 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
   getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
   getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
+  getL1Timestamp: z.function().args().returns(schemas.BigInt),
   syncImmediate: z.function().args().returns(z.void()),
 };

package/src/interfaces/service.ts

@@ -16,7 +16,7 @@ export interface Service {
 }
 
 /** Tries to call stop on a given object and awaits it. Logs any errors and does not rethrow. */
-export async function tryStop(service?: Partial<Service>, logger?: Logger): Promise<void> {
+export async function tryStop(service?: Partial<Pick<Service, 'stop'>>, logger?: Logger): Promise<void> {
   try {
     return typeof service === 'object' && service && 'stop' in service && typeof service.stop === 'function'
       ? await service.stop()
@@ -25,13 +25,3 @@ export async function tryStop(service?: Partial<Service>, logger?: Logger): Prom
     logger?.error(`Error stopping service ${(service as object).constructor?.name}: ${err}`);
   }
 }
-
-export function tryRestart(service?: Partial<Service>, logger?: Logger) {
-  try {
-    return typeof service === 'object' && service && 'restart' in service && typeof service.restart === 'function'
-      ? service.restart()
-      : Promise.resolve();
-  } catch (err) {
-    logger?.error(`Error restarting service ${(service as object).constructor?.name}: ${err}`);
-  }
-}

package/src/kernel/combined_constant_data.ts

@@ -0,0 +1,128 @@
+import { Fr } from '@aztec/foundation/fields';
+import { type ZodFor, hexSchemaFor, schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { z } from 'zod';
+
+import { BlockHeader } from '../tx/block_header.js';
+import { GlobalVariables } from '../tx/global_variables.js';
+import type { TxConstantData } from '../tx/tx_constant_data.js';
+import { TxContext } from '../tx/tx_context.js';
+
+/**
+ * Data that is constant/not modified by neither of the kernels.
+ */
+export class CombinedConstantData {
+  constructor(
+    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
+    public historicalHeader: BlockHeader,
+    /**
+     * Context of the transaction.
+     *
+     * Note: `chainId` and `version` in txContext are not redundant to the values in
+     * self.historical_header.global_variables because they can be different in case of a protocol upgrade. In such
+     * a situation we could be using header from a block before the upgrade took place but be using the updated
+     * protocol to execute and prove the transaction.
+     */
+    public txContext: TxContext,
+    /**
+     * Root of the vk tree for the protocol circuits.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * Root of the tree for the protocol contracts.
+     */
+    public protocolContractTreeRoot: Fr,
+    /** Present when output by a public kernel, empty otherwise. */
+    public globalVariables: GlobalVariables,
+  ) {}
+
+  static combine(TxConstantData: TxConstantData, globalVariables: GlobalVariables) {
+    return new CombinedConstantData(
+      TxConstantData.historicalHeader,
+      TxConstantData.txContext,
+      TxConstantData.vkTreeRoot,
+      TxConstantData.protocolContractTreeRoot,
+      globalVariables,
+    );
+  }
+
+  static get schema(): ZodFor<CombinedConstantData> {
+    return z
+      .object({
+        historicalHeader: BlockHeader.schema,
+        txContext: TxContext.schema,
+        vkTreeRoot: schemas.Fr,
+        protocolContractTreeRoot: schemas.Fr,
+        globalVariables: GlobalVariables.schema,
+      })
+      .transform(CombinedConstantData.from)
+      .or(hexSchemaFor(CombinedConstantData));
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.historicalHeader,
+      this.txContext,
+      this.vkTreeRoot,
+      this.protocolContractTreeRoot,
+      this.globalVariables,
+    );
+  }
+
+  clone(): CombinedConstantData {
+    return CombinedConstantData.fromBuffer(this.toBuffer());
+  }
+
+  getSize() {
+    return (
+      this.historicalHeader.getSize() +
+      this.txContext.getSize() +
+      this.vkTreeRoot.size +
+      this.protocolContractTreeRoot.size +
+      this.globalVariables.getSize()
+    );
+  }
+
+  static from({
+    historicalHeader,
+    txContext,
+    vkTreeRoot,
+    protocolContractTreeRoot,
+    globalVariables,
+  }: FieldsOf<CombinedConstantData>): CombinedConstantData {
+    return new CombinedConstantData(historicalHeader, txContext, vkTreeRoot, protocolContractTreeRoot, globalVariables);
+  }
+
+  /**
+   * Deserializes from a buffer or reader, corresponding to a write in cpp.
+   * @param buffer - Buffer or buffer reader to read from.
+   * @returns A new instance of CombinedConstantData.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader): CombinedConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new CombinedConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readObject(GlobalVariables),
+    );
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): CombinedConstantData {
+    const reader = FieldReader.asReader(fields);
+    return new CombinedConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      reader.readField(),
+      reader.readField(),
+      reader.readObject(GlobalVariables),
+    );
+  }
+
+  static empty() {
+    return new CombinedConstantData(BlockHeader.empty(), TxContext.empty(), Fr.ZERO, Fr.ZERO, GlobalVariables.empty());
+  }
+}

package/src/kernel/index.ts

@@ -1,4 +1,5 @@
 export * from './private_to_rollup_accumulated_data.js';
+export * from './combined_constant_data.js';
 export * from './private_to_rollup_kernel_circuit_public_inputs.js';
 export * from './private_accumulated_data.js';
 export * from './private_call_data.js';

package/src/rollup/base_or_merge_rollup_public_inputs.ts

@@ -6,7 +6,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { RollupTypes } from '../types/shared.js';
-import { BlockConstantData } from './block_constant_data.js';
+import { ConstantRollupData } from './constant_rollup_data.js';
 
 /**
  * Output of the base and merge rollup circuits.
@@ -24,7 +24,7 @@ export class BaseOrMergeRollupPublicInputs {
     /**
      * Data which is forwarded through the rollup circuits unchanged.
      */
-    public constants: BlockConstantData,
+    public constants: ConstantRollupData,
     /**
      * Partial state reference at the start of the rollup circuit.
      */
@@ -61,7 +61,7 @@ export class BaseOrMergeRollupPublicInputs {
     return new BaseOrMergeRollupPublicInputs(
       RollupTypes.Base,
       0,
-      BlockConstantData.empty(),
+      ConstantRollupData.empty(),
       PartialStateReference.empty(),
       PartialStateReference.empty(),
       SpongeBlob.empty(),
@@ -83,7 +83,7 @@ export class BaseOrMergeRollupPublicInputs {
     return new BaseOrMergeRollupPublicInputs(
       reader.readNumber(),
       reader.readNumber(),
-      reader.readObject(BlockConstantData),
+      reader.readObject(ConstantRollupData),
       reader.readObject(PartialStateReference),
       reader.readObject(PartialStateReference),
       reader.readObject(SpongeBlob),

package/src/rollup/base_rollup_hints.ts

@@ -8,9 +8,8 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { PublicDataHint } from '../avm/public_data_hint.js';
 import { ContractClassLogFields } from '../logs/index.js';
-import { AppendOnlyTreeSnapshot } from '../trees/index.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { BlockConstantData } from './block_constant_data.js';
+import { ConstantRollupData } from './constant_rollup_data.js';
 import { PrivateBaseStateDiffHints } from './state_diff_hints.js';
 
 export type BaseRollupHints = PrivateBaseRollupHints | PublicBaseRollupHints;
@@ -44,7 +43,7 @@ export class PrivateBaseRollupHints {
     /**
      * Data which is not modified by the base rollup circuit.
      */
-    public constants: BlockConstantData,
+    public constants: ConstantRollupData,
   ) {}
 
   static from(fields: FieldsOf<PrivateBaseRollupHints>): PrivateBaseRollupHints {
@@ -88,7 +87,7 @@ export class PrivateBaseRollupHints {
       reader.readObject(PublicDataHint),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
-      reader.readObject(BlockConstantData),
+      reader.readObject(ConstantRollupData),
     );
   }
 
@@ -104,7 +103,7 @@ export class PrivateBaseRollupHints {
       PublicDataHint.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
-      BlockConstantData.empty(),
+      ConstantRollupData.empty(),
     );
   }
 }
@@ -115,10 +114,6 @@ export class PublicBaseRollupHints {
      * Sponge state to absorb blob inputs at the start of the rollup.
      */
     public startSpongeBlob: SpongeBlob,
-    /**
-     * Archive tree snapshot at the very beginning of the block containing this base rollup.
-     */
-    public lastArchive: AppendOnlyTreeSnapshot,
     /**
      * Membership witnesses of blocks referred by each of the 2 kernels.
      */
@@ -127,6 +122,10 @@ export class PublicBaseRollupHints {
      * Preimages to the kernel's contractClassLogsHashes.
      */
     public contractClassLogsFields: Tuple<ContractClassLogFields, typeof MAX_CONTRACT_CLASS_LOGS_PER_TX>,
+    /**
+     * Data which is not modified by the base rollup circuit.
+     */
+    public constants: ConstantRollupData,
   ) {}
 
   static from(fields: FieldsOf<PublicBaseRollupHints>): PublicBaseRollupHints {
@@ -136,9 +135,9 @@ export class PublicBaseRollupHints {
   static getFields(fields: FieldsOf<PublicBaseRollupHints>) {
     return [
       fields.startSpongeBlob,
-      fields.lastArchive,
       fields.archiveRootMembershipWitness,
       fields.contractClassLogsFields,
+      fields.constants,
     ] as const;
   }
 
@@ -162,9 +161,9 @@ export class PublicBaseRollupHints {
     const reader = BufferReader.asReader(buffer);
     return new PublicBaseRollupHints(
       reader.readObject(SpongeBlob),
-      reader.readObject(AppendOnlyTreeSnapshot),
       MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
+      reader.readObject(ConstantRollupData),
     );
   }
 
@@ -175,9 +174,9 @@ export class PublicBaseRollupHints {
   static empty() {
     return new PublicBaseRollupHints(
       SpongeBlob.empty(),
-      AppendOnlyTreeSnapshot.empty(),
       MembershipWitness.empty(ARCHIVE_HEIGHT),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
+      ConstantRollupData.empty(),
     );
   }
 }

package/src/rollup/block_root_or_block_merge_public_inputs.ts

@@ -9,17 +9,12 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { GlobalVariables } from '../tx/global_variables.js';
-import { EpochConstantData } from './epoch_constant_data.js';
 
 /**
  * Output of the block root and block merge rollup circuits.
  */
 export class BlockRootOrBlockMergePublicInputs {
   constructor(
-    /**
-     * Constants for the entire epoch.
-     */
-    public constants: EpochConstantData,
     /**
      * Archive tree immediately before this block range.
      */
@@ -49,6 +44,18 @@ export class BlockRootOrBlockMergePublicInputs {
      * The summed `transaction_fee`s and recipients of the constituent blocks.
      */
     public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    /**
+     * Root of the verification key tree.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * Root of the protocol contract tree.
+     */
+    public protocolContractTreeRoot: Fr,
+    /**
+     * TODO(#7346): Temporarily added prover_id while we verify block-root proofs on L1
+     */
+    public proverId: Fr,
     /**
      * Public inputs required to verify a blob (challenge point z, evaluation y = p(z), and the commitment to p() for each blob)
      */
@@ -63,7 +70,6 @@ export class BlockRootOrBlockMergePublicInputs {
   static fromBuffer(buffer: Buffer | BufferReader): BlockRootOrBlockMergePublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootOrBlockMergePublicInputs(
-      reader.readObject(EpochConstantData),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(GlobalVariables),
@@ -71,6 +77,9 @@ export class BlockRootOrBlockMergePublicInputs {
       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),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, BlockBlobPublicInputs),
     );
   }
@@ -81,7 +90,6 @@ export class BlockRootOrBlockMergePublicInputs {
    */
   toBuffer() {
     return serializeToBuffer(
-      this.constants,
       this.previousArchive,
       this.newArchive,
       this.startGlobalVariables,
@@ -89,6 +97,9 @@ export class BlockRootOrBlockMergePublicInputs {
       this.outHash,
       this.proposedBlockHeaderHashes,
       this.fees,
+      this.vkTreeRoot,
+      this.protocolContractTreeRoot,
+      this.proverId,
       this.blobPublicInputs,
     );
   }

package/src/rollup/block_root_rollup.ts

@@ -38,7 +38,7 @@ export class BlockRootRollupData {
      */
     public previousBlockHeader: BlockHeader,
     /**
-     * Identifier of the prover.
+     * TODO(#7346): Temporarily added prover_id while we verify block-root proofs on L1
      */
     public proverId: Fr,
   ) {}

package/src/rollup/constant_rollup_data.ts

@@ -0,0 +1,54 @@
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { GlobalVariables } from '../tx/global_variables.js';
+
+/**
+ * Data which is forwarded through the base rollup circuits unchanged.
+ */
+export class ConstantRollupData {
+  constructor(
+    /** Archive tree snapshot at the very beginning of the entire rollup. */
+    public lastArchive: AppendOnlyTreeSnapshot,
+    /**
+     * Root of the verification key tree.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * Root of the protocol contract tree.
+     */
+    public protocolContractTreeRoot: Fr,
+    /**
+     * Global variables for the block
+     */
+    public globalVariables: GlobalVariables,
+  ) {}
+
+  static from(fields: FieldsOf<ConstantRollupData>): ConstantRollupData {
+    return new ConstantRollupData(...ConstantRollupData.getFields(fields));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ConstantRollupData {
+    const reader = BufferReader.asReader(buffer);
+    return new ConstantRollupData(
+      reader.readObject(AppendOnlyTreeSnapshot),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      reader.readObject(GlobalVariables),
+    );
+  }
+
+  static getFields(fields: FieldsOf<ConstantRollupData>) {
+    return [fields.lastArchive, fields.vkTreeRoot, fields.protocolContractTreeRoot, fields.globalVariables] as const;
+  }
+
+  static empty() {
+    return new ConstantRollupData(AppendOnlyTreeSnapshot.zero(), Fr.ZERO, Fr.ZERO, GlobalVariables.empty());
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...ConstantRollupData.getFields(this));
+  }
+}

package/src/rollup/empty_block_root_rollup_inputs.ts

@@ -3,8 +3,8 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { BlockConstantData } from './block_constant_data.js';
 import { BlockRootRollupData } from './block_root_rollup.js';
+import { ConstantRollupData } from './constant_rollup_data.js';
 
 /**
  * Represents inputs of the empty block root rollup circuit.
@@ -12,7 +12,7 @@ import { BlockRootRollupData } from './block_root_rollup.js';
 export class EmptyBlockRootRollupInputs {
   constructor(
     public readonly data: BlockRootRollupData,
-    public readonly constants: BlockConstantData,
+    public readonly constants: ConstantRollupData,
     public readonly isPadding: boolean,
   ) {}
 
@@ -59,7 +59,7 @@ export class EmptyBlockRootRollupInputs {
     const reader = BufferReader.asReader(buffer);
     return new EmptyBlockRootRollupInputs(
       reader.readObject(BlockRootRollupData),
-      reader.readObject(BlockConstantData),
+      reader.readObject(ConstantRollupData),
       reader.readBoolean(),
     );
   }

package/src/rollup/index.ts

@@ -1,11 +1,10 @@
 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 './constant_rollup_data.js';
 export * from './empty_block_root_rollup_inputs.js';
-export * from './epoch_constant_data.js';
 export * from './block_root_rollup.js';
 export * from './merge_rollup.js';
 export * from './previous_rollup_block_data.js';

package/src/rollup/root_rollup.ts

@@ -21,6 +21,8 @@ export class RootRollupInputs {
      * from 2 block merge circuits.
      */
     public previousRollupData: [PreviousRollupBlockData, PreviousRollupBlockData],
+    /** Identifier of the prover for this root rollup. */
+    public proverId: Fr,
   ) {}
 
   /**
@@ -54,7 +56,7 @@ export class RootRollupInputs {
    * @returns An array of fields.
    */
   static getFields(fields: FieldsOf<RootRollupInputs>) {
-    return [fields.previousRollupData] as const;
+    return [fields.previousRollupData, fields.proverId] as const;
   }
 
   /**
@@ -64,10 +66,10 @@ export class RootRollupInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader): RootRollupInputs {
     const reader = BufferReader.asReader(buffer);
-    return new RootRollupInputs([
-      reader.readObject(PreviousRollupBlockData),
-      reader.readObject(PreviousRollupBlockData),
-    ]);
+    return new RootRollupInputs(
+      [reader.readObject(PreviousRollupBlockData), reader.readObject(PreviousRollupBlockData)],
+      Fr.fromBuffer(reader),
+    );
   }
 
   /**