@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/rollup/checkpoint_constant_data.ts

@@ -0,0 +1,124 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { inspect } from 'util';
+
+import { AztecAddress } from '../aztec-address/index.js';
+import { GasFees } from '../gas/gas_fees.js';
+
+/**
+ * Constants that are the same for the entire checkpoint.
+ * Used in circuits during rollup proving.
+ */
+export class CheckpointConstantData {
+  constructor(
+    /** ChainId of the rollup. */
+    public chainId: Fr,
+    /** Version of the rollup. */
+    public version: Fr,
+    /** Root of the verification key tree. */
+    public vkTreeRoot: Fr,
+    /** Hash of the protocol contracts list. */
+    public protocolContractsHash: Fr,
+    /** Identifier of the prover. */
+    public proverId: Fr,
+    /** Slot number of the checkpoint. */
+    public slotNumber: SlotNumber,
+    /** Coinbase address of the rollup. */
+    public coinbase: EthAddress,
+    /** Address to receive fees. */
+    public feeRecipient: AztecAddress,
+    /** Global gas fees for this checkpoint. */
+    public gasFees: GasFees,
+  ) {}
+
+  static from(fields: FieldsOf<CheckpointConstantData>) {
+    return new CheckpointConstantData(...CheckpointConstantData.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<CheckpointConstantData>) {
+    return [
+      fields.chainId,
+      fields.version,
+      fields.vkTreeRoot,
+      fields.protocolContractsHash,
+      fields.proverId,
+      fields.slotNumber,
+      fields.coinbase,
+      fields.feeRecipient,
+      fields.gasFees,
+    ] as const;
+  }
+
+  static empty() {
+    return new CheckpointConstantData(
+      Fr.ZERO,
+      Fr.ZERO,
+      Fr.ZERO,
+      Fr.ZERO,
+      Fr.ZERO,
+      SlotNumber.ZERO,
+      EthAddress.ZERO,
+      AztecAddress.ZERO,
+      GasFees.empty(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.chainId,
+      this.version,
+      this.vkTreeRoot,
+      this.protocolContractsHash,
+      this.proverId,
+      new Fr(this.slotNumber),
+      this.coinbase,
+      this.feeRecipient,
+      this.gasFees,
+    );
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CheckpointConstantData(
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      SlotNumber(Fr.fromBuffer(reader).toNumber()),
+      reader.readObject(EthAddress),
+      reader.readObject(AztecAddress),
+      reader.readObject(GasFees),
+    );
+  }
+
+  /**
+   * Returns the slot number as a SlotNumber branded type.
+   * @deprecated Use slotNumber directly instead.
+   */
+  getSlotNumber(): SlotNumber {
+    return this.slotNumber;
+  }
+
+  toInspect() {
+    return {
+      chainId: this.chainId.toNumber(),
+      version: this.version.toNumber(),
+      vkTreeRoot: this.vkTreeRoot.toString(),
+      protocolContractsHash: this.protocolContractsHash.toString(),
+      proverId: this.proverId.toString(),
+      slotNumber: this.slotNumber,
+      coinbase: this.coinbase.toString(),
+      feeRecipient: this.feeRecipient.toString(),
+      gasFees: this.gasFees.toInspect(),
+    };
+  }
+
+  [inspect.custom]() {
+    return `CheckpointConstantData ${inspect(this.toInspect())}`;
+  }
+}

package/src/{tx/proposed_block_header.ts → rollup/checkpoint_header.ts}

@@ -1,7 +1,8 @@
-import type { ViemHeader } from '@aztec/ethereum';
-import { sha256ToField } from '@aztec/foundation/crypto';
+import type { ViemHeader } from '@aztec/ethereum/contracts';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { sha256ToField } from '@aztec/foundation/crypto/sha256';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
 import type { ZodFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -13,18 +14,23 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 import { GasFees } from '../gas/index.js';
 import { schemas } from '../schemas/index.js';
+import { ContentCommitment } from '../tx/content_commitment.js';
 import type { UInt64 } from '../types/shared.js';
-import { ContentCommitment } from './content_commitment.js';
 
-/** The proposed values of an L2 block. */
-export class ProposedBlockHeader {
+/**
+ * Header of a checkpoint. A checkpoint is a collection of blocks submitted to L1 all within the same slot.
+ * TODO(palla/mbps): Should this include chainId and version as well? Is this used just in circuits?
+ */
+export class CheckpointHeader {
   constructor(
     /** Root of the archive tree before this block is added. */
     public lastArchiveRoot: Fr,
+    /** Hash of the headers of all blocks in this checkpoint. */
+    public blockHeadersHash: Fr,
     /** Content commitment of the L2 block. */
     public contentCommitment: ContentCommitment,
     /** Slot number of the L2 block */
-    public slotNumber: Fr,
+    public slotNumber: SlotNumber,
     /** Timestamp of the L2 block. */
     public timestamp: UInt64,
     /** Recipient of block reward. */
@@ -37,24 +43,26 @@ export class ProposedBlockHeader {
     public totalManaUsed: Fr,
   ) {}
 
-  static get schema(): ZodFor<ProposedBlockHeader> {
+  static get schema(): ZodFor<CheckpointHeader> {
     return z
       .object({
         lastArchiveRoot: schemas.Fr,
+        blockHeadersHash: schemas.Fr,
         contentCommitment: ContentCommitment.schema,
-        slotNumber: schemas.Fr,
+        slotNumber: schemas.SlotNumber,
         timestamp: schemas.BigInt,
         coinbase: schemas.EthAddress,
         feeRecipient: schemas.AztecAddress,
         gasFees: GasFees.schema,
         totalManaUsed: schemas.Fr,
       })
-      .transform(ProposedBlockHeader.from);
+      .transform(CheckpointHeader.from);
   }
 
-  static getFields(fields: FieldsOf<ProposedBlockHeader>) {
+  static getFields(fields: FieldsOf<CheckpointHeader>) {
     return [
       fields.lastArchiveRoot,
+      fields.blockHeadersHash,
       fields.contentCommitment,
       fields.slotNumber,
       fields.timestamp,
@@ -65,17 +73,18 @@ export class ProposedBlockHeader {
     ] as const;
   }
 
-  static from(fields: FieldsOf<ProposedBlockHeader>) {
-    return new ProposedBlockHeader(...ProposedBlockHeader.getFields(fields));
+  static from(fields: FieldsOf<CheckpointHeader>) {
+    return new CheckpointHeader(...CheckpointHeader.getFields(fields));
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader): ProposedBlockHeader {
+  static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
 
-    return new ProposedBlockHeader(
+    return new CheckpointHeader(
+      reader.readObject(Fr),
       reader.readObject(Fr),
       reader.readObject(ContentCommitment),
-      Fr.fromBuffer(reader),
+      SlotNumber(Fr.fromBuffer(reader).toNumber()),
       reader.readUInt64(),
       reader.readObject(EthAddress),
       reader.readObject(AztecAddress),
@@ -84,12 +93,27 @@ export class ProposedBlockHeader {
     );
   }
 
+  equals(other: CheckpointHeader) {
+    return (
+      this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
+      this.blockHeadersHash.equals(other.blockHeadersHash) &&
+      this.contentCommitment.equals(other.contentCommitment) &&
+      this.slotNumber === other.slotNumber &&
+      this.timestamp === other.timestamp &&
+      this.coinbase.equals(other.coinbase) &&
+      this.feeRecipient.equals(other.feeRecipient) &&
+      this.gasFees.equals(other.gasFees) &&
+      this.totalManaUsed.equals(other.totalManaUsed)
+    );
+  }
+
   toBuffer() {
     // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return serializeToBuffer([
       this.lastArchiveRoot,
+      this.blockHeadersHash,
       this.contentCommitment,
-      this.slotNumber,
+      new Fr(this.slotNumber),
       bigintToUInt64BE(this.timestamp),
       this.coinbase,
       this.feeRecipient,
@@ -102,11 +126,12 @@ export class ProposedBlockHeader {
     return sha256ToField([this.toBuffer()]);
   }
 
-  static empty(fields: Partial<FieldsOf<ProposedBlockHeader>> = {}): ProposedBlockHeader {
-    return ProposedBlockHeader.from({
+  static empty(fields: Partial<FieldsOf<CheckpointHeader>> = {}) {
+    return CheckpointHeader.from({
       lastArchiveRoot: Fr.ZERO,
+      blockHeadersHash: Fr.ZERO,
       contentCommitment: ContentCommitment.empty(),
-      slotNumber: Fr.ZERO,
+      slotNumber: SlotNumber.ZERO,
       timestamp: 0n,
       coinbase: EthAddress.ZERO,
       feeRecipient: AztecAddress.ZERO,
@@ -116,11 +141,29 @@ export class ProposedBlockHeader {
     });
   }
 
+  static random(
+    overrides: Partial<FieldsOf<CheckpointHeader>> & Partial<FieldsOf<ContentCommitment>> = {},
+  ): CheckpointHeader {
+    return CheckpointHeader.from({
+      lastArchiveRoot: Fr.random(),
+      blockHeadersHash: Fr.random(),
+      contentCommitment: ContentCommitment.random(overrides),
+      slotNumber: SlotNumber(Math.floor(Math.random() * 1000) + 1),
+      timestamp: BigInt(Math.floor(Date.now() / 1000)),
+      coinbase: EthAddress.random(),
+      feeRecipient: new AztecAddress(Fr.random()),
+      gasFees: GasFees.random(),
+      totalManaUsed: new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+      ...overrides,
+    });
+  }
+
   isEmpty(): boolean {
     return (
       this.lastArchiveRoot.isZero() &&
+      this.blockHeadersHash.isZero() &&
       this.contentCommitment.isEmpty() &&
-      this.slotNumber.isZero() &&
+      this.slotNumber === 0 &&
       this.timestamp === 0n &&
       this.coinbase.isZero() &&
       this.feeRecipient.isZero() &&
@@ -137,15 +180,16 @@ export class ProposedBlockHeader {
     return bufferToHex(this.toBuffer());
   }
 
-  static fromString(str: string): ProposedBlockHeader {
-    return ProposedBlockHeader.fromBuffer(hexToBuffer(str));
+  static fromString(str: string) {
+    return CheckpointHeader.fromBuffer(hexToBuffer(str));
   }
 
   static fromViem(header: ViemHeader) {
-    return new ProposedBlockHeader(
+    return new CheckpointHeader(
       Fr.fromString(header.lastArchiveRoot),
+      Fr.fromString(header.blockHeadersHash),
       ContentCommitment.fromViem(header.contentCommitment),
-      new Fr(header.slotNumber),
+      SlotNumber.fromBigInt(header.slotNumber),
       header.timestamp,
       new EthAddress(hexToBuffer(header.coinbase)),
       new AztecAddress(hexToBuffer(header.feeRecipient)),
@@ -154,11 +198,20 @@ export class ProposedBlockHeader {
     );
   }
 
+  /**
+   * Returns the slot number as a SlotNumber branded type.
+   * @deprecated Use slotNumber directly instead.
+   */
+  getSlotNumber(): SlotNumber {
+    return this.slotNumber;
+  }
+
   toViem(): ViemHeader {
     return {
       lastArchiveRoot: this.lastArchiveRoot.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
       contentCommitment: this.contentCommitment.toViem(),
-      slotNumber: this.slotNumber.toBigInt(),
+      slotNumber: BigInt(this.slotNumber),
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: `0x${this.feeRecipient.toBuffer().toString('hex').padStart(64, '0')}`,
@@ -173,8 +226,9 @@ export class ProposedBlockHeader {
   toInspect() {
     return {
       lastArchive: this.lastArchiveRoot.toString(),
+      blockHeadersHash: this.blockHeadersHash.toString(),
       contentCommitment: this.contentCommitment.toInspect(),
-      slotNumber: this.slotNumber.toBigInt(),
+      slotNumber: this.slotNumber,
       timestamp: this.timestamp,
       coinbase: this.coinbase.toString(),
       feeRecipient: this.feeRecipient.toString(),
@@ -187,8 +241,9 @@ export class ProposedBlockHeader {
     const gasfees = `da:${this.gasFees.feePerDaGas}, l2:${this.gasFees.feePerL2Gas}`;
     return `Header {
   lastArchiveRoot: ${this.lastArchiveRoot.toString()},
+  blockHeadersHash: ${this.blockHeadersHash.toString()},
   contentCommitment: ${inspect(this.contentCommitment)},
-  slotNumber: ${this.slotNumber.toBigInt()},
+  slotNumber: ${this.slotNumber},
   timestamp: ${this.timestamp},
   coinbase: ${this.coinbase.toString()},
   feeRecipient: ${this.feeRecipient.toString()},

package/src/rollup/checkpoint_merge_rollup_private_inputs.ts

@@ -0,0 +1,49 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+import { CheckpointRollupPublicInputs } from './checkpoint_rollup_public_inputs.js';
+
+/**
+ * Represents inputs of the checkpoint merge rollup circuit.
+ */
+export class CheckpointMergeRollupPrivateInputs {
+  constructor(
+    /**
+     * Previous rollup data from the 2 checkpoint root or merge rollup circuits that preceded this checkpoint merge rollup circuit.
+     */
+    public previousRollups: [
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+      RollupHonkProofData<CheckpointRollupPublicInputs>,
+    ],
+  ) {}
+
+  toBuffer() {
+    return serializeToBuffer(this.previousRollups);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new CheckpointMergeRollupPrivateInputs([
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+      ProofData.fromBuffer(reader, CheckpointRollupPublicInputs),
+    ]);
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return CheckpointMergeRollupPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(CheckpointMergeRollupPrivateInputs);
+  }
+}

package/src/rollup/{block_root_or_block_merge_public_inputs.ts → checkpoint_rollup_public_inputs.ts}

@@ -1,113 +1,87 @@
-import { BlockBlobPublicInputs } from '@aztec/blob-lib';
+import { BlobAccumulator, FinalBlobBatchingChallenges } from '@aztec/blob-lib/types';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-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 { 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.
+ * Output of the checkpoint root and checkpoint merge rollup circuits.
  */
-export class BlockRootOrBlockMergePublicInputs {
+export class CheckpointRollupPublicInputs {
   constructor(
     /**
      * Constants for the entire epoch.
      */
     public constants: EpochConstantData,
     /**
-     * Archive tree immediately before this block range.
+     * Archive tree immediately before this checkpoint range.
      */
     public previousArchive: AppendOnlyTreeSnapshot,
     /**
-     * Archive tree after adding this block range.
+     * Archive tree after adding this checkpoint range.
      */
     public newArchive: AppendOnlyTreeSnapshot,
     /**
-     * Global variables for the first block in the range.
+     * The hashes of the headers of the constituent checkpoints.
      */
-    public startGlobalVariables: GlobalVariables,
+    public checkpointHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
     /**
-     * Global variables for the last block in the range.
+     * The summed transaction fees and recipients of the constituent checkpoints.
      */
-    public endGlobalVariables: GlobalVariables,
-    /**
-     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
-     * Note: Truncated to 31 bytes to fit in Fr.
-     */
-    public outHash: Fr,
+    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
     /**
-     * The hashes of the proposed block headers of the constituent blocks.
+     * Accumulated opening proofs for all blobs before this checkpoint range.
      */
-    public proposedBlockHeaderHashes: Tuple<Fr, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public startBlobAccumulator: BlobAccumulator,
     /**
-     * The summed `transaction_fee`s and recipients of the constituent blocks.
+     * Accumulated opening proofs for all blobs after applying this checkpoint range.
      */
-    public fees: Tuple<FeeRecipient, typeof AZTEC_MAX_EPOCH_DURATION>,
+    public endBlobAccumulator: BlobAccumulator,
     /**
-     * Public inputs required to verify a batch of blobs.
+     * Final values z and gamma, shared across the epoch.
      */
-    public blobPublicInputs: BlockBlobPublicInputs,
+    public finalBlobChallenges: FinalBlobBatchingChallenges,
   ) {}
 
-  /**
-   * Deserializes from a buffer or reader.
-   * @param buffer - Buffer or reader to read from.
-   * @returns The deserialized public inputs.
-   */
-  static fromBuffer(buffer: Buffer | BufferReader): BlockRootOrBlockMergePublicInputs {
+  static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new BlockRootOrBlockMergePublicInputs(
+    return new CheckpointRollupPublicInputs(
       reader.readObject(EpochConstantData),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(GlobalVariables),
-      reader.readObject(GlobalVariables),
-      Fr.fromBuffer(reader),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, Fr),
       reader.readArray(AZTEC_MAX_EPOCH_DURATION, FeeRecipient),
-      reader.readObject(BlockBlobPublicInputs),
+      reader.readObject(BlobAccumulator),
+      reader.readObject(BlobAccumulator),
+      reader.readObject(FinalBlobBatchingChallenges),
     );
   }
 
-  /**
-   * Serialize this as a buffer.
-   * @returns The buffer.
-   */
   toBuffer() {
     return serializeToBuffer(
       this.constants,
       this.previousArchive,
       this.newArchive,
-      this.startGlobalVariables,
-      this.endGlobalVariables,
-      this.outHash,
-      this.proposedBlockHeaderHashes,
+      this.checkpointHeaderHashes,
       this.fees,
-      this.blobPublicInputs,
+      this.startBlobAccumulator,
+      this.endBlobAccumulator,
+      this.finalBlobChallenges,
     );
   }
 
-  /**
-   * Serialize this as a hex string.
-   * @returns - The hex string.
-   */
   toString() {
     return bufferToHex(this.toBuffer());
   }
 
-  /**
-   * Deserializes from a hex string.
-   * @param str - A hex string to deserialize from.
-   * @returns A new BaseOrMergeRollupPublicInputs instance.
-   */
   static fromString(str: string) {
-    return BlockRootOrBlockMergePublicInputs.fromBuffer(hexToBuffer(str));
+    return CheckpointRollupPublicInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -117,7 +91,7 @@ export class BlockRootOrBlockMergePublicInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BlockRootOrBlockMergePublicInputs);
+    return bufferSchemaFor(CheckpointRollupPublicInputs);
   }
 }
 
@@ -144,6 +118,10 @@ export class FeeRecipient {
     return serializeToFields(...FeeRecipient.getFields(this));
   }
 
+  static empty() {
+    return new FeeRecipient(EthAddress.ZERO, Fr.ZERO);
+  }
+
   isEmpty() {
     return this.value.isZero() && this.recipient.isZero();
   }