@aztec/world-state 0.0.0-test.0 → 0.0.1-commit.24de95ac

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/synchronizer/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAElC,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,8BAA8B,EAAE,MAAM,CAAC;IAEvC,+CAA+C;IAC/C,0BAA0B,EAAE,OAAO,CAAC;IAEpC,2FAA2F;IAC3F,+BAA+B,CAAC,EAAE,MAAM,CAAC;IAEzC,mJAAmJ;IACnJ,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B,2GAA2G;IAC3G,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAEjC,gDAAgD;IAChD,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,wBAAwB,EAAE,kBAAkB,CAAC,gBAAgB,CA+BzE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,gBAAgB,CAE7D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/synchronizer/config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,0BAA0B,CAAC;AAElC,qDAAqD;AACrD,MAAM,WAAW,gBAAgB;IAC/B,uCAAuC;IACvC,8BAA8B,EAAE,MAAM,CAAC;IAEvC,+CAA+C;IAC/C,0BAA0B,EAAE,OAAO,CAAC;IAEpC,2FAA2F;IAC3F,+BAA+B,CAAC,EAAE,MAAM,CAAC;IAEzC,mJAAmJ;IACnJ,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B,2JAA2J;IAC3J,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,6JAA6J;IAC7J,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAEhC,6JAA6J;IAC7J,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B,2JAA2J;IAC3J,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAE9B,+JAA+J;IAC/J,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAEjC,2GAA2G;IAC3G,uBAAuB,CAAC,EAAE,MAAM,CAAC;IAEjC,gDAAgD;IAChD,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED,eAAO,MAAM,wBAAwB,EAAE,kBAAkB,CAAC,gBAAgB,CA6DzE,CAAC;AAEF;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,gBAAgB,CAE7D"}

package/dest/synchronizer/config.js

@@ -19,7 +19,32 @@ export const worldStateConfigMappings = {
     worldStateDbMapSizeKb: {
         env: 'WS_DB_MAP_SIZE_KB',
         parseEnv: (val)=>val ? +val : undefined,
-        description: 'The maximum possible size of the world state DB'
+        description: 'The maximum possible size of the world state DB in KB. Overwrites the general dataStoreMapSizeKb.'
+    },
+    archiveTreeMapSizeKb: {
+        env: 'ARCHIVE_TREE_MAP_SIZE_KB',
+        parseEnv: (val)=>val ? +val : undefined,
+        description: 'The maximum possible size of the world state archive tree in KB. Overwrites the general worldStateDbMapSizeKb.'
+    },
+    nullifierTreeMapSizeKb: {
+        env: 'NULLIFIER_TREE_MAP_SIZE_KB',
+        parseEnv: (val)=>val ? +val : undefined,
+        description: 'The maximum possible size of the world state nullifier tree in KB. Overwrites the general worldStateDbMapSizeKb.'
+    },
+    noteHashTreeMapSizeKb: {
+        env: 'NOTE_HASH_TREE_MAP_SIZE_KB',
+        parseEnv: (val)=>val ? +val : undefined,
+        description: 'The maximum possible size of the world state note hash tree in KB. Overwrites the general worldStateDbMapSizeKb.'
+    },
+    messageTreeMapSizeKb: {
+        env: 'MESSAGE_TREE_MAP_SIZE_KB',
+        parseEnv: (val)=>val ? +val : undefined,
+        description: 'The maximum possible size of the world state message tree in KB. Overwrites the general worldStateDbMapSizeKb.'
+    },
+    publicDataTreeMapSizeKb: {
+        env: 'PUBLIC_DATA_TREE_MAP_SIZE_KB',
+        parseEnv: (val)=>val ? +val : undefined,
+        description: 'The maximum possible size of the world state public data tree in KB. Overwrites the general worldStateDbMapSizeKb.'
     },
     worldStateDataDirectory: {
         env: 'WS_DATA_DIRECTORY',

package/dest/synchronizer/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class WorldStateSynchronizerError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/synchronizer/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAGpD"}

package/dest/synchronizer/errors.js

@@ -0,0 +1,5 @@
+export class WorldStateSynchronizerError extends Error {
+    constructor(message, options){
+        super(message, options);
+    }
+}

package/dest/synchronizer/factory.d.ts

@@ -7,6 +7,13 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
 import { NativeWorldStateService } from '../native/native_world_state.js';
 import type { WorldStateConfig } from './config.js';
 import { ServerWorldStateSynchronizer } from './server_world_state_synchronizer.js';
+export interface WorldStateTreeMapSizes {
+    archiveTreeMapSizeKb: number;
+    nullifierTreeMapSizeKb: number;
+    noteHashTreeMapSizeKb: number;
+    messageTreeMapSizeKb: number;
+    publicDataTreeMapSizeKb: number;
+}
 export declare function createWorldStateSynchronizer(config: WorldStateConfig & DataStoreConfig, l2BlockSource: L2BlockSource & L1ToL2MessageSource, prefilledPublicData?: PublicDataTreeLeaf[], client?: TelemetryClient): Promise<ServerWorldStateSynchronizer>;
-export declare function createWorldState(config: WorldStateConfig & DataStoreConfig, prefilledPublicData?: PublicDataTreeLeaf[], instrumentation?: WorldStateInstrumentation): Promise<NativeWorldStateService>;
+export declare function createWorldState(config: Pick<WorldStateConfig, 'worldStateDataDirectory' | 'worldStateDbMapSizeKb' | 'archiveTreeMapSizeKb' | 'nullifierTreeMapSizeKb' | 'noteHashTreeMapSizeKb' | 'messageTreeMapSizeKb' | 'publicDataTreeMapSizeKb'> & Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb' | 'l1Contracts'>, prefilledPublicData?: PublicDataTreeLeaf[], instrumentation?: WorldStateInstrumentation): Promise<NativeWorldStateService>;
 //# sourceMappingURL=factory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/synchronizer/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AAEpF,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,gBAAgB,GAAG,eAAe,EAC1C,aAAa,EAAE,aAAa,GAAG,mBAAmB,EAClD,mBAAmB,GAAE,kBAAkB,EAAO,EAC9C,MAAM,GAAE,eAAsC,yCAK/C;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,gBAAgB,GAAG,eAAe,EAC1C,mBAAmB,GAAE,kBAAkB,EAAO,EAC9C,eAAe,GAAE,yBAA+E,oCA2BjG"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/synchronizer/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AAEpF,MAAM,WAAW,sBAAsB;IACrC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,gBAAgB,GAAG,eAAe,EAC1C,aAAa,EAAE,aAAa,GAAG,mBAAmB,EAClD,mBAAmB,GAAE,kBAAkB,EAAO,EAC9C,MAAM,GAAE,eAAsC,yCAK/C;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,IAAI,CACV,gBAAgB,EACd,yBAAyB,GACzB,uBAAuB,GACvB,sBAAsB,GACtB,wBAAwB,GACxB,uBAAuB,GACvB,sBAAsB,GACtB,yBAAyB,CAC5B,GACC,IAAI,CAAC,eAAe,EAAE,eAAe,GAAG,oBAAoB,GAAG,aAAa,CAAC,EAC/E,mBAAmB,GAAE,kBAAkB,EAAO,EAC9C,eAAe,GAAE,yBAA+E,oCAgCjG"}

package/dest/synchronizer/factory.js

@@ -8,15 +8,20 @@ export async function createWorldStateSynchronizer(config, l2BlockSource, prefil
     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
+    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) : await NativeWorldStateService.tmp(config.l1Contracts.rollupAddress, ![
         'true',
         '1'
     ].includes(process.env.DEBUG_WORLD_STATE), prefilledPublicData);

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 Logger } from '@aztec/foundation/log';
 import type { L2BlockSource, L2BlockStream, L2BlockStreamEvent, L2BlockStreamEventHandler, L2BlockStreamLocalDataProvider, 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.
@@ -26,21 +27,27 @@ export declare class ServerWorldStateSynchronizer implements WorldStateSynchroni
     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>;
+    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>;
+    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 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
      */
-    syncImmediate(targetBlockNumber?: number): Promise<number>;
+    syncImmediate(targetBlockNumber?: number, skipThrowIfTargetNotReached?: boolean): Promise<number>;
     /** Returns the L2 block hash for a given number. Used by the L2BlockStream for detecting reorgs. */
     getL2BlockHash(number: number): Promise<string | undefined>;
     /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
@@ -74,6 +81,6 @@ export declare class ServerWorldStateSynchronizer implements WorldStateSynchroni
      * @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>;
+    protected verifyMessagesHashToInHash(l1ToL2Messages: Fr[], inHash: Fr): Promise<void>;
 }
 //# sourceMappingURL=server_world_state_synchronizer.d.ts.map

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":"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"}

package/dest/synchronizer/server_world_state_synchronizer.js

@@ -1,13 +1,14 @@
 import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import { SHA256Trunc } from '@aztec/foundation/crypto';
 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 { WorldStateRunningState } from '@aztec/stdlib/interfaces/server';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import { TraceableL2BlockStream, 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.
@@ -25,6 +26,9 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     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;
@@ -48,6 +52,12 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     fork(blockNumber) {
         return this.merkleTreeDb.fork(blockNumber);
     }
+    backupTo(dstPath, compact) {
+        return this.merkleTreeDb.backupTo(dstPath, compact);
+    }
+    clear() {
+        return this.merkleTreeDb.clear();
+    }
     async start() {
         if (this.currentState === WorldStateRunningState.STOPPED) {
             throw new Error('Synchronizer already stopped');
@@ -93,9 +103,9 @@ 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),
+            latestBlockNumber: Number(summary.unfinalizedBlockNumber),
+            latestBlockHash: await this.getL2BlockHash(Number(summary.unfinalizedBlockNumber)) ?? '',
+            finalizedBlockNumber: Number(summary.finalizedBlockNumber),
             oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
             treesAreSynched: summary.treesAreSynched
         };
@@ -107,26 +117,58 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     async getLatestBlockNumber() {
         return (await this.getL2Tips()).latest.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 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
-   */ async syncImmediate(targetBlockNumber) {
-        if (this.currentState !== WorldStateRunningState.RUNNING || this.blockStream === undefined) {
+   */ async syncImmediate(targetBlockNumber, skipThrowIfTargetNotReached) {
+        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;
         }
         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 = 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})`);
+        if (!skipThrowIfTargetNotReached && targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
+            throw new WorldStateSynchronizerError(`Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`, {
+                cause: {
+                    reason: 'block_not_available',
+                    previousBlockNumber: currentBlockNumber,
+                    updatedBlockNumber,
+                    targetBlockNumber
+                }
+            });
         }
         return updatedBlockNumber;
     }
@@ -144,41 +186,37 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
     }
     /** 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 unfinalizedBlockHash = await this.getL2BlockHash(Number(status.unfinalizedBlockNumber));
         const latestBlockId = {
-            number: Number(status.unfinalisedBlockNumber),
-            hash: unfinalisedBlockHash
+            number: Number(status.unfinalizedBlockNumber),
+            hash: unfinalizedBlockHash
         };
         return {
             latest: latestBlockId,
             finalized: {
-                number: Number(status.finalisedBlockNumber),
+                number: Number(status.finalizedBlockNumber),
                 hash: ''
             },
             proven: {
-                number: Number(status.finalisedBlockNumber),
+                number: Number(this.provenBlockNumber ?? status.finalizedBlockNumber),
                 hash: ''
             }
         };
     }
     /** 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.map((b)=>b.block));
+                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;
         }
     }
     /**
@@ -187,16 +225,16 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
    * @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 messagePromises = l2Blocks.map((block)=>this.l2BlockSource.getL1ToL2Messages(block.number));
         const l1ToL2Messages = await Promise.all(messagePromises);
         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}`, {
+            this.log.info(`World state updated with L2 block ${l2Blocks[i].number}`, {
                 eventName: 'l2-block-handled',
                 duration,
-                unfinalisedBlockNumber: result.summary.unfinalisedBlockNumber,
-                finalisedBlockNumber: result.summary.finalisedBlockNumber,
+                unfinalizedBlockNumber: result.summary.unfinalizedBlockNumber,
+                finalizedBlockNumber: result.summary.finalizedBlockNumber,
                 oldestHistoricBlock: result.summary.oldestHistoricalBlock,
                 ...l2Blocks[i].getStats()
             });
@@ -233,11 +271,11 @@ 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(BigInt(blockNumber));
         if (this.historyToKeep === undefined) {
             return;
         }
-        const newHistoricBlock = summary.finalisedBlockNumber - BigInt(this.historyToKeep) + 1n;
+        const newHistoricBlock = summary.finalizedBlockNumber - BigInt(this.historyToKeep) + 1n;
         if (newHistoricBlock <= 1) {
             return;
         }
@@ -246,6 +284,7 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
         this.log.debug(`World state summary `, status.summary);
     }
     handleChainProven(blockNumber) {
+        this.provenBlockNumber = BigInt(blockNumber);
         this.log.debug(`Proven chain is now at block ${blockNumber}`);
         return Promise.resolve();
     }
@@ -253,6 +292,7 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
         this.log.warn(`Chain pruned to block ${blockNumber}`);
         const status = await this.merkleTreeDb.unwindBlocks(BigInt(blockNumber));
         this.latestBlockHashQuery = undefined;
+        this.provenBlockNumber = undefined;
         this.instrumentation.updateWorldStateMetrics(status);
     }
     /**
@@ -270,7 +310,7 @@ import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js
    */ 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)) {
+        if (!root.equals(inHash.toBuffer())) {
             throw new Error('Obtained L1 to L2 messages failed to be hashed to the block inHash');
         }
     }

package/dest/test/utils.d.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/fields';
 import { L2Block } from '@aztec/stdlib/block';
 import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import type { NativeWorldStateService } from '../native/native_world_state.js';
-export declare function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations): Promise<{
+export declare function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations, maxEffects?: number | undefined): Promise<{
     block: L2Block;
     messages: Fr[];
 }>;

package/dest/test/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAG3G,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GA+C9F;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GAiDrF;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB;;;GAchH;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAQrG;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAYlG"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/test/utils.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,KAAK,EAEV,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,iCAAiC,CAAC;AAGzC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,yBAAyB,EAC/B,UAAU,GAAE,MAAM,GAAG,SAAqB;;;GAsD3C;AAED,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,yBAAyB;;;GAiDrF;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB;;;GAchH;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAQrG;AAED,wBAAsB,aAAa,CAAC,IAAI,EAAE,wBAAwB,EAAE,KAAK,EAAE,wBAAwB,iBAYlG"}

package/dest/test/utils.js

@@ -3,28 +3,31 @@ import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { L2Block } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
-export async function mockBlock(blockNum, size, fork) {
-    const l2Block = await L2Block.random(blockNum, size);
-    const l1ToL2Messages = Array(16).fill(0).map(Fr.random);
-    // Sync the append only trees
+export async function mockBlock(blockNum, size, fork, maxEffects = undefined) {
+    const l2Block = await L2Block.random(blockNum, size, maxEffects);
+    const l1ToL2Messages = Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(0).map(Fr.random);
     {
+        const insertData = async (treeId, data, subTreeHeight, fork)=>{
+            for (const dataBatch of data){
+                await fork.batchInsert(treeId, dataBatch, subTreeHeight);
+            }
+        };
+        const publicDataInsert = insertData(MerkleTreeId.PUBLIC_DATA_TREE, l2Block.body.txEffects.map((txEffect)=>txEffect.publicDataWrites.map((write)=>write.toBuffer())), 0, fork);
+        const nullifierInsert = insertData(MerkleTreeId.NULLIFIER_TREE, l2Block.body.txEffects.map((txEffect)=>padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX).map((nullifier)=>nullifier.toBuffer())), NULLIFIER_SUBTREE_HEIGHT, fork);
         const noteHashesPadded = l2Block.body.txEffects.flatMap((txEffect)=>padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
-        await fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
         const l1ToL2MessagesPadded = padArrayEnd(l1ToL2Messages, Fr.ZERO, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
-        await fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
-    }
-    // Sync the indexed trees
-    {
-        // We insert the public data tree leaves with one batch per tx to avoid updating the same key twice
-        for (const txEffect of l2Block.body.txEffects){
-            await fork.batchInsert(MerkleTreeId.PUBLIC_DATA_TREE, txEffect.publicDataWrites.map((write)=>write.toBuffer()), 0);
-            const nullifiersPadded = padArrayEnd(txEffect.nullifiers, Fr.ZERO, MAX_NULLIFIERS_PER_TX);
-            await fork.batchInsert(MerkleTreeId.NULLIFIER_TREE, nullifiersPadded.map((nullifier)=>nullifier.toBuffer()), NULLIFIER_SUBTREE_HEIGHT);
-        }
+        const noteHashInsert = fork.appendLeaves(MerkleTreeId.NOTE_HASH_TREE, noteHashesPadded);
+        const messageInsert = fork.appendLeaves(MerkleTreeId.L1_TO_L2_MESSAGE_TREE, l1ToL2MessagesPadded);
+        await Promise.all([
+            publicDataInsert,
+            nullifierInsert,
+            noteHashInsert,
+            messageInsert
+        ]);
     }
     const state = await fork.getStateReference();
     l2Block.header.state = state;
-    await fork.updateArchive(l2Block.header);
+    await fork.updateArchive(l2Block.getBlockHeader());
     const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
     l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
     return {
@@ -35,7 +38,7 @@ export async function mockBlock(blockNum, size, fork) {
 export async function mockEmptyBlock(blockNum, fork) {
     const l2Block = L2Block.empty();
     const l1ToL2Messages = Array(16).fill(0).map(Fr.zero);
-    l2Block.header.globalVariables.blockNumber = new Fr(blockNum);
+    l2Block.header.globalVariables.blockNumber = blockNum;
     // Sync the append only trees
     {
         const noteHashesPadded = l2Block.body.txEffects.flatMap((txEffect)=>padArrayEnd(txEffect.noteHashes, Fr.ZERO, MAX_NOTE_HASHES_PER_TX));
@@ -54,7 +57,7 @@ export async function mockEmptyBlock(blockNum, fork) {
     }
     const state = await fork.getStateReference();
     l2Block.header.state = state;
-    await fork.updateArchive(l2Block.header);
+    await fork.updateArchive(l2Block.getBlockHeader());
     const archiveState = await fork.getTreeInfo(MerkleTreeId.ARCHIVE);
     l2Block.archive = new AppendOnlyTreeSnapshot(Fr.fromBuffer(archiveState.root), Number(archiveState.size));
     return {

package/dest/testing.d.ts

@@ -4,7 +4,7 @@ import { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 export declare const defaultInitialAccountFeeJuice: Fr;
 export declare function getGenesisValues(initialAccounts: AztecAddress[], initialAccountFeeJuice?: Fr, genesisPublicData?: PublicDataTreeLeaf[]): Promise<{
     genesisArchiveRoot: Fr;
-    genesisBlockHash: Fr;
     prefilledPublicData: PublicDataTreeLeaf[];
+    fundingNeeded: bigint;
 }>;
 //# sourceMappingURL=testing.d.ts.map

package/dest/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AA6BvE,eAAO,MAAM,6BAA6B,IAAqB,CAAC;AAEhE,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,YAAY,EAAE,EAC/B,sBAAsB,KAAgC,EACtD,iBAAiB,GAAE,kBAAkB,EAAO;;;;GAqB7C"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAgB,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAyBvE,eAAO,MAAM,6BAA6B,IAAqB,CAAC;AAEhE,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,YAAY,EAAE,EAC/B,sBAAsB,KAAgC,EACtD,iBAAiB,GAAE,kBAAkB,EAAO;;;;GAqB7C"}

package/dest/testing.js

@@ -1,4 +1,4 @@
-import { GENESIS_ARCHIVE_ROOT, GENESIS_BLOCK_HASH } from '@aztec/constants';
+import { GENESIS_ARCHIVE_ROOT } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
@@ -6,19 +6,15 @@ import { NativeWorldStateService } from './native/index.js';
 async function generateGenesisValues(prefilledPublicData) {
     if (!prefilledPublicData.length) {
         return {
-            genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT),
-            genesisBlockHash: new Fr(GENESIS_BLOCK_HASH)
+            genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT)
         };
     }
     // Create a temporary world state to compute the genesis values.
     const ws = await NativeWorldStateService.tmp(undefined /* rollupAddress */ , true, prefilledPublicData);
-    const initialHeader = ws.getInitialHeader();
-    const genesisBlockHash = await initialHeader.hash();
     const genesisArchiveRoot = new Fr((await ws.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
     await ws.close();
     return {
-        genesisArchiveRoot,
-        genesisBlockHash
+        genesisArchiveRoot
     };
 }
 export const defaultInitialAccountFeeJuice = new Fr(10n ** 22n);
@@ -28,10 +24,10 @@ export async function getGenesisValues(initialAccounts, initialAccountFeeJuice =
     // Add user-defined public data
     prefilledPublicData = prefilledPublicData.concat(genesisPublicData);
     prefilledPublicData.sort((a, b)=>b.slot.lt(a.slot) ? 1 : -1);
-    const { genesisBlockHash, genesisArchiveRoot } = await generateGenesisValues(prefilledPublicData);
+    const { genesisArchiveRoot } = await generateGenesisValues(prefilledPublicData);
     return {
         genesisArchiveRoot,
-        genesisBlockHash,
-        prefilledPublicData
+        prefilledPublicData,
+        fundingNeeded: BigInt(initialAccounts.length) * initialAccountFeeJuice.toBigInt()
     };
 }

package/dest/world-state-db/merkle_tree_db.d.ts

@@ -33,8 +33,10 @@ export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
      * Handles a single L2 block (i.e. Inserts the new note hashes into the merkle tree).
      * @param block - The L2 block to handle.
      * @param l1ToL2Messages - The L1 to L2 messages for the block.
+     * @param isFirstBlock - Whether the block is the first block in a checkpoint. Temporary hack to only insert l1 to l2
+     * messages for the first block in a checkpoint. TODO(#17027) Remove this.
      */
-    handleL2BlockAndMessages(block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull>;
+    handleL2BlockAndMessages(block: L2Block, l1ToL2Messages: Fr[], isFirstBlock?: boolean): Promise<WorldStateStatusFull>;
     /**
      * Gets a handle that allows reading the latest committed state
      */
@@ -52,11 +54,11 @@ export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
      */
     unwindBlocks(toBlockNumber: bigint): Promise<WorldStateStatusFull>;
     /**
-     * Advances the finalised block number to be the number provided
-     * @param toBlockNumber The block number that is now the tip of the finalised chain
+     * Advances the finalized block number to be the number provided
+     * @param toBlockNumber The block number that is now the tip of the finalized chain
      * @returns The new WorldStateStatus
      */
-    setFinalised(toBlockNumber: bigint): Promise<WorldStateStatusSummary>;
+    setFinalized(toBlockNumber: bigint): Promise<WorldStateStatusSummary>;
     /**
      * Gets the current status summary of the database.
      * @returns The current WorldStateStatus.
@@ -64,5 +66,7 @@ export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations {
     getStatusSummary(): Promise<WorldStateStatusSummary>;
     /** Stops the database */
     close(): Promise<void>;
+    /** Deletes the db. */
+    clear(): Promise<void>;
 }
 //# sourceMappingURL=merkle_tree_db.d.ts.map

package/dest/world-state-db/merkle_tree_db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merkle_tree_db.d.ts","sourceRoot":"","sources":["../../src/world-state-db/merkle_tree_db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE1F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,2BAA2B,QAA4B,CAAC;AAErE,eAAO,MAAM,6BAA6B,QAAmD,CAAC;AAE9F,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACnD,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAChD,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;IACrD,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE;;;;OAIG;IACH,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE9F;;OAEG;IACH,YAAY,IAAI,wBAAwB,CAAC;IAEzC;;;;OAIG;IACH,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE7E;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEnE;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEtE;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAErD,yBAAyB;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}
+{"version":3,"file":"merkle_tree_db.d.ts","sourceRoot":"","sources":["../../src/world-state-db/merkle_tree_db.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC1G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,KAAK,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAE1F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,2BAA2B,QAA4B,CAAC;AAErE,eAAO,MAAM,6BAA6B,QAAmD,CAAC;AAE9F,MAAM,MAAM,aAAa,GAAG;IAC1B,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,mBAAmB,CAAC;IACnD,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IAChD,CAAC,YAAY,CAAC,gBAAgB,CAAC,EAAE,mBAAmB,CAAC;IACrD,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE;;;;;;OAMG;IACH,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,EAAE,EAAE,YAAY,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEtH;;OAEG;IACH,YAAY,IAAI,wBAAwB,CAAC;IAEzC;;;;OAIG;IACH,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE7E;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAEnE;;;;OAIG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEtE;;;OAGG;IACH,gBAAgB,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAErD,yBAAyB;IACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB,sBAAsB;IACtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}