test(fast-inbox): epoch proof over per-block message slices and a msgs-only block (A-1385)

Drive the streaming Inbox shapes through the entire proving DAG (block roots
incl. msgs-only, block merge, checkpoint roots, checkpoint merge, root rollup)
at simulated-circuit fidelity in the top-tree orchestrator suite: a checkpoint
whose messages land in a non-first block plus a zero-tx message-only block,
followed by message-carrying and message-less checkpoints. Asserts the root
rollup's inbox rolling-hash range matches the accumulation over the epoch's
messages in block order.

TestContext now threads the inbox rolling hash across the checkpoints it
builds (previously hardcoded to zero), so a checkpoint built after a
message-carrying one commits the correct continuation in its header and the
checkpoint merge continuity assert can be exercised.

Author: spalladino

yarn-project/prover-client/src/mocks/test_context.ts

@@ -59,6 +59,10 @@ export class TestContext {
   private nextBlockNumber = 1;
   private epochNumber = 1;
   private feePayerBalance: Fr;
+  // Running inbox rolling hash across the checkpoints built by this context (never resets: the protocol threads it
+  // from genesis). Each checkpoint's builder starts from it, and it advances by the checkpoint's messages, so a
+  // checkpoint built after a message-carrying one commits the correct continuation in its header.
+  private currentInboxRollingHash = Fr.ZERO;
 
   constructor(
     public worldState: MerkleTreeAdminDatabase,
@@ -241,11 +245,12 @@ export class TestContext {
 
     const cleanFork = await this.worldState.fork();
     const previousCheckpointOutHashes = this.checkpointOutHashes;
+    const startInboxRollingHash = this.currentInboxRollingHash;
     const builder = LightweightCheckpointBuilder.startNewCheckpoint(
       checkpointNumber,
       { ...constants, timestamp },
       previousCheckpointOutHashes,
-      Fr.ZERO,
+      startInboxRollingHash,
       cleanFork,
     );
 
@@ -272,6 +277,7 @@ export class TestContext {
     const checkpoint = await builder.completeCheckpoint();
     this.checkpoints.push(checkpoint);
     this.checkpointOutHashes.push(checkpoint.getCheckpointOutHash());
+    this.currentInboxRollingHash = checkpoint.header.inboxRollingHash;
 
     return {
       constants,
@@ -280,6 +286,7 @@ export class TestContext {
       blocks,
       l1ToL2Messages,
       previousBlockHeader,
+      startInboxRollingHash,
     };
   }
 
@@ -288,8 +295,9 @@ export class TestContext {
    * (streaming Inbox / AZIP-22 Fast Inbox): `l1ToL2MessagesPerBlock[i]` is block `i`'s own message slice,
    * appended at compact indices in insertion order. Lets tests exercise checkpoints whose messages span more
    * than one block, including a non-first block carrying a bundle — the single-block-per-checkpoint
-   * `makeCheckpoint` puts every message in the first block. Non-first blocks must carry at least one tx (an
-   * empty non-first block is rejected by the builder), so `numTxsPerBlock` defaults to 1.
+   * `makeCheckpoint` puts every message in the first block. `numTxsPerBlock` defaults to 1 because the builder
+   * rejects a non-first block with neither txs nor messages; a zero-tx entry whose slice is non-empty is valid
+   * and produces a message-only block.
    */
   public async makeCheckpointWithMessagesPerBlock(
     l1ToL2MessagesPerBlock: Fr[][],
@@ -364,14 +372,15 @@ export class TestContext {
 
     const cleanFork = await this.worldState.fork();
     const previousCheckpointOutHashes = this.checkpointOutHashes;
+    const startInboxRollingHash = this.currentInboxRollingHash;
     // Empty checkpoint-level list + `insertMessagesPerBlock` so the builder inserts each block's slice via
     // `addBlock` (and accumulates them into the checkpoint's rolling hash) rather than up front.
     const builder = await LightweightCheckpointBuilder.startNewCheckpoint(
       checkpointNumber,
       { ...constants, timestamp },
       [],
       previousCheckpointOutHashes,
-      Fr.ZERO,
+      startInboxRollingHash,
       cleanFork,
       undefined,
       0n,
@@ -400,6 +409,7 @@ export class TestContext {
     const checkpoint = await builder.completeCheckpoint();
     this.checkpoints.push(checkpoint);
     this.checkpointOutHashes.push(checkpoint.getCheckpointOutHash());
+    this.currentInboxRollingHash = checkpoint.header.inboxRollingHash;
 
     return {
       constants,
@@ -409,6 +419,7 @@ export class TestContext {
       l1ToL2Messages,
       l1ToL2MessagesPerBlock,
       previousBlockHeader,
+      startInboxRollingHash,
     };
   }
 

yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts

@@ -7,7 +7,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { retryUntil } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
-import { ScopedL2ToL1Message, computeEpochOutHash } from '@aztec/stdlib/messaging';
+import { ScopedL2ToL1Message, accumulateInboxRollingHash, computeEpochOutHash } from '@aztec/stdlib/messaging';
 import { makeScopedL2ToL1Message } from '@aztec/stdlib/testing';
 
 import { TestContext, makeTestDeferredJobQueue } from '../mocks/test_context.js';
@@ -42,20 +42,14 @@ describe('prover/orchestrator/top-tree', () => {
     await context.cleanup();
   });
 
+  /** The checkpoint fixture shape shared by `makeCheckpoint` and `makeCheckpointWithMessagesPerBlock`. */
+  type CheckpointFixture = Awaited<ReturnType<TestContext['makeCheckpoint']>>;
+
   /**
-   * Drives a single checkpoint through `CheckpointSubTreeOrchestrator` and returns
-   * the assembled `CheckpointTopTreeData` plus the originating checkpoint metadata.
+   * Drives a checkpoint fixture through `CheckpointSubTreeOrchestrator`, feeding block `i` the message slice
+   * `messagesPerBlock[i]`, and returns the assembled `CheckpointTopTreeData` plus the originating fixture.
    */
-  async function driveSubTree(numBlocks: number, numTxsPerBlock: number, numL1ToL2Messages = 0, numL2ToL1Messages = 0) {
-    const fixture = await context.makeCheckpoint(numBlocks, {
-      numTxsPerBlock,
-      numL1ToL2Messages,
-      makeProcessedTxOpts:
-        numL2ToL1Messages > 0
-          ? () => ({ privateOnly: false, avmAccumulatedData: { l2ToL1Msgs: makeL2ToL1Messages(numL2ToL1Messages) } })
-          : undefined,
-    });
-
+  async function driveFixture(fixture: CheckpointFixture, messagesPerBlock: Fr[][]) {
     const subTree = await CheckpointSubTreeOrchestrator.start(
       context.worldState,
       context.prover,
@@ -66,20 +60,15 @@ describe('prover/orchestrator/top-tree', () => {
       makeTestDeferredJobQueue(),
       fixture.constants,
       fixture.l1ToL2Messages,
-      Fr.ZERO,
-      numBlocks,
+      fixture.startInboxRollingHash,
+      fixture.blocks.length,
       fixture.previousBlockHeader,
     );
     const resultPromise = subTree.getSubTreeResult();
 
     for (const [blockIndex, block] of fixture.blocks.entries()) {
       const { blockNumber, timestamp } = block.header.globalVariables;
-      await subTree.startNewBlock(
-        blockNumber,
-        timestamp,
-        block.txs.length,
-        blockIndex === 0 ? fixture.l1ToL2Messages : [],
-      );
+      await subTree.startNewBlock(blockNumber, timestamp, block.txs.length, messagesPerBlock[blockIndex]);
       if (block.txs.length > 0) {
         await subTree.addTxs(block.txs);
       }
@@ -103,6 +92,33 @@ describe('prover/orchestrator/top-tree', () => {
     return { fixture, topTreeData };
   }
 
+  /**
+   * Builds a checkpoint via `makeCheckpoint` (every message in the first block) and drives it through
+   * `CheckpointSubTreeOrchestrator`, returning the assembled `CheckpointTopTreeData` plus the fixture.
+   */
+  async function driveSubTree(numBlocks: number, numTxsPerBlock: number, numL1ToL2Messages = 0, numL2ToL1Messages = 0) {
+    const fixture = await context.makeCheckpoint(numBlocks, {
+      numTxsPerBlock,
+      numL1ToL2Messages,
+      makeProcessedTxOpts:
+        numL2ToL1Messages > 0
+          ? () => ({ privateOnly: false, avmAccumulatedData: { l2ToL1Msgs: makeL2ToL1Messages(numL2ToL1Messages) } })
+          : undefined,
+    });
+    const messagesPerBlock = fixture.blocks.map((_, i) => (i === 0 ? fixture.l1ToL2Messages : []));
+    return await driveFixture(fixture, messagesPerBlock);
+  }
+
+  /**
+   * Like {@link driveSubTree} but distributes the checkpoint's messages across its blocks (streaming Inbox,
+   * AZIP-22): block `i` carries `l1ToL2MessagesPerBlock[i]` as its own slice. A zero-tx entry in `numTxsPerBlock`
+   * whose slice is non-empty produces a message-only block, proven by the msgs-only block root.
+   */
+  async function driveSubTreeWithMessageSlices(l1ToL2MessagesPerBlock: Fr[][], numTxsPerBlock: number[]) {
+    const fixture = await context.makeCheckpointWithMessagesPerBlock(l1ToL2MessagesPerBlock, { numTxsPerBlock });
+    return await driveFixture(fixture, l1ToL2MessagesPerBlock);
+  }
+
   it('produces an epoch proof for a single-checkpoint, single-block, single-tx epoch', async () => {
     const { topTreeData } = await driveSubTree(1, 1);
     const challenges = await context.getFinalBlobChallenges();
@@ -169,6 +185,39 @@ describe('prover/orchestrator/top-tree', () => {
     }
   });
 
+  it('produces an epoch proof when messages span blocks, including a message-only block', async () => {
+    // The streaming Inbox (AZIP-22 Fast Inbox) shapes, driven through the entire proving DAG at simulated-circuit
+    // fidelity: a checkpoint whose messages land in a non-first block, a zero-tx message-only block (proven by the
+    // msgs-only block root), a block merge above the three block roots, the two-input checkpoint root over per-block
+    // bundles, the single-block checkpoint root for the follow-on checkpoints, the checkpoint merge asserting inbox
+    // rolling-hash continuity across a message-carrying boundary, and the root rollup exposing the epoch's
+    // rolling-hash range.
+    const ckpt1Slices = [[new Fr(0x100), new Fr(0x101)], [], [new Fr(0x102), new Fr(0x103), new Fr(0x104)]];
+    const a = await driveSubTreeWithMessageSlices(ckpt1Slices, [1, 1, 0]);
+    // A single-block checkpoint with messages after a message-carrying checkpoint: its parity chain starts from
+    // checkpoint 0's (non-zero) end rolling hash.
+    const b = await driveSubTree(1, 1, 2);
+    // A message-less checkpoint after message-carrying ones: the rolling hash must pass through unchanged.
+    const c = await driveSubTree(1, 1);
+    const challenges = await context.getFinalBlobChallenges();
+
+    const topTree = new TopTreeOrchestrator(context.prover, EthAddress.ZERO, makeTestDeferredJobQueue());
+    try {
+      const result = await topTree.prove(EpochNumber(1), 3, challenges, [a.topTreeData, b.topTreeData, c.topTreeData]);
+      expect(result.proof).toBeDefined();
+      expect(result.publicInputs).toBeDefined();
+
+      // The epoch's rolling-hash range binds the exact message sequence consumed, in block order, across all three
+      // checkpoints; L1 validates this range against the Inbox when the proof lands.
+      const epochMessages = [...a.fixture.l1ToL2Messages, ...b.fixture.l1ToL2Messages];
+      expect(epochMessages.length).toBe(7); // sanity: the fixtures really did carry messages
+      expect(result.publicInputs.previousInboxRollingHash).toEqual(Fr.ZERO);
+      expect(result.publicInputs.endInboxRollingHash).toEqual(accumulateInboxRollingHash(Fr.ZERO, epochMessages));
+    } finally {
+      await topTree.stop();
+    }
+  }, 300_000);
+
   it('pipelines: starts ckpt0 root rollup before ckpt1 sub-tree resolves', async () => {
     // Drive both sub-trees synchronously (still no top tree running).
     const a = await driveSubTree(1, 1);