@aztec/world-state 0.0.0-test.0 → 0.0.1-commit.001888fc

package/dest/synchronizer/factory.js

@@ -2,23 +2,28 @@ import { getTelemetryClient } from '@aztec/telemetry-client';
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
 import { NativeWorldStateService } from '../native/native_world_state.js';
 import { ServerWorldStateSynchronizer } from './server_world_state_synchronizer.js';
-export async function createWorldStateSynchronizer(config, l2BlockSource, prefilledPublicData = [], client = getTelemetryClient()) {
+export async function createWorldStateSynchronizer(config, l2BlockSource, prefilledPublicData = [], client = getTelemetryClient(), bindings) {
     const instrumentation = new WorldStateInstrumentation(client);
-    const merkleTrees = await createWorldState(config, prefilledPublicData, instrumentation);
+    const merkleTrees = await createWorldState(config, prefilledPublicData, instrumentation, bindings);
     return new ServerWorldStateSynchronizer(merkleTrees, l2BlockSource, config, instrumentation);
 }
-export async function createWorldState(config, prefilledPublicData = [], instrumentation = new WorldStateInstrumentation(getTelemetryClient())) {
-    const newConfig = {
-        dataDirectory: config.worldStateDataDirectory ?? config.dataDirectory,
-        dataStoreMapSizeKB: config.worldStateDbMapSizeKb ?? config.dataStoreMapSizeKB
+export async function createWorldState(config, prefilledPublicData = [], instrumentation = new WorldStateInstrumentation(getTelemetryClient()), bindings) {
+    const dataDirectory = config.worldStateDataDirectory ?? config.dataDirectory;
+    const dataStoreMapSizeKb = config.worldStateDbMapSizeKb ?? config.dataStoreMapSizeKb;
+    const wsTreeMapSizes = {
+        archiveTreeMapSizeKb: config.archiveTreeMapSizeKb ?? dataStoreMapSizeKb,
+        nullifierTreeMapSizeKb: config.nullifierTreeMapSizeKb ?? dataStoreMapSizeKb,
+        noteHashTreeMapSizeKb: config.noteHashTreeMapSizeKb ?? dataStoreMapSizeKb,
+        messageTreeMapSizeKb: config.messageTreeMapSizeKb ?? dataStoreMapSizeKb,
+        publicDataTreeMapSizeKb: config.publicDataTreeMapSizeKb ?? dataStoreMapSizeKb
     };
     if (!config.l1Contracts?.rollupAddress) {
         throw new Error('Rollup address is required to create a world state synchronizer.');
     }
     // If a data directory is provided in config, then create a persistent store.
-    const merkleTrees = newConfig.dataDirectory ? await NativeWorldStateService.new(config.l1Contracts.rollupAddress, newConfig.dataDirectory, newConfig.dataStoreMapSizeKB, prefilledPublicData, instrumentation) : await NativeWorldStateService.tmp(config.l1Contracts.rollupAddress, ![
+    const merkleTrees = dataDirectory ? await NativeWorldStateService.new(config.l1Contracts.rollupAddress, dataDirectory, wsTreeMapSizes, prefilledPublicData, instrumentation, bindings) : await NativeWorldStateService.tmp(config.l1Contracts.rollupAddress, ![
         'true',
         '1'
-    ].includes(process.env.DEBUG_WORLD_STATE), prefilledPublicData);
+    ].includes(process.env.DEBUG_WORLD_STATE), prefilledPublicData, instrumentation, bindings);
     return merkleTrees;
 }

package/dest/synchronizer/index.d.ts

@@ -1,3 +1,3 @@
 export * from './server_world_state_synchronizer.js';
 export * from './factory.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zeW5jaHJvbml6ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLGNBQWMsQ0FBQyJ9

package/dest/synchronizer/server_world_state_synchronizer.d.ts

@@ -1,13 +1,14 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type { Fr } from '@aztec/foundation/fields';
-import type { L2BlockSource, L2BlockStream, L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider, L2Tips } from '@aztec/stdlib/block';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { type Logger } from '@aztec/foundation/log';
+import { type BlockHash, type L2BlockSource, L2BlockStream, type L2BlockStreamEvent, type L2BlockStreamEventHandler, type L2BlockStreamLocalDataProvider, type L2Tips } from '@aztec/stdlib/block';
 import { type WorldStateSynchronizer, type WorldStateSynchronizerStatus } from '@aztec/stdlib/interfaces/server';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { SnapshotDataKeys } from '@aztec/stdlib/snapshots';
 import { type MerkleTreeReadOperations, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
 import type { MerkleTreeAdminDatabase } from '../world-state-db/merkle_tree_db.js';
 import type { WorldStateConfig } from './config.js';
+export type { SnapshotDataKeys };
 /**
  * Synchronizes the world state with the L2 blocks from a L2BlockSource via a block stream.
  * The synchronizer will download the L2 blocks from the L2BlockSource and update the merkle trees.
@@ -23,42 +24,38 @@ export declare class ServerWorldStateSynchronizer implements WorldStateSynchroni
     private latestBlockNumberAtStart;
     private historyToKeep;
     private currentState;
-    private latestBlockHashQuery;
     private syncPromise;
     protected blockStream: L2BlockStream | undefined;
-    constructor(merkleTreeDb: MerkleTreeAdminDatabase, l2BlockSource: L2BlockSource & L1ToL2MessageSource, config: WorldStateConfig, instrumentation?: WorldStateInstrumentation, log?: import("@aztec/foundation/log").Logger);
+    private provenBlockNumber;
+    constructor(merkleTreeDb: MerkleTreeAdminDatabase, l2BlockSource: L2BlockSource & L1ToL2MessageSource, config: WorldStateConfig, instrumentation?: WorldStateInstrumentation, log?: Logger);
     getCommitted(): MerkleTreeReadOperations;
-    getSnapshot(blockNumber: number): MerkleTreeReadOperations;
-    fork(blockNumber?: number): Promise<MerkleTreeWriteOperations>;
+    getSnapshot(blockNumber: BlockNumber): MerkleTreeReadOperations;
+    fork(blockNumber?: BlockNumber, opts?: {
+        closeDelayMs?: number;
+    }): Promise<MerkleTreeWriteOperations>;
+    backupTo(dstPath: string, compact?: boolean): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>>;
+    clear(): Promise<void>;
     start(): Promise<void | import("@aztec/foundation/promise").PromiseWithResolvers<void>>;
     protected createBlockStream(): L2BlockStream;
     stop(): Promise<void>;
     status(): Promise<WorldStateSynchronizerStatus>;
-    getLatestBlockNumber(): Promise<number>;
+    getLatestBlockNumber(): Promise<BlockNumber>;
+    stopSync(): Promise<void>;
+    resumeSync(): void;
     /**
      * Forces an immediate sync.
-     * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it. Throws if cannot be reached.
+     * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+     * @param blockHash - If provided, verifies the block at targetBlockNumber matches this hash. On mismatch, triggers a resync (reorg detection).
      * @returns A promise that resolves with the block number the world state was synced to
      */
-    syncImmediate(targetBlockNumber?: number): Promise<number>;
+    syncImmediate(targetBlockNumber?: BlockNumber, blockHash?: BlockHash): Promise<BlockNumber>;
     /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
-    getL2BlockHash(number: number): Promise<string | undefined>;
+    getL2BlockHash(number: BlockNumber): Promise<string | undefined>;
     /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
     getL2Tips(): Promise<L2Tips>;
     /** Handles an event emitted by the block stream. */
     handleBlockStreamEvent(event: L2BlockStreamEvent): Promise<void>;
-    /**
-     * Handles a list of L2 blocks (i.e. Inserts the new note hashes into the merkle tree).
-     * @param l2Blocks - The L2 blocks to handle.
-     * @returns Whether the block handled was produced by this same node.
-     */
     private handleL2Blocks;
-    /**
-     * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
-     * @param l2Block - The L2 block to handle.
-     * @param l1ToL2Messages - The L1 to L2 messages for the block.
-     * @returns Whether the block handled was produced by this same node.
-     */
     private handleL2Block;
     private handleChainFinalized;
     private handleChainProven;
@@ -68,12 +65,5 @@ export declare class ServerWorldStateSynchronizer implements WorldStateSynchroni
      * @param newState - New state value.
      */
     private setCurrentState;
-    /**
-     * 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 verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Buffer): Promise<void>;
 }
-//# sourceMappingURL=server_world_state_synchronizer.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyX3dvcmxkX3N0YXRlX3N5bmNocm9uaXplci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3N5bmNocm9uaXplci9zZXJ2ZXJfd29ybGRfc3RhdGVfc3luY2hyb25pemVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxXQUFXLEVBQW9CLE1BQU0saUNBQWlDLENBQUM7QUFFaEYsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFnQixNQUFNLHVCQUF1QixDQUFDO0FBR2xFLE9BQU8sRUFDTCxLQUFLLFNBQVMsRUFJZCxLQUFLLGFBQWEsRUFDbEIsYUFBYSxFQUNiLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUsseUJBQXlCLEVBQzlCLEtBQUssOEJBQThCLEVBQ25DLEtBQUssTUFBTSxFQUNaLE1BQU0scUJBQXFCLENBQUM7QUFDN0IsT0FBTyxFQUdMLEtBQUssc0JBQXNCLEVBQzNCLEtBQUssNEJBQTRCLEVBQ2xDLE1BQU0saUNBQWlDLENBQUM7QUFDekMsT0FBTyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRWhFLE9BQU8sRUFBZ0IsS0FBSyx3QkFBd0IsRUFBRSxLQUFLLHlCQUF5QixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFHbEgsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sdUNBQXVDLENBQUM7QUFFbEYsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUNuRixPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUdwRCxZQUFZLEVBQUUsZ0JBQWdCLEVBQUUsQ0FBQztBQUVqQzs7OztHQUlHO0FBQ0gscUJBQWEsNEJBQ1gsWUFBVyxzQkFBc0IsRUFBRSw4QkFBOEIsRUFBRSx5QkFBeUI7SUFnQjFGLE9BQU8sQ0FBQyxRQUFRLENBQUMsWUFBWTtJQUM3QixPQUFPLENBQUMsUUFBUSxDQUFDLGFBQWE7SUFDOUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNO0lBQ3ZCLE9BQU8sQ0FBQyxlQUFlO0lBQ3ZCLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRztJQWxCdEIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FBMkI7SUFFL0QsT0FBTyxDQUFDLHdCQUF3QixDQUFvQjtJQUNwRCxPQUFPLENBQUMsYUFBYSxDQUFxQjtJQUMxQyxPQUFPLENBQUMsWUFBWSxDQUF1RDtJQUUzRSxPQUFPLENBQUMsV0FBVyxDQUFnQztJQUNuRCxTQUFTLENBQUMsV0FBVyxFQUFFLGFBQWEsR0FBRyxTQUFTLENBQUM7SUFJakQsT0FBTyxDQUFDLGlCQUFpQixDQUEwQjtJQUVuRCxZQUNtQixZQUFZLEVBQUUsdUJBQXVCLEVBQ3JDLGFBQWEsRUFBRSxhQUFhLEdBQUcsbUJBQW1CLEVBQ2xELE1BQU0sRUFBRSxnQkFBZ0IsRUFDakMsZUFBZSw0QkFBc0QsRUFDNUQsR0FBRyxHQUFFLE1BQW9DLEVBUzNEO0lBRU0sWUFBWSxJQUFJLHdCQUF3QixDQUU5QztJQUVNLFdBQVcsQ0FBQyxXQUFXLEVBQUUsV0FBVyxHQUFHLHdCQUF3QixDQUVyRTtJQUVNLElBQUksQ0FBQyxXQUFXLENBQUMsRUFBRSxXQUFXLEVBQUUsSUFBSSxDQUFDLEVBQUU7UUFBRSxZQUFZLENBQUMsRUFBRSxNQUFNLENBQUE7S0FBRSxHQUFHLE9BQU8sQ0FBQyx5QkFBeUIsQ0FBQyxDQUUzRztJQUVNLFFBQVEsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLE9BQU8sQ0FBQyxFQUFFLE9BQU8sR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxnQkFBZ0IsRUFBRSxVQUFVLENBQUMsRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUVsSDtJQUVNLEtBQUssSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBRTVCO0lBRVksS0FBSyxtRkE0QmpCO0lBRUQsU0FBUyxDQUFDLGlCQUFpQixJQUFJLGFBQWEsQ0FPM0M7SUFFWSxJQUFJLGtCQU9oQjtJQUVZLE1BQU0sSUFBSSxPQUFPLENBQUMsNEJBQTRCLENBQUMsQ0FhM0Q7SUFFWSxvQkFBb0IseUJBRWhDO0lBRVksUUFBUSxrQkFJcEI7SUFFTSxVQUFVLFNBT2hCO0lBRUQ7Ozs7O09BS0c7SUFDVSxhQUFhLENBQUMsaUJBQWlCLENBQUMsRUFBRSxXQUFXLEVBQUUsU0FBUyxDQUFDLEVBQUUsU0FBUyxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0EyRXZHO0lBRUQsb0dBQW9HO0lBQ3ZGLGNBQWMsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBSzVFO0lBRUQsZ0dBQWdHO0lBQ25GLFNBQVMsSUFBSSxPQUFPLENBQUMsTUFBTSxDQUFDLENBbUN4QztJQUVELG9EQUFvRDtJQUN2QyxzQkFBc0IsQ0FBQyxLQUFLLEVBQUUsa0JBQWtCLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWU1RTtZQU9hLGNBQWM7WUF5Q2QsYUFBYTtZQWtCYixvQkFBb0I7SUF3Q2xDLE9BQU8sQ0FBQyxpQkFBaUI7WUFNWCxpQkFBaUI7SUFPL0I7OztPQUdHO0lBQ0gsT0FBTyxDQUFDLGVBQWU7Q0FJeEIifQ==

package/dest/synchronizer/server_world_state_synchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server_world_state_synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/server_world_state_synchronizer.ts"],"names":[],"mappings":";;AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAMnD,OAAO,KAAK,EAGV,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,yBAAyB,EACzB,8BAA8B,EAC9B,MAAM,EACP,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EAClC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAgB,KAAK,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAGlH,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;GAIG;AACH,qBAAa,4BACX,YAAW,sBAAsB,EAAE,8BAA8B,EAAE,yBAAyB;IAa1F,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAftB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA2B;IAE/D,OAAO,CAAC,wBAAwB,CAAK;IACrC,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,YAAY,CAAuD;IAC3E,OAAO,CAAC,oBAAoB,CAA4E;IAExG,OAAO,CAAC,WAAW,CAAgC;IACnD,SAAS,CAAC,WAAW,EAAE,aAAa,GAAG,SAAS,CAAC;gBAG9B,YAAY,EAAE,uBAAuB,EACrC,aAAa,EAAE,aAAa,GAAG,mBAAmB,EAClD,MAAM,EAAE,gBAAgB,EACjC,eAAe,4BAAsD,EAC5D,GAAG,yCAA8B;IAW7C,YAAY,IAAI,wBAAwB;IAIxC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,wBAAwB;IAI1D,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAIxD,KAAK;IAgClB,SAAS,CAAC,iBAAiB,IAAI,aAAa;IAU/B,IAAI;IASJ,MAAM,IAAI,OAAO,CAAC,4BAA4B,CAAC;IAe/C,oBAAoB;IAIjC;;;;OAIG;IACU,aAAa,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAwBvE,oGAAoG;IACvF,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAexE,gGAAgG;IACnF,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAYzC,oDAAoD;IACvC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB7E;;;;OAIG;YACW,cAAc;IAyB5B;;;;;OAKG;YACW,aAAa;YAuBb,oBAAoB;IAelC,OAAO,CAAC,iBAAiB;YAKX,iBAAiB;IAO/B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAKvB;;;;;OAKG;cACa,0BAA0B,CAAC,cAAc,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM;CAahF"}
+{"version":3,"file":"server_world_state_synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/server_world_state_synchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAoB,MAAM,iCAAiC,CAAC;AAEhF,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAGlE,OAAO,EACL,KAAK,SAAS,EAId,KAAK,aAAa,EAClB,aAAa,EACb,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,8BAA8B,EACnC,KAAK,MAAM,EACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EAClC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,OAAO,EAAgB,KAAK,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAGlH,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AACnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;;GAIG;AACH,qBAAa,4BACX,YAAW,sBAAsB,EAAE,8BAA8B,EAAE,yBAAyB;IAgB1F,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAlBtB,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA2B;IAE/D,OAAO,CAAC,wBAAwB,CAAoB;IACpD,OAAO,CAAC,aAAa,CAAqB;IAC1C,OAAO,CAAC,YAAY,CAAuD;IAE3E,OAAO,CAAC,WAAW,CAAgC;IACnD,SAAS,CAAC,WAAW,EAAE,aAAa,GAAG,SAAS,CAAC;IAIjD,OAAO,CAAC,iBAAiB,CAA0B;IAEnD,YACmB,YAAY,EAAE,uBAAuB,EACrC,aAAa,EAAE,aAAa,GAAG,mBAAmB,EAClD,MAAM,EAAE,gBAAgB,EACjC,eAAe,4BAAsD,EAC5D,GAAG,GAAE,MAAoC,EAS3D;IAEM,YAAY,IAAI,wBAAwB,CAE9C;IAEM,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,wBAAwB,CAErE;IAEM,IAAI,CAAC,WAAW,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAE3G;IAEM,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,gBAAgB,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC,CAElH;IAEM,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAE5B;IAEY,KAAK,mFA4BjB;IAED,SAAS,CAAC,iBAAiB,IAAI,aAAa,CAO3C;IAEY,IAAI,kBAOhB;IAEY,MAAM,IAAI,OAAO,CAAC,4BAA4B,CAAC,CAa3D;IAEY,oBAAoB,yBAEhC;IAEY,QAAQ,kBAIpB;IAEM,UAAU,SAOhB;IAED;;;;;OAKG;IACU,aAAa,CAAC,iBAAiB,CAAC,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,CA2EvG;IAED,oGAAoG;IACvF,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAK5E;IAED,gGAAgG;IACnF,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAmCxC;IAED,oDAAoD;IACvC,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5E;YAOa,cAAc;YAyCd,aAAa;YAkBb,oBAAoB;IAwClC,OAAO,CAAC,iBAAiB;YAMX,iBAAiB;IAO/B;;;OAGG;IACH,OAAO,CAAC,eAAe;CAIxB"}

package/dest/synchronizer/server_world_state_synchronizer.js

@@ -1,13 +1,14 @@
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { GENESIS_BLOCK_HEADER_HASH, INITIAL_CHECKPOINT_NUMBER, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import { createLogger } from '@aztec/foundation/log';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
-import { MerkleTreeCalculator } from '@aztec/foundation/trees';
-import { SHA256Trunc } from '@aztec/merkle-tree';
+import { GENESIS_CHECKPOINT_HEADER_HASH, L2BlockStream } from '@aztec/stdlib/block';
 import { WorldStateRunningState } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
-import { TraceableL2BlockStream, getTelemetryClient } from '@aztec/telemetry-client';
+import { getTelemetryClient } from '@aztec/telemetry-client';
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
+import { WorldStateSynchronizerError } from './errors.js';
 /**
  * Synchronizes the world state with the L2 blocks from a L2BlockSource via a block stream.
  * The synchronizer will download the L2 blocks from the L2BlockSource and update the merkle trees.
@@ -22,21 +23,22 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     latestBlockNumberAtStart;
     historyToKeep;
     currentState;
-    latestBlockHashQuery;
     syncPromise;
     blockStream;
+    // 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
+    provenBlockNumber;
     constructor(merkleTreeDb, l2BlockSource, config, instrumentation = new WorldStateInstrumentation(getTelemetryClient()), log = createLogger('world_state')){
         this.merkleTreeDb = merkleTreeDb;
         this.l2BlockSource = l2BlockSource;
         this.config = config;
         this.instrumentation = instrumentation;
         this.log = log;
-        this.latestBlockNumberAtStart = 0;
+        this.latestBlockNumberAtStart = BlockNumber.ZERO;
         this.currentState = WorldStateRunningState.IDLE;
-        this.latestBlockHashQuery = undefined;
         this.syncPromise = promiseWithResolvers();
         this.merkleTreeCommitted = this.merkleTreeDb.getCommitted();
-        this.historyToKeep = config.worldStateBlockHistory < 1 ? undefined : config.worldStateBlockHistory;
+        this.historyToKeep = config.worldStateCheckpointHistory < 1 ? undefined : config.worldStateCheckpointHistory;
         this.log.info(`Created world state synchroniser with block history of ${this.historyToKeep === undefined ? 'infinity' : this.historyToKeep}`);
     }
     getCommitted() {
@@ -45,8 +47,14 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     getSnapshot(blockNumber) {
         return this.merkleTreeDb.getSnapshot(blockNumber);
     }
-    fork(blockNumber) {
-        return this.merkleTreeDb.fork(blockNumber);
+    fork(blockNumber, opts) {
+        return this.merkleTreeDb.fork(blockNumber, opts);
+    }
+    backupTo(dstPath, compact) {
+        return this.merkleTreeDb.backupTo(dstPath, compact);
+    }
+    clear() {
+        return this.merkleTreeDb.clear();
     }
     async start() {
         if (this.currentState === WorldStateRunningState.STOPPED) {
@@ -56,7 +64,7 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
             return this.syncPromise;
         }
         // Get the current latest block number
-        this.latestBlockNumberAtStart = await (this.config.worldStateProvenBlocksOnly ? this.l2BlockSource.getProvenBlockNumber() : this.l2BlockSource.getBlockNumber());
+        this.latestBlockNumberAtStart = BlockNumber(await this.l2BlockSource.getBlockNumber());
         const blockToDownloadFrom = await this.getLatestBlockNumber() + 1;
         if (blockToDownloadFrom <= this.latestBlockNumberAtStart) {
             // If there are blocks to be retrieved, go to a synching state
@@ -74,12 +82,11 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
         return this.syncPromise.promise;
     }
     createBlockStream() {
-        const tracer = this.instrumentation.telemetry.getTracer('WorldStateL2BlockStream');
         const logger = createLogger('world-state:block_stream');
-        return new TraceableL2BlockStream(this.l2BlockSource, this, this, tracer, 'WorldStateL2BlockStream', logger, {
-            proven: this.config.worldStateProvenBlocksOnly,
+        return new L2BlockStream(this.l2BlockSource, this, this, logger, {
             pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
-            batchSize: this.config.worldStateBlockRequestBatchSize
+            batchSize: this.config.worldStateBlockRequestBatchSize,
+            ignoreCheckpoints: true
         });
     }
     async stop() {
@@ -93,10 +100,10 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     async status() {
         const summary = await this.merkleTreeDb.getStatusSummary();
         const status = {
-            latestBlockNumber: Number(summary.unfinalisedBlockNumber),
-            latestBlockHash: await this.getL2BlockHash(Number(summary.unfinalisedBlockNumber)) ?? '',
-            finalisedBlockNumber: Number(summary.finalisedBlockNumber),
-            oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
+            latestBlockNumber: summary.unfinalizedBlockNumber,
+            latestBlockHash: await this.getL2BlockHash(summary.unfinalizedBlockNumber) ?? '',
+            finalizedBlockNumber: summary.finalizedBlockNumber,
+            oldestHistoricBlockNumber: summary.oldestHistoricalBlock,
             treesAreSynched: summary.treesAreSynched
         };
         return {
@@ -105,80 +112,159 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
         };
     }
     async getLatestBlockNumber() {
-        return (await this.getL2Tips()).latest.number;
+        return (await this.getL2Tips()).proposed.number;
+    }
+    async stopSync() {
+        this.log.debug('Stopping sync...');
+        await this.blockStream?.stop();
+        this.log.info('Stopped sync');
+    }
+    resumeSync() {
+        if (!this.blockStream) {
+            throw new Error('Cannot resume sync as block stream is not initialized');
+        }
+        this.log.debug('Resuming sync...');
+        this.blockStream.start();
+        this.log.info('Resumed sync');
     }
     /**
    * Forces an immediate sync.
-   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it. Throws if cannot be reached.
+   * @param targetBlockNumber - The target block number that we must sync to. Will download unproven blocks if needed to reach it.
+   * @param blockHash - If provided, verifies the block at targetBlockNumber matches this hash. On mismatch, triggers a resync (reorg detection).
    * @returns A promise that resolves with the block number the world state was synced to
-   */ async syncImmediate(targetBlockNumber) {
-        if (this.currentState !== WorldStateRunningState.RUNNING || this.blockStream === undefined) {
+   */ async syncImmediate(targetBlockNumber, blockHash) {
+        if (this.currentState !== WorldStateRunningState.RUNNING) {
             throw new Error(`World State is not running. Unable to perform sync.`);
         }
+        if (this.blockStream === undefined) {
+            throw new Error('Block stream is not initialized. Unable to perform sync.');
+        }
         // If we have been given a block number to sync to and we have reached that number then return
         const currentBlockNumber = await this.getLatestBlockNumber();
         if (targetBlockNumber !== undefined && targetBlockNumber <= currentBlockNumber) {
-            return currentBlockNumber;
+            if (blockHash === undefined) {
+                return currentBlockNumber;
+            }
+            // If a block hash was provided, verify we're on the expected fork
+            const currentHash = await this.getL2BlockHash(targetBlockNumber);
+            if (currentHash === blockHash.toString()) {
+                return currentBlockNumber;
+            }
+            // Hash mismatch: a reorg may have occurred, fall through to trigger sync
+            this.log.debug(`World state block hash mismatch at ${targetBlockNumber} (expected ${blockHash}, got ${currentHash}). Triggering resync.`);
         }
         this.log.debug(`World State at ${currentBlockNumber} told to sync to ${targetBlockNumber ?? 'latest'}`);
+        // If the archiver is behind the target block, force an archiver sync
+        if (targetBlockNumber) {
+            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();
+            }
+        }
         // Force the block stream to sync against the archiver now
         await this.blockStream.sync();
         // If we have been given a block number to sync to and we have not reached that number then fail
         const updatedBlockNumber = await this.getLatestBlockNumber();
         if (targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
-            throw new Error(`Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`);
+            throw new WorldStateSynchronizerError(`Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`, {
+                cause: {
+                    reason: 'block_not_available',
+                    previousBlockNumber: currentBlockNumber,
+                    updatedBlockNumber,
+                    targetBlockNumber
+                }
+            });
+        }
+        // If a block hash was provided, verify we're on the expected fork after syncing, throw otherwise
+        if (blockHash !== undefined && targetBlockNumber !== undefined) {
+            const updatedHash = await this.getL2BlockHash(targetBlockNumber);
+            if (updatedHash !== blockHash.toString()) {
+                throw new WorldStateSynchronizerError(`Block hash mismatch at block ${targetBlockNumber} (expected ${blockHash} but got ${updatedHash})`, {
+                    cause: {
+                        reason: 'block_hash_mismatch',
+                        targetBlockNumber,
+                        expectedHash: blockHash.toString(),
+                        actualHash: updatedHash
+                    }
+                });
+            }
         }
         return updatedBlockNumber;
     }
     /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */ async getL2BlockHash(number) {
-        if (number === 0) {
+        if (number === BlockNumber.ZERO) {
             return (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
         }
-        if (this.latestBlockHashQuery?.hash === undefined || number !== this.latestBlockHashQuery.blockNumber) {
-            this.latestBlockHashQuery = {
-                hash: await this.merkleTreeCommitted.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number)).then((leaf)=>leaf?.toString()),
-                blockNumber: number
-            };
-        }
-        return this.latestBlockHashQuery.hash;
+        return this.merkleTreeCommitted.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number)).then((leaf)=>leaf?.toString());
     }
     /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */ async getL2Tips() {
         const status = await this.merkleTreeDb.getStatusSummary();
-        const unfinalisedBlockHash = await this.getL2BlockHash(Number(status.unfinalisedBlockNumber));
+        const unfinalizedBlockHashPromise = this.getL2BlockHash(status.unfinalizedBlockNumber);
+        const finalizedBlockHashPromise = this.getL2BlockHash(status.finalizedBlockNumber);
+        const provenBlockNumber = this.provenBlockNumber ?? status.finalizedBlockNumber;
+        const provenBlockHashPromise = this.provenBlockNumber === undefined ? finalizedBlockHashPromise : this.getL2BlockHash(this.provenBlockNumber);
+        const [unfinalizedBlockHash, finalizedBlockHash, provenBlockHash] = await Promise.all([
+            unfinalizedBlockHashPromise,
+            finalizedBlockHashPromise,
+            provenBlockHashPromise
+        ]);
         const latestBlockId = {
-            number: Number(status.unfinalisedBlockNumber),
-            hash: unfinalisedBlockHash
+            number: status.unfinalizedBlockNumber,
+            hash: unfinalizedBlockHash
         };
+        // World state doesn't track checkpointed blocks or checkpoints themselves.
+        // but we use a block stream so we need to provide 'local' L2Tips.
+        // We configure the block stream to ignore checkpoints and set checkpoint values to genesis here.
+        const genesisCheckpointHeaderHash = GENESIS_CHECKPOINT_HEADER_HASH.toString();
         return {
-            latest: latestBlockId,
+            proposed: latestBlockId,
+            checkpointed: {
+                block: {
+                    number: INITIAL_L2_BLOCK_NUM,
+                    hash: GENESIS_BLOCK_HEADER_HASH.toString()
+                },
+                checkpoint: {
+                    number: INITIAL_CHECKPOINT_NUMBER,
+                    hash: genesisCheckpointHeaderHash
+                }
+            },
             finalized: {
-                number: Number(status.finalisedBlockNumber),
-                hash: ''
+                block: {
+                    number: status.finalizedBlockNumber,
+                    hash: finalizedBlockHash ?? ''
+                },
+                checkpoint: {
+                    number: INITIAL_CHECKPOINT_NUMBER,
+                    hash: genesisCheckpointHeaderHash
+                }
             },
             proven: {
-                number: Number(status.finalisedBlockNumber),
-                hash: ''
+                block: {
+                    number: provenBlockNumber,
+                    hash: provenBlockHash ?? ''
+                },
+                checkpoint: {
+                    number: INITIAL_CHECKPOINT_NUMBER,
+                    hash: genesisCheckpointHeaderHash
+                }
             }
         };
     }
     /** Handles an event emitted by the block stream. */ async handleBlockStreamEvent(event) {
-        try {
-            switch(event.type){
-                case 'blocks-added':
-                    await this.handleL2Blocks(event.blocks);
-                    break;
-                case 'chain-pruned':
-                    await this.handleChainPruned(event.blockNumber);
-                    break;
-                case 'chain-proven':
-                    await this.handleChainProven(event.blockNumber);
-                    break;
-                case 'chain-finalized':
-                    await this.handleChainFinalized(event.blockNumber);
-                    break;
-            }
-        } catch (err) {
-            this.log.error('Error processing block stream', err);
+        switch(event.type){
+            case 'blocks-added':
+                await this.handleL2Blocks(event.blocks);
+                break;
+            case 'chain-pruned':
+                await this.handleChainPruned(event.block.number);
+                break;
+            case 'chain-proven':
+                await this.handleChainProven(event.block.number);
+                break;
+            case 'chain-finalized':
+                await this.handleChainFinalized(event.block.number);
+                break;
         }
     }
     /**
@@ -186,19 +272,23 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
    * @param l2Blocks - The L2 blocks to handle.
    * @returns Whether the block handled was produced by this same node.
    */ async handleL2Blocks(l2Blocks) {
-        this.log.trace(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1).number}`);
-        const messagePromises = l2Blocks.map((block)=>this.l2BlockSource.getL1ToL2Messages(BigInt(block.number)));
-        const l1ToL2Messages = await Promise.all(messagePromises);
+        this.log.debug(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1).number}`);
+        // Fetch the L1->L2 messages for the first block in a checkpoint.
+        const messagesForBlocks = new Map();
+        await Promise.all(l2Blocks.filter((b)=>b.indexWithinCheckpoint === 0).map(async (block)=>{
+            const l1ToL2Messages = await this.l2BlockSource.getL1ToL2Messages(block.checkpointNumber);
+            messagesForBlocks.set(block.number, l1ToL2Messages);
+        }));
         let updateStatus = undefined;
-        for(let i = 0; i < l2Blocks.length; i++){
-            const [duration, result] = await elapsed(()=>this.handleL2Block(l2Blocks[i], l1ToL2Messages[i]));
-            this.log.verbose(`World state updated with L2 block ${l2Blocks[i].number}`, {
+        for (const block of l2Blocks){
+            const [duration, result] = await elapsed(()=>this.handleL2Block(block, messagesForBlocks.get(block.number) ?? []));
+            this.log.info(`World state updated with L2 block ${block.number}`, {
                 eventName: 'l2-block-handled',
                 duration,
-                unfinalisedBlockNumber: result.summary.unfinalisedBlockNumber,
-                finalisedBlockNumber: result.summary.finalisedBlockNumber,
-                oldestHistoricBlock: result.summary.oldestHistoricalBlock,
-                ...l2Blocks[i].getStats()
+                unfinalizedBlockNumber: BigInt(result.summary.unfinalizedBlockNumber),
+                finalizedBlockNumber: BigInt(result.summary.finalizedBlockNumber),
+                oldestHistoricBlock: BigInt(result.summary.oldestHistoricalBlock),
+                ...block.getStats()
             });
             updateStatus = result;
         }
@@ -213,16 +303,12 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
    * @param l1ToL2Messages - The L1 to L2 messages for the block.
    * @returns Whether the block handled was produced by this same node.
    */ async handleL2Block(l2Block, l1ToL2Messages) {
-        // 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);
-        // If the above check succeeds, we can proceed to handle the block.
-        this.log.trace(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
+        this.log.debug(`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())
+            l1ToL2Messages: l1ToL2Messages.map((msg)=>msg.toString()),
+            blockHeader: l2Block.header.toInspect(),
+            blockStats: l2Block.getStats()
         });
         const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
         if (this.currentState === WorldStateRunningState.SYNCHING && l2Block.number >= this.latestBlockNumberAtStart) {
@@ -233,26 +319,47 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     }
     async handleChainFinalized(blockNumber) {
         this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
-        const summary = await this.merkleTreeDb.setFinalised(BigInt(blockNumber));
+        const summary = await this.merkleTreeDb.setFinalized(blockNumber);
         if (this.historyToKeep === undefined) {
             return;
         }
-        const newHistoricBlock = summary.finalisedBlockNumber - BigInt(this.historyToKeep) + 1n;
-        if (newHistoricBlock <= 1) {
+        // Get the checkpointed block for the finalized block number
+        const finalisedCheckpoint = await this.l2BlockSource.getCheckpointedBlock(summary.finalizedBlockNumber);
+        if (finalisedCheckpoint === undefined) {
+            this.log.warn(`Failed to retrieve checkpointed block for finalized block number: ${summary.finalizedBlockNumber}`);
+            return;
+        }
+        // Compute the required historic checkpoint number
+        const newHistoricCheckpointNumber = finalisedCheckpoint.checkpointNumber - this.historyToKeep + 1;
+        if (newHistoricCheckpointNumber <= 1) {
+            return;
+        }
+        // Retrieve the historic checkpoint
+        const historicCheckpoints = await this.l2BlockSource.getCheckpoints(CheckpointNumber(newHistoricCheckpointNumber), 1);
+        if (historicCheckpoints.length === 0 || historicCheckpoints[0] === undefined) {
+            this.log.warn(`Failed to retrieve checkpoint number ${newHistoricCheckpointNumber} from Archiver`);
+            return;
+        }
+        const historicCheckpoint = historicCheckpoints[0];
+        if (historicCheckpoint.checkpoint.blocks.length === 0 || historicCheckpoint.checkpoint.blocks[0] === undefined) {
+            this.log.warn(`Retrieved checkpoint number ${newHistoricCheckpointNumber} has no blocks!`);
             return;
         }
-        this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
-        const status = await this.merkleTreeDb.removeHistoricalBlocks(newHistoricBlock);
+        // Find the block at the start of the checkpoint and remove blocks up to this one
+        const newHistoricBlock = historicCheckpoint.checkpoint.blocks[0];
+        this.log.verbose(`Pruning historic blocks to ${newHistoricBlock.number}`);
+        const status = await this.merkleTreeDb.removeHistoricalBlocks(BlockNumber(newHistoricBlock.number));
         this.log.debug(`World state summary `, status.summary);
     }
     handleChainProven(blockNumber) {
+        this.provenBlockNumber = blockNumber;
         this.log.debug(`Proven chain is now at block ${blockNumber}`);
         return Promise.resolve();
     }
     async handleChainPruned(blockNumber) {
-        this.log.warn(`Chain pruned to block ${blockNumber}`);
-        const status = await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
-        this.latestBlockHashQuery = undefined;
+        this.log.info(`Chain pruned to block ${blockNumber}`);
+        const status = await this.merkleTreeDb.unwindBlocks(blockNumber);
+        this.provenBlockNumber = undefined;
         this.instrumentation.updateWorldStateMetrics(status);
     }
     /**
@@ -262,16 +369,4 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
         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.
-   */ async verifyMessagesHashToInHash(l1ToL2Messages, inHash) {
-        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)) {
-            throw new Error('Obtained L1 to L2 messages failed to be hashed to the block inHash');
-        }
-    }
 }

package/dest/test/index.d.ts

@@ -1,2 +1,2 @@
 export * from './utils.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFDIn0=

package/dest/test/utils.d.ts

@@ -1,19 +1,26 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { L2Block } from '@aztec/stdlib/block';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { mockCheckpointAndMessages } from '@aztec/stdlib/testing';
 import type { NativeWorldStateService } from '../native/native_world_state.js';
-export declare function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations): Promise<{
+export declare function updateBlockState(block: L2Block, l1ToL2Messages: Fr[], fork: MerkleTreeWriteOperations): Promise<void>;
+export declare function mockBlock(blockNum: BlockNumber, size: number, fork: MerkleTreeWriteOperations, maxEffects?: number | undefined, numL1ToL2Messages?: number, isFirstBlockInCheckpoint?: boolean): Promise<{
     block: L2Block;
     messages: Fr[];
 }>;
-export declare function mockEmptyBlock(blockNum: number, fork: MerkleTreeWriteOperations): Promise<{
+export declare function mockEmptyBlock(blockNum: BlockNumber, fork: MerkleTreeWriteOperations): Promise<{
     block: L2Block;
     messages: Fr[];
 }>;
-export declare function mockBlocks(from: number, count: number, numTxs: number, worldState: NativeWorldStateService): Promise<{
+export declare function mockBlocks(from: BlockNumber, count: number, numTxs: number, worldState: NativeWorldStateService): Promise<{
     blocks: L2Block[];
     messages: Fr[][];
 }>;
+export declare function mockCheckpoint(checkpointNumber: CheckpointNumber, fork: MerkleTreeWriteOperations, options?: Partial<Parameters<typeof mockCheckpointAndMessages>[1]>): Promise<{
+    checkpoint: import("@aztec/stdlib/checkpoint").Checkpoint;
+    messages: Fr[];
+}>;
 export declare function assertSameState(forkA: MerkleTreeReadOperations, forkB: MerkleTreeReadOperations): Promise<void>;
 export declare function compareChains(left: MerkleTreeReadOperations, right: MerkleTreeReadOperations): Promise<void>;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90ZXN0L3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU9BLE9BQU8sRUFBRSxXQUFXLEVBQUUsS0FBSyxnQkFBZ0IsRUFBeUIsTUFBTSxpQ0FBaUMsQ0FBQztBQUU1RyxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQzlDLE9BQU8sS0FBSyxFQUVWLHdCQUF3QixFQUN4Qix5QkFBeUIsRUFDMUIsTUFBTSxpQ0FBaUMsQ0FBQztBQUN6QyxPQUFPLEVBQUUseUJBQXlCLEVBQXNCLE1BQU0sdUJBQXVCLENBQUM7QUFJdEYsT0FBTyxLQUFLLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUUvRSx3QkFBc0IsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLE9BQU8sRUFBRSxjQUFjLEVBQUUsRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLHlCQUF5QixpQkE4QzNHO0FBRUQsd0JBQXNCLFNBQVMsQ0FDN0IsUUFBUSxFQUFFLFdBQVcsRUFDckIsSUFBSSxFQUFFLE1BQU0sRUFDWixJQUFJLEVBQUUseUJBQXlCLEVBQy9CLFVBQVUsR0FBRSxNQUFNLEdBQUcsU0FBZ0IsRUFDckMsaUJBQWlCLEdBQUUsTUFBNEMsRUFDL0Qsd0JBQXdCLEdBQUUsT0FBYzs7O0dBZXpDO0FBRUQsd0JBQXNCLGNBQWMsQ0FBQyxRQUFRLEVBQUUsV0FBVyxFQUFFLElBQUksRUFBRSx5QkFBeUI7OztHQVkxRjtBQUVELHdCQUFzQixVQUFVLENBQzlCLElBQUksRUFBRSxXQUFXLEVBQ2pCLEtBQUssRUFBRSxNQUFNLEVBQ2IsTUFBTSxFQUFFLE1BQU0sRUFDZCxVQUFVLEVBQUUsdUJBQXVCOzs7R0FlcEM7QUFFRCx3QkFBc0IsY0FBYyxDQUNsQyxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFDbEMsSUFBSSxFQUFFLHlCQUF5QixFQUMvQixPQUFPLEdBQUUsT0FBTyxDQUFDLFVBQVUsQ0FBQyxPQUFPLHlCQUF5QixDQUFDLENBQUMsQ0FBQyxDQUFDLENBQU07OztHQU92RTtBQUVELHdCQUFzQixlQUFlLENBQUMsS0FBSyxFQUFFLHdCQUF3QixFQUFFLEtBQUssRUFBRSx3QkFBd0IsaUJBUXJHO0FBRUQsd0JBQXNCLGFBQWEsQ0FBQyxJQUFJLEVBQUUsd0JBQXdCLEVBQUUsS0FBSyxFQUFFLHdCQUF3QixpQkFZbEcifQ==