@aztec/world-state 0.0.1-commit.b6e433891 → 0.0.1-commit.b9865e97

package/src/native/native_world_state_instance.ts

@@ -1,291 +1,107 @@
-import {
-  ARCHIVE_HEIGHT,
-  DomainSeparator,
-  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, type LoggerBindings, 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');
-
-export interface NativeWorldStateInstance {
-  call<T extends WorldStateMessageType>(
-    messageType: T,
-    body: WorldStateRequest[T] & WorldStateRequestCategories,
-  ): Promise<WorldStateResponse[T]>;
-  // TODO(dbanks12): this returns any type, but we should strongly type it
-  getHandle(): any;
-}
 
 /**
- * Strongly-typed interface to access the WorldState class in the native world_state_napi module.
+ * Backend-agnostic handle to a running aztec-wsdb world state, accessed by the TS layer.
+ *
+ * The legacy in-process NAPI implementation has been removed; the C++ AVM (NAPI) now connects to
+ * the same aztec-wsdb process using the IPC path returned by {@link getIpcPath}.
  */
-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,
-    bindings?: LoggerBindings,
-    private readonly log: Logger = createLogger('world-state:database', bindings),
-  ) {
-    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,
-      DomainSeparator.BLOCK_HEADER_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.getBindings(),
-      this.log,
-    );
-  }
+export interface NativeWorldStateInstance {
+  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;
+    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>;
 
   /**
-   * Gets the native WorldState handle from the underlying native instance.
-   * We call the getHandle() method on the native WorldState to get a NAPI External
-   * that wraps the underlying C++ WorldState pointer.
-   * @returns The NAPI External handle to the native WorldState instance,since
-   * the NAPI external type is opaque, we return any (we could also use an opaque symbol type)
+   * 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 getHandle(): any {
-    const worldStateWrapper = (this.instance as any).dest;
-
-    if (!worldStateWrapper) {
-      throw new Error('No WorldStateWrapper found');
-    }
-
-    if (typeof worldStateWrapper.getHandle !== 'function') {
-      throw new Error('WorldStateWrapper does not have getHandle method');
-    }
-
-    // Call getHandle() to get the NAPI External
-    try {
-      return worldStateWrapper.getHandle();
-    } catch (error) {
-      this.log.error('Failed to get native WorldState handle', error);
-    }
-  }
+  getIpcPath(): string;
 
   /**
-   * 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
+   * 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 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;
-  }
-
-  /**
-   * Stops the native instance.
-   */
-  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,4 +1,9 @@
-import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  getConfigFromMappings,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec/foundation/config';
 
 /** World State synchronizer configuration values. */
 export interface WorldStateConfig {
@@ -36,47 +41,46 @@ export interface WorldStateConfig {
 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.',
   },
   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.',
   },

package/src/synchronizer/factory.ts

@@ -2,7 +2,7 @@ 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';
@@ -21,12 +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, bindings);
+  const merkleTrees = isGenesisData(genesisOrNativeWorldState)
+    ? await createWorldState(config, genesisOrNativeWorldState, instrumentation, bindings)
+    : genesisOrNativeWorldState;
   return new ServerWorldStateSynchronizer(merkleTrees, l2BlockSource, config, instrumentation);
 }
 
@@ -41,8 +43,8 @@ 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,
 ) {
@@ -56,24 +58,23 @@ 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,
       );

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,4 +1,4 @@
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_CHECKPOINT_NUMBER, INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { INITIAL_CHECKPOINT_NUMBER } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
@@ -287,10 +287,15 @@ export class ServerWorldStateSynchronizer
     // 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();
+    const initialBlockHash = (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
     return {
       proposed: latestBlockId,
       checkpointed: {
-        block: { number: INITIAL_L2_BLOCK_NUM, hash: GENESIS_BLOCK_HEADER_HASH.toString() },
+        block: { number: BlockNumber.ZERO, hash: initialBlockHash },
+        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
+      },
+      proposedCheckpoint: {
+        block: { number: BlockNumber.ZERO, hash: initialBlockHash },
         checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
       },
       finalized: {
@@ -404,29 +409,26 @@ export class ServerWorldStateSynchronizer
     if (this.historyToKeep === undefined) {
       return;
     }
-    // Get the checkpointed block for the finalized block number
-    const finalisedCheckpoint = await this.l2BlockSource.getCheckpointedBlock(summary.finalizedBlockNumber);
-    if (finalisedCheckpoint === undefined) {
+    const finalisedBlockData = await this.l2BlockSource.getBlockData({ number: summary.finalizedBlockNumber });
+    if (finalisedBlockData === 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;
+    const newHistoricCheckpointNumber = finalisedBlockData.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) {
+    const historicCheckpoint = await this.l2BlockSource.getCheckpoint({
+      number: CheckpointNumber(newHistoricCheckpointNumber),
+    });
+    if (!historicCheckpoint) {
       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;
@@ -453,7 +455,9 @@ export class ServerWorldStateSynchronizer
   private async handleChainPruned(blockNumber: BlockNumber) {
     this.log.info(`Chain pruned to block ${blockNumber}`);
     const status = await this.merkleTreeDb.unwindBlocks(blockNumber);
-    this.provenBlockNumber = undefined;
+    if (this.provenBlockNumber !== undefined && this.provenBlockNumber > blockNumber) {
+      this.provenBlockNumber = undefined;
+    }
     this.instrumentation.updateWorldStateMetrics(status);
   }