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

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

@@ -13,11 +13,10 @@ 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 {
+export class CheckpointHeader {
   constructor(
     /** Root of the archive tree before this block is added. */
     public lastArchiveRoot: Fr,
@@ -37,7 +36,7 @@ export class ProposedBlockHeader {
     public totalManaUsed: Fr,
   ) {}
 
-  static get schema(): ZodFor<ProposedBlockHeader> {
+  static get schema(): ZodFor<CheckpointHeader> {
     return z
       .object({
         lastArchiveRoot: schemas.Fr,
@@ -49,10 +48,10 @@ export class ProposedBlockHeader {
         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.contentCommitment,
@@ -65,14 +64,14 @@ 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(ContentCommitment),
       Fr.fromBuffer(reader),
@@ -102,8 +101,8 @@ 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,
       contentCommitment: ContentCommitment.empty(),
       slotNumber: Fr.ZERO,
@@ -116,8 +115,8 @@ export class ProposedBlockHeader {
     });
   }
 
-  static random(): ProposedBlockHeader {
-    return new ProposedBlockHeader(
+  static random(): CheckpointHeader {
+    return new CheckpointHeader(
       Fr.random(),
       ContentCommitment.random(),
       new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)),
@@ -150,12 +149,12 @@ 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),
       ContentCommitment.fromViem(header.contentCommitment),
       new Fr(header.slotNumber),

package/src/rollup/checkpoint_merge_rollup.ts

@@ -0,0 +1,50 @@
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { ProofData } from '../proofs/proof_data.js';
+import { CheckpointRollupPublicInputs } from './checkpoint_rollup_public_inputs.js';
+import type { RollupProofData } from './rollup_proof_data.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: [
+      RollupProofData<CheckpointRollupPublicInputs>,
+      RollupProofData<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,4 +1,4 @@
-import { BlockBlobPublicInputs } from '@aztec/blob-lib';
+import { BlobAccumulatorPublicInputs, FinalBlobBatchingChallenges } from '@aztec/blob-lib';
 import { AZTEC_MAX_EPOCH_DURATION } from '@aztec/constants';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -8,106 +8,80 @@ 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 onchain).
-     * 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: BlobAccumulatorPublicInputs,
     /**
-     * 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: BlobAccumulatorPublicInputs,
     /**
-     * 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(BlobAccumulatorPublicInputs),
+      reader.readObject(BlobAccumulatorPublicInputs),
+      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);
   }
 }
 

package/src/rollup/checkpoint_root_rollup.ts

@@ -0,0 +1,216 @@
+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 } from '../proofs/proof_data.js';
+import { BlockHeader } from '../tx/block_header.js';
+import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
+import type { RollupProofData } from './rollup_proof_data.js';
+
+export class CheckpointRootRollupHints {
+  constructor(
+    /**
+     * 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: [RollupProofData<BlockRollupPublicInputs>, RollupProofData<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: RollupProofData<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

@@ -3,16 +3,19 @@ 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 './epoch_constant_data.js';
+export * from './block_rollup_public_inputs.js';
 export * from './block_root_rollup.js';
+export * from './checkpoint_constant_data.js';
+export * from './checkpoint_header.js';
+export * from './checkpoint_merge_rollup.js';
+export * from './checkpoint_rollup_public_inputs.js';
+export * from './checkpoint_root_rollup.js';
+export * from './epoch_constant_data.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 './rollup_proof_data.js';
 export * from './public_tube_private_inputs.js';
 export * from './root_rollup.js';
 export * from './state_diff_hints.js';

package/src/rollup/rollup_proof_data.ts

@@ -0,0 +1,12 @@
+import { NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import type { Bufferable } from '@aztec/foundation/serialize';
+
+import type { ParityPublicInputs } from '../parity/index.js';
+import { ProofData } from '../proofs/index.js';
+
+/**
+ * Represents the data of a nested recursive rollup proof.
+ */
+export type RollupProofData<T extends Bufferable> = ProofData<T, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;
+
+export type RootParityProofData = ProofData<ParityPublicInputs, typeof NESTED_RECURSIVE_PROOF_LENGTH>;