feat(fast-inbox): answer message-checkpoint queries from records, not index math (A-1384)

Post-flip, 1024-per-checkpoint index arithmetic is wrong for compact indices, so
the node answers from stored records instead (AZIP-22 Fast Inbox):

- getL1ToL2MessageCheckpoint binary-searches the block records for the first block
  whose L1-to-L2 tree leaf count exceeds the message index, returning that block's
  checkpoint (portal claim helpers depend on this).
- prover-node collectRegisterData derives the checkpoint's consumed messages from
  the Inbox buckets between the parent checkpoint's position and the last block,
  replacing the legacy per-checkpoint getL1ToL2Messages fetch.

The message_store index-formula methods (smallestIndexForCheckpoint etc.) have no
correctness-critical live callers left; the public-simulator fetch degrades safely
without them. They are retired in FI-18.

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

Author: spalladino

yarn-project/aztec-node/src/aztec-node/server.test.ts

@@ -37,7 +37,6 @@ import type { ContractDataSource, ContractInstanceWithAddress } from '@aztec/std
 import { EmptyL1RollupConstants, type L1RollupConstants } from '@aztec/stdlib/epoch-helpers';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { L2LogsSource, MerkleTreeReadOperations, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { mockTx, randomContractInstanceWithAddress } from '@aztec/stdlib/testing';
@@ -1569,13 +1568,18 @@ describe('aztec node', () => {
   });
 
   describe('getL1ToL2MessageCheckpoint', () => {
-    it('returns the checkpoint for a message at index 0n', async () => {
+    it('returns the checkpoint of the block that consumed the message', async () => {
       const msg = Fr.random();
       l1ToL2MessageSource.getL1ToL2MessageIndex.mockResolvedValue(0n);
+      // The first block (checkpoint 1) consumed message index 0: its L1-to-L2 tree leaf count is 1 > 0.
+      l2BlockSource.getBlockNumber.mockResolvedValue(BlockNumber(1));
+      l2BlockSource.getBlockData.mockResolvedValue({
+        checkpointNumber: CheckpointNumber(1),
+        header: { state: { l1ToL2MessageTree: { nextAvailableLeafIndex: 1 } } },
+      } as unknown as BlockData);
 
       const result = await node.getL1ToL2MessageCheckpoint(msg);
-      expect(result).toEqual(InboxLeaf.checkpointNumberFromIndex(0n));
-      expect(result).not.toBeUndefined();
+      expect(result).toEqual(CheckpointNumber(1));
     });
 
     it('returns undefined when the message is not found', async () => {

yarn-project/aztec-node/src/modules/node_world_state_queries.ts

@@ -1,4 +1,9 @@
-import { ARCHIVE_HEIGHT, type L1_TO_L2_MSG_TREE_HEIGHT, type NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
+import {
+  ARCHIVE_HEIGHT,
+  INITIAL_L2_BLOCK_NUM,
+  type L1_TO_L2_MSG_TREE_HEIGHT,
+  type NOTE_HASH_TREE_HEIGHT,
+} from '@aztec/constants';
 import { BlockNumber, type CheckpointNumber, type EpochNumber } from '@aztec/foundation/branded-types';
 import { chunkBy } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -7,6 +12,7 @@ import { sleep } from '@aztec/foundation/sleep';
 import { MembershipWitness, type SiblingPath } from '@aztec/foundation/trees';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import {
+  type BlockData,
   type BlockHash,
   type BlockParameter,
   type DataInBlock,
@@ -16,7 +22,7 @@ import {
 } from '@aztec/stdlib/block';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import type { WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server';
-import { InboxLeaf, type L1ToL2MessageSource, type L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
+import type { L1ToL2MessageSource, L2ToL1MembershipWitness } from '@aztec/stdlib/messaging';
 import {
   MerkleTreeId,
   type NullifierLeafPreimage,
@@ -179,7 +185,35 @@ export class NodeWorldStateQueries {
 
   public async getL1ToL2MessageCheckpoint(l1ToL2Message: Fr): Promise<CheckpointNumber | undefined> {
     const messageIndex = await this.l1ToL2MessageSource.getL1ToL2MessageIndex(l1ToL2Message);
-    return messageIndex !== undefined ? InboxLeaf.checkpointNumberFromIndex(messageIndex) : undefined;
+    if (messageIndex === undefined) {
+      return undefined;
+    }
+    // Post-flip, an L1-to-L2 message at compact leaf index `i` is consumed by the first block whose L1-to-L2 tree leaf
+    // count exceeds `i` (leaf counts are monotonic in block number); that block's checkpoint is the answer, sourced
+    // from the stored block records rather than 1024-per-checkpoint index arithmetic (AZIP-22 Fast Inbox).
+    const block = await this.#findBlockConsumingL1ToL2MessageIndex(messageIndex);
+    return block?.checkpointNumber;
+  }
+
+  /** Binary-searches the block records for the first block whose L1-to-L2 tree leaf count exceeds `messageIndex`. */
+  async #findBlockConsumingL1ToL2MessageIndex(messageIndex: bigint): Promise<BlockData | undefined> {
+    let lo = INITIAL_L2_BLOCK_NUM;
+    let hi = await this.blockSource.getBlockNumber();
+    let result: BlockData | undefined;
+    while (lo <= hi) {
+      const mid = lo + Math.floor((hi - lo) / 2);
+      const block = await this.blockSource.getBlockData({ number: BlockNumber(mid) });
+      if (block === undefined) {
+        break;
+      }
+      if (BigInt(block.header.state.l1ToL2MessageTree.nextAvailableLeafIndex) > messageIndex) {
+        result = block;
+        hi = mid - 1;
+      } else {
+        lo = mid + 1;
+      }
+    }
+    return result;
   }
 
   /**

yarn-project/prover-node/src/prover-node.ts

@@ -13,7 +13,9 @@ import { getLastSiblingPath } from '@aztec/prover-client/helpers';
 import { ChonkCache } from '@aztec/prover-client/orchestrator';
 import { type AvmSimulator, PublicProcessorFactory } from '@aztec/simulator/server';
 import {
+  type BlockHeader,
   EventDrivenL2BlockStream,
+  type L2Block,
   type L2BlockId,
   type L2BlockSource,
   type L2BlockStreamEvent,
@@ -349,9 +351,11 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
   ): Promise<RegisterCheckpointData> {
     const previousBlockNumber = BlockNumber(checkpoint.blocks[0].number - 1);
     const previousBlockHeader = await this.gatherPreviousBlockHeader(previousBlockNumber);
-    const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpoint.number);
-    const previousInboxRollingHash = await this.gatherPreviousInboxRollingHash(checkpoint.number);
     const lastBlock = checkpoint.blocks.at(-1)!;
+    // Streaming Inbox (AZIP-22 Fast Inbox): the checkpoint's consumed messages are those in the Inbox buckets between
+    // the parent checkpoint's consumed position and this checkpoint's last block (compact leaf-count range).
+    const l1ToL2Messages = await this.deriveCheckpointConsumedMessages(previousBlockHeader, lastBlock);
+    const previousInboxRollingHash = await this.gatherPreviousInboxRollingHash(checkpoint.number);
     const lastBlockHash = await lastBlock.header.hash();
     await this.worldState.syncImmediate(lastBlock.number, lastBlockHash);
     const previousArchiveSiblingPath = await getLastSiblingPath(
@@ -367,6 +371,27 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra
     };
   }
 
+  /**
+   * Derives a checkpoint's consumed L1-to-L2 messages, in order, from the Inbox buckets between the parent
+   * checkpoint's consumed position (the block before the checkpoint's first block) and the checkpoint's last block
+   * (compact leaf counts), for the prover to slice per block (AZIP-22 Fast Inbox).
+   */
+  private async deriveCheckpointConsumedMessages(previousBlockHeader: BlockHeader, lastBlock: L2Block): Promise<Fr[]> {
+    const startLeafCount = BigInt(previousBlockHeader.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+    const endLeafCount = BigInt(lastBlock.header.state.l1ToL2MessageTree.nextAvailableLeafIndex);
+    if (endLeafCount <= startLeafCount) {
+      return [];
+    }
+    const startBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(startLeafCount);
+    const endBucket = await this.l1ToL2MessageSource.getInboxBucketByTotalMsgCount(endLeafCount);
+    if (startBucket === undefined || endBucket === undefined) {
+      throw new Error(
+        `Cannot resolve consumed messages for checkpoint ending at block ${lastBlock.number} from the Inbox buckets`,
+      );
+    }
+    return this.l1ToL2MessageSource.getL1ToL2MessagesBetweenBuckets(startBucket.seq, endBucket.seq);
+  }
+
   /**
    * Sources the inbox rolling hash chain-start for a checkpoint: the previous checkpoint's `inboxRollingHash`, or zero
    * for the genesis checkpoint. The prover threads this into the base parity circuits so the rebuilt checkpoint header