feat(fast-inbox): drop bundle num_real_msgs and pad in the prover path (A-1384)

Align the node message-bundle representation and prover orchestrator with the
circuit flip (AZIP-22 Fast Inbox):

- stdlib L1ToL2MessageBundle drops numRealMsgs (single numMsgs real count);
  makeL1ToL2MessageBundle and the noir conversion follow.
- Prover orchestrator: compact (unpadded) L1-to-L2 tree insertion, checkpoint
  InboxParity in_hash hint fed zero, getPaddedL1ToL2Messages/getNumRealL1ToL2Messages
  retired.

Known follow-up (flagged in-code): the prover still assigns the whole checkpoint's
messages to its first block; post-flip a block carries at most
MAX_L1_TO_L2_MSGS_PER_BLOCK and a checkpoint drains across up to four blocks, so
the per-block message split (with per-block snapshots and compact frontier hints)
still needs the proving-path rework, verified by epoch-proving e2e on CI.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: spalladino

yarn-project/noir-protocol-circuits-types/src/conversion/server.ts

@@ -836,7 +836,6 @@ function mapL1ToL2MessageBundleToNoir(bundle: L1ToL2MessageBundle) {
     // get the fixed-length `FixedLengthArray` the generated `L1ToL2MessageBundle.messages` type requires.
     messages: mapFieldArrayToNoir(bundle.messages, MAX_L1_TO_L2_MSGS_PER_BLOCK),
     num_msgs: mapNumberToNoir(bundle.numMsgs),
-    num_real_msgs: mapNumberToNoir(bundle.numRealMsgs),
   };
 }
 

yarn-project/prover-client/src/orchestrator/block-proving-state.ts

@@ -12,7 +12,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { L1ToL2MessageBundle } from '@aztec/stdlib/messaging';
+import { L1ToL2MessageBundle, makeL1ToL2MessageBundle } from '@aztec/stdlib/messaging';
 import type { RollupHonkProofData } from '@aztec/stdlib/proofs';
 import {
   BlockRollupPublicInputs,
@@ -368,18 +368,17 @@ export class BlockProvingState {
   }
 
   /**
-   * The message bundle this block appends. Transitionally the first block carries the whole checkpoint's messages
-   * padded to `MAX_L1_TO_L2_MSGS_PER_BLOCK` — inserted as a full aligned subtree into the L1-to-L2 tree (`numMsgs` =
-   * the cap), while only the real messages are absorbed into the message sponge (`numRealMsgs`, matching the
-   * checkpoint's InboxParity proof). Non-first blocks carry an empty bundle.
+   * The real-count message bundle this block appends (AZIP-22 Fast Inbox): the real leaves inserted at compact indices
+   * and absorbed into the message sponge.
+   *
+   * TODO(fast-inbox): the prover still assigns the whole checkpoint's messages to the first block. Post-flip a block
+   * carries at most `MAX_L1_TO_L2_MSGS_PER_BLOCK` and a checkpoint drains its consumption across up to four blocks, so
+   * this must split the checkpoint's messages per block (with per-block start/end snapshots and full-height frontier
+   * hints at compact indices). Requires the proving-path rework; verified by epoch-proving e2e on CI.
    */
   #getMessageBundle(): L1ToL2MessageBundle {
     if (this.isFirstBlock) {
-      return new L1ToL2MessageBundle(
-        this.parentCheckpoint.getPaddedL1ToL2Messages(),
-        MAX_L1_TO_L2_MSGS_PER_BLOCK,
-        this.parentCheckpoint.getNumRealL1ToL2Messages(),
-      );
+      return makeL1ToL2MessageBundle(this.parentCheckpoint.getL1ToL2Messages());
     }
     return L1ToL2MessageBundle.empty();
   }

yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts

@@ -10,7 +10,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees';
 import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server';
-import { L1ToL2MessageSponge, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+import { L1ToL2MessageSponge } from '@aztec/stdlib/messaging';
 import { InboxParityPrivateInputs, type ParityPublicInputs } from '@aztec/stdlib/parity';
 import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData } from '@aztec/stdlib/rollup';
 import type { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
@@ -54,9 +54,6 @@ export class CheckpointProvingState {
       Fr,
       typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH
     >,
-    // The checkpoint's messages padded to `MAX_L1_TO_L2_MSGS_PER_CHECKPOINT` (the first block's transitional bundle,
-    // inserted as a full subtree into the L1-to-L2 tree).
-    private readonly paddedL1ToL2Messages: Fr[],
     // Message-bundle sponge over the checkpoint's real messages (real-count absorb). Equals the InboxParity proof's
     // end sponge and the sponge the block roots accumulate, so it is threaded into non-first block roots as their
     // inherited `startMsgSponge`.
@@ -71,14 +68,9 @@ export class CheckpointProvingState {
     this.firstBlockNumber = BlockNumber(headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1);
   }
 
-  /** The checkpoint's messages padded to the per-checkpoint cap (the first block's transitional bundle). */
-  public getPaddedL1ToL2Messages(): Fr[] {
-    return this.paddedL1ToL2Messages;
-  }
-
-  /** Number of real (non-padding) L1-to-L2 messages in the checkpoint — the sponge/InboxParity real-count. */
-  public getNumRealL1ToL2Messages(): number {
-    return this.l1ToL2Messages.length;
+  /** The checkpoint's real L1-to-L2 messages (unpadded), consumed across its blocks (AZIP-22 Fast Inbox). */
+  public getL1ToL2Messages(): Fr[] {
+    return this.l1ToL2Messages;
   }
 
   /** The message-bundle sponge over the checkpoint's real messages (real-count absorb) — inherited by non-first block roots. */
@@ -179,7 +171,8 @@ export class CheckpointProvingState {
       this.l1ToL2Messages,
       this.startInboxRollingHash,
       L1ToL2MessageSponge.empty(),
-      computeInHashFromL1ToL2Messages(this.l1ToL2Messages),
+      // Legacy in_hash is dead post-flip; the InboxParity pass-through hint carries zero (AZIP-22 Fast Inbox).
+      Fr.ZERO,
       this.constants.vkTreeRoot,
       this.constants.proverId,
     );

yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts

@@ -3,11 +3,9 @@ import {
   type ARCHIVE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
-  MAX_L1_TO_L2_MSGS_PER_CHECKPOINT,
   NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH,
 } from '@aztec/constants';
 import { BlockNumber, type EpochNumber } from '@aztec/foundation/branded-types';
-import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { AbortError } from '@aztec/foundation/error';
 import type { LoggerBindings } from '@aztec/foundation/log';
@@ -528,10 +526,8 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       newL1ToL2MessageSubtreeRootSiblingPath,
     } = await this.updateL1ToL2MessageTree(l1ToL2Messages, db);
 
-    // The first block inserts the whole checkpoint's messages as a full padded subtree into the L1-to-L2 tree, so keep
-    // the padded array for the block-root bundle. The message sponge, however, absorbs only the real messages
-    // (real-count), so it matches the checkpoint's single InboxParity proof; non-first block roots inherit this sponge.
-    const paddedL1ToL2Messages = padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT);
+    // The message sponge absorbs the checkpoint's real messages (real-count), matching the checkpoint's single
+    // InboxParity proof; non-first block roots inherit this sponge (AZIP-22 Fast Inbox).
     const checkpointMsgSponge = L1ToL2MessageSponge.empty();
     await checkpointMsgSponge.absorb(l1ToL2Messages);
 
@@ -547,7 +543,6 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler {
       lastL1ToL2MessageSubtreeRootSiblingPath,
       newL1ToL2MessageTreeSnapshot,
       newL1ToL2MessageSubtreeRootSiblingPath,
-      paddedL1ToL2Messages,
       checkpointMsgSponge,
       Number(this.epochNumber),
       /* isAlive */ () => !this.cancelled,

yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts

@@ -6,33 +6,29 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 /**
- * A block's L1-to-L2 message bundle: the leaves it inserts into the L1-to-L2 message tree plus the two counts a block
- * root needs — one for the (transitionally padded) tree insert, one for the real-count sponge absorb. See the Noir
- * `L1ToL2MessageBundle`. Once the tree insert becomes real-count too, `numMsgs === numRealMsgs` and `numRealMsgs` is
- * dropped.
+ * A block's L1-to-L2 message bundle: the real message leaves it inserts into the L1-to-L2 message tree and the count
+ * that drives both the compact (unpadded) tree append and the message-sponge absorb (AZIP-22 Fast Inbox). See the Noir
+ * `L1ToL2MessageBundle`.
  */
 export class L1ToL2MessageBundle {
   constructor(
-    /** The message leaves, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a plain array (not a tuple)
-     * to avoid TS's deep-instantiation limit on the 1024-lane type. */
+    /** The real message leaves in the leading lanes, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a
+     * plain array (not a tuple) to avoid TS's deep-instantiation limit on the wide type. */
     public readonly messages: Fr[],
-    /** Number of leaves inserted into the L1-to-L2 message tree (the padded subtree size, or 0 for an empty block). */
+    /** Number of real messages: drives both the compact tree append and the sponge absorb. */
     public readonly numMsgs: number,
-    /** Number of real (non-padding) messages absorbed into the message sponge. */
-    public readonly numRealMsgs: number,
   ) {}
 
   /** An empty bundle: no leaves inserted, nothing absorbed. */
   static empty(): L1ToL2MessageBundle {
     return new L1ToL2MessageBundle(
       Array.from({ length: MAX_L1_TO_L2_MSGS_PER_BLOCK }, () => Fr.ZERO),
       0,
-      0,
     );
   }
 
   toBuffer() {
-    return serializeToBuffer(this.messages, this.numMsgs, this.numRealMsgs);
+    return serializeToBuffer(this.messages, this.numMsgs);
   }
 
   toString() {
@@ -43,7 +39,7 @@ export class L1ToL2MessageBundle {
     const reader = BufferReader.asReader(buffer);
     // Array.from (not readArray with the literal cap) keeps the type `Fr[]` and avoids TS's deep-tuple instantiation.
     const messages = Array.from({ length: MAX_L1_TO_L2_MSGS_PER_BLOCK }, () => Fr.fromBuffer(reader));
-    return new L1ToL2MessageBundle(messages, reader.readNumber(), reader.readNumber());
+    return new L1ToL2MessageBundle(messages, reader.readNumber());
   }
 
   static fromString(str: string) {
@@ -59,12 +55,11 @@ export class L1ToL2MessageBundle {
   }
 }
 
-/** Pads `messages` to a full subtree and wraps it into a bundle whose tree-insert count is the padded subtree size. */
+/** Wraps `messages` (the real leaves) into a bundle: the leaves fill the leading lanes, the count is the real count. */
 export function makeL1ToL2MessageBundle(messages: Fr[]): L1ToL2MessageBundle {
   // Explicit `<Fr, number>` keeps the result `Fr[]`; padding to the literal cap would otherwise infer a deep tuple.
   return new L1ToL2MessageBundle(
     padArrayEnd<Fr, number>(messages, Fr.ZERO, MAX_L1_TO_L2_MSGS_PER_BLOCK),
-    MAX_L1_TO_L2_MSGS_PER_BLOCK,
     messages.length,
   );
 }

yarn-project/stdlib/src/tests/factories.ts

@@ -966,11 +966,7 @@ export function makeTxMergeRollupPrivateInputs(seed = 0): TxMergeRollupPrivateIn
 export function makeBlockRootFirstRollupPrivateInputs(seed = 0) {
   return new BlockRootFirstRollupPrivateInputs(
     [makeProofData(seed + 0x1000, makeTxRollupPublicInputs), makeProofData(seed + 0x2000, makeTxRollupPublicInputs)],
-    new L1ToL2MessageBundle(
-      makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500),
-      MAX_L1_TO_L2_MSGS_PER_BLOCK,
-      MAX_L1_TO_L2_MSGS_PER_BLOCK,
-    ),
+    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), MAX_L1_TO_L2_MSGS_PER_BLOCK),
     makeAppendOnlyTreeSnapshot(seed + 0x3000),
     makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_TREE_HEIGHT),
     makeSiblingPath(seed + 0x5000, ARCHIVE_HEIGHT),
@@ -980,7 +976,7 @@ export function makeBlockRootFirstRollupPrivateInputs(seed = 0) {
 export function makeBlockRootSingleTxRollupPrivateInputs(seed = 0) {
   return new BlockRootSingleTxRollupPrivateInputs(
     makeProofData(seed + 0x1000, makeTxRollupPublicInputs),
-    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), 0, 0),
+    new L1ToL2MessageBundle(makeArray(MAX_L1_TO_L2_MSGS_PER_BLOCK, fr, seed + 0x2500), 0),
     makeAppendOnlyTreeSnapshot(seed + 0x2800),
     makeL1ToL2MessageSponge(seed + 0x3000),
     makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_TREE_HEIGHT),