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

@@ -443,22 +443,22 @@ 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);
     });
 

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);
   }

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

@@ -1,13 +1,13 @@
 import type { BlobClientInterface } from '@aztec/blob-client/client';
 import { EpochCache } from '@aztec/epoch-cache';
-import { InboxContract, type InboxContractState, RollupContract } from '@aztec/ethereum/contracts';
+import { InboxContract, type InboxContractBucket, RollupContract } from '@aztec/ethereum/contracts';
 import type { L1BlockId } from '@aztec/ethereum/l1-types';
 import { getFinalizedL1Block } from '@aztec/ethereum/queries';
 import type { ViemPublicClient, ViemPublicDebugClient } from '@aztec/ethereum/types';
 import { asyncPool } from '@aztec/foundation/async-pool';
 import { maxBigint } from '@aztec/foundation/bigint';
 import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types';
-import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { compactArray, partition, pick } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -430,16 +430,14 @@ export class ArchiverL1Synchronizer implements Traceable {
       return true;
     }
 
-    // Compare local message store state with the remote. If they match, we just advance the match pointer.
-    const remoteMessagesState = await this.inbox.getState({ blockNumber: currentL1BlockNumber });
+    // Compare local message store state with the remote. If they match, we just advance the match pointer. The
+    // remote state is the Inbox's current bucket (AZIP-22 Fast Inbox): its cumulative total and consensus rolling
+    // hash are the Inbox's live chain position.
+    const remoteBucket = await this.inbox.getCurrentBucket({ blockNumber: currentL1BlockNumber });
     const localLastMessage = await this.stores.messages.getLastMessage();
-    if (await this.localStateMatches(localLastMessage, remoteMessagesState)) {
+    if (await this.localStateMatches(localLastMessage, remoteBucket)) {
       this.log.trace(`Local L1 to L2 messages are already in sync with remote at L1 block ${currentL1BlockNumber}`);
-      await this.stores.messages.setMessageSyncState(
-        currentL1Block,
-        remoteMessagesState.treeInProgress,
-        finalizedL1Block,
-      );
+      await this.stores.messages.setMessageSyncState(currentL1Block, finalizedL1Block);
       return true;
     }
 
@@ -455,7 +453,7 @@ export class ArchiverL1Synchronizer implements Traceable {
           `Failed to store L1 to L2 messages retrieved from L1: ${error.message}. Rolling back syncpoint to retry.`,
           { inboxMessage: error.inboxMessage },
         );
-        await this.rollbackL1ToL2Messages(remoteMessagesState);
+        await this.rollbackL1ToL2Messages(remoteBucket);
         return false;
       }
       throw error;
@@ -465,32 +463,28 @@ export class ArchiverL1Synchronizer implements Traceable {
     // we'd notice by comparing our local state with the remote one again, and seeing they don't match even after
     // our sync attempt. In this case, we also rollback our syncpoint, and trigger a retry.
     const localLastMessageAfterSync = await this.stores.messages.getLastMessage();
-    if (!(await this.localStateMatches(localLastMessageAfterSync, remoteMessagesState))) {
+    if (!(await this.localStateMatches(localLastMessageAfterSync, remoteBucket))) {
       this.log.warn(
         `Local L1 to L2 messages state does not match remote after sync attempt. Rolling back syncpoint to retry.`,
-        { localLastMessageAfterSync, remoteMessagesState },
+        { localLastMessageAfterSync, remoteBucket },
       );
-      await this.rollbackL1ToL2Messages(remoteMessagesState);
+      await this.rollbackL1ToL2Messages(remoteBucket);
       return false;
     }
 
     // Advance the syncpoint after a successful sync
-    await this.stores.messages.setMessageSyncState(
-      currentL1Block,
-      remoteMessagesState.treeInProgress,
-      finalizedL1Block,
-    );
+    await this.stores.messages.setMessageSyncState(currentL1Block, finalizedL1Block);
     return true;
   }
 
-  /** Checks if the local rolling hash and message count matches the remote state */
-  private async localStateMatches(localLastMessage: InboxMessage | undefined, remoteState: InboxContractState) {
+  /** Checks if the local consensus rolling hash and message count match the remote Inbox current bucket. */
+  private async localStateMatches(localLastMessage: InboxMessage | undefined, remoteBucket: InboxContractBucket) {
     const localMessageCount = await this.stores.messages.getTotalL1ToL2MessageCount();
-    this.log.trace(`Comparing local and remote inbox state`, { localMessageCount, localLastMessage, remoteState });
+    this.log.trace(`Comparing local and remote inbox state`, { localMessageCount, localLastMessage, remoteBucket });
 
     return (
-      remoteState.totalMessagesInserted === localMessageCount &&
-      remoteState.messagesRollingHash.equals(localLastMessage?.rollingHash ?? Buffer16.ZERO)
+      remoteBucket.totalMsgCount === localMessageCount &&
+      remoteBucket.rollingHash.equals(localLastMessage?.inboxRollingHash ?? Fr.ZERO)
     );
   }
 
@@ -518,19 +512,19 @@ export class ArchiverL1Synchronizer implements Traceable {
     } while (searchEndBlock < toL1Block);
 
     if (messageCount > 0) {
-      this.log.info(
-        `Retrieved ${messageCount} new L1 to L2 messages up to message with index ${lastMessage?.index} for checkpoint ${lastMessage?.checkpointNumber}`,
-        { lastMessage, messageCount },
-      );
+      this.log.info(`Retrieved ${messageCount} new L1 to L2 messages up to message with index ${lastMessage?.index}`, {
+        lastMessage,
+        messageCount,
+      });
     }
   }
 
   /**
    * Rolls back local L1 to L2 messages to the last common message with L1, and updates the syncpoint to the L1 block of that message.
    * If no common message is found, rolls back all messages and sets the syncpoint to the start block.
    */
-  private async rollbackL1ToL2Messages(remoteMessagesState: InboxContractState): Promise<L1BlockId> {
-    const { treeInProgress: remoteTreeInProgress, messagesRollingHash: remoteRollingHash } = remoteMessagesState;
+  private async rollbackL1ToL2Messages(remoteBucket: InboxContractBucket): Promise<L1BlockId> {
+    const remoteRollingHash = remoteBucket.rollingHash;
 
     const messagesFinalizedL1Block = await this.stores.messages.getMessagesFinalizedL1Block();
     const finalizedL1BlockNumber = messagesFinalizedL1Block?.l1BlockNumber;
@@ -542,12 +536,12 @@ export class ArchiverL1Synchronizer implements Traceable {
     let messagesToDelete = 0;
     this.log.verbose(`Searching most recent common L1 to L2 message`);
     for await (const localMsg of this.stores.messages.iterateL1ToL2Messages({ reverse: true })) {
-      const logCtx = { remoteMsg: undefined as InboxMessage | undefined, localMsg, remoteMessagesState };
+      const logCtx = { remoteMsg: undefined as InboxMessage | undefined, localMsg, remoteBucket };
 
       // First check if the local message rolling hash matches the current rolling hash of the inbox contract,
       // which means we just need to rollback some local messages and we should be back in sync. This means there
       // was an L1 reorg that removed some of the messages we had, but no new messages were added compared.
-      if (localMsg.rollingHash.equals(remoteRollingHash)) {
+      if (localMsg.inboxRollingHash.equals(remoteRollingHash)) {
         this.log.info(
           `Found common L1 to L2 message at index ${localMsg.index} on L1 block ${localMsg.l1BlockNumber} matching current remote state`,
           logCtx,
@@ -570,7 +564,7 @@ export class ArchiverL1Synchronizer implements Traceable {
       // an archival rpc node, since the message could be from a long time ago if we're catching up with syncing.
       const remoteMsg = await retrieveL1ToL2Message(this.inbox, localMsg);
       logCtx.remoteMsg = remoteMsg;
-      if (remoteMsg && remoteMsg.rollingHash.equals(localMsg.rollingHash)) {
+      if (remoteMsg && remoteMsg.inboxRollingHash.equals(localMsg.inboxRollingHash)) {
         this.log.info(
           `Found most recent common L1 to L2 message at index ${localMsg.index} on L1 block ${localMsg.l1BlockNumber}`,
           logCtx,
@@ -612,10 +606,9 @@ export class ArchiverL1Synchronizer implements Traceable {
         : await this.getL1BlockHash(syncPointL1BlockNumber);
 
     const messagesSyncPoint = { l1BlockNumber: syncPointL1BlockNumber, l1BlockHash: syncPointL1BlockHash };
-    await this.stores.messages.setMessageSyncState(messagesSyncPoint, remoteTreeInProgress);
+    await this.stores.messages.setMessageSyncState(messagesSyncPoint);
     this.log.verbose(`Updated messages syncpoint to L1 block ${messagesSyncPoint.l1BlockNumber}`, {
       ...messagesSyncPoint,
-      remoteTreeInProgress,
     });
     return messagesSyncPoint;
   }

yarn-project/archiver/src/store/data_stores.ts

@@ -13,7 +13,7 @@ import { FunctionNamesCache } from './function_names_cache.js';
 import { LogStore } from './log_store.js';
 import { MessageStore } from './message_store.js';
 
-export const ARCHIVER_DB_VERSION = 8;
+export const ARCHIVER_DB_VERSION = 9;
 
 /**
  * Represents the latest L1 block processed by the archiver for various objects in L2.