@aztec/world-state 0.0.1-commit.b655e406 → 0.0.1-commit.b8a057fa

package/src/native/native_world_state_instance.ts

@@ -1,261 +1,104 @@
-import {
-  ARCHIVE_HEIGHT,
-  GeneratorIndex,
-  L1_TO_L2_MSG_TREE_HEIGHT,
-  MAX_NULLIFIERS_PER_TX,
-  MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  NOTE_HASH_TREE_HEIGHT,
-  NULLIFIER_TREE_HEIGHT,
-  PUBLIC_DATA_TREE_HEIGHT,
-} from '@aztec/constants';
-import { type Logger, createLogger } from '@aztec/foundation/log';
-import { NativeWorldState as BaseNativeWorldState, MsgpackChannel } from '@aztec/native';
-import { MerkleTreeId } from '@aztec/stdlib/trees';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-
-import assert from 'assert';
-import { cpus } from 'os';
-
-import type { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
-import type { WorldStateTreeMapSizes } from '../synchronizer/factory.js';
-import {
-  WorldStateMessageType,
-  type WorldStateRequest,
-  type WorldStateRequestCategories,
-  type WorldStateResponse,
-  isWithCanonical,
-  isWithForkId,
-  isWithRevision,
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { IndexedTreeId, TreeInfo } from '@aztec/stdlib/interfaces/server';
+import type { MerkleTreeId } from '@aztec/stdlib/trees';
+import type { WorldStateRevision } from '@aztec/stdlib/world-state';
+
+import type {
+  BlockStateReference,
+  SerializedBatchInsertionResult,
+  SerializedIndexedLeaf,
+  SerializedLeafValue,
+  SerializedSequentialInsertionResult,
+  SerializedSiblingPathAndIndex,
+  TreeStateReference,
+  WorldStateStatusFull,
+  WorldStateStatusSummary,
 } from './message.js';
-import { WorldStateOpsQueue } from './world_state_ops_queue.js';
-
-const MAX_WORLD_STATE_THREADS = +(process.env.HARDWARE_CONCURRENCY || '16');
 
+/** Backend-agnostic handle to a running aztec-wsdb world state, accessed by the TS layer. */
 export interface NativeWorldStateInstance {
-  call<T extends WorldStateMessageType>(
-    messageType: T,
-    body: WorldStateRequest[T] & WorldStateRequestCategories,
-  ): Promise<WorldStateResponse[T]>;
-}
-
-/**
- * Strongly-typed interface to access the WorldState class in the native world_state_napi module.
- */
-export class NativeWorldState implements NativeWorldStateInstance {
-  private open = true;
-
-  // We maintain a map of queue to fork
-  private queues = new Map<number, WorldStateOpsQueue>();
-
-  private instance: MsgpackChannel<WorldStateMessageType, WorldStateRequest, WorldStateResponse>;
-
-  /** Creates a new native WorldState instance */
-  constructor(
-    private readonly dataDir: string,
-    private readonly wsTreeMapSizes: WorldStateTreeMapSizes,
-    private readonly prefilledPublicData: PublicDataTreeLeaf[] = [],
-    private readonly instrumentation: WorldStateInstrumentation,
-    private readonly log: Logger = createLogger('world-state:database'),
-  ) {
-    const threads = Math.min(cpus().length, MAX_WORLD_STATE_THREADS);
-    log.info(
-      `Creating world state data store at directory ${dataDir} with map sizes ${JSON.stringify(
-        wsTreeMapSizes,
-      )} and ${threads} threads.`,
-    );
-    const prefilledPublicDataBufferArray = prefilledPublicData.map(d => [d.slot.toBuffer(), d.value.toBuffer()]);
-    const ws = new BaseNativeWorldState(
-      dataDir,
-      {
-        [MerkleTreeId.NULLIFIER_TREE]: NULLIFIER_TREE_HEIGHT,
-        [MerkleTreeId.NOTE_HASH_TREE]: NOTE_HASH_TREE_HEIGHT,
-        [MerkleTreeId.PUBLIC_DATA_TREE]: PUBLIC_DATA_TREE_HEIGHT,
-        [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: L1_TO_L2_MSG_TREE_HEIGHT,
-        [MerkleTreeId.ARCHIVE]: ARCHIVE_HEIGHT,
-      },
-      {
-        [MerkleTreeId.NULLIFIER_TREE]: 2 * MAX_NULLIFIERS_PER_TX,
-        [MerkleTreeId.PUBLIC_DATA_TREE]: 2 * MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-      },
-      prefilledPublicDataBufferArray,
-      GeneratorIndex.BLOCK_HASH,
-      {
-        [MerkleTreeId.NULLIFIER_TREE]: wsTreeMapSizes.nullifierTreeMapSizeKb,
-        [MerkleTreeId.NOTE_HASH_TREE]: wsTreeMapSizes.noteHashTreeMapSizeKb,
-        [MerkleTreeId.PUBLIC_DATA_TREE]: wsTreeMapSizes.publicDataTreeMapSizeKb,
-        [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: wsTreeMapSizes.messageTreeMapSizeKb,
-        [MerkleTreeId.ARCHIVE]: wsTreeMapSizes.archiveTreeMapSizeKb,
-      },
-      threads,
-    );
-    this.instance = new MsgpackChannel(ws);
-    // Manually create the queue for the canonical fork
-    this.queues.set(0, new WorldStateOpsQueue());
-  }
-
-  public getDataDir() {
-    return this.dataDir;
-  }
-
-  public clone() {
-    return new NativeWorldState(
-      this.dataDir,
-      this.wsTreeMapSizes,
-      this.prefilledPublicData,
-      this.instrumentation,
-      this.log,
-    );
-  }
+  getTreeInfo(treeId: MerkleTreeId, revision: WorldStateRevision): Promise<TreeInfo>;
+  getStateReference(revision: WorldStateRevision): Promise<Record<number, TreeStateReference>>;
+  getInitialStateReference(): Promise<Record<number, TreeStateReference>>;
+  getLeafValue(
+    treeId: MerkleTreeId,
+    revision: WorldStateRevision,
+    leafIndex: bigint,
+  ): Promise<SerializedLeafValue | undefined>;
+  getLeafPreimage(
+    treeId: IndexedTreeId,
+    revision: WorldStateRevision,
+    leafIndex: bigint,
+  ): Promise<SerializedIndexedLeaf | undefined>;
+  getSiblingPath(treeId: MerkleTreeId, revision: WorldStateRevision, leafIndex: bigint): Promise<Buffer[]>;
+  getBlockNumbersForLeafIndices(
+    treeId: MerkleTreeId,
+    revision: WorldStateRevision,
+    leafIndices: bigint[],
+  ): Promise<(bigint | undefined)[]>;
+  findLeafIndices(
+    treeId: MerkleTreeId,
+    revision: WorldStateRevision,
+    leaves: SerializedLeafValue[],
+    startIndex: bigint,
+  ): Promise<(bigint | undefined)[]>;
+  findLowLeaf(
+    treeId: IndexedTreeId,
+    revision: WorldStateRevision,
+    key: Fr,
+  ): Promise<{ index: bigint; alreadyPresent: boolean }>;
+  findSiblingPaths(
+    treeId: MerkleTreeId,
+    revision: WorldStateRevision,
+    leaves: SerializedLeafValue[],
+  ): Promise<(SerializedSiblingPathAndIndex | undefined)[]>;
+  updateArchive(forkId: number, blockStateRef: BlockStateReference, blockHeaderHash: Buffer): Promise<void>;
+  appendLeaves(treeId: MerkleTreeId, forkId: number, leaves: SerializedLeafValue[]): Promise<void>;
+  batchInsert(
+    treeId: IndexedTreeId,
+    forkId: number,
+    leaves: SerializedLeafValue[],
+    subtreeDepth: number,
+  ): Promise<SerializedBatchInsertionResult>;
+  sequentialInsert(
+    treeId: IndexedTreeId,
+    forkId: number,
+    leaves: SerializedLeafValue[],
+  ): Promise<SerializedSequentialInsertionResult>;
+  syncBlock(input: {
+    blockNumber: BlockNumber;
+    blockStateRef: BlockStateReference;
+    blockHeaderHash: Buffer;
+    expectedArchiveRoot: Buffer;
+    expectedPreviousArchiveRoot: Buffer;
+    paddedNoteHashes: readonly SerializedLeafValue[];
+    paddedL1ToL2Messages: readonly SerializedLeafValue[];
+    paddedNullifiers: readonly SerializedLeafValue[];
+    publicDataWrites: readonly SerializedLeafValue[];
+  }): Promise<WorldStateStatusFull>;
+  createFork(input: { latest: boolean; blockNumber: BlockNumber }): Promise<number>;
+  deleteFork(forkId: number): Promise<void>;
+  finalizeBlocks(toBlockNumber: BlockNumber): Promise<WorldStateStatusSummary>;
+  unwindBlocks(toBlockNumber: BlockNumber): Promise<WorldStateStatusFull>;
+  removeHistoricalBlocks(toBlockNumber: BlockNumber): Promise<WorldStateStatusFull>;
+  getStatus(): Promise<WorldStateStatusSummary>;
+  createCheckpoint(forkId: number): Promise<number>;
+  commitCheckpoint(forkId: number): Promise<void>;
+  revertCheckpoint(forkId: number): Promise<void>;
+  commitAllCheckpoints(forkId: number, depth: number): Promise<void>;
+  revertAllCheckpoints(forkId: number, depth: number): Promise<void>;
+  copyStores(dstPath: string, compact: boolean): Promise<void>;
 
   /**
-   * Sends a message to the native instance and returns the response.
-   * @param messageType - The type of message to send
-   * @param body - The message body
-   * @param responseHandler - A callback accepting the response, executed on the job queue
-   * @param errorHandler - A callback called on request error, executed on the job queue
-   * @returns The response to the message
+   * IPC path the underlying aztec-wsdb process listens on. The C++ AVM uses this to attach to the
+   * same world state instance the TS layer is using.
    */
-  public async call<T extends WorldStateMessageType>(
-    messageType: T,
-    body: WorldStateRequest[T] & WorldStateRequestCategories,
-    // allows for the pre-processing of responses on the job queue before being passed back
-    responseHandler = (response: WorldStateResponse[T]): WorldStateResponse[T] => response,
-    errorHandler = (_: string) => {},
-  ): Promise<WorldStateResponse[T]> {
-    // Here we determine which fork the request is being executed against and whether it requires uncommitted data
-    // We use the fork Id to select the appropriate request queue and the uncommitted data flag to pass to the queue
-    let forkId = -1;
-    // We assume it includes uncommitted unless explicitly told otherwise
-    let committedOnly = false;
-
-    // Canonical requests ALWAYS go against the canonical fork
-    // These include things like block syncs/unwinds etc
-    // These requests don't contain a fork ID
-    if (isWithCanonical(body)) {
-      forkId = 0;
-    } else if (isWithForkId(body)) {
-      forkId = body.forkId;
-    } else if (isWithRevision(body)) {
-      forkId = body.revision.forkId;
-      committedOnly = body.revision.includeUncommitted === false;
-    } else {
-      const _: never = body;
-      throw new Error(`Unable to determine forkId for message=${WorldStateMessageType[messageType]}`);
-    }
-
-    // Get the queue or create a new one
-    let requestQueue = this.queues.get(forkId);
-    if (requestQueue === undefined) {
-      requestQueue = new WorldStateOpsQueue();
-      this.queues.set(forkId, requestQueue);
-    }
-
-    // Enqueue the request and wait for the response
-    const response = await requestQueue.execute(
-      async () => {
-        assert.notEqual(messageType, WorldStateMessageType.CLOSE, 'Use close() to close the native instance');
-        assert.equal(this.open, true, 'Native instance is closed');
-        let response: WorldStateResponse[T];
-        try {
-          response = await this._sendMessage(messageType, body);
-        } catch (error: any) {
-          errorHandler(error.message);
-          throw error;
-        }
-        return responseHandler(response);
-      },
-      messageType,
-      committedOnly,
-    );
-
-    // If the request was to delete the fork then we clean it up here
-    if (messageType === WorldStateMessageType.DELETE_FORK) {
-      await requestQueue.stop();
-      this.queues.delete(forkId);
-    }
-    return response;
-  }
+  getIpcPath(): string;
 
   /**
-   * Stops the native instance.
+   * Shut down the world state instance. Cancels any in-flight queues, closes the IPC channel, and
+   * terminates the underlying aztec-wsdb process. Idempotent.
    */
-  public async close(): Promise<void> {
-    if (!this.open) {
-      return;
-    }
-    this.open = false;
-    const queue = this.queues.get(0)!;
-
-    await queue.execute(
-      async () => {
-        await this._sendMessage(WorldStateMessageType.CLOSE, { canonical: true });
-      },
-      WorldStateMessageType.CLOSE,
-      false,
-    );
-    await queue.stop();
-  }
-
-  private async _sendMessage<T extends WorldStateMessageType>(
-    messageType: T,
-    body: WorldStateRequest[T] & WorldStateRequestCategories,
-  ): Promise<WorldStateResponse[T]> {
-    let logMetadata: Record<string, any> = {};
-
-    if (body) {
-      if ('treeId' in body) {
-        logMetadata['treeId'] = MerkleTreeId[body.treeId];
-      }
-
-      if ('revision' in body) {
-        logMetadata = { ...logMetadata, ...body.revision };
-      }
-
-      if ('forkId' in body) {
-        logMetadata['forkId'] = body.forkId;
-      }
-
-      if ('blockNumber' in body) {
-        logMetadata['blockNumber'] = body.blockNumber;
-      }
-
-      if ('toBlockNumber' in body) {
-        logMetadata['toBlockNumber'] = body.toBlockNumber;
-      }
-
-      if ('leafIndex' in body) {
-        logMetadata['leafIndex'] = body.leafIndex;
-      }
-
-      if ('blockHeaderHash' in body) {
-        logMetadata['blockHeaderHash'] = '0x' + body.blockHeaderHash.toString('hex');
-      }
-
-      if ('leaves' in body) {
-        logMetadata['leavesCount'] = body.leaves.length;
-      }
-
-      // sync operation
-      if ('paddedNoteHashes' in body) {
-        logMetadata['notesCount'] = body.paddedNoteHashes.length;
-        logMetadata['nullifiersCount'] = body.paddedNullifiers.length;
-        logMetadata['l1ToL2MessagesCount'] = body.paddedL1ToL2Messages.length;
-        logMetadata['publicDataWritesCount'] = body.publicDataWrites.length;
-      }
-    }
-
-    try {
-      const { duration, response } = await this.instance.sendMessage(messageType, body);
-      this.log.trace(`Call ${WorldStateMessageType[messageType]} took (ms)`, {
-        duration,
-        ...logMetadata,
-      });
-
-      this.instrumentation.recordRoundTrip(duration.totalUs, messageType);
-      return response;
-    } catch (error) {
-      this.log.error(`Call ${WorldStateMessageType[messageType]} failed: ${error}`, error, logMetadata);
-      throw error;
-    }
-  }
+  close(): Promise<void>;
 }

package/src/native/world_state_operation.ts

@@ -0,0 +1,33 @@
+/**
+ * Names of the world-state operations, used as labels for instrumentation and
+ * logging. (Read/write ordering is enforced server-side by the wsdb scheduler,
+ * so there is no longer a client-side operation queue.)
+ */
+export type WorldStateOperationName =
+  | 'getTreeInfo'
+  | 'getStateReference'
+  | 'getInitialStateReference'
+  | 'getLeafValue'
+  | 'getLeafPreimage'
+  | 'getSiblingPath'
+  | 'getBlockNumbersForLeafIndices'
+  | 'findLeafIndices'
+  | 'findLowLeaf'
+  | 'findSiblingPaths'
+  | 'appendLeaves'
+  | 'batchInsert'
+  | 'sequentialInsert'
+  | 'updateArchive'
+  | 'syncBlock'
+  | 'createFork'
+  | 'deleteFork'
+  | 'finalizeBlocks'
+  | 'unwindBlocks'
+  | 'removeHistoricalBlocks'
+  | 'getStatus'
+  | 'createCheckpoint'
+  | 'commitCheckpoint'
+  | 'revertCheckpoint'
+  | 'commitAllCheckpoints'
+  | 'revertAllCheckpoints'
+  | 'copyStores';

package/src/synchronizer/config.ts

@@ -1,8 +1,8 @@
 import {
   type ConfigMappingsType,
-  booleanConfigHelper,
   getConfigFromMappings,
   numberConfigHelper,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
 
 /** World State synchronizer configuration values. */
@@ -10,9 +10,6 @@ export interface WorldStateConfig {
   /** The frequency in which to check. */
   worldStateBlockCheckIntervalMS: number;
 
-  /** Whether to follow only the proven chain. */
-  worldStateProvenBlocksOnly: boolean;
-
   /** Size of the batch for each get-blocks request from the synchronizer to the archiver. */
   worldStateBlockRequestBatchSize?: number;
 
@@ -37,59 +34,53 @@ export interface WorldStateConfig {
   /** Optional directory for the world state DB, if unspecified will default to the general data directory */
   worldStateDataDirectory?: string;
 
-  /** The number of historic blocks to maintain */
-  worldStateBlockHistory: number;
+  /** The number of historic checkpoints worth of blocks to maintain */
+  worldStateCheckpointHistory: number;
 }
 
 export const worldStateConfigMappings: ConfigMappingsType<WorldStateConfig> = {
   worldStateBlockCheckIntervalMS: {
     env: 'WS_BLOCK_CHECK_INTERVAL_MS',
-    parseEnv: (val: string) => +val,
-    defaultValue: 100,
+    ...numberConfigHelper(100),
     description: 'The frequency in which to check.',
   },
-  worldStateProvenBlocksOnly: {
-    env: 'WS_PROVEN_BLOCKS_ONLY',
-    description: 'Whether to follow only the proven chain.',
-    ...booleanConfigHelper(),
-  },
   worldStateBlockRequestBatchSize: {
     env: 'WS_BLOCK_REQUEST_BATCH_SIZE',
-    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     description: 'Size of the batch for each get-blocks request from the synchronizer to the archiver.',
   },
   worldStateDbMapSizeKb: {
     env: 'WS_DB_MAP_SIZE_KB',
-    parseEnv: (val: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     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: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     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: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     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: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     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: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     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: string | undefined) => (val ? +val : undefined),
+    ...optionalNumberConfigHelper(),
     description:
       'The maximum possible size of the world state public data tree in KB. Overwrites the general worldStateDbMapSizeKb.',
   },
@@ -97,9 +88,11 @@ export const worldStateConfigMappings: ConfigMappingsType<WorldStateConfig> = {
     env: 'WS_DATA_DIRECTORY',
     description: 'Optional directory for the world state database',
   },
-  worldStateBlockHistory: {
-    env: 'WS_NUM_HISTORIC_BLOCKS',
-    description: 'The number of historic blocks to maintain. Values less than 1 mean all history is maintained',
+  worldStateCheckpointHistory: {
+    env: 'WS_NUM_HISTORIC_CHECKPOINTS',
+    description:
+      'The number of historic checkpoints worth of blocks to maintain. Values less than 1 mean all history is maintained',
+    fallback: ['WS_NUM_HISTORIC_BLOCKS'],
     ...numberConfigHelper(64),
   },
 };

package/src/synchronizer/errors.ts

@@ -1,5 +1,13 @@
+/**
+ * Thrown by {@link ServerWorldStateSynchronizer.syncImmediate} when world state cannot be synced to the requested
+ * target: either the block is not available from the block source (`block_not_available`, e.g. it was pruned away)
+ * or the synced block does not match the requested hash (`block_hash_mismatch`, i.e. a reorg). Both causes are
+ * transient from the caller's perspective: re-resolving the query against the current chain and retrying may succeed
+ * or produce a more precise error.
+ */
 export class WorldStateSynchronizerError extends Error {
   constructor(message: string, options?: ErrorOptions) {
     super(message, options);
+    this.name = 'WorldStateSynchronizerError';
   }
 }

package/src/synchronizer/factory.ts

@@ -1,7 +1,8 @@
-import type { DataStoreConfig } from '@aztec/kv-store/config';
+import type { LoggerBindings } from '@aztec/foundation/log';
 import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { DataStoreConfig } from '@aztec/stdlib/kv-store';
 import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
-import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { EMPTY_GENESIS_DATA, type GenesisData, isGenesisData } from '@aztec/stdlib/world-state';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
@@ -20,11 +21,14 @@ export interface WorldStateTreeMapSizes {
 export async function createWorldStateSynchronizer(
   config: WorldStateConfig & DataStoreConfig,
   l2BlockSource: L2BlockSource & L1ToL2MessageSource,
-  prefilledPublicData: PublicDataTreeLeaf[] = [],
+  genesisOrNativeWorldState: GenesisData | NativeWorldStateService,
   client: TelemetryClient = getTelemetryClient(),
+  bindings?: LoggerBindings,
 ) {
   const instrumentation = new WorldStateInstrumentation(client);
-  const merkleTrees = await createWorldState(config, prefilledPublicData, instrumentation);
+  const merkleTrees = isGenesisData(genesisOrNativeWorldState)
+    ? await createWorldState(config, genesisOrNativeWorldState, instrumentation, bindings)
+    : genesisOrNativeWorldState;
   return new ServerWorldStateSynchronizer(merkleTrees, l2BlockSource, config, instrumentation);
 }
 
@@ -39,9 +43,10 @@ export async function createWorldState(
     | 'messageTreeMapSizeKb'
     | 'publicDataTreeMapSizeKb'
   > &
-    Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb' | 'l1Contracts'>,
-  prefilledPublicData: PublicDataTreeLeaf[] = [],
+    Pick<DataStoreConfig, 'dataDirectory' | 'dataStoreMapSizeKb' | 'rollupAddress'>,
+  genesis: GenesisData = EMPTY_GENESIS_DATA,
   instrumentation: WorldStateInstrumentation = new WorldStateInstrumentation(getTelemetryClient()),
+  bindings?: LoggerBindings,
 ) {
   const dataDirectory = config.worldStateDataDirectory ?? config.dataDirectory;
   const dataStoreMapSizeKb = config.worldStateDbMapSizeKb ?? config.dataStoreMapSizeKb;
@@ -53,23 +58,25 @@ export async function createWorldState(
     publicDataTreeMapSizeKb: config.publicDataTreeMapSizeKb ?? dataStoreMapSizeKb,
   };
 
-  if (!config.l1Contracts?.rollupAddress) {
+  if (!config.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 = dataDirectory
     ? await NativeWorldStateService.new(
-        config.l1Contracts.rollupAddress,
+        config.rollupAddress,
         dataDirectory,
         wsTreeMapSizes,
-        prefilledPublicData,
+        genesis,
         instrumentation,
+        bindings,
       )
     : await NativeWorldStateService.tmp(
-        config.l1Contracts.rollupAddress,
         !['true', '1'].includes(process.env.DEBUG_WORLD_STATE!),
-        prefilledPublicData,
+        genesis,
+        instrumentation,
+        bindings,
       );
 
   return merkleTrees;

package/src/synchronizer/index.ts

@@ -1,2 +1,3 @@
 export * from './server_world_state_synchronizer.js';
 export * from './factory.js';
+export * from './errors.js';