@aztec/stdlib 6.0.0-nightly.20260810 → 6.0.0-nightly.20260821

package/src/rollup/block_rollup_public_inputs.ts

@@ -4,6 +4,7 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
+import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
 import { StateReference } from '../tx/state_reference.js';
 import type { UInt64 } from '../types/shared.js';
@@ -53,9 +54,14 @@ export class BlockRollupPublicInputs {
      */
     public blockHeadersHash: Fr,
     /**
-     * SHA256 hash of l1 to l2 messages.
+     * Message-bundle sponge threaded across the checkpoint's blocks, before this block range absorbs its bundle.
      */
-    public inHash: Fr,
+    public startMsgSponge: L1ToL2MessageSponge,
+    /**
+     * Message-bundle sponge after this block range absorbs its bundle. The checkpoint root asserts the final value
+     * matches the parity root's sponge over the same (padded) message list.
+     */
+    public endMsgSponge: L1ToL2MessageSponge,
     /**
      * SHA256 hash of L2 to L1 messages created in this block range.
      */
@@ -82,7 +88,8 @@ export class BlockRollupPublicInputs {
       reader.readObject(SpongeBlob),
       reader.readUInt64(),
       Fr.fromBuffer(reader),
-      Fr.fromBuffer(reader),
+      reader.readObject(L1ToL2MessageSponge),
+      reader.readObject(L1ToL2MessageSponge),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
@@ -100,7 +107,8 @@ export class BlockRollupPublicInputs {
       this.endSpongeBlob,
       bigintToUInt64BE(this.timestamp),
       this.blockHeadersHash,
-      this.inHash,
+      this.startMsgSponge,
+      this.endMsgSponge,
       this.outHash,
       this.accumulatedFees,
       this.accumulatedManaUsed,
@@ -124,7 +132,8 @@ export class BlockRollupPublicInputs {
       previousArchiveRoot: this.previousArchive.root.toString(),
       newArchiveRoot: this.newArchive.root.toString(),
       blockHeadersHash: this.blockHeadersHash.toString(),
-      inHash: this.inHash.toString(),
+      startMsgSpongeNumAbsorbed: this.startMsgSponge.numAbsorbed,
+      endMsgSpongeNumAbsorbed: this.endMsgSponge.numAbsorbed,
       outHash: this.outHash.toString(),
       timestamp: this.timestamp.toString(),
       accumulatedFees: this.accumulatedFees.toString(),

package/src/rollup/block_root_rollup_private_inputs.ts

@@ -1,149 +1,21 @@
-import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH } from '@aztec/constants';
+import { SpongeBlob } from '@aztec/blob-lib/types';
+import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 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 { L1ToL2MessageBundle } from '../messaging/l1_to_l2_message_bundle.js';
+import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js';
+import { ProofData, type RollupHonkProofData } 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 {
+export class BlockRootNoTxsRollupPrivateInputs {
   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.
      */
@@ -161,52 +33,72 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
      */
     public timestamp: UInt64,
     /**
-     * Hint for inserting the new l1 to l2 message subtree root.
+     * Sponge blob this block starts from: initialized for the checkpoint's first block, inherited from the previous
+     * block otherwise (checked against `SpongeBlob.init()` or the previous block's `endSpongeBlob` respectively).
+     */
+    public startSpongeBlob: SpongeBlob,
+    /**
+     * Message sponge this block starts from: empty for the checkpoint's first block, inherited from the previous block
+     * otherwise (checked against the empty sponge or the previous block's `endMsgSponge` respectively).
+     */
+    public startMsgSponge: L1ToL2MessageSponge,
+    /**
+     * L1-to-L2 message bundle inserted by this block.
+     */
+    public messageBundle: L1ToL2MessageBundle,
+    /**
+     * Frontier hint for appending the message bundle to the previous state's l1 to l2 message tree.
      */
-    public newL1ToL2MessageSubtreeRootSiblingPath: Tuple<Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH>,
+    public l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>,
     /**
      * 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 from(fields: FieldsOf<BlockRootNoTxsRollupPrivateInputs>) {
+    return new BlockRootNoTxsRollupPrivateInputs(...BlockRootNoTxsRollupPrivateInputs.getFields(fields));
   }
 
-  static getFields(fields: FieldsOf<BlockRootEmptyTxFirstRollupPrivateInputs>) {
+  static getFields(fields: FieldsOf<BlockRootNoTxsRollupPrivateInputs>) {
     return [
-      fields.l1ToL2Roots,
       fields.previousArchive,
       fields.previousState,
       fields.constants,
       fields.timestamp,
-      fields.newL1ToL2MessageSubtreeRootSiblingPath,
+      fields.startSpongeBlob,
+      fields.startMsgSponge,
+      fields.messageBundle,
+      fields.l1ToL2MessageFrontierHint,
       fields.newArchiveSiblingPath,
     ] as const;
   }
 
   toBuffer() {
-    return serializeToBuffer([
-      this.l1ToL2Roots,
+    return serializeToBuffer(
       this.previousArchive,
       this.previousState,
       this.constants,
       bigintToUInt64BE(this.timestamp),
-      this.newL1ToL2MessageSubtreeRootSiblingPath,
+      this.startSpongeBlob,
+      this.startMsgSponge,
+      this.messageBundle,
+      this.l1ToL2MessageFrontierHint,
       this.newArchiveSiblingPath,
-    ]);
+    );
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new BlockRootEmptyTxFirstRollupPrivateInputs(
-      ProofData.fromBuffer(reader, ParityPublicInputs),
+    return new BlockRootNoTxsRollupPrivateInputs(
       AppendOnlyTreeSnapshot.fromBuffer(reader),
       StateReference.fromBuffer(reader),
       CheckpointConstantData.fromBuffer(reader),
       reader.readUInt64(),
-      reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr),
+      reader.readObject(SpongeBlob),
+      reader.readObject(L1ToL2MessageSponge),
+      reader.readObject(L1ToL2MessageBundle),
+      reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
@@ -216,7 +108,7 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs {
   }
 
   static get schema() {
-    return bufferSchemaFor(BlockRootEmptyTxFirstRollupPrivateInputs);
+    return bufferSchemaFor(BlockRootNoTxsRollupPrivateInputs);
   }
 }
 
@@ -226,6 +118,24 @@ export class BlockRootRollupPrivateInputs {
      * The previous rollup proof data from base or merge rollup circuits.
      */
     public previousRollups: [RollupHonkProofData<TxRollupPublicInputs>, RollupHonkProofData<TxRollupPublicInputs>],
+    /**
+     * L1-to-L2 message bundle inserted by this block.
+     */
+    public messageBundle: L1ToL2MessageBundle,
+    /**
+     * The l1 to l2 message tree snapshot this block builds on (the previous block's post-insertion snapshot). Pinned by
+     * block-merge continuity to the previous block's end state; the circuit appends this block's bundle on top and
+     * asserts the tx constants carry the resulting post-bundle snapshot.
+     */
+    public previousL1ToL2: AppendOnlyTreeSnapshot,
+    /**
+     * Message sponge inherited from the previous block (checked against its `endMsgSponge` in the merge/checkpoint root).
+     */
+    public startMsgSponge: L1ToL2MessageSponge,
+    /**
+     * Frontier hint for appending the message bundle to `previousL1ToL2`.
+     */
+    public l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>,
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -237,17 +147,35 @@ export class BlockRootRollupPrivateInputs {
   }
 
   static getFields(fields: FieldsOf<BlockRootRollupPrivateInputs>) {
-    return [fields.previousRollups, fields.newArchiveSiblingPath] as const;
+    return [
+      fields.previousRollups,
+      fields.messageBundle,
+      fields.previousL1ToL2,
+      fields.startMsgSponge,
+      fields.l1ToL2MessageFrontierHint,
+      fields.newArchiveSiblingPath,
+    ] as const;
   }
 
   toBuffer() {
-    return serializeToBuffer(...BlockRootRollupPrivateInputs.getFields(this));
+    return serializeToBuffer(
+      this.previousRollups,
+      this.messageBundle,
+      this.previousL1ToL2,
+      this.startMsgSponge,
+      this.l1ToL2MessageFrontierHint,
+      this.newArchiveSiblingPath,
+    );
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootRollupPrivateInputs(
       [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)],
+      reader.readObject(L1ToL2MessageBundle),
+      AppendOnlyTreeSnapshot.fromBuffer(reader),
+      reader.readObject(L1ToL2MessageSponge),
+      reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }
@@ -267,6 +195,24 @@ export class BlockRootSingleTxRollupPrivateInputs {
      * The previous rollup proof data from base or merge rollup circuits.
      */
     public previousRollup: RollupHonkProofData<TxRollupPublicInputs>,
+    /**
+     * L1-to-L2 message bundle inserted by this block.
+     */
+    public messageBundle: L1ToL2MessageBundle,
+    /**
+     * The l1 to l2 message tree snapshot this block builds on (the previous block's post-insertion snapshot). Pinned by
+     * block-merge continuity to the previous block's end state; the circuit appends this block's bundle on top and
+     * asserts the tx constants carry the resulting post-bundle snapshot.
+     */
+    public previousL1ToL2: AppendOnlyTreeSnapshot,
+    /**
+     * Message sponge inherited from the previous block (checked against its `endMsgSponge` in the merge/checkpoint root).
+     */
+    public startMsgSponge: L1ToL2MessageSponge,
+    /**
+     * Frontier hint for appending the message bundle to `previousL1ToL2`.
+     */
+    public l1ToL2MessageFrontierHint: Tuple<Fr, typeof L1_TO_L2_MSG_TREE_HEIGHT>,
     /**
      * Hint for inserting the new block hash to the last archive.
      */
@@ -278,17 +224,35 @@ export class BlockRootSingleTxRollupPrivateInputs {
   }
 
   static getFields(fields: FieldsOf<BlockRootSingleTxRollupPrivateInputs>) {
-    return [fields.previousRollup, fields.newArchiveSiblingPath] as const;
+    return [
+      fields.previousRollup,
+      fields.messageBundle,
+      fields.previousL1ToL2,
+      fields.startMsgSponge,
+      fields.l1ToL2MessageFrontierHint,
+      fields.newArchiveSiblingPath,
+    ] as const;
   }
 
   toBuffer() {
-    return serializeToBuffer(...BlockRootSingleTxRollupPrivateInputs.getFields(this));
+    return serializeToBuffer(
+      this.previousRollup,
+      this.messageBundle,
+      this.previousL1ToL2,
+      this.startMsgSponge,
+      this.l1ToL2MessageFrontierHint,
+      this.newArchiveSiblingPath,
+    );
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
     return new BlockRootSingleTxRollupPrivateInputs(
       ProofData.fromBuffer(reader, TxRollupPublicInputs),
+      reader.readObject(L1ToL2MessageBundle),
+      AppendOnlyTreeSnapshot.fromBuffer(reader),
+      reader.readObject(L1ToL2MessageSponge),
+      reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr),
       reader.readArray(ARCHIVE_HEIGHT, Fr),
     );
   }

package/src/rollup/checkpoint_header.ts

@@ -30,8 +30,12 @@ export class CheckpointHeader {
     public blockHeadersHash: Fr,
     /** Hash of the blobs in the checkpoint. */
     public blobsHash: Fr,
-    /** Root of the l1 to l2 messages subtree. */
-    public inHash: Fr,
+    /**
+     * Inbox rolling-hash chain value after consuming all L1-to-L2 messages bundled into this checkpoint:
+     * the truncated-to-field sha256 chain the L1 Inbox accumulates. This is the checkpoint's only inbox
+     * commitment.
+     */
+    public inboxRollingHash: Fr,
     /**
      * The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at
      * index 0, the second at index 1, and so on.
@@ -62,7 +66,7 @@ export class CheckpointHeader {
         lastArchiveRoot: schemas.Fr,
         blockHeadersHash: schemas.Fr,
         blobsHash: schemas.Fr,
-        inHash: schemas.Fr,
+        inboxRollingHash: schemas.Fr,
         epochOutHash: schemas.Fr,
         slotNumber: schemas.SlotNumber,
         timestamp: schemas.BigInt,
@@ -80,7 +84,7 @@ export class CheckpointHeader {
       fields.lastArchiveRoot,
       fields.blockHeadersHash,
       fields.blobsHash,
-      fields.inHash,
+      fields.inboxRollingHash,
       fields.epochOutHash,
       fields.slotNumber,
       fields.timestamp,
@@ -120,7 +124,7 @@ export class CheckpointHeader {
       this.lastArchiveRoot.equals(other.lastArchiveRoot) &&
       this.blockHeadersHash.equals(other.blockHeadersHash) &&
       this.blobsHash.equals(other.blobsHash) &&
-      this.inHash.equals(other.inHash) &&
+      this.inboxRollingHash.equals(other.inboxRollingHash) &&
       this.epochOutHash.equals(other.epochOutHash) &&
       this.slotNumber === other.slotNumber &&
       this.timestamp === other.timestamp &&
@@ -149,7 +153,7 @@ export class CheckpointHeader {
       this.lastArchiveRoot,
       this.blockHeadersHash,
       this.blobsHash,
-      this.inHash,
+      this.inboxRollingHash,
       this.epochOutHash,
       new Fr(this.slotNumber),
       bigintToUInt64BE(this.timestamp),
@@ -170,7 +174,7 @@ export class CheckpointHeader {
       lastArchiveRoot: Fr.ZERO,
       blockHeadersHash: Fr.ZERO,
       blobsHash: Fr.ZERO,
-      inHash: Fr.ZERO,
+      inboxRollingHash: Fr.ZERO,
       epochOutHash: Fr.ZERO,
       slotNumber: SlotNumber.ZERO,
       timestamp: 0n,
@@ -188,7 +192,7 @@ export class CheckpointHeader {
       lastArchiveRoot: Fr.random(),
       blockHeadersHash: Fr.random(),
       blobsHash: Fr.random(),
-      inHash: Fr.random(),
+      inboxRollingHash: Fr.random(),
       epochOutHash: Fr.random(),
       slotNumber: SlotNumber(Math.floor(Math.random() * 1000) + 1),
       timestamp: BigInt(Math.floor(Date.now() / 1000)),
@@ -206,7 +210,7 @@ export class CheckpointHeader {
       this.lastArchiveRoot.isZero() &&
       this.blockHeadersHash.isZero() &&
       this.blobsHash.isZero() &&
-      this.inHash.isZero() &&
+      this.inboxRollingHash.isZero() &&
       this.epochOutHash.isZero() &&
       this.slotNumber === 0 &&
       this.timestamp === 0n &&
@@ -235,7 +239,7 @@ export class CheckpointHeader {
       Fr.fromString(header.lastArchiveRoot),
       Fr.fromString(header.blockHeadersHash),
       Fr.fromString(header.blobsHash),
-      Fr.fromString(header.inHash),
+      Fr.fromString(header.inboxRollingHash),
       Fr.fromString(header.outHash),
       SlotNumber.fromBigInt(header.slotNumber),
       header.timestamp,
@@ -260,7 +264,7 @@ export class CheckpointHeader {
       lastArchiveRoot: this.lastArchiveRoot.toString(),
       blockHeadersHash: this.blockHeadersHash.toString(),
       blobsHash: this.blobsHash.toString(),
-      inHash: this.inHash.toString(),
+      inboxRollingHash: this.inboxRollingHash.toString(),
       outHash: this.epochOutHash.toString(),
       slotNumber: BigInt(this.slotNumber),
       timestamp: this.timestamp,
@@ -280,7 +284,7 @@ export class CheckpointHeader {
       lastArchive: this.lastArchiveRoot.toString(),
       blockHeadersHash: this.blockHeadersHash.toString(),
       blobsHash: this.blobsHash.toString(),
-      inHash: this.inHash.toString(),
+      inboxRollingHash: this.inboxRollingHash.toString(),
       epochOutHash: this.epochOutHash.toString(),
       slotNumber: this.slotNumber,
       timestamp: this.timestamp,
@@ -297,7 +301,7 @@ export class CheckpointHeader {
   lastArchiveRoot: ${this.lastArchiveRoot.toString()},
   blockHeadersHash: ${this.blockHeadersHash.toString()},
   blobsHash: ${inspect(this.blobsHash)},
-  inHash: ${inspect(this.inHash)},
+  inboxRollingHash: ${inspect(this.inboxRollingHash)},
   epochOutHash: ${inspect(this.epochOutHash)},
   slotNumber: ${this.slotNumber},
   timestamp: ${this.timestamp},

package/src/rollup/checkpoint_rollup_public_inputs.ts

@@ -35,6 +35,15 @@ export class CheckpointRollupPublicInputs {
      * The out hash tree snapshot after applying this checkpoint range.
      */
     public newOutHash: AppendOnlyTreeSnapshot,
+    /**
+     * Inbox rolling hash before consuming this checkpoint range's messages.
+     */
+    public startInboxRollingHash: Fr,
+    /**
+     * Inbox rolling hash after consuming this checkpoint range's messages (the end value lands in the checkpoint
+     * header). Checkpoint merges assert `right.start == left.end` for chain continuity.
+     */
+    public endInboxRollingHash: Fr,
     /**
      * The hashes of the headers of the constituent checkpoints.
      */
@@ -65,6 +74,8 @@ export class CheckpointRollupPublicInputs {
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
       reader.readObject(AppendOnlyTreeSnapshot),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
       reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr),
       reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient),
       reader.readObject(BlobAccumulator),
@@ -80,6 +91,8 @@ export class CheckpointRollupPublicInputs {
       this.newArchive,
       this.previousOutHash,
       this.newOutHash,
+      this.startInboxRollingHash,
+      this.endInboxRollingHash,
       this.checkpointHeaderHashes,
       this.fees,
       this.startBlobAccumulator,
@@ -108,6 +121,8 @@ export class CheckpointRollupPublicInputs {
       newArchiveRoot: this.newArchive.root.toString(),
       previousOutHashRoot: this.previousOutHash.root.toString(),
       newOutHashRoot: this.newOutHash.root.toString(),
+      startInboxRollingHash: this.startInboxRollingHash.toString(),
+      endInboxRollingHash: this.endInboxRollingHash.toString(),
     };
   }
 

package/src/rollup/checkpoint_root_rollup_private_inputs.ts

@@ -7,7 +7,8 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js';
+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 { BlockHeader } from '../tx/block_header.js';
 import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js';
@@ -117,6 +118,11 @@ export class CheckpointRootRollupPrivateInputs {
       RollupHonkProofData<BlockRollupPublicInputs>,
       RollupHonkProofData<BlockRollupPublicInputs>,
     ],
+    /**
+     * Inbox parity proof over the checkpoint's L1-to-L2 messages: it commits to the checkpoint's
+     * message list, and its message sponge is checked against the blocks' accumulated one.
+     */
+    public inboxParity: UltraHonkProofData<ParityPublicInputs>,
     public hints: CheckpointRootRollupHints,
   ) {}
 
@@ -125,7 +131,7 @@ export class CheckpointRootRollupPrivateInputs {
   }
 
   static getFields(fields: FieldsOf<CheckpointRootRollupPrivateInputs>) {
-    return [fields.previousRollups, fields.hints] as const;
+    return [fields.previousRollups, fields.inboxParity, fields.hints] as const;
   }
 
   toBuffer() {
@@ -136,6 +142,7 @@ export class CheckpointRootRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new CheckpointRootRollupPrivateInputs(
       [ProofData.fromBuffer(reader, BlockRollupPublicInputs), ProofData.fromBuffer(reader, BlockRollupPublicInputs)],
+      ProofData.fromBuffer(reader, ParityPublicInputs),
       CheckpointRootRollupHints.fromBuffer(reader),
     );
   }
@@ -160,6 +167,11 @@ export class CheckpointRootRollupPrivateInputs {
 export class CheckpointRootSingleBlockRollupPrivateInputs {
   constructor(
     public previousRollup: RollupHonkProofData<BlockRollupPublicInputs>,
+    /**
+     * Inbox parity proof over the checkpoint's L1-to-L2 messages: it commits to the checkpoint's
+     * message list, and its message sponge is checked against the block's accumulated one.
+     */
+    public inboxParity: UltraHonkProofData<ParityPublicInputs>,
     public hints: CheckpointRootRollupHints,
   ) {}
 
@@ -170,7 +182,7 @@ export class CheckpointRootSingleBlockRollupPrivateInputs {
   }
 
   static getFields(fields: FieldsOf<CheckpointRootSingleBlockRollupPrivateInputs>) {
-    return [fields.previousRollup, fields.hints] as const;
+    return [fields.previousRollup, fields.inboxParity, fields.hints] as const;
   }
 
   toBuffer() {
@@ -181,6 +193,7 @@ export class CheckpointRootSingleBlockRollupPrivateInputs {
     const reader = BufferReader.asReader(buffer);
     return new CheckpointRootSingleBlockRollupPrivateInputs(
       ProofData.fromBuffer(reader, BlockRollupPublicInputs),
+      ProofData.fromBuffer(reader, ParityPublicInputs),
       CheckpointRootRollupHints.fromBuffer(reader),
     );
   }

package/src/rollup/root_rollup_public_inputs.ts

@@ -26,6 +26,10 @@ export class RootRollupPublicInputs {
      * The out hash of the first checkpoint in the epoch is inserted at index 0, the second at index 1, and so on.
      */
     public outHash: Fr,
+    /** Inbox rolling hash before the epoch's first checkpoint's messages. */
+    public previousInboxRollingHash: Fr,
+    /** Inbox rolling hash after the epoch's last checkpoint's messages. */
+    public endInboxRollingHash: Fr,
     /** Hashes of checkpoint headers for this rollup. */
     public checkpointHeaderHashes: Tuple<Fr, typeof MAX_CHECKPOINTS_PER_EPOCH>,
     public fees: Tuple<FeeRecipient, typeof MAX_CHECKPOINTS_PER_EPOCH>,
@@ -38,6 +42,8 @@ export class RootRollupPublicInputs {
       fields.previousArchiveRoot,
       fields.endArchiveRoot,
       fields.outHash,
+      fields.previousInboxRollingHash,
+      fields.endInboxRollingHash,
       fields.checkpointHeaderHashes,
       fields.fees,
       fields.constants,
@@ -65,6 +71,8 @@ export class RootRollupPublicInputs {
   public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
     return new RootRollupPublicInputs(
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
       Fr.fromBuffer(reader),
@@ -96,6 +104,8 @@ export class RootRollupPublicInputs {
   /** Creates a random instance. Used for testing only - will not prove/verify. */
   static random() {
     return new RootRollupPublicInputs(
+      Fr.random(),
+      Fr.random(),
       Fr.random(),
       Fr.random(),
       Fr.random(),