test(fast-inbox): prover orchestrator multi-block message-slice coverage (A-1385)

Add a checkpoint-sub-tree orchestrator test for a checkpoint whose L1-to-L2
messages span multiple blocks, including a non-first block carrying a bundle.
Asserts per-block start/end L1-to-L2 snapshot continuity and slice partitioning
(no gap/overlap; block slice = [prevBlockLeafCount, blockLeafCount)).

Adds TestContext.makeCheckpointWithMessagesPerBlock to distribute a bundle
across a checkpoint's blocks (the single-block-per-checkpoint makeCheckpoint
puts every message in the first block).

Author: spalladino

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

@@ -283,6 +283,135 @@ export class TestContext {
     };
   }
 
+  /**
+   * Like {@link makeCheckpoint} but distributes the L1-to-L2 message bundle across the checkpoint's blocks
+   * (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.
+   */
+  public async makeCheckpointWithMessagesPerBlock(
+    l1ToL2MessagesPerBlock: Fr[][],
+    {
+      numTxsPerBlock = 1,
+      makeProcessedTxOpts = () => ({}),
+      ...constantOpts
+    }: {
+      numTxsPerBlock?: number | number[];
+      makeProcessedTxOpts?: (
+        blockGlobalVariables: GlobalVariables,
+        txIndex: number,
+      ) => Partial<Parameters<typeof mockProcessedTx>[0]>;
+    } & Partial<FieldsOf<CheckpointConstantData>> = {},
+  ) {
+    const numBlocks = l1ToL2MessagesPerBlock.length;
+    if (numBlocks === 0) {
+      throw new Error('Cannot make a checkpoint with 0 blocks.');
+    }
+
+    const checkpointIndex = this.nextCheckpointIndex++;
+    const checkpointNumber = this.nextCheckpointNumber;
+    this.nextCheckpointNumber++;
+    const slotNumber = checkpointNumber * 15;
+
+    const constants = makeCheckpointConstants(slotNumber, constantOpts);
+    const l1ToL2Messages = l1ToL2MessagesPerBlock.flat();
+
+    const fork = await this.worldState.fork();
+
+    const startBlockNumber = this.nextBlockNumber;
+    const previousBlockHeader = this.getBlockHeader(BlockNumber(startBlockNumber - 1));
+    const timestamp = BigInt(slotNumber * 26);
+
+    const blockGlobalVariables = times(numBlocks, i =>
+      makeGlobals(startBlockNumber + i, slotNumber, {
+        coinbase: constants.coinbase,
+        feeRecipient: constants.feeRecipient,
+        gasFees: constants.gasFees,
+        timestamp,
+      }),
+    );
+    this.nextBlockNumber += numBlocks;
+
+    // Build txs per block. Append the block's message slice to the fork before its txs so the per-block end
+    // state matches the builder's (message-tree and tx-effect trees are independent, so append order does not
+    // matter, but the cumulative message tree must reflect the slices already inserted).
+    let totalTxs = 0;
+    const blockEndStates: StateReference[] = [];
+    const blockTxs = await timesAsync(numBlocks, async blockIndex => {
+      await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPerBlock[blockIndex]);
+      const newL1ToL2Snapshot = await getTreeSnapshot(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, fork);
+
+      const txIndexOffset = totalTxs;
+      const numTxs = typeof numTxsPerBlock === 'number' ? numTxsPerBlock : numTxsPerBlock[blockIndex];
+      totalTxs += numTxs;
+      const txs = await timesAsync(numTxs, txIndex =>
+        this.makeProcessedTx({
+          seed: (txIndexOffset + txIndex + 1) * 321 + (checkpointIndex + 1) * 123456 + this.epochNumber * 0x99999,
+          globalVariables: blockGlobalVariables[blockIndex],
+          anchorBlockHeader: previousBlockHeader,
+          newL1ToL2Snapshot,
+          ...makeProcessedTxOpts(blockGlobalVariables[blockIndex], txIndexOffset + txIndex),
+        }),
+      );
+
+      const endState = await this.updateTrees(txs, fork);
+      blockEndStates.push(endState);
+
+      return txs;
+    });
+
+    const cleanFork = await this.worldState.fork();
+    const previousCheckpointOutHashes = this.checkpointOutHashes;
+    // 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,
+      cleanFork,
+      undefined,
+      0n,
+      true,
+    );
+
+    const blocks = [];
+    for (let i = 0; i < numBlocks; i++) {
+      const txs = blockTxs[i];
+      const state = blockEndStates[i];
+
+      const { block } = await builder.addBlock(blockGlobalVariables[i], txs, {
+        expectedEndState: state,
+        insertTxsEffects: true,
+        l1ToL2Messages: l1ToL2MessagesPerBlock[i],
+      });
+
+      const header = block.header;
+      this.headers.set(block.number, header);
+
+      await this.worldState.handleL2BlockAndMessages(block, l1ToL2MessagesPerBlock[i]);
+
+      blocks.push({ header, txs });
+    }
+
+    const checkpoint = await builder.completeCheckpoint();
+    this.checkpoints.push(checkpoint);
+    this.checkpointOutHashes.push(checkpoint.getCheckpointOutHash());
+
+    return {
+      constants,
+      checkpoint,
+      header: checkpoint.header,
+      blocks,
+      l1ToL2Messages,
+      l1ToL2MessagesPerBlock,
+      previousBlockHeader,
+    };
+  }
+
   private async makeProcessedTx(opts: Parameters<typeof mockProcessedTx>[0] = {}): Promise<ProcessedTx> {
     const tx = await mockProcessedTx({
       vkTreeRoot: getVKTreeRoot(),

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

@@ -219,4 +219,77 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => {
       await subTree.stop();
     }
   });
+
+  it('slices L1-to-L2 messages per block across a multi-block checkpoint', async () => {
+    // A checkpoint whose messages span more than one block: the first block carries a bundle, a middle block
+    // carries none (txs only), and a non-first block carries a bundle. The sub-tree must append each block's
+    // own slice at compact indices with contiguous, non-overlapping per-block snapshots (AZIP-22 Fast Inbox).
+    const l1ToL2MessagesPerBlock = [[new Fr(1001), new Fr(1002)], [], [new Fr(1003), new Fr(1004), new Fr(1005)]];
+    const numBlocks = l1ToL2MessagesPerBlock.length;
+    const { constants, blocks, l1ToL2Messages, previousBlockHeader } = await context.makeCheckpointWithMessagesPerBlock(
+      l1ToL2MessagesPerBlock,
+      { numTxsPerBlock: 1 },
+    );
+    expect(l1ToL2Messages.length).toBe(5);
+
+    const subTree = await CheckpointSubTreeOrchestrator.start(
+      context.worldState,
+      context.prover,
+      EthAddress.ZERO,
+      chonkCache,
+      EpochNumber(1),
+      false,
+      makeTestDeferredJobQueue(),
+      constants,
+      l1ToL2Messages,
+      Fr.ZERO,
+      numBlocks,
+      previousBlockHeader,
+    );
+    try {
+      const resultPromise = subTree.getSubTreeResult();
+
+      for (const [blockIndex, block] of blocks.entries()) {
+        const { blockNumber, timestamp } = block.header.globalVariables;
+        await subTree.startNewBlock(blockNumber, timestamp, block.txs.length, l1ToL2MessagesPerBlock[blockIndex]);
+        if (block.txs.length > 0) {
+          await subTree.addTxs(block.txs);
+        }
+        await subTree.setBlockCompleted(blockNumber, block.header);
+      }
+
+      const result = await resultPromise;
+      expect(result.blockProofOutputs).toHaveLength(numBlocks);
+
+      // Order the block outputs by block number (the archive tree grows by exactly one leaf per block).
+      const ordered = [...result.blockProofOutputs].sort(
+        (a, b) => a.inputs.previousArchive.nextAvailableLeafIndex - b.inputs.previousArchive.nextAvailableLeafIndex,
+      );
+
+      // Walk the blocks in order, asserting the L1-to-L2 message tree partitions cleanly into per-block slices,
+      // with each block's start snapshot equal to the previous block's end snapshot (the "threaded" per-block
+      // L1-to-L2 tree state).
+      const baseLeaf = ordered[0].inputs.startState.l1ToL2MessageTree.nextAvailableLeafIndex;
+      let expectedStartLeaf = baseLeaf;
+      for (const [i, output] of ordered.entries()) {
+        const inputs = output.inputs;
+        const startLeaf = inputs.startState.l1ToL2MessageTree.nextAvailableLeafIndex;
+        const endLeaf = inputs.endState.l1ToL2MessageTree.nextAvailableLeafIndex;
+        const sliceLen = l1ToL2MessagesPerBlock[i].length;
+
+        // Only the checkpoint's first block flags isFirstBlock.
+        expect(inputs.isFirstBlock).toBe(i === 0);
+        // Contiguous, non-overlapping slices: this block starts where the previous one ended (no gap/overlap).
+        expect(startLeaf).toBe(expectedStartLeaf);
+        // Block slice = [prevBlockLeafCount, blockLeafCount): the tree grows by exactly this block's bundle size.
+        expect(endLeaf - startLeaf).toBe(sliceLen);
+        expectedStartLeaf = endLeaf;
+      }
+
+      // Every message is accounted for with no gap or overlap across the checkpoint's blocks.
+      expect(expectedStartLeaf - baseLeaf).toBe(l1ToL2Messages.length);
+    } finally {
+      await subTree.stop();
+    }
+  });
 });