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

package/src/p2p/block_proposal.ts

@@ -18,6 +18,7 @@ import type { L2Block } from '../block/l2_block.js';
 import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
 import { DutyType, type SigningContext } from '../ha-signing/index.js';
+import { InboxBucketRef } from '../messaging/inbox_bucket.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
 import type { Tx } from '../tx/tx.js';
@@ -70,9 +71,6 @@ export class BlockProposal extends Gossipable implements Signable {
     /** Index of this block within the checkpoint (0-indexed) */
     public readonly indexWithinCheckpoint: IndexWithinCheckpoint,
 
-    /** Hash of L1 to L2 messages for this checkpoint (constant across all blocks in checkpoint) */
-    public readonly inHash: Fr,
-
     /** Archive root after this block is applied */
     public readonly archiveRoot: Fr,
 
@@ -87,6 +85,13 @@ export class BlockProposal extends Gossipable implements Signable {
 
     /** The signed transactions in the block (optional, for DA guarantees) */
     public readonly signedTxs?: SignedTxs,
+
+    /**
+     * Reference to the Inbox bucket this block proposes to consume, when the proposer commits to one. Validators
+     * resolve it against their own Inbox view and derive the consumed message bundle from it rather than trusting a
+     * proposer-supplied message list. Covered by the proposal signature (part of `getPayloadToSign`).
+     */
+    public readonly bucketRef?: InboxBucketRef,
   ) {
     super();
   }
@@ -124,16 +129,18 @@ export class BlockProposal extends Gossipable implements Signable {
 
   /**
    * Get the payload to sign for this block proposal.
-   * The signature is over: blockHeader + indexWithinCheckpoint + inHash + archiveRoot + txHashes
+   * The signature is over: blockHeader + indexWithinCheckpoint + archiveRoot + txHashes, plus the bucket reference
+   * when set. Appending only when set binds the reference to the signature so a relay cannot strip or inject it
+   * without breaking recovery.
    */
   getPayloadToSign(): Buffer {
     return serializeToBuffer([
       this.blockHeader,
       this.indexWithinCheckpoint,
-      this.inHash,
       this.archiveRoot,
       this.txHashes.length,
       this.txHashes,
+      ...(this.bucketRef ? [this.bucketRef] : []),
     ]);
   }
 
@@ -156,23 +163,24 @@ export class BlockProposal extends Gossipable implements Signable {
     blockHeader: BlockHeader,
     checkpointNumber: CheckpointNumber,
     indexWithinCheckpoint: IndexWithinCheckpoint,
-    inHash: Fr,
     archiveRoot: Fr,
     txHashes: TxHash[],
     txs: Tx[] | undefined,
     signatureContext: CoordinationSignatureContext,
     proposalSigner: (typedData: TypedDataDefinition, context: SigningContext) => Promise<Signature>,
     txsSigner?: (typedData: TypedDataDefinition, context: SigningContext) => Promise<Signature>,
+    bucketRef?: InboxBucketRef,
   ): Promise<BlockProposal> {
     // Create a temporary proposal to get the payload to sign
     const tempProposal = new BlockProposal(
       blockHeader,
       indexWithinCheckpoint,
-      inHash,
       archiveRoot,
       txHashes,
       Signature.empty(),
       signatureContext,
+      undefined,
+      bucketRef,
     );
 
     // Create the block signing context
@@ -202,12 +210,12 @@ export class BlockProposal extends Gossipable implements Signable {
     return new BlockProposal(
       blockHeader,
       indexWithinCheckpoint,
-      inHash,
       archiveRoot,
       txHashes,
       sig,
       signatureContext,
       signedTxs,
+      bucketRef,
     );
   }
 
@@ -248,7 +256,6 @@ export class BlockProposal extends Gossipable implements Signable {
     const buffer: any[] = [
       this.blockHeader,
       this.indexWithinCheckpoint,
-      this.inHash,
       this.archiveRoot,
       this.signature,
       serializeCoordinationSignatureContext(this.signatureContext),
@@ -261,6 +268,12 @@ export class BlockProposal extends Gossipable implements Signable {
     } else {
       buffer.push(0); // hasSignedTxs = false
     }
+    // Optional bucket-reference tail. Appended only when set, so a proposal without a reference
+    // serializes without the tail and a decoder that reaches EOF reads it as unset.
+    if (this.bucketRef) {
+      buffer.push(1); // hasBucketRef = true
+      buffer.push(this.bucketRef.toBuffer());
+    }
     return serializeToBuffer(buffer);
   }
 
@@ -269,7 +282,6 @@ export class BlockProposal extends Gossipable implements Signable {
 
     const blockHeader = reader.readObject(BlockHeader);
     const indexWithinCheckpoint = IndexWithinCheckpoint(reader.readNumber());
-    const inHash = reader.readObject(Fr);
     const archiveRoot = reader.readObject(Fr);
     const signature = reader.readObject(Signature);
     const signatureContext = readCoordinationSignatureContext(reader);
@@ -279,31 +291,33 @@ export class BlockProposal extends Gossipable implements Signable {
     }
     const txHashes = reader.readArray(txHashCount, TxHash);
 
+    let signedTxs: SignedTxs | undefined;
     if (!reader.isEmpty()) {
       const hasSignedTxs = reader.readNumber();
       if (hasSignedTxs) {
-        const signedTxs = SignedTxs.fromBuffer(reader);
-        return new BlockProposal(
-          blockHeader,
-          indexWithinCheckpoint,
-          inHash,
-          archiveRoot,
-          txHashes,
-          signature,
-          signatureContext,
-          signedTxs,
-        );
+        signedTxs = SignedTxs.fromBuffer(reader);
+      }
+    }
+
+    // Optional bucket-reference tail. A buffer that ends after the signedTxs flag decodes as
+    // "no reference", so proposals written without the tail round-trip cleanly.
+    let bucketRef: InboxBucketRef | undefined;
+    if (!reader.isEmpty()) {
+      const hasBucketRef = reader.readNumber();
+      if (hasBucketRef) {
+        bucketRef = InboxBucketRef.fromBuffer(reader);
       }
     }
 
     return new BlockProposal(
       blockHeader,
       indexWithinCheckpoint,
-      inHash,
       archiveRoot,
       txHashes,
       signature,
       signatureContext,
+      signedTxs,
+      bucketRef,
     );
   }
 
@@ -311,7 +325,6 @@ export class BlockProposal extends Gossipable implements Signable {
     return (
       this.blockHeader.getSize() +
       4 /* indexWithinCheckpoint */ +
-      this.inHash.size +
       this.archiveRoot.size +
       this.signature.getSize() +
       4 /* chainId */ +
@@ -319,7 +332,8 @@ export class BlockProposal extends Gossipable implements Signable {
       4 /* txHashes.length */ +
       this.txHashes.length * TxHash.SIZE +
       4 /* hasSignedTxs flag */ +
-      (this.signedTxs ? this.signedTxs.getSize() : 0)
+      (this.signedTxs ? this.signedTxs.getSize() : 0) +
+      (this.bucketRef ? 4 /* hasBucketRef flag */ + this.bucketRef.getSize() : 0)
     );
   }
 
@@ -328,7 +342,6 @@ export class BlockProposal extends Gossipable implements Signable {
       BlockHeader.empty(),
       IndexWithinCheckpoint(0),
       Fr.ZERO,
-      Fr.ZERO,
       [],
       Signature.empty(),
       EMPTY_COORDINATION_SIGNATURE_CONTEXT,
@@ -340,7 +353,6 @@ export class BlockProposal extends Gossipable implements Signable {
       BlockHeader.random(),
       IndexWithinCheckpoint(Math.floor(Math.random() * 5)),
       Fr.random(),
-      Fr.random(),
       [TxHash.random(), TxHash.random()],
       Signature.random(),
       EMPTY_COORDINATION_SIGNATURE_CONTEXT,
@@ -351,12 +363,12 @@ export class BlockProposal extends Gossipable implements Signable {
     return {
       blockHeader: this.blockHeader.toInspect(),
       indexWithinCheckpoint: this.indexWithinCheckpoint,
-      inHash: this.inHash.toString(),
       archiveRoot: this.archiveRoot.toString(),
       signature: this.signature.toString(),
       txHashes: this.txHashes.map(h => h.toString()),
       chainId: this.signatureContext.chainId,
       rollupAddress: this.signatureContext.rollupAddress.toString(),
+      bucketRef: this.bucketRef?.toInspect(),
     };
   }
 
@@ -378,11 +390,12 @@ export class BlockProposal extends Gossipable implements Signable {
     return new BlockProposal(
       this.blockHeader,
       this.indexWithinCheckpoint,
-      this.inHash,
       this.archiveRoot,
       this.txHashes,
       this.signature,
       this.signatureContext,
+      undefined,
+      this.bucketRef,
     );
   }
 }

package/src/p2p/checkpoint_proposal.ts

@@ -15,6 +15,7 @@ import type { TypedDataDefinition } from 'viem';
 import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
 import { DutyType, type SigningContext } from '../ha-signing/index.js';
+import { InboxBucketRef } from '../messaging/inbox_bucket.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import { BlockHeader } from '../tx/block_header.js';
 import { TxHash } from '../tx/index.js';
@@ -69,6 +70,11 @@ export type CheckpointLastBlock = Omit<CheckpointLastBlockData, 'txs'> & {
   signature: Signature;
   /** The signed transactions in the last block (optional, for DA guarantees) */
   signedTxs?: SignedTxs;
+  /**
+   * Reference to the Inbox bucket the last block proposes to consume. When set, its rolling hash must equal the
+   * checkpoint header's `inboxRollingHash` (enforced at construction).
+   */
+  bucketRef?: InboxBucketRef;
 };
 
 /**
@@ -104,10 +110,11 @@ export class CheckpointProposal extends Gossipable implements Signable {
   ) {
     super();
 
-    // Check that last block properties match those of the checkpoint.
-    if (lastBlock && 'inHash' in lastBlock && !lastBlock.inHash.equals(checkpointHeader.inHash)) {
+    // Check that last block properties match those of the checkpoint. The last block's bucket reference
+    // commits to the same rolling hash as the checkpoint header. Only enforced when the reference is set.
+    if (lastBlock?.bucketRef && !lastBlock.bucketRef.inboxRollingHash.equals(checkpointHeader.inboxRollingHash)) {
       throw new Error(
-        `CheckpointProposal lastBlock inHash ${lastBlock.inHash} does not match checkpoint inHash ${checkpointHeader.inHash}`,
+        `CheckpointProposal lastBlock bucketRef rolling hash ${lastBlock.bucketRef.inboxRollingHash} does not match checkpoint inboxRollingHash ${checkpointHeader.inboxRollingHash}`,
       );
     }
     if (lastBlock && 'archiveRoot' in lastBlock && !lastBlock.archiveRoot.equals(archive)) {
@@ -134,7 +141,6 @@ export class CheckpointProposal extends Gossipable implements Signable {
 
   /**
    * Extract a BlockProposal from the last block info.
-   * Uses inHash from checkpointHeader.contentCommitment.inHash
    */
   getBlockProposal(): BlockProposal | undefined {
     if (!this.lastBlock) {
@@ -144,12 +150,12 @@ export class CheckpointProposal extends Gossipable implements Signable {
     return new BlockProposal(
       this.lastBlock.blockHeader,
       this.lastBlock.indexWithinCheckpoint,
-      this.checkpointHeader.inHash,
       this.archive,
       this.lastBlock.txHashes,
       this.lastBlock.signature,
       this.signatureContext,
       this.lastBlock.signedTxs,
+      this.lastBlock.bucketRef,
     );
   }
 
@@ -288,6 +294,12 @@ export class CheckpointProposal extends Gossipable implements Signable {
       } else {
         buffer.push(0); // hasSignedTxs = false
       }
+      // Optional bucket-reference tail. Appended only when set, so a proposal without a reference
+      // serializes without the tail and a decoder that reaches EOF reads it as unset.
+      if (this.lastBlock.bucketRef) {
+        buffer.push(1); // hasBucketRef = true
+        buffer.push(this.lastBlock.bucketRef.toBuffer());
+      }
     } else {
       buffer.push(0); // hasLastBlock = false
     }
@@ -324,12 +336,23 @@ export class CheckpointProposal extends Gossipable implements Signable {
         }
       }
 
+      // Optional bucket-reference tail. A buffer that ends after the signedTxs flag decodes as
+      // "no reference", so proposals written without the tail round-trip cleanly.
+      let bucketRef: InboxBucketRef | undefined;
+      if (!reader.isEmpty()) {
+        const hasBucketRef = reader.readNumber();
+        if (hasBucketRef) {
+          bucketRef = InboxBucketRef.fromBuffer(reader);
+        }
+      }
+
       return new CheckpointProposal(checkpointHeader, archive, feeAssetPriceModifier, signature, signatureContext, {
         blockHeader,
         indexWithinCheckpoint,
         txHashes,
         signature: blockSignature,
         signedTxs,
+        bucketRef,
       });
     }
 
@@ -354,7 +377,8 @@ export class CheckpointProposal extends Gossipable implements Signable {
         4 /* txHashes.length */ +
         this.lastBlock.txHashes.length * TxHash.SIZE +
         4 /* hasSignedTxs flag */ +
-        (this.lastBlock.signedTxs ? this.lastBlock.signedTxs.getSize() : 0);
+        (this.lastBlock.signedTxs ? this.lastBlock.signedTxs.getSize() : 0) +
+        (this.lastBlock.bucketRef ? 4 /* hasBucketRef flag */ + this.lastBlock.bucketRef.getSize() : 0);
     }
 
     return size;
@@ -400,6 +424,7 @@ export class CheckpointProposal extends Gossipable implements Signable {
             indexWithinCheckpoint: this.lastBlock.indexWithinCheckpoint,
             txHashes: this.lastBlock.txHashes.map(h => h.toString()),
             signature: this.lastBlock.signature.toString(),
+            bucketRef: this.lastBlock.bucketRef?.toInspect(),
           }
         : undefined,
     };

package/src/p2p/index.ts

@@ -7,6 +7,7 @@ export * from './gossipable.js';
 export * from './signature_utils.js';
 export * from './signed_txs.js';
 export * from './topic_type.js';
+export * from './validated_proposal.js';
 export * from './message_validator.js';
 export * from './peer_error.js';
 export * from './constants.js';

package/src/p2p/validated_proposal.ts

@@ -0,0 +1,43 @@
+import type { Branded } from '@aztec/foundation/branded-types';
+
+import type { BlockProposal } from './block_proposal.js';
+import type { CheckpointProposalCore } from './checkpoint_proposal.js';
+
+/**
+ * A block proposal that has passed p2p ingress validation.
+ *
+ * Downstream consumers (the validator client's proposal handlers) rely on that validation having already
+ * happened and do not repeat it, so this brand marks the proposals they are allowed to receive. It is a
+ * compile-time marker only: at runtime a `ValidatedBlockProposal` is just a `BlockProposal`.
+ */
+export type ValidatedBlockProposal = Branded<BlockProposal, 'ValidatedBlockProposal'>;
+
+/**
+ * Marks a block proposal as having passed p2p ingress validation.
+ *
+ * May only be called at a point where the gossipsub topic validator has accepted the proposal, which covers
+ * the signature context, the signature itself, the expected proposer for the slot, the index within the
+ * checkpoint, the tx field checks, and the receive-window timeliness check.
+ */
+export function ValidatedBlockProposal(proposal: BlockProposal): ValidatedBlockProposal {
+  return proposal as ValidatedBlockProposal;
+}
+
+/**
+ * A checkpoint proposal (without its last block) that has passed p2p ingress validation.
+ *
+ * Downstream consumers (the validator client's proposal handlers) rely on that validation having already
+ * happened and do not repeat it, so this brand marks the proposals they are allowed to receive. It is a
+ * compile-time marker only: at runtime a `ValidatedCheckpointProposalCore` is just a `CheckpointProposalCore`.
+ */
+export type ValidatedCheckpointProposalCore = Branded<CheckpointProposalCore, 'ValidatedCheckpointProposalCore'>;
+
+/**
+ * Marks a checkpoint proposal as having passed p2p ingress validation.
+ *
+ * May only be called at a point where the gossipsub topic validator has accepted the proposal, which covers
+ * the expected proposer for the slot and the receive-window timeliness check.
+ */
+export function ValidatedCheckpointProposalCore(proposal: CheckpointProposalCore): ValidatedCheckpointProposalCore {
+  return proposal as ValidatedCheckpointProposalCore;
+}

package/src/p2p/wire_compat_fixtures.ts

@@ -0,0 +1,23 @@
+// Golden wire fixtures that pin the exact bytes a peer produces and consumes, so the optional bucket-reference tail
+// added to proposals stays wire compatible: an unset proposal must serialize to these bytes, and decoding these bytes
+// must yield no bucket reference. The block-proposal fixtures were refreshed for the removal of the legacy `inHash`
+// field; the checkpoint-proposal fixture was refreshed for the checkpoint-header format change.
+//
+// Both fixtures come from a deterministic proposal built with:
+//   BlockHeader.empty(), IndexWithinCheckpoint(3), archiveRoot=Fr(99),
+//   txHashes=[TxHash.fromField(Fr(7)), TxHash.fromField(Fr(8))], Signature.empty(), EMPTY_COORDINATION_SIGNATURE_CONTEXT
+// (checkpoint: CheckpointHeader.empty(), archive=Fr(123), feeAssetPriceModifier=0, empty signature/context, and a
+// lastBlock with BlockHeader.empty(), IndexWithinCheckpoint(4), txHashes=[TxHash.fromField(Fr(7))], empty signature).
+// Regenerate the checkpoint fixture only when the checkpoint serialization format changes on purpose.
+
+/** Legacy `BlockProposal.toBuffer()` bytes (no signedTxs, no bucket reference). */
+export const LEGACY_BLOCK_PROPOSAL_HEX =
+  '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000630000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000007000000000000000000000000000000000000000000000000000000000000000800000000';
+
+/** Legacy `CheckpointProposal.toBuffer()` bytes (lastBlock without signedTxs or bucket reference). */
+export const LEGACY_CHECKPOINT_PROPOSAL_HEX =
+  '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000700000000';
+
+/** Legacy `BlockProposal.getPayloadToSign()` bytes (no bucket reference). */
+export const LEGACY_BLOCK_PROPOSAL_PAYLOAD_HEX =
+  '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000630000000200000000000000000000000000000000000000000000000000000000000000070000000000000000000000000000000000000000000000000000000000000008';

package/src/parity/inbox_parity_private_inputs.ts

@@ -0,0 +1,116 @@
+import { INBOX_PARITY_SIZE_LARGE, INBOX_PARITY_SIZE_MEDIUM, INBOX_PARITY_SIZE_SMALL } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
+
+/** The InboxParity size ladder, ascending. One VK per size; the prover proves the smallest that fits. */
+export const INBOX_PARITY_SIZES = [INBOX_PARITY_SIZE_SMALL, INBOX_PARITY_SIZE_MEDIUM, INBOX_PARITY_SIZE_LARGE] as const;
+
+/** A valid InboxParity ladder size. */
+export type InboxParitySize = (typeof INBOX_PARITY_SIZES)[number];
+
+/**
+ * Picks the smallest ladder size that can hold `numMessages` messages.
+ * @throws if `numMessages` exceeds the largest rung.
+ */
+export function pickInboxParitySize(numMessages: number): InboxParitySize {
+  const size = INBOX_PARITY_SIZES.find(s => numMessages <= s);
+  if (size === undefined) {
+    throw new Error(
+      `Cannot fit ${numMessages} L1-to-L2 messages into any InboxParity size (max ${INBOX_PARITY_SIZE_LARGE})`,
+    );
+  }
+  return size;
+}
+
+/**
+ * Private inputs for one `InboxParity<S>` proof (S = `size`). The prover produces exactly one per checkpoint, sized
+ * by the checkpoint's message count via {@link pickInboxParitySize}.
+ */
+export class InboxParityPrivateInputs {
+  constructor(
+    /** Ladder size S: the length of `messages` and the circuit variant to prove ({@link INBOX_PARITY_SIZES}). */
+    public readonly size: InboxParitySize,
+    /** The checkpoint's L1-to-L2 messages, padded with zeros to `size`; the first `numMessages` are real. */
+    public readonly messages: Fr[],
+    /** Number of real (non-padding) messages in `messages`. */
+    public readonly numMessages: number,
+    /** Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end; genesis is zero). */
+    public readonly startRollingHash: Fr,
+    /** Prover identity committed to by the circuit, for sybil protection. */
+    public readonly proverId: Fr,
+  ) {
+    if (messages.length !== size) {
+      throw new Error(`InboxParity messages length (${messages.length}) must equal size (${size})`);
+    }
+  }
+
+  /**
+   * Builds the inputs from a checkpoint's real messages, sizing the circuit by the message count and padding the
+   * message array out to that size.
+   */
+  static fromMessages(messages: Fr[], startRollingHash: Fr, proverId: Fr): InboxParityPrivateInputs {
+    const size = pickInboxParitySize(messages.length);
+    // Explicit `<Fr, number>` keeps the result `Fr[]`; padding to the union-literal `size` would infer a deep tuple.
+    return new InboxParityPrivateInputs(
+      size,
+      padArrayEnd<Fr, number>(messages, Fr.ZERO, size),
+      messages.length,
+      startRollingHash,
+      proverId,
+    );
+  }
+
+  /** Serializes the inputs to a buffer. */
+  toBuffer() {
+    return serializeToBuffer(
+      new Fr(this.size),
+      this.messages,
+      new Fr(this.numMessages),
+      this.startRollingHash,
+      this.proverId,
+    );
+  }
+
+  /** Serializes the inputs to a hex string. */
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
+
+  /**
+   * Deserializes the inputs from a buffer.
+   * @param buffer - The buffer to deserialize from.
+   */
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    const size = Fr.fromBuffer(reader).toNumber() as InboxParitySize;
+    // Array.from keeps the type `Fr[]`; readArray with the union-literal `size` would infer a deep tuple.
+    const messages = Array.from({ length: size }, () => Fr.fromBuffer(reader));
+    return new InboxParityPrivateInputs(
+      size,
+      messages,
+      Fr.fromBuffer(reader).toNumber(),
+      Fr.fromBuffer(reader),
+      Fr.fromBuffer(reader),
+    );
+  }
+
+  /**
+   * Deserializes the inputs from a hex string.
+   * @param str - The hex string to deserialize from.
+   */
+  static fromString(str: string) {
+    return InboxParityPrivateInputs.fromBuffer(hexToBuffer(str));
+  }
+
+  /** Returns a buffer representation for JSON serialization. */
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static get schema() {
+    return bufferSchemaFor(InboxParityPrivateInputs);
+  }
+}

package/src/parity/index.ts

@@ -1,3 +1,2 @@
-export * from './parity_base_private_inputs.js';
+export * from './inbox_parity_private_inputs.js';
 export * from './parity_public_inputs.js';
-export * from './parity_root_private_inputs.js';

package/src/parity/parity_public_inputs.ts

@@ -4,28 +4,26 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
+import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js';
+
 export class ParityPublicInputs {
   constructor(
-    /** Root of the SHA256 tree. */
-    public shaRoot: Fr,
-    /** Root of the converted tree. */
-    public convertedRoot: Fr,
-    /** Root of the VK tree */
-    public vkTreeRoot: Fr,
+    /** Inbox rolling hash before absorbing this checkpoint's messages. */
+    public startRollingHash: Fr,
+    /** Inbox rolling hash after absorbing the checkpoint's real messages. */
+    public endRollingHash: Fr,
+    /** Message-bundle sponge after absorbing the same real messages into the empty per-checkpoint sponge. */
+    public endSponge: L1ToL2MessageSponge,
     /** Prover identity committed to by the circuit, for sybil protection. */
     public proverId: Fr,
-  ) {
-    if (shaRoot.toBuffer()[0] != 0) {
-      throw new Error(`shaRoot buffer must be 31 bytes. Got 32 bytes`);
-    }
-  }
+  ) {}
 
   /**
    * Serializes the inputs to a buffer.
    * @returns The inputs serialized to a buffer.
    */
   toBuffer() {
-    return serializeToBuffer(...ParityPublicInputs.getFields(this));
+    return serializeToBuffer(this.startRollingHash, this.endRollingHash, this.endSponge, this.proverId);
   }
 
   /**
@@ -56,7 +54,7 @@ export class ParityPublicInputs {
    * @returns The instance fields.
    */
   static getFields(fields: FieldsOf<ParityPublicInputs>) {
-    return [fields.shaRoot, fields.convertedRoot, fields.vkTreeRoot, fields.proverId] as const;
+    return [fields.startRollingHash, fields.endRollingHash, fields.endSponge, fields.proverId] as const;
   }
 
   /**
@@ -69,7 +67,7 @@ export class ParityPublicInputs {
     return new ParityPublicInputs(
       reader.readObject(Fr),
       reader.readObject(Fr),
-      Fr.fromBuffer(reader),
+      reader.readObject(L1ToL2MessageSponge),
       Fr.fromBuffer(reader),
     );
   }

package/src/proofs/proving_request_type.ts

@@ -5,11 +5,9 @@ export enum ProvingRequestType {
   PRIVATE_TX_BASE_ROLLUP,
   PUBLIC_TX_BASE_ROLLUP,
   TX_MERGE_ROLLUP,
-  BLOCK_ROOT_FIRST_ROLLUP,
-  BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
-  BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
   BLOCK_ROOT_ROLLUP,
   BLOCK_ROOT_SINGLE_TX_ROLLUP,
+  BLOCK_ROOT_NO_TXS_ROLLUP,
   BLOCK_MERGE_ROLLUP,
   CHECKPOINT_ROOT_ROLLUP,
   CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
@@ -17,6 +15,5 @@ export enum ProvingRequestType {
   CHECKPOINT_MERGE_ROLLUP,
   ROOT_ROLLUP,
 
-  PARITY_BASE,
-  PARITY_ROOT,
+  INBOX_PARITY,
 }

package/src/rollup/block_constant_data.ts

@@ -13,10 +13,10 @@ export class BlockConstantData {
     /** Archive tree snapshot at the very beginning of the entire rollup. */
     public lastArchive: AppendOnlyTreeSnapshot,
     /**
-     * L1-to-L2 message tree snapshot after this block lands.
-     * For the first block in a checkpoint, this should be the snapshot after inserting the new l1-to-l2 message subtree
-     * into the last l1-to-l2 tree snapshot in `last_archive`.
-     * For subsequent blocks, this should match the snapshot of the previous block.
+     * L1-to-L2 message tree snapshot after this block's own message bundle has been inserted. The AVM validates this
+     * block's l1-to-l2 message read requests against it, so a tx in this block can read the messages this block
+     * inserts (same-block consumption). Every block-root variant that carries txs asserts this equals its computed
+     * post-bundle root, whether or not the block is the first in its checkpoint.
      */
     public l1ToL2TreeSnapshot: AppendOnlyTreeSnapshot,
     /** Root of the verification key tree. */