@aztec/world-state 0.0.1-commit.9b94fc1 → 0.0.1-commit.d3ec352c

package/src/native/message.ts

@@ -1,3 +1,4 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/fields';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
@@ -56,11 +57,11 @@ interface WithTreeId {
 
 export interface WorldStateStatusSummary {
   /** Last block number that can still be unwound. */
-  unfinalizedBlockNumber: bigint;
+  unfinalizedBlockNumber: BlockNumber;
   /** Last block number that is finalized and cannot be unwound. */
-  finalizedBlockNumber: bigint;
+  finalizedBlockNumber: BlockNumber;
   /** Oldest block still available for historical queries and forks. */
-  oldestHistoricalBlock: bigint;
+  oldestHistoricalBlock: BlockNumber;
   /** Whether the trees are in sync with each other */
   treesAreSynched: boolean;
 }
@@ -81,11 +82,11 @@ export interface TreeMeta {
   /** The tree's initial root value  */
   initialRoot: Fr;
   /** The current oldest historical block number of the tree */
-  oldestHistoricBlock: bigint;
+  oldestHistoricBlock: BlockNumber;
   /** The current unfinalized block number of the tree */
-  unfinalizedBlockHeight: bigint;
+  unfinalizedBlockHeight: BlockNumber;
   /** The current finalized block number of the tree */
-  finalizedBlockHeight: bigint;
+  finalizedBlockHeight: BlockNumber;
 }
 
 export interface DBStats {
@@ -173,9 +174,9 @@ export function buildEmptyTreeMeta() {
     depth: 0,
     size: 0n,
     committedSize: 0n,
-    unfinalizedBlockHeight: 0n,
-    finalizedBlockHeight: 0n,
-    oldestHistoricBlock: 0n,
+    unfinalizedBlockHeight: BlockNumber.ZERO,
+    finalizedBlockHeight: BlockNumber.ZERO,
+    oldestHistoricBlock: BlockNumber.ZERO,
     root: Fr.ZERO,
     initialRoot: Fr.ZERO,
     initialSize: 0n,
@@ -204,9 +205,9 @@ export function buildEmptyWorldStateDBStats() {
 
 export function buildEmptyWorldStateSummary() {
   return {
-    unfinalizedBlockNumber: 0n,
-    finalizedBlockNumber: 0n,
-    oldestHistoricalBlock: 0n,
+    unfinalizedBlockNumber: BlockNumber.ZERO,
+    finalizedBlockNumber: BlockNumber.ZERO,
+    oldestHistoricalBlock: BlockNumber.ZERO,
     treesAreSynched: true,
   } as WorldStateStatusSummary;
 }
@@ -220,9 +221,9 @@ export function buildEmptyWorldStateStatusFull() {
 }
 
 export function sanitizeSummary(summary: WorldStateStatusSummary) {
-  summary.finalizedBlockNumber = BigInt(summary.finalizedBlockNumber);
-  summary.unfinalizedBlockNumber = BigInt(summary.unfinalizedBlockNumber);
-  summary.oldestHistoricalBlock = BigInt(summary.oldestHistoricalBlock);
+  summary.finalizedBlockNumber = BlockNumber.fromBigInt(BigInt(summary.finalizedBlockNumber));
+  summary.unfinalizedBlockNumber = BlockNumber.fromBigInt(BigInt(summary.unfinalizedBlockNumber));
+  summary.oldestHistoricalBlock = BlockNumber.fromBigInt(BigInt(summary.oldestHistoricalBlock));
   return summary;
 }
 
@@ -234,11 +235,11 @@ export function sanitizeDBStats(stats: DBStats) {
 
 export function sanitizeMeta(meta: TreeMeta) {
   meta.committedSize = BigInt(meta.committedSize);
-  meta.finalizedBlockHeight = BigInt(meta.finalizedBlockHeight);
+  meta.finalizedBlockHeight = BlockNumber.fromBigInt(BigInt(meta.finalizedBlockHeight));
   meta.initialSize = BigInt(meta.initialSize);
-  meta.oldestHistoricBlock = BigInt(meta.oldestHistoricBlock);
+  meta.oldestHistoricBlock = BlockNumber.fromBigInt(BigInt(meta.oldestHistoricBlock));
   meta.size = BigInt(meta.size);
-  meta.unfinalizedBlockHeight = BigInt(meta.unfinalizedBlockHeight);
+  meta.unfinalizedBlockHeight = BlockNumber.fromBigInt(BigInt(meta.unfinalizedBlockHeight));
   return meta;
 }
 
@@ -310,7 +311,7 @@ interface WithLeafValues {
 }
 
 interface BlockShiftRequest extends WithCanonicalForkId {
-  toBlockNumber: bigint;
+  toBlockNumber: BlockNumber;
 }
 
 interface WithLeaves {
@@ -409,7 +410,7 @@ interface UpdateArchiveRequest extends WithForkId {
 }
 
 interface SyncBlockRequest extends WithCanonicalForkId {
-  blockNumber: number;
+  blockNumber: BlockNumber;
   blockStateRef: BlockStateReference;
   blockHeaderHash: Fr;
   paddedNoteHashes: readonly SerializedLeafValue[];
@@ -420,7 +421,7 @@ interface SyncBlockRequest extends WithCanonicalForkId {
 
 interface CreateForkRequest extends WithCanonicalForkId {
   latest: boolean;
-  blockNumber: number;
+  blockNumber: BlockNumber;
 }
 
 interface CreateForkResponse {

package/src/native/native_world_state.ts

@@ -1,10 +1,11 @@
 import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { fromEntries, padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
 import { tryRmDir } from '@aztec/foundation/fs';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import type { L2Block, L2BlockNew } from '@aztec/stdlib/block';
+import type { L2BlockNew } from '@aztec/stdlib/block';
 import { DatabaseVersionManager } from '@aztec/stdlib/database-version';
 import type {
   IndexedTreeId,
@@ -150,7 +151,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     return new MerkleTreesFacade(this.instance, this.initialHeader!, WorldStateRevision.empty());
   }
 
-  public getSnapshot(blockNumber: number): MerkleTreeReadOperations {
+  public getSnapshot(blockNumber: BlockNumber): MerkleTreeReadOperations {
     return new MerkleTreesFacade(
       this.instance,
       this.initialHeader!,
@@ -158,16 +159,20 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     );
   }
 
-  public async fork(blockNumber?: number): Promise<MerkleTreeWriteOperations> {
+  public async fork(blockNumber?: BlockNumber): Promise<MerkleTreeWriteOperations> {
     const resp = await this.instance.call(WorldStateMessageType.CREATE_FORK, {
       latest: blockNumber === undefined,
-      blockNumber: blockNumber ?? 0,
+      blockNumber: blockNumber ?? BlockNumber.ZERO,
       canonical: true,
     });
     return new MerkleTreesForkFacade(
       this.instance,
       this.initialHeader!,
-      new WorldStateRevision(/*forkId=*/ resp.forkId, /* blockNumber=*/ 0, /* includeUncommitted=*/ true),
+      new WorldStateRevision(
+        /*forkId=*/ resp.forkId,
+        /* blockNumber=*/ BlockNumber.ZERO,
+        /* includeUncommitted=*/ true,
+      ),
     );
   }
 
@@ -176,20 +181,26 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   }
 
   public async handleL2BlockAndMessages(
-    l2Block: L2Block | L2BlockNew,
+    l2Block: L2BlockNew,
     l1ToL2Messages: Fr[],
-    // TODO(#17027)
-    // Temporary hack to only insert l1 to l2 messages for the first block in a checkpoint.
-    isFirstBlock = true,
+    isFirstBlock: boolean,
   ): Promise<WorldStateStatusFull> {
-    // We have to pad both the values within tx effects because that's how the trees are built by circuits.
-    const paddedNoteHashes = l2Block.body.txEffects.flatMap(txEffect =>
-      padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
-    );
+    if (!isFirstBlock && l1ToL2Messages.length > 0) {
+      throw new Error(
+        `L1 to L2 messages must be empty for non-first blocks, but got ${l1ToL2Messages.length} messages for block ${l2Block.number}.`,
+      );
+    }
+
+    // We have to pad the given l1 to l2 messages, and the note hashes and nullifiers within tx effects, because that's
+    // how the trees are built by circuits.
     const paddedL1ToL2Messages = isFirstBlock
       ? padArrayEnd<Fr, number>(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP)
       : [];
 
+    const paddedNoteHashes = l2Block.body.txEffects.flatMap(txEffect =>
+      padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX),
+    );
+
     const paddedNullifiers = l2Block.body.txEffects
       .flatMap(txEffect => padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX))
       .map(nullifier => new NullifierLeaf(nullifier));
@@ -256,7 +267,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    * @param toBlockNumber The block number that is now the tip of the finalized chain
    * @returns The new WorldStateStatus
    */
-  public async setFinalized(toBlockNumber: bigint) {
+  public async setFinalized(toBlockNumber: BlockNumber) {
     try {
       await this.instance.call(
         WorldStateMessageType.FINALIZE_BLOCKS,
@@ -279,7 +290,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    * @param toBlockNumber The block number of the new oldest historical block
    * @returns The new WorldStateStatus
    */
-  public async removeHistoricalBlocks(toBlockNumber: bigint) {
+  public async removeHistoricalBlocks(toBlockNumber: BlockNumber) {
     try {
       return await this.instance.call(
         WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS,
@@ -301,7 +312,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    * @param toBlockNumber The block number of the new tip of the pending chain,
    * @returns The new WorldStateStatus
    */
-  public async unwindBlocks(toBlockNumber: bigint) {
+  public async unwindBlocks(toBlockNumber: BlockNumber) {
     try {
       return await this.instance.call(
         WorldStateMessageType.UNWIND_BLOCKS,

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,13 +1,11 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
-import { SHA256Trunc } from '@aztec/foundation/crypto';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
-import { MerkleTreeCalculator } from '@aztec/foundation/trees';
 import type {
-  L2Block,
   L2BlockId,
+  L2BlockNew,
   L2BlockSource,
   L2BlockStream,
   L2BlockStreamEvent,
@@ -32,6 +30,7 @@ import type { WorldStateStatusFull } from '../native/message.js';
 import type { MerkleTreeAdminDatabase } from '../world-state-db/merkle_tree_db.js';
 import type { WorldStateConfig } from './config.js';
 import { WorldStateSynchronizerError } from './errors.js';
+import { findFirstBlocksInCheckpoints } from './utils.js';
 
 export type { SnapshotDataKeys };
 
@@ -45,17 +44,17 @@ export class ServerWorldStateSynchronizer
 {
   private readonly merkleTreeCommitted: MerkleTreeReadOperations;
 
-  private latestBlockNumberAtStart = 0;
+  private latestBlockNumberAtStart = BlockNumber.ZERO;
   private historyToKeep: number | undefined;
   private currentState: WorldStateRunningState = WorldStateRunningState.IDLE;
-  private latestBlockHashQuery: { blockNumber: number; hash: string | undefined } | undefined = undefined;
+  private latestBlockHashQuery: { blockNumber: BlockNumber; hash: string | undefined } | undefined = undefined;
 
   private syncPromise = promiseWithResolvers<void>();
   protected blockStream: L2BlockStream | undefined;
 
   // WorldState doesn't track the proven block number, it only tracks the latest tips of the pending chain and the finalized chain
   // store the proven block number here, in the synchronizer, so that we don't end up spamming the logs with 'chain-proved' events
-  private provenBlockNumber: bigint | undefined;
+  private provenBlockNumber: BlockNumber | undefined;
 
   constructor(
     private readonly merkleTreeDb: MerkleTreeAdminDatabase,
@@ -77,11 +76,11 @@ export class ServerWorldStateSynchronizer
     return this.merkleTreeDb.getCommitted();
   }
 
-  public getSnapshot(blockNumber: number): MerkleTreeReadOperations {
+  public getSnapshot(blockNumber: BlockNumber): MerkleTreeReadOperations {
     return this.merkleTreeDb.getSnapshot(blockNumber);
   }
 
-  public fork(blockNumber?: number): Promise<MerkleTreeWriteOperations> {
+  public fork(blockNumber?: BlockNumber): Promise<MerkleTreeWriteOperations> {
     return this.merkleTreeDb.fork(blockNumber);
   }
 
@@ -102,9 +101,11 @@ export class ServerWorldStateSynchronizer
     }
 
     // Get the current latest block number
-    this.latestBlockNumberAtStart = await (this.config.worldStateProvenBlocksOnly
-      ? this.l2BlockSource.getProvenBlockNumber()
-      : this.l2BlockSource.getBlockNumber());
+    this.latestBlockNumberAtStart = BlockNumber(
+      await (this.config.worldStateProvenBlocksOnly
+        ? this.l2BlockSource.getProvenBlockNumber()
+        : this.l2BlockSource.getBlockNumber()),
+    );
 
     const blockToDownloadFrom = (await this.getLatestBlockNumber()) + 1;
 
@@ -147,10 +148,10 @@ export class ServerWorldStateSynchronizer
   public async status(): Promise<WorldStateSynchronizerStatus> {
     const summary = await this.merkleTreeDb.getStatusSummary();
     const status: WorldStateSyncStatus = {
-      latestBlockNumber: Number(summary.unfinalizedBlockNumber),
-      latestBlockHash: (await this.getL2BlockHash(Number(summary.unfinalizedBlockNumber))) ?? '',
-      finalizedBlockNumber: Number(summary.finalizedBlockNumber),
-      oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
+      latestBlockNumber: summary.unfinalizedBlockNumber,
+      latestBlockHash: (await this.getL2BlockHash(summary.unfinalizedBlockNumber)) ?? '',
+      finalizedBlockNumber: summary.finalizedBlockNumber,
+      oldestHistoricBlockNumber: summary.oldestHistoricalBlock,
       treesAreSynched: summary.treesAreSynched,
     };
     return {
@@ -184,7 +185,10 @@ export class ServerWorldStateSynchronizer
    * @param skipThrowIfTargetNotReached - Whether to skip throwing if the target block number is not reached.
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  public async syncImmediate(targetBlockNumber?: number, skipThrowIfTargetNotReached?: boolean): Promise<number> {
+  public async syncImmediate(
+    targetBlockNumber?: BlockNumber,
+    skipThrowIfTargetNotReached?: boolean,
+  ): Promise<BlockNumber> {
     if (this.currentState !== WorldStateRunningState.RUNNING) {
       throw new Error(`World State is not running. Unable to perform sync.`);
     }
@@ -202,7 +206,7 @@ export class ServerWorldStateSynchronizer
 
     // If the archiver is behind the target block, force an archiver sync
     if (targetBlockNumber) {
-      const archiverLatestBlock = await this.l2BlockSource.getBlockNumber();
+      const archiverLatestBlock = BlockNumber(await this.l2BlockSource.getBlockNumber());
       if (archiverLatestBlock < targetBlockNumber) {
         this.log.debug(`Archiver is at ${archiverLatestBlock} behind target block ${targetBlockNumber}.`);
         await this.l2BlockSource.syncImmediate();
@@ -232,8 +236,8 @@ export class ServerWorldStateSynchronizer
   }
 
   /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
-  public async getL2BlockHash(number: number): Promise<string | undefined> {
-    if (number === 0) {
+  public async getL2BlockHash(number: BlockNumber): Promise<string | undefined> {
+    if (number === BlockNumber.ZERO) {
       return (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
     }
     if (this.latestBlockHashQuery?.hash === undefined || number !== this.latestBlockHashQuery.blockNumber) {
@@ -250,13 +254,13 @@ export class ServerWorldStateSynchronizer
   /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
   public async getL2Tips(): Promise<L2Tips> {
     const status = await this.merkleTreeDb.getStatusSummary();
-    const unfinalizedBlockHash = await this.getL2BlockHash(Number(status.unfinalizedBlockNumber));
-    const latestBlockId: L2BlockId = { number: Number(status.unfinalizedBlockNumber), hash: unfinalizedBlockHash! };
+    const unfinalizedBlockHash = await this.getL2BlockHash(status.unfinalizedBlockNumber);
+    const latestBlockId: L2BlockId = { number: status.unfinalizedBlockNumber, hash: unfinalizedBlockHash! };
 
     return {
       latest: latestBlockId,
-      finalized: { number: Number(status.finalizedBlockNumber), hash: '' },
-      proven: { number: Number(this.provenBlockNumber ?? status.finalizedBlockNumber), hash: '' }, // TODO(palla/reorg): Using finalized as proven for now
+      finalized: { number: status.finalizedBlockNumber, hash: '' },
+      proven: { number: this.provenBlockNumber ?? status.finalizedBlockNumber, hash: '' }, // TODO(palla/reorg): Using finalized as proven for now
     };
   }
 
@@ -264,16 +268,16 @@ export class ServerWorldStateSynchronizer
   public async handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void> {
     switch (event.type) {
       case 'blocks-added':
-        await this.handleL2Blocks(event.blocks.map(b => b.block));
+        await this.handleL2Blocks(event.blocks.map(b => b.block.toL2Block()));
         break;
       case 'chain-pruned':
-        await this.handleChainPruned(event.block.number);
+        await this.handleChainPruned(BlockNumber(event.block.number));
         break;
       case 'chain-proven':
-        await this.handleChainProven(event.block.number);
+        await this.handleChainProven(BlockNumber(event.block.number));
         break;
       case 'chain-finalized':
-        await this.handleChainFinalized(event.block.number);
+        await this.handleChainFinalized(BlockNumber(event.block.number));
         break;
     }
   }
@@ -283,22 +287,23 @@ export class ServerWorldStateSynchronizer
    * @param l2Blocks - The L2 blocks to handle.
    * @returns Whether the block handled was produced by this same node.
    */
-  private async handleL2Blocks(l2Blocks: L2Block[]) {
+  private async handleL2Blocks(l2Blocks: L2BlockNew[]) {
     this.log.trace(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
 
-    const messagePromises = l2Blocks.map(block => this.l2BlockSource.getL1ToL2Messages(block.number));
-    const l1ToL2Messages: Fr[][] = await Promise.all(messagePromises);
-    let updateStatus: WorldStateStatusFull | undefined = undefined;
+    const firstBlocksInCheckpoints = await findFirstBlocksInCheckpoints(l2Blocks, this.l2BlockSource);
 
-    for (let i = 0; i < l2Blocks.length; i++) {
-      const [duration, result] = await elapsed(() => this.handleL2Block(l2Blocks[i], l1ToL2Messages[i]));
-      this.log.info(`World state updated with L2 block ${l2Blocks[i].number}`, {
+    let updateStatus: WorldStateStatusFull | undefined = undefined;
+    for (const block of l2Blocks) {
+      const l1ToL2Messages = firstBlocksInCheckpoints.get(block.number) ?? [];
+      const isFirstBlock = firstBlocksInCheckpoints.has(block.number);
+      const [duration, result] = await elapsed(() => this.handleL2Block(block, l1ToL2Messages, isFirstBlock));
+      this.log.info(`World state updated with L2 block ${block.number}`, {
         eventName: 'l2-block-handled',
         duration,
-        unfinalizedBlockNumber: result.summary.unfinalizedBlockNumber,
-        finalizedBlockNumber: result.summary.finalizedBlockNumber,
-        oldestHistoricBlock: result.summary.oldestHistoricalBlock,
-        ...l2Blocks[i].getStats(),
+        unfinalizedBlockNumber: BigInt(result.summary.unfinalizedBlockNumber),
+        finalizedBlockNumber: BigInt(result.summary.finalizedBlockNumber),
+        oldestHistoricBlock: BigInt(result.summary.oldestHistoricalBlock),
+        ...block.getStats(),
       } satisfies L2BlockHandledStats);
       updateStatus = result;
     }
@@ -314,20 +319,18 @@ export class ServerWorldStateSynchronizer
    * @param l1ToL2Messages - The L1 to L2 messages for the block.
    * @returns Whether the block handled was produced by this same node.
    */
-  private async handleL2Block(l2Block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull> {
-    // First we check that the L1 to L2 messages hash to the block inHash.
-    // Note that we cannot optimize this check by checking the root of the subtree after inserting the messages
-    // to the real L1_TO_L2_MESSAGE_TREE (like we do in merkleTreeDb.handleL2BlockAndMessages(...)) because that
-    // tree uses pedersen and we don't have access to the converted root.
-    await this.verifyMessagesHashToInHash(l1ToL2Messages, l2Block.header.contentCommitment.inHash);
-
+  private async handleL2Block(
+    l2Block: L2BlockNew,
+    l1ToL2Messages: Fr[],
+    isFirstBlock: boolean,
+  ): Promise<WorldStateStatusFull> {
     // If the above check succeeds, we can proceed to handle the block.
     this.log.trace(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
       blockNumber: l2Block.number,
       blockHash: await l2Block.hash().then(h => h.toString()),
       l1ToL2Messages: l1ToL2Messages.map(msg => msg.toString()),
     });
-    const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
+    const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages, isFirstBlock);
 
     if (this.currentState === WorldStateRunningState.SYNCHING && l2Block.number >= this.latestBlockNumberAtStart) {
       this.setCurrentState(WorldStateRunningState.RUNNING);
@@ -337,14 +340,14 @@ export class ServerWorldStateSynchronizer
     return result;
   }
 
-  private async handleChainFinalized(blockNumber: number) {
+  private async handleChainFinalized(blockNumber: BlockNumber) {
     this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
-    const summary = await this.merkleTreeDb.setFinalized(BigInt(blockNumber));
+    const summary = await this.merkleTreeDb.setFinalized(blockNumber);
     if (this.historyToKeep === undefined) {
       return;
     }
-    const newHistoricBlock = summary.finalizedBlockNumber - BigInt(this.historyToKeep) + 1n;
-    if (newHistoricBlock <= 1) {
+    const newHistoricBlock = BlockNumber(summary.finalizedBlockNumber - this.historyToKeep + 1);
+    if (newHistoricBlock <= BlockNumber(1)) {
       return;
     }
     this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
@@ -352,15 +355,15 @@ export class ServerWorldStateSynchronizer
     this.log.debug(`World state summary `, status.summary);
   }
 
-  private handleChainProven(blockNumber: number) {
-    this.provenBlockNumber = BigInt(blockNumber);
+  private handleChainProven(blockNumber: BlockNumber) {
+    this.provenBlockNumber = blockNumber;
     this.log.debug(`Proven chain is now at block ${blockNumber}`);
     return Promise.resolve();
   }
 
-  private async handleChainPruned(blockNumber: number) {
+  private async handleChainPruned(blockNumber: BlockNumber) {
     this.log.warn(`Chain pruned to block ${blockNumber}`);
-    const status = await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
+    const status = await this.merkleTreeDb.unwindBlocks(blockNumber);
     this.latestBlockHashQuery = undefined;
     this.provenBlockNumber = undefined;
     this.instrumentation.updateWorldStateMetrics(status);
@@ -374,24 +377,4 @@ export class ServerWorldStateSynchronizer
     this.currentState = newState;
     this.log.debug(`Moved to state ${WorldStateRunningState[this.currentState]}`);
   }
-
-  /**
-   * Verifies that the L1 to L2 messages hash to the block inHash.
-   * @param l1ToL2Messages - The L1 to L2 messages for the block.
-   * @param inHash - The inHash of the block.
-   * @throws If the L1 to L2 messages do not hash to the block inHash.
-   */
-  protected async verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Fr) {
-    const treeCalculator = await MerkleTreeCalculator.create(
-      L1_TO_L2_MSG_SUBTREE_HEIGHT,
-      Buffer.alloc(32),
-      (lhs, rhs) => Promise.resolve(new SHA256Trunc().hash(lhs, rhs)),
-    );
-
-    const root = await treeCalculator.computeTreeRoot(l1ToL2Messages.map(msg => msg.toBuffer()));
-
-    if (!root.equals(inHash.toBuffer())) {
-      throw new Error('Obtained L1 to L2 messages failed to be hashed to the block inHash');
-    }
-  }
 }

package/src/synchronizer/utils.ts

@@ -0,0 +1,83 @@
+import { BlockNumber, type SlotNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/fields';
+import type { L2BlockNew, L2BlockSource } from '@aztec/stdlib/block';
+import type { Checkpoint } from '@aztec/stdlib/checkpoint';
+import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging';
+
+/**
+ * Determine which blocks in the given array are the first block in a checkpoint.
+ * @param blocks - The candidate blocks, sorted by block number in ascending order.
+ * @param l2BlockSource - The L2 block source to use to fetch the checkpoints, block headers and L1->L2 messages.
+ * @returns A map of block numbers that begin a checkpoint to the L1->L2 messages for that checkpoint.
+ */
+export async function findFirstBlocksInCheckpoints(
+  blocks: L2BlockNew[],
+  l2BlockSource: L2BlockSource & L1ToL2MessageSource,
+): Promise<Map<number, Fr[]>> {
+  // Select the blocks that are the final block within each group of identical slot numbers.
+  let seenSlot: SlotNumber | undefined;
+  const maybeLastBlocks = [...blocks]
+    .reverse()
+    .filter(b => {
+      if (b.header.globalVariables.slotNumber !== seenSlot) {
+        seenSlot = b.header.globalVariables.slotNumber;
+        return true;
+      }
+      return false;
+    })
+    .reverse();
+
+  // Try to fetch the checkpoints for those blocks. If undefined (which should only occur for blocks.at(-1)),
+  // then the block is not the last one in a checkpoint.
+  // If we are not checking the inHashes below, only blocks.at(-1) would need its checkpoint header fetched.
+  const checkpointedBlocks = (
+    await Promise.all(
+      maybeLastBlocks.map(async b => ({
+        blockNumber: b.number,
+        // A checkpoint's archive root is the archive root of its last block.
+        checkpoint: await l2BlockSource.getCheckpointByArchive(b.archive.root),
+      })),
+    )
+  ).filter(b => b.checkpoint !== undefined) as { blockNumber: BlockNumber; checkpoint: Checkpoint }[];
+
+  // Verify that the L1->L2 messages hash to the checkpoint's inHash.
+  const checkpointedL1ToL2Messages: Fr[][] = await Promise.all(
+    checkpointedBlocks.map(b => l2BlockSource.getL1ToL2MessagesForCheckpoint(b.checkpoint!.number)),
+  );
+  checkpointedBlocks.forEach((b, i) => {
+    const computedInHash = computeInHashFromL1ToL2Messages(checkpointedL1ToL2Messages[i]);
+    const inHash = b.checkpoint.header.contentCommitment.inHash;
+    if (!computedInHash.equals(inHash)) {
+      throw new Error('Obtained L1 to L2 messages failed to be hashed to the checkpoint inHash');
+    }
+  });
+
+  // Compute the first block numbers, which should be right after each checkpointed block. Exclude blocks that haven't
+  // been added yet.
+  const firstBlockNumbers = checkpointedBlocks
+    .map(b => BlockNumber(b.blockNumber + 1))
+    .filter(n => n <= blocks.at(-1)!.number);
+  // Check if blocks[0] is the first block in a checkpoint.
+  if (blocks[0].number === 1) {
+    firstBlockNumbers.push(blocks[0].number);
+  } else {
+    const lastBlockHeader = await l2BlockSource.getBlockHeader(BlockNumber(blocks[0].number - 1));
+    if (!lastBlockHeader) {
+      throw new Error(`Failed to get block ${blocks[0].number - 1}`);
+    }
+    if (lastBlockHeader.globalVariables.slotNumber !== blocks[0].header.globalVariables.slotNumber) {
+      firstBlockNumbers.push(blocks[0].number);
+    }
+  }
+
+  // Fetch the L1->L2 messages for the first blocks and assign them to the map.
+  const messagesByBlockNumber = new Map<BlockNumber, Fr[]>();
+  await Promise.all(
+    firstBlockNumbers.map(async blockNumber => {
+      const l1ToL2Messages = await l2BlockSource.getL1ToL2Messages(blockNumber);
+      messagesByBlockNumber.set(blockNumber, l1ToL2Messages);
+    }),
+  );
+
+  return messagesByBlockNumber;
+}