chore(fast-inbox): delete legacy per-checkpoint and 128-bit message paths in the archiver (A-1388)

Removes the legacy getL1ToL2Messages(checkpointNumber) flow, the padded
per-checkpoint index invariants, the inboxTreeInProgress readiness gate, and the
L1ToL2MessagesNotReadyError. InboxMessage drops the 128-bit keccak rollingHash and
the vacuous derived checkpointNumber, so messages carry only the compact global
index and the full-width consensus rolling hash; the store serialization changes and
ARCHIVER_DB_VERSION bumps to 9 (nodes resync, no migration). Reorg detection now
compares the local consensus rolling hash and total against the Inbox's current
rolling-hash bucket via new getBucket/getCurrentBucketSeq/getCurrentBucket wrappers,
replacing the 128-bit getState comparison. Test fakes/mocks move to compact indexing.

Author: spalladino

yarn-project/archiver/README.md

@@ -44,9 +44,9 @@ Two independent syncpoints track progress on L1:
 
 ### L1-to-L2 Messages
 
-Messages are synced from the Inbox contract. The sync compares local state (message count and rolling hash) against the Inbox contract state on L1, downloads any missing messages, and verifies consistency afterwards. On success, the syncpoint advances to the current L1 block. On failure (L1 reorg or inconsistency), the syncpoint rolls back to the last known-good message and the operation retries (up to 3 times within the same sync iteration).
+Messages are synced from the Inbox contract. The sync compares local state (message count and consensus rolling hash) against the Inbox's current rolling-hash bucket on L1, downloads any missing messages, and verifies consistency afterwards. On success, the syncpoint advances to the current L1 block. On failure (L1 reorg or inconsistency), the syncpoint rolls back to the last known-good message and the operation retries (up to 3 times within the same sync iteration).
 
-1. Query Inbox state at the current L1 block (message count + rolling hash)
+1. Query the Inbox's current bucket at the current L1 block (cumulative message count + consensus rolling hash)
 2. Compare local state against remote
 3. If they match, advance syncpoint and return
 4. If mismatch, fetch `MessageSent` events in batches and store them
@@ -55,7 +55,7 @@ Messages are synced from the Inbox contract. The sync compares local state (mess
    - If still mismatched (e.g., messages missed due to a concurrent L1 reorg), rollback and retry
 6. On success, advance the syncpoint
 
-The syncpoint and the `inboxTreeInProgress` marker (which tracks which checkpoint's messages are currently being filled on L1) are updated atomically. The marker is only advanced after messages are stored, so concurrent reads don't see an unsealed checkpoint as readable before its messages are available.
+Messages are stored with compact (unpadded) global indices matching the Inbox's insertion order, and each carries the consensus rolling hash (a truncated sha256 chain) and the sequence of the Inbox bucket it was absorbed into (AZIP-22 Fast Inbox). Bucket snapshots let the sequencer and validator resolve message bundles per block.
 
 ### Checkpoints
 
@@ -70,13 +70,12 @@ Checkpoints are synced from the Rollup contract via `handleCheckpoints()`:
    - Verify archive matches (checkpoint still in chain)
    - Validate attestations (2/3 + 1 committee signatures required)
    - Skip invalid checkpoints (see "Invalid Checkpoints" in Edge Cases)
-   - Verify `inHash` matches expected value (see below)
    - Store valid checkpoints with their blocks
 6. Update proven checkpoint again (may have advanced after storing new checkpoints)
 7. Handle epoch prune if applicable
 8. Check for checkpoints behind syncpoint (L1 reorg case)
 
-The `inHash` is a hash of all L1-to-L2 messages consumed by a checkpoint. The archiver computes the expected `inHash` from locally stored messages and compares it against the checkpoint header. A mismatch indicates a bug (messages out of sync with checkpoints) and causes a fatal error.
+L1 enforces at propose time that a checkpoint header's consensus rolling hash matches the Inbox bucket the checkpoint consumes through (AZIP-22 Fast Inbox), so the archiver does not re-derive or cross-check a per-checkpoint message hash while syncing.
 
 The `blocksSynchedTo` syncpoint is updated:
 - When checkpoints are stored: set to the L1 block of the last stored checkpoint

yarn-project/archiver/src/archiver-sync.test.ts

@@ -16,6 +16,7 @@ import { sum, times } from '@aztec/foundation/collection';
 import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { toArray } from '@aztec/foundation/iterable';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { retryFastUntil } from '@aztec/foundation/retry';
 import { TestDateProvider } from '@aztec/foundation/timer';
@@ -36,7 +37,7 @@ import { type MockProxy, mock } from 'jest-mock-extended';
 import type { GetBlockReturnType } from 'viem';
 
 import { Archiver, type ArchiverEmitter } from './archiver.js';
-import { BlockOrCheckpointSlotExpiredError, L1ToL2MessagesNotReadyError } from './errors.js';
+import { BlockOrCheckpointSlotExpiredError } from './errors.js';
 import type { ArchiverInstrumentation } from './modules/instrumentation.js';
 import { ArchiverL1Synchronizer } from './modules/l1_synchronizer.js';
 import { type ArchiverDataStores, createArchiverDataStores } from './store/data_stores.js';
@@ -186,6 +187,11 @@ describe('Archiver Sync', () => {
     await archiver?.stop();
   });
 
+  // Returns every stored L1-to-L2 message leaf (as hex), in insertion order (compact indexing, AZIP-22 Fast Inbox).
+  const getStoredLeaves = async () =>
+    (await toArray(archiverStore.messages.iterateL1ToL2Messages())).map(m => m.leaf.toString());
+  const asHex = (leaves: Fr[]) => leaves.map(l => l.toString());
+
   describe('basic sync', () => {
     it('syncs l1 to l2 messages and checkpoints', async () => {
       expect(await archiver.getCheckpointNumber()).toEqual(CheckpointNumber(0));
@@ -220,7 +226,7 @@ describe('Archiver Sync', () => {
       expect(await archiver.getCheckpointNumber()).toEqual(CheckpointNumber(1));
 
       // Verify messages for checkpoint 1
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(1))).toEqual(msgs1);
+      expect(await getStoredLeaves()).toEqual(asHex(msgs1));
 
       // Mark checkpoint 1 as proven
       fake.markCheckpointAsProven(CheckpointNumber(1));
@@ -233,11 +239,8 @@ describe('Archiver Sync', () => {
       await archiver.syncImmediate();
       expect(await archiver.getCheckpointNumber()).toEqual(CheckpointNumber(3));
 
-      // Verify messages for all checkpoints
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(1))).toEqual(msgs1);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(2))).toEqual(msgs2);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(3))).toEqual(msgs3);
-      await expect(archiver.getL1ToL2Messages(CheckpointNumber(4))).rejects.toThrow(L1ToL2MessagesNotReadyError);
+      // Verify messages for all checkpoints, stored contiguously in insertion order.
+      expect(await getStoredLeaves()).toEqual(asHex([...msgs1, ...msgs2, ...msgs3]));
 
       // Verify private logs are surfaced through the block body.
       for (const checkpoint of [cp1, cp2, cp3]) {
@@ -440,29 +443,29 @@ describe('Archiver Sync', () => {
       logger.warn('Initial sync');
       await archiver.syncImmediate();
 
-      expect(inboxContract.getState).toHaveBeenCalledTimes(1);
+      expect(inboxContract.getCurrentBucket).toHaveBeenCalledTimes(1);
       expect(rollupContract.status).toHaveBeenCalledTimes(1);
-      inboxContract.getState.mockClear();
+      inboxContract.getCurrentBucket.mockClear();
       rollupContract.status.mockClear();
 
       // We sync again, but since chain didn't move, no new calls should be expected
       logger.warn('Sync with no L1 advancement');
       await archiver.syncImmediate();
-      expect(inboxContract.getState).toHaveBeenCalledTimes(0);
+      expect(inboxContract.getCurrentBucket).toHaveBeenCalledTimes(0);
       expect(rollupContract.status).toHaveBeenCalledTimes(0);
 
       // Advance the chain and we should see calls again
       fake.setL1BlockNumber(150n);
       logger.warn('Sync after L1 advancement');
       await archiver.syncImmediate();
-      expect(inboxContract.getState).toHaveBeenCalledTimes(1);
+      expect(inboxContract.getCurrentBucket).toHaveBeenCalledTimes(1);
       expect(rollupContract.status).toHaveBeenCalledTimes(1);
     });
 
     it('does not fetch messages when local and remote state both have zero messages', async () => {
-      // When there are no messages on L1, the remote inbox state has messagesRollingHash = Buffer16.ZERO
-      // and totalMessagesInserted = 0. The local store also returns 0 messages and undefined lastMessage.
-      // The fallback for the local rolling hash must use Buffer16.ZERO (not Buffer32.ZERO) to match.
+      // When there are no messages on L1, the remote Inbox current bucket is genesis (rolling hash Fr.ZERO,
+      // total 0). The local store also returns 0 messages and undefined lastMessage, whose rolling-hash fallback
+      // is Fr.ZERO — so local and remote state match and no message fetch is attempted.
       fake.setL1BlockNumber(100n);
 
       // Add a checkpoint with zero messages so the sync has something to process
@@ -1094,10 +1097,7 @@ describe('Archiver Sync', () => {
       // Sync
       await archiver.syncImmediate();
 
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(2);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(2))).toHaveLength(0);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(3))).toHaveLength(4);
-      await expect(archiver.getL1ToL2Messages(CheckpointNumber(4))).rejects.toThrow(L1ToL2MessagesNotReadyError);
+      expect(await getStoredLeaves()).toEqual(asHex([...msgs1, ...msgs3]));
 
       // Simulate L1 reorg: remove last 2 messages from checkpoint 3, add new messages for checkpoints 4 and 5
       logger.warn('Reorging L1 to L2 messages');
@@ -1114,18 +1114,8 @@ describe('Archiver Sync', () => {
       fake.setL1BlockNumber(111n);
       await archiver.syncImmediate();
 
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(2);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(2))).toHaveLength(0);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(3))).toHaveLength(2); // Reduced from 4 to 2
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(4))).toHaveLength(1);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(5))).toHaveLength(2);
-
-      expect((await archiver.getL1ToL2Messages(CheckpointNumber(4))).map(leaf => leaf.toString())).toEqual(
-        [msg40].map(leaf => leaf.toString()),
-      );
-      expect((await archiver.getL1ToL2Messages(CheckpointNumber(5))).map(leaf => leaf.toString())).toEqual(
-        [msg50, msg51].map(leaf => leaf.toString()),
-      );
+      // The reorg kept the first 4 messages (2 from CP1, 2 from CP3) and appended the new ones.
+      expect(await getStoredLeaves()).toEqual(asHex([msgs1[0], msgs1[1], msgs3[0], msgs3[1], msg40, msg50, msg51]));
     });
 
     it('short-circuits rollback at the finalized L1 block', async () => {
@@ -1141,8 +1131,7 @@ describe('Archiver Sync', () => {
       fake.setL1BlockNumber(110n);
       await archiver.syncImmediate();
 
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(2);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(3))).toHaveLength(4);
+      expect(await getStoredLeaves()).toEqual(asHex([...msgs1, ...msgs3]));
 
       // Simulate L1 reorg: remove the last 2 messages from checkpoint 3 and add new ones.
       fake.removeMessagesAfter(4);
@@ -1163,8 +1152,7 @@ describe('Archiver Sync', () => {
       );
       expect(callsAtFinalizedOrBelow).toHaveLength(0);
 
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(2);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(4))).toHaveLength(1);
+      expect(await getStoredLeaves()).toEqual(asHex([msgs1[0], msgs1[1], msgs3[0], msgs3[1], msg40]));
     });
 
     it('falls back to per-message log queries when finalized block is undefined', async () => {
@@ -1193,8 +1181,7 @@ describe('Archiver Sync', () => {
       // 2 messages mismatch on remote (msgs3[2], msgs3[3]) and one matches (msgs3[1]) before we break.
       expect(eventByHashSpy).toHaveBeenCalledTimes(3);
 
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(1))).toHaveLength(2);
-      expect(await archiver.getL1ToL2Messages(CheckpointNumber(4))).toHaveLength(1);
+      expect(await getStoredLeaves()).toEqual(asHex([msgs1[0], msgs1[1], msgs3[0], msgs3[1], msg40]));
     });
 
     it('persists the finalized L1 block monotonically after message sync', async () => {

yarn-project/archiver/src/archiver.ts

@@ -764,14 +764,14 @@ export class Archiver extends ArchiverDataSourceBase implements L2BlockSink, Tra
       `Removing checkpoints after checkpoint ${targetCheckpointNumber} (target block ${targetL2BlockNumber})`,
     );
     await this.updater.removeCheckpointsAfter(targetCheckpointNumber);
-    this.log.info(`Rolling back L1 to L2 messages to checkpoint ${targetCheckpointNumber}`);
-    await this.stores.messages.rollbackL1ToL2MessagesToCheckpoint(targetCheckpointNumber);
+    this.log.info(`Rolling back L1 to L2 messages inserted after L1 block ${targetL1BlockNumber}`);
+    await this.stores.messages.rollbackL1ToL2MessagesAfterL1Block(targetL1BlockNumber);
     this.log.info(`Setting L1 syncpoints to ${targetL1BlockNumber}`);
     await this.stores.blocks.setSynchedL1BlockNumber(targetL1BlockNumber);
-    await this.stores.messages.setMessageSyncState(
-      { l1BlockNumber: targetL1BlockNumber, l1BlockHash: targetL1BlockHash },
-      undefined,
-    );
+    await this.stores.messages.setMessageSyncState({
+      l1BlockNumber: targetL1BlockNumber,
+      l1BlockHash: targetL1BlockHash,
+    });
     if (targetL2BlockNumber < currentProvenBlock) {
       this.log.info(`Rolling back proven L2 checkpoint to ${targetCheckpointNumber}`);
       await this.updater.setProvenCheckpointNumber(targetCheckpointNumber);

yarn-project/archiver/src/errors.ts

@@ -102,20 +102,6 @@ export class BlockAlreadyCheckpointedError extends Error {
   }
 }
 
-/** Thrown when L1 to L2 messages are requested for a checkpoint whose message tree hasn't been sealed yet. */
-export class L1ToL2MessagesNotReadyError extends Error {
-  constructor(
-    public readonly checkpointNumber: number,
-    public readonly inboxTreeInProgress: bigint,
-  ) {
-    super(
-      `Cannot get L1 to L2 messages for checkpoint ${checkpointNumber}: ` +
-        `inbox tree in progress is ${inboxTreeInProgress}, messages not yet sealed`,
-    );
-    this.name = 'L1ToL2MessagesNotReadyError';
-  }
-}
-
 /** Thrown when a proposed checkpoint number is stale (already processed). */
 export class ProposedCheckpointStaleError extends Error {
   constructor(

yarn-project/archiver/src/l1/data_retrieval.ts

@@ -24,7 +24,6 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 import { RollupAbi } from '@aztec/l1-artifacts';
 import { Body, CommitteeAttestation, L2Block } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
-import { InboxLeaf } from '@aztec/stdlib/messaging';
 import { Proof } from '@aztec/stdlib/proofs';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
@@ -386,10 +385,6 @@ function mapLogInboxMessage(log: MessageSentLog): InboxMessage {
     leaf: log.args.leaf,
     l1BlockNumber: log.l1BlockNumber,
     l1BlockHash: log.l1BlockHash,
-    // The Inbox no longer emits a checkpoint number (AZIP-22 Fast Inbox). Derive it from the compact index for the
-    // legacy per-checkpoint message store, which the node still keeps until it drops the per-checkpoint flow.
-    checkpointNumber: InboxLeaf.checkpointNumberFromIndex(log.args.index),
-    rollingHash: log.args.rollingHash,
     inboxRollingHash: log.args.inboxRollingHash,
     bucketSeq: log.args.bucketSeq,
     bucketTimestamp: log.l1BlockTimestamp,

yarn-project/archiver/src/modules/data_source_base.ts

@@ -316,10 +316,6 @@ export abstract class ArchiverDataSourceBase
     return this.stores.functionNames.register(signatures);
   }
 
-  public getL1ToL2Messages(checkpointNumber: CheckpointNumber): Promise<Fr[]> {
-    return this.stores.messages.getL1ToL2Messages(checkpointNumber);
-  }
-
   public getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
     return this.stores.messages.getL1ToL2MessageIndex(l1ToL2Message);
   }