test(fast-inbox): rework l1 publisher integration test for streaming inbox consumption (A-1388)

The suite still modeled the legacy per-checkpoint lag (a shift register
consuming messages sent two checkpoints earlier) and built every checkpoint
header from a zero previous rolling hash, neither of which can pass the
streaming-inbox propose validation. Each checkpoint now consumes every
message sent while it was built: the previous checkpoint's inboxRollingHash
threads into the next header, and the propose bucket hint is read from the
Inbox's current bucket, which also satisfies the mandatory-consumption
assert. Single-checkpoint helpers default to consuming nothing (bucket hint
0 against the genesis bucket) instead of a padded zero-filled list.

The suite cannot run locally (stale circuit artifacts in
noir-protocol-circuits-types); CI is the runner of record.

Author: spalladino

yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts

@@ -22,7 +22,12 @@ import { EpochCache } from '@aztec/epoch-cache';
 import { createEthereumChain } from '@aztec/ethereum/chain';
 import { createExtendedL1Client } from '@aztec/ethereum/client';
 import { type L1ContractsConfig, getL1ContractsConfigEnvVars } from '@aztec/ethereum/config';
-import { GovernanceProposerContract, RollupContract, SimulationOverridesBuilder } from '@aztec/ethereum/contracts';
+import {
+  GovernanceProposerContract,
+  InboxContract,
+  RollupContract,
+  SimulationOverridesBuilder,
+} from '@aztec/ethereum/contracts';
 import { type DeployAztecL1ContractsArgs, deployAztecL1Contracts } from '@aztec/ethereum/deploy-aztec-l1-contracts';
 import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
 import { TxUtilsState, createL1TxUtils } from '@aztec/ethereum/l1-tx-utils';
@@ -111,7 +116,8 @@ const logger = createLogger('integration_l1_publisher');
 // depending on @aztec/aztec-node, which would create a sequencer-client <-> aztec-node cycle.
 const config: SequencerClientConfig & L1ContractsConfig = { ...getL1ContractsConfigEnvVars(), ...getConfigEnvVars() };
 
-// Must exceed the inbox lag (network default 2) so at least one checkpoint consumes a real L1->L2 message.
+// Several consecutive checkpoints, each consuming the L1->L2 messages sent while it was being built, so real
+// messages are genuinely consumed and validated on L1 (AZIP-22 Fast Inbox).
 const numberOfConsecutiveBlocks = 3;
 
 jest.setTimeout(1000000);
@@ -444,13 +450,16 @@ describe('L1Publisher integration', () => {
 
   /**
    * Build a checkpoint with a single block using the LightweightCheckpointBuilder.
-   * This properly computes all checkpoint header fields (blobsHash, blockHeadersHash, inHash, epochOutHash, etc.)
+   * This properly computes all checkpoint header fields (blobsHash, blockHeadersHash, inboxRollingHash,
+   * epochOutHash, etc.). `previousInboxRollingHash` is the previous checkpoint's rolling hash (zero at genesis), so
+   * the header's `inboxRollingHash` continues the on-chain Inbox chain over `l1ToL2Messages`.
    */
   const buildCheckpoint = async (
     globalVariables: GlobalVariables,
     txs: ProcessedTx[],
     l1ToL2Messages: Fr[],
     previousCheckpointOutHashes: Fr[] = [],
+    previousInboxRollingHash: Fr = Fr.ZERO,
   ): Promise<Checkpoint> => {
     await worldStateSynchronizer.syncImmediate();
     const tempFork = await worldStateSynchronizer.fork(BlockNumber(globalVariables.blockNumber - 1));
@@ -472,7 +481,7 @@ describe('L1Publisher integration', () => {
       checkpointConstants,
       l1ToL2Messages,
       previousCheckpointOutHashes,
-      Fr.ZERO,
+      previousInboxRollingHash,
       tempFork,
     );
 
@@ -486,7 +495,8 @@ describe('L1Publisher integration', () => {
   const buildSingleCheckpoint = async (
     opts: { l1ToL2Messages?: Fr[]; blockNumber?: BlockNumber; slot?: SlotNumber } = {},
   ) => {
-    const l1ToL2Messages = opts.l1ToL2Messages ?? new Array(MAX_L1_TO_L2_MSGS_PER_CHECKPOINT).fill(Fr.ZERO);
+    // By default a single checkpoint consumes no Inbox messages (bucketHint 0 against the genesis bucket).
+    const l1ToL2Messages = opts.l1ToL2Messages ?? [];
 
     const txs = await Promise.all([makeProcessedTx(0x1000), makeProcessedTx(0x2000)]);
     const ts = (await l1Client.getBlock()).timestamp;
@@ -516,10 +526,8 @@ describe('L1Publisher integration', () => {
 
   describe('block building', () => {
     beforeEach(async () => {
-      // This suite proposes consecutive checkpoints and models the inbox lag by hand (a checkpoint
-      // consumes the L1->L2 messages sent inboxLag checkpoints earlier -- see the shift register in
-      // buildAndPublishBlock). It inherits the network default lag and proposes enough checkpoints
-      // that a real message is actually consumed and validated on L1.
+      // This suite proposes consecutive checkpoints, each consuming the streaming-Inbox messages sent while it was
+      // being built (AZIP-22 Fast Inbox), so real messages are genuinely consumed and validated on L1.
       await setup();
     });
 
@@ -534,11 +542,12 @@ describe('L1Publisher integration', () => {
         '0x1647b194c649f5dd01d7c832f89b0f496043c9150797923ea89e93d5ac619a93',
       );
 
-      // Legacy per-checkpoint lag model: a message inserted while building checkpoint N was only consumable at
-      // checkpoint N + inboxLag. Modeled with a shift register so a real message is genuinely consumed and validated
-      // on L1. Retained here for the integration flow; the streaming Inbox (AZIP-22) consumes per block instead.
-      const inboxLag = 2;
-      const messagesInFlight: Fr[][] = Array.from({ length: inboxLag }, () => []);
+      // Streaming Inbox consumption (AZIP-22 Fast Inbox): each checkpoint consumes every message sent so far, so
+      // its header rolling hash continues the previous checkpoint's and matches the Inbox's current bucket. The
+      // bucket hint is read from the Inbox at propose time; consuming through the newest bucket trivially satisfies
+      // the mandatory-consumption assert.
+      const inboxContract = new InboxContract(l1Client, l1ContractAddresses.inboxAddress.toString());
+      let previousInboxRollingHash = Fr.ZERO;
       const blobFieldsPerCheckpoint: Fr[][] = [];
       // The below batched blob is used for testing different epochs with 1..numberOfConsecutiveBlocks blocks on L1.
       // For real usage, always collect ALL epoch blobs first then call .batch().
@@ -549,15 +558,11 @@ describe('L1Publisher integration', () => {
         // and causes a chain prune
         const l1ToL2Content = range(Math.min(16, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT), 128 * i + 1 + 0x400).map(fr);
 
-        const sentThisCheckpoint: Fr[] = [];
+        const currentL1ToL2Messages: Fr[] = [];
         for (let j = 0; j < l1ToL2Content.length; j++) {
-          sentThisCheckpoint.push(await sendToL2(l1ToL2Content[j], recipientAddress));
+          currentL1ToL2Messages.push(await sendToL2(l1ToL2Content[j], recipientAddress));
         }
 
-        // Consume the messages sent inboxLag checkpoints ago, then enqueue this checkpoint's messages.
-        const currentL1ToL2Messages = messagesInFlight.shift()!;
-        messagesInFlight.push(sentThisCheckpoint);
-
         // Ensure that each transaction has unique (non-intersecting nullifier values)
         const totalNullifiersPerBlock = 4 * MAX_NULLIFIERS_PER_TX;
         const txs = await timesParallel(numTxs, txIndex =>
@@ -579,7 +584,14 @@ describe('L1Publisher integration', () => {
           new GasFees(0, await rollup.getManaMinFeeAt(timestamp, true)),
         );
 
-        const checkpoint = await buildCheckpoint(globalVariables, txs, currentL1ToL2Messages);
+        const checkpoint = await buildCheckpoint(
+          globalVariables,
+          txs,
+          currentL1ToL2Messages,
+          [],
+          previousInboxRollingHash,
+        );
+        previousInboxRollingHash = checkpoint.header.inboxRollingHash;
         const block = checkpoint.blocks[0];
 
         const totalManaUsed = txs.reduce((acc, tx) => acc.add(new Fr(tx.gasUsed.billedGas.l2Gas)), Fr.ZERO);
@@ -609,11 +621,13 @@ describe('L1Publisher integration', () => {
           deployerAccount.address,
         );
 
+        // The checkpoint consumed everything sent so far, so its consumed bucket is the Inbox's newest.
+        const bucketHint = await inboxContract.getCurrentBucketSeq();
         await publisher.enqueueProposeCheckpoint(
           checkpoint,
           CommitteeAttestationsAndSigners.empty(getSignatureContext()),
           Signature.empty(),
-          0n,
+          bucketHint,
         );
         // Align chain time so the bundle simulate and the L1 send both run at the header's slot.
         await progressToSlot(BigInt(checkpoint.header.slotNumber));