@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/src/rollup/block_rollup_public_inputs.ts

@@ -0,0 +1,123 @@
+import { SpongeBlob } from '@aztec/blob-lib/types';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { StateReference } from '../tx/state_reference.js';
+import type { UInt64 } from '../types/shared.js';
+import { CheckpointConstantData } from './checkpoint_constant_data.js';
+
+/**
+ * Output of the block root and block merge rollup circuits.
+ */
+export class BlockRollupPublicInputs {
+  constructor(
+    /**
+     * Constants for the entire checkpoint.
+     */
+    public constants: CheckpointConstantData,
+    /**
+     * Archive tree immediately before this block range.
+     */
+    public previousArchive: AppendOnlyTreeSnapshot,
+    /**
+     * Archive tree after applying this block range.
+     */
+    public newArchive: AppendOnlyTreeSnapshot,
+    /**
+     * State reference immediately before this block range.
+     */
+    public startState: StateReference,
+    /**
+     * State reference after applying this block range.
+     */
+    public endState: StateReference,
+    /**
+     * Sponge state to absorb blob inputs at the start of this block range.
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * Sponge state to absorb blob inputs at the end of this block range.
+     */
+    public endSpongeBlob: SpongeBlob,
+    /**
+     * Timestamp of the first block in this block range.
+     */
+    public startTimestamp: UInt64,
+    /**
+     * Timestamp of the last block in this block range.
+     */
+    public endTimestamp: UInt64,
+    /**
+     * SHA256 hash of l1 to l2 messages.
+     */
+    public inHash: Fr,
+    /**
+     * SHA256 hash of L2 to L1 messages created in this block range.
+     */
+    public outHash: Fr,
+    /**
+     * The summed transaction fees of all the txs in this block range.
+     */
+    public accumulatedFees: Fr,
+    /**
+     * The summed mana used of all the txs in this block range.
+     */
+    public accumulatedManaUsed: Fr,
+  ) {}
+
+  static fromBuffer(buffer: Buffer | BufferReader): BlockRollupPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRollupPublicInputs(
+      reader.readObject(CheckpointConstantData),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(AppendOnlyTreeSnapshot),
+      reader.readObject(StateReference),
+      reader.readObject(StateReference),
+      reader.readObject(SpongeBlob),
+      reader.readObject(SpongeBlob),
+      reader.readUInt64(),
+      reader.readUInt64(),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(
+      this.constants,
+      this.previousArchive,
+      this.newArchive,
+      this.startState,
+      this.endState,
+      this.startSpongeBlob,
+      this.endSpongeBlob,
+      bigintToUInt64BE(this.startTimestamp),
+      bigintToUInt64BE(this.endTimestamp),
+      this.inHash,
+      this.outHash,
+      this.accumulatedFees,
+      this.accumulatedManaUsed,
+    );
+  }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  static fromString(str: string) {
+    return BlockRollupPublicInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRollupPublicInputs);
+  }
+}

package/src/rollup/block_root_rollup_private_inputs.ts

@@ -0,0 +1,312 @@
+import { SpongeBlob } from '@aztec/blob-lib/types';
+import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, type Tuple, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { ParityPublicInputs } from '../parity/parity_public_inputs.js';
+import { ProofData, type RollupHonkProofData, type UltraHonkProofData } from '../proofs/proof_data.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { StateReference } from '../tx/state_reference.js';
+import type { UInt64 } from '../types/shared.js';
+import { CheckpointConstantData } from './checkpoint_constant_data.js';
+import { TxRollupPublicInputs } from './tx_rollup_public_inputs.js';
+
+export class BlockRootFirstRollupPrivateInputs {
+  constructor(
+    /**
+     * The original and converted roots of the L1 to L2 messages subtrees.
+     */
+    public l1ToL2Roots: UltraHonkProofData<ParityPublicInputs>,
+    /**
+     * The previous rollup proof data from base or merge rollup circuits.
+     */
+    public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
+    /**
+     * The l1 to l2 message tree snapshot immediately before this block.
+     */
+    public previousL1ToL2: AppendOnlyTreeSnapshot,
+    /**
+     * Hint for inserting the new l1 to l2 message subtree root into `previousL1ToL2`.
+     */
+    public newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
+    /**
+     * Hint for inserting the new block hash to the last archive.
+     */
+    public newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+  ) {}
+
+  static from(fields: FieldsOf<BlockRootFirstRollupPrivateInputs>) {
+    return new BlockRootFirstRollupPrivateInputs(...BlockRootFirstRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<BlockRootFirstRollupPrivateInputs>) {
+    return [
+      fields.l1ToL2Roots,
+      fields.previousRollups,
+      fields.previousL1ToL2,
+      fields.newL1ToL2MessageSubtreeRootSiblingPath,
+      fields.newArchiveSiblingPath,
+    ] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlockRootFirstRollupPrivateInputs.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRootFirstRollupPrivateInputs(
+      ProofData.fromBuffer(reader, ParityPublicInputs),
+      [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
+      AppendOnlyTreeSnapshot.fromBuffer(reader),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
+    );
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRootFirstRollupPrivateInputs);
+  }
+}
+
+export class BlockRootSingleTxFirstRollupPrivateInputs {
+  constructor(
+    /**
+     * The original and converted roots of the L1 to L2 messages subtrees.
+     */
+    public l1ToL2Roots: UltraHonkProofData<ParityPublicInputs>,
+    /**
+     * The previous rollup proof data from base or merge rollup circuits.
+     */
+    public previousRollup: RollupHonkProofData<TxRollupPublicInputs>,
+    /**
+     * The l1 to l2 message tree snapshot immediately before this block.
+     */
+    public previousL1ToL2: AppendOnlyTreeSnapshot,
+    /**
+     * Hint for inserting the new l1 to l2 message subtree root.
+     */
+    public newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
+    /**
+     * Hint for inserting the new block hash to the last archive.
+     */
+    public newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+  ) {}
+
+  static from(fields: FieldsOf<BlockRootSingleTxFirstRollupPrivateInputs>) {
+    return new BlockRootSingleTxFirstRollupPrivateInputs(
+      ...BlockRootSingleTxFirstRollupPrivateInputs.getFields(fields),
+    );
+  }
+
+  static getFields(fields: FieldsOf<BlockRootSingleTxFirstRollupPrivateInputs>) {
+    return [
+      fields.l1ToL2Roots,
+      fields.previousRollup,
+      fields.previousL1ToL2,
+      fields.newL1ToL2MessageSubtreeRootSiblingPath,
+      fields.newArchiveSiblingPath,
+    ] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlockRootSingleTxFirstRollupPrivateInputs.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRootSingleTxFirstRollupPrivateInputs(
+      ProofData.fromBuffer(reader, ParityPublicInputs),
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+      AppendOnlyTreeSnapshot.fromBuffer(reader),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
+    );
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRootSingleTxFirstRollupPrivateInputs);
+  }
+}
+
+export class BlockRootEmptyTxFirstRollupPrivateInputs {
+  constructor(
+    /**
+     * The original and converted roots of the L1 to L2 messages subtrees.
+     */
+    public l1ToL2Roots: UltraHonkProofData<ParityPublicInputs>,
+    /**
+     * The archive after applying the previous block.
+     */
+    public previousArchive: AppendOnlyTreeSnapshot,
+    /**
+     * The state reference of the previous block.
+     */
+    public previousState: StateReference,
+    /**
+     * The constants of the checkpoint.
+     */
+    public constants: CheckpointConstantData,
+    /**
+     * The start sponge blob of this block. No data has been absorbed into it yet, since it's the first block. But the
+     * number of expected fields must be set to the total number of fields in the entire checkpoint.
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * The timestamp of this block.
+     */
+    public timestamp: UInt64,
+    /**
+     * Hint for inserting the new l1 to l2 message subtree root.
+     */
+    public newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
+    /**
+     * Hint for inserting the new block hash to the last archive.
+     */
+    public newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+  ) {}
+
+  static from(fields: FieldsOf<BlockRootEmptyTxFirstRollupPrivateInputs>) {
+    return new BlockRootEmptyTxFirstRollupPrivateInputs(...BlockRootEmptyTxFirstRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<BlockRootEmptyTxFirstRollupPrivateInputs>) {
+    return [
+      fields.l1ToL2Roots,
+      fields.previousArchive,
+      fields.previousState,
+      fields.constants,
+      fields.startSpongeBlob,
+      fields.timestamp,
+      fields.newL1ToL2MessageSubtreeRootSiblingPath,
+      fields.newArchiveSiblingPath,
+    ] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer([
+      this.l1ToL2Roots,
+      this.previousArchive,
+      this.previousState,
+      this.constants,
+      this.startSpongeBlob,
+      bigintToUInt64BE(this.timestamp),
+      this.newL1ToL2MessageSubtreeRootSiblingPath,
+      this.newArchiveSiblingPath,
+    ]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRootEmptyTxFirstRollupPrivateInputs(
+      ProofData.fromBuffer(reader, ParityPublicInputs),
+      AppendOnlyTreeSnapshot.fromBuffer(reader),
+      StateReference.fromBuffer(reader),
+      CheckpointConstantData.fromBuffer(reader),
+      SpongeBlob.fromBuffer(reader),
+      reader.readUInt64(),
+      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
+    );
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRootEmptyTxFirstRollupPrivateInputs);
+  }
+}
+
+export class BlockRootRollupPrivateInputs {
+  constructor(
+    /**
+     * The previous rollup proof data from base or merge rollup circuits.
+     */
+    public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
+    /**
+     * Hint for inserting the new block hash to the last archive.
+     */
+    public newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+  ) {}
+
+  static from(fields: FieldsOf<BlockRootRollupPrivateInputs>) {
+    return new BlockRootRollupPrivateInputs(...BlockRootRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<BlockRootRollupPrivateInputs>) {
+    return [fields.previousRollups, fields.newArchiveSiblingPath] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlockRootRollupPrivateInputs.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRootRollupPrivateInputs(
+      [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
+    );
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRootRollupPrivateInputs);
+  }
+}
+
+export class BlockRootSingleTxRollupPrivateInputs {
+  constructor(
+    /**
+     * The previous rollup proof data from base or merge rollup circuits.
+     */
+    public previousRollup: RollupHonkProofData<TxRollupPublicInputs>,
+    /**
+     * Hint for inserting the new block hash to the last archive.
+     */
+    public newArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
+  ) {}
+
+  static from(fields: FieldsOf<BlockRootSingleTxRollupPrivateInputs>) {
+    return new BlockRootSingleTxRollupPrivateInputs(...BlockRootSingleTxRollupPrivateInputs.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<BlockRootSingleTxRollupPrivateInputs>) {
+    return [fields.previousRollup, fields.newArchiveSiblingPath] as const;
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...BlockRootSingleTxRollupPrivateInputs.getFields(this));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    return new BlockRootSingleTxRollupPrivateInputs(
+      ProofData.fromBuffer(reader, TxRollupPublicInputs),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
+    );
+  }
+
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(BlockRootSingleTxRollupPrivateInputs);
+  }
+}

package/src/rollup/checkpoint_constant_data.ts

@@ -0,0 +1,84 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { AztecAddress } from '../aztec-address/index.js';
+import { GasFees } from '../gas/gas_fees.js';
+
+/**
+ * Constants that are the same for the entire checkpoint.
+ */
+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: Fr,
+    /** 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,
+      Fr.ZERO,
+      EthAddress.ZERO,
+      AztecAddress.ZERO,
+      GasFees.empty(),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...CheckpointConstantData.getFields(this));
+  }
+
+  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),
+      Fr.fromBuffer(reader),
+      reader.readObject(EthAddress),
+      reader.readObject(AztecAddress),
+      reader.readObject(GasFees),
+    );
+  }
+}

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),
@@ -84,6 +83,19 @@ export class ProposedBlockHeader {
     );
   }
 
+  equals(other: CheckpointHeader) {
+    return (
+      this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
+      this.contentCommitment.equals(other.contentCommitment) &&
+      this.slotNumber.equals(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([
@@ -102,8 +114,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,6 +128,19 @@ export class ProposedBlockHeader {
     });
   }
 
+  static random(): CheckpointHeader {
+    return new CheckpointHeader(
+      Fr.random(),
+      ContentCommitment.random(),
+      new Fr(BigInt(Math.floor(Math.random() * 1000) + 1)),
+      BigInt(Math.floor(Date.now() / 1000)),
+      EthAddress.random(),
+      new AztecAddress(Fr.random()),
+      GasFees.random(),
+      new Fr(BigInt(Math.floor(Math.random() * 1000000))),
+    );
+  }
+
   isEmpty(): boolean {
     return (
       this.lastArchiveRoot.isZero() &&
@@ -137,12 +162,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_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);
+  }
+}