@aztec/world-state 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

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/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,26 @@ 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,
+        config.rollupAddress,
         !['true', '1'].includes(process.env.DEBUG_WORLD_STATE!),
-        prefilledPublicData,
+        genesis,
+        instrumentation,
+        bindings,
       );
 
   return merkleTrees;

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,13 +1,14 @@
-import { GENESIS_BLOCK_HEADER_HASH, INITIAL_L2_BLOCK_NUM, INITIAL_L2_CHECKPOINT_NUM } from '@aztec/constants';
-import { BlockNumber } from '@aztec/foundation/branded-types';
+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';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
 import { elapsed } from '@aztec/foundation/timer';
 import {
+  type BlockHash,
   GENESIS_CHECKPOINT_HEADER_HASH,
+  type L2Block,
   type L2BlockId,
-  type L2BlockNew,
   type L2BlockSource,
   L2BlockStream,
   type L2BlockStreamEvent,
@@ -48,7 +49,6 @@ export class ServerWorldStateSynchronizer
   private latestBlockNumberAtStart = BlockNumber.ZERO;
   private historyToKeep: number | undefined;
   private currentState: WorldStateRunningState = WorldStateRunningState.IDLE;
-  private latestBlockHashQuery: { blockNumber: BlockNumber; hash: string | undefined } | undefined = undefined;
 
   private syncPromise = promiseWithResolvers<void>();
   protected blockStream: L2BlockStream | undefined;
@@ -65,7 +65,7 @@ export class ServerWorldStateSynchronizer
     private readonly log: Logger = createLogger('world_state'),
   ) {
     this.merkleTreeCommitted = this.merkleTreeDb.getCommitted();
-    this.historyToKeep = config.worldStateBlockHistory < 1 ? undefined : config.worldStateBlockHistory;
+    this.historyToKeep = config.worldStateCheckpointHistory < 1 ? undefined : config.worldStateCheckpointHistory;
     this.log.info(
       `Created world state synchroniser with block history of ${
         this.historyToKeep === undefined ? 'infinity' : this.historyToKeep
@@ -102,11 +102,7 @@ export class ServerWorldStateSynchronizer
     }
 
     // Get the current latest block number
-    this.latestBlockNumberAtStart = BlockNumber(
-      await (this.config.worldStateProvenBlocksOnly
-        ? this.l2BlockSource.getProvenBlockNumber()
-        : this.l2BlockSource.getBlockNumber()),
-    );
+    this.latestBlockNumberAtStart = BlockNumber(await this.l2BlockSource.getBlockNumber());
 
     const blockToDownloadFrom = (await this.getLatestBlockNumber()) + 1;
 
@@ -130,7 +126,6 @@ export class ServerWorldStateSynchronizer
   protected createBlockStream(): L2BlockStream {
     const logger = createLogger('world-state:block_stream');
     return new L2BlockStream(this.l2BlockSource, this, this, logger, {
-      proven: this.config.worldStateProvenBlocksOnly,
       pollIntervalMS: this.config.worldStateBlockCheckIntervalMS,
       batchSize: this.config.worldStateBlockRequestBatchSize,
       ignoreCheckpoints: true,
@@ -183,13 +178,10 @@ export class ServerWorldStateSynchronizer
   /**
    * Forces an immediate sync.
    * @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.
+   * @param blockHash - If provided, verifies the block at targetBlockNumber matches this hash. On mismatch, triggers a resync (reorg detection).
    * @returns A promise that resolves with the block number the world state was synced to
    */
-  public async syncImmediate(
-    targetBlockNumber?: BlockNumber,
-    skipThrowIfTargetNotReached?: boolean,
-  ): Promise<BlockNumber> {
+  public async syncImmediate(targetBlockNumber?: BlockNumber, blockHash?: BlockHash): Promise<BlockNumber> {
     if (this.currentState !== WorldStateRunningState.RUNNING) {
       throw new Error(`World State is not running. Unable to perform sync.`);
     }
@@ -201,7 +193,19 @@ export class ServerWorldStateSynchronizer
     // If we have been given a block number to sync to and we have reached that number then return
     const currentBlockNumber = await this.getLatestBlockNumber();
     if (targetBlockNumber !== undefined && targetBlockNumber <= currentBlockNumber) {
-      return currentBlockNumber;
+      if (blockHash === undefined) {
+        return currentBlockNumber;
+      }
+
+      // If a block hash was provided, verify we're on the expected fork
+      const currentHash = await this.getL2BlockHash(targetBlockNumber);
+      if (currentHash === blockHash.toString()) {
+        return currentBlockNumber;
+      }
+      // Hash mismatch: a reorg may have occurred, fall through to trigger sync
+      this.log.debug(
+        `World state block hash mismatch at ${targetBlockNumber} (expected ${blockHash}, got ${currentHash}). Triggering resync.`,
+      );
     }
     this.log.debug(`World State at ${currentBlockNumber} told to sync to ${targetBlockNumber ?? 'latest'}`);
 
@@ -219,7 +223,7 @@ export class ServerWorldStateSynchronizer
 
     // 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 (!skipThrowIfTargetNotReached && targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
+    if (targetBlockNumber !== undefined && targetBlockNumber > updatedBlockNumber) {
       throw new WorldStateSynchronizerError(
         `Unable to sync to block number ${targetBlockNumber} (last synced is ${updatedBlockNumber})`,
         {
@@ -233,6 +237,24 @@ export class ServerWorldStateSynchronizer
       );
     }
 
+    // If a block hash was provided, verify we're on the expected fork after syncing, throw otherwise
+    if (blockHash !== undefined && targetBlockNumber !== undefined) {
+      const updatedHash = await this.getL2BlockHash(targetBlockNumber);
+      if (updatedHash !== blockHash.toString()) {
+        throw new WorldStateSynchronizerError(
+          `Block hash mismatch at block ${targetBlockNumber} (expected ${blockHash} but got ${updatedHash})`,
+          {
+            cause: {
+              reason: 'block_hash_mismatch',
+              targetBlockNumber,
+              expectedHash: blockHash.toString(),
+              actualHash: updatedHash,
+            },
+          },
+        );
+      }
+    }
+
     return updatedBlockNumber;
   }
 
@@ -241,41 +263,49 @@ export class ServerWorldStateSynchronizer
     if (number === BlockNumber.ZERO) {
       return (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
     }
-    if (this.latestBlockHashQuery?.hash === undefined || number !== this.latestBlockHashQuery.blockNumber) {
-      this.latestBlockHashQuery = {
-        hash: await this.merkleTreeCommitted
-          .getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number))
-          .then(leaf => leaf?.toString()),
-        blockNumber: number,
-      };
-    }
-    return this.latestBlockHashQuery.hash;
+    return this.merkleTreeCommitted.getLeafValue(MerkleTreeId.ARCHIVE, BigInt(number)).then(leaf => leaf?.toString());
   }
 
   /** Returns the latest L2 block number for each tip of the chain (latest, proven, finalized). */
   public async getL2Tips(): Promise<L2Tips> {
     const status = await this.merkleTreeDb.getStatusSummary();
-    const unfinalizedBlockHash = await this.getL2BlockHash(status.unfinalizedBlockNumber);
+    const unfinalizedBlockHashPromise = this.getL2BlockHash(status.unfinalizedBlockNumber);
+    const finalizedBlockHashPromise = this.getL2BlockHash(status.finalizedBlockNumber);
+
+    const provenBlockNumber = this.provenBlockNumber ?? status.finalizedBlockNumber;
+    const provenBlockHashPromise =
+      this.provenBlockNumber === undefined ? finalizedBlockHashPromise : this.getL2BlockHash(this.provenBlockNumber);
+
+    const [unfinalizedBlockHash, finalizedBlockHash, provenBlockHash] = await Promise.all([
+      unfinalizedBlockHashPromise,
+      finalizedBlockHashPromise,
+      provenBlockHashPromise,
+    ]);
     const latestBlockId: L2BlockId = { number: status.unfinalizedBlockNumber, hash: unfinalizedBlockHash! };
 
     // World state doesn't track checkpointed blocks or checkpoints themselves.
     // but we use a block stream so we need to provide 'local' L2Tips.
     // We configure the block stream to ignore checkpoints and set checkpoint values to genesis here.
     const genesisCheckpointHeaderHash = GENESIS_CHECKPOINT_HEADER_HASH.toString();
+    const initialBlockHash = (await this.merkleTreeCommitted.getInitialHeader().hash()).toString();
     return {
       proposed: latestBlockId,
       checkpointed: {
-        block: { number: INITIAL_L2_BLOCK_NUM, hash: GENESIS_BLOCK_HEADER_HASH.toString() },
-        checkpoint: { number: INITIAL_L2_CHECKPOINT_NUM, hash: genesisCheckpointHeaderHash },
+        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: {
-        block: { number: status.finalizedBlockNumber, hash: '' },
-        checkpoint: { number: INITIAL_L2_CHECKPOINT_NUM, hash: genesisCheckpointHeaderHash },
+        block: { number: status.finalizedBlockNumber, hash: finalizedBlockHash ?? '' },
+        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
       },
       proven: {
-        block: { number: this.provenBlockNumber ?? status.finalizedBlockNumber, hash: '' },
-        checkpoint: { number: INITIAL_L2_CHECKPOINT_NUM, hash: genesisCheckpointHeaderHash },
-      }, // TODO(palla/reorg): Using finalized as proven for now
+        block: { number: provenBlockNumber, hash: provenBlockHash ?? '' },
+        checkpoint: { number: INITIAL_CHECKPOINT_NUMBER, hash: genesisCheckpointHeaderHash },
+      },
     };
   }
 
@@ -302,8 +332,8 @@ export class ServerWorldStateSynchronizer
    * @param l2Blocks - The L2 blocks to handle.
    * @returns Whether the block handled was produced by this same node.
    */
-  private async handleL2Blocks(l2Blocks: L2BlockNew[]) {
-    this.log.trace(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
+  private async handleL2Blocks(l2Blocks: L2Block[]) {
+    this.log.debug(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
 
     // Fetch the L1->L2 messages for the first block in a checkpoint.
     const messagesForBlocks = new Map<BlockNumber, Fr[]>();
@@ -343,11 +373,13 @@ export class ServerWorldStateSynchronizer
    * @param l1ToL2Messages - The L1 to L2 messages for the block.
    * @returns Whether the block handled was produced by this same node.
    */
-  private async handleL2Block(l2Block: L2BlockNew, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull> {
-    this.log.trace(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
+  private async handleL2Block(l2Block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull> {
+    this.log.debug(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
       blockNumber: l2Block.number,
       blockHash: await l2Block.hash().then(h => h.toString()),
       l1ToL2Messages: l1ToL2Messages.map(msg => msg.toString()),
+      blockHeader: l2Block.header.toInspect(),
+      blockStats: l2Block.getStats(),
     });
     const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
 
@@ -361,16 +393,56 @@ export class ServerWorldStateSynchronizer
 
   private async handleChainFinalized(blockNumber: BlockNumber) {
     this.log.verbose(`Finalized chain is now at block ${blockNumber}`);
+    // If the finalized block number is older than the oldest available block in world state,
+    // skip entirely. The finalized block number can jump backwards (e.g. when the finalization
+    // heuristic changes) and try to read block data that has already been pruned. When this
+    // happens, there is nothing useful to do — the native world state is already finalized
+    // past this point and pruning has already happened.
+    const currentSummary = await this.merkleTreeDb.getStatusSummary();
+    if (blockNumber < currentSummary.oldestHistoricalBlock || blockNumber < 1) {
+      this.log.trace(
+        `Finalized block ${blockNumber} is older than the oldest available block ${currentSummary.oldestHistoricalBlock}. Skipping.`,
+      );
+      return;
+    }
     const summary = await this.merkleTreeDb.setFinalized(blockNumber);
     if (this.historyToKeep === undefined) {
       return;
     }
-    const newHistoricBlock = summary.finalizedBlockNumber - this.historyToKeep + 1;
-    if (newHistoricBlock <= 1) {
+    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 = finalisedBlockData.checkpointNumber - this.historyToKeep + 1;
+    if (newHistoricCheckpointNumber <= 1) {
+      return;
+    }
+    // Retrieve the historic checkpoint
+    const historicCheckpoint = await this.l2BlockSource.getCheckpoint({
+      number: CheckpointNumber(newHistoricCheckpointNumber),
+    });
+    if (!historicCheckpoint) {
+      this.log.warn(`Failed to retrieve checkpoint number ${newHistoricCheckpointNumber} from Archiver`);
       return;
     }
-    this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
-    const status = await this.merkleTreeDb.removeHistoricalBlocks(BlockNumber(newHistoricBlock));
+    if (historicCheckpoint.checkpoint.blocks.length === 0 || historicCheckpoint.checkpoint.blocks[0] === undefined) {
+      this.log.warn(`Retrieved checkpoint number ${newHistoricCheckpointNumber} has no blocks!`);
+      return;
+    }
+    // Find the block at the start of the checkpoint and remove blocks up to this one
+    const newHistoricBlock = historicCheckpoint.checkpoint.blocks[0];
+    if (newHistoricBlock.number <= currentSummary.oldestHistoricalBlock) {
+      this.log.debug(
+        `Historic block ${newHistoricBlock.number} is not newer than oldest available ${currentSummary.oldestHistoricalBlock}. Skipping prune.`,
+      );
+      return;
+    }
+    this.log.verbose(`Pruning historic blocks to ${newHistoricBlock.number}`);
+    const status = await this.merkleTreeDb.removeHistoricalBlocks(BlockNumber(newHistoricBlock.number));
     this.log.debug(`World state summary `, status.summary);
   }
 
@@ -381,10 +453,11 @@ export class ServerWorldStateSynchronizer
   }
 
   private async handleChainPruned(blockNumber: BlockNumber) {
-    this.log.warn(`Chain pruned to block ${blockNumber}`);
+    this.log.info(`Chain pruned to block ${blockNumber}`);
     const status = await this.merkleTreeDb.unwindBlocks(blockNumber);
-    this.latestBlockHashQuery = undefined;
-    this.provenBlockNumber = undefined;
+    if (this.provenBlockNumber !== undefined && this.provenBlockNumber > blockNumber) {
+      this.provenBlockNumber = undefined;
+    }
     this.instrumentation.updateWorldStateMetrics(status);
   }
 

package/src/test/utils.ts

@@ -5,10 +5,10 @@ import {
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
 } from '@aztec/constants';
 import { asyncMap } from '@aztec/foundation/async-map';
-import { BlockNumber, type CheckpointNumber } from '@aztec/foundation/branded-types';
+import { BlockNumber, type CheckpointNumber, IndexWithinCheckpoint } from '@aztec/foundation/branded-types';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { L2BlockNew } from '@aztec/stdlib/block';
+import { L2Block } from '@aztec/stdlib/block';
 import type {
   IndexedTreeId,
   MerkleTreeReadOperations,
@@ -20,7 +20,7 @@ import { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { NativeWorldStateService } from '../native/native_world_state.js';
 
-export async function updateBlockState(block: L2BlockNew, l1ToL2Messages: Fr[], fork: MerkleTreeWriteOperations) {
+export async function updateBlockState(block: L2Block, l1ToL2Messages: Fr[], fork: MerkleTreeWriteOperations) {
   const insertData = async (
     treeId: IndexedTreeId,
     data: Buffer[][],
@@ -76,8 +76,8 @@ export async function mockBlock(
   numL1ToL2Messages: number = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
   isFirstBlockInCheckpoint: boolean = true,
 ) {
-  const block = await L2BlockNew.random(blockNum, {
-    indexWithinCheckpoint: isFirstBlockInCheckpoint ? 0 : 1,
+  const block = await L2Block.random(blockNum, {
+    indexWithinCheckpoint: isFirstBlockInCheckpoint ? IndexWithinCheckpoint(0) : IndexWithinCheckpoint(1),
     txsPerBlock: size,
     txOptions: { maxEffects },
   });
@@ -92,7 +92,7 @@ export async function mockBlock(
 }
 
 export async function mockEmptyBlock(blockNum: BlockNumber, fork: MerkleTreeWriteOperations) {
-  const l2Block = L2BlockNew.empty();
+  const l2Block = L2Block.empty();
   const l1ToL2Messages = Array(16).fill(0).map(Fr.zero);
 
   l2Block.header.globalVariables.blockNumber = blockNum;

package/src/testing.ts

@@ -3,22 +3,19 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { computeFeePayerBalanceLeafSlot } from '@aztec/protocol-contracts/fee-juice';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { MerkleTreeId, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import type { GenesisData } from '@aztec/stdlib/world-state';
 
 import { NativeWorldStateService } from './native/index.js';
 
-async function generateGenesisValues(prefilledPublicData: PublicDataTreeLeaf[]) {
-  if (!prefilledPublicData.length) {
+async function generateGenesisValues(genesis: GenesisData) {
+  if (!genesis.prefilledPublicData.length && genesis.genesisTimestamp === 0n) {
     return {
       genesisArchiveRoot: new Fr(GENESIS_ARCHIVE_ROOT),
     };
   }
 
   // Create a temporary world state to compute the genesis values.
-  const ws = await NativeWorldStateService.tmp(
-    undefined /* rollupAddress */,
-    true /* cleanupTmpDir */,
-    prefilledPublicData,
-  );
+  const ws = await NativeWorldStateService.tmp(undefined /* rollupAddress */, true /* cleanupTmpDir */, genesis);
   const genesisArchiveRoot = new Fr((await ws.getCommitted().getTreeInfo(MerkleTreeId.ARCHIVE)).root);
   await ws.close();
 
@@ -33,6 +30,7 @@ export async function getGenesisValues(
   initialAccounts: AztecAddress[],
   initialAccountFeeJuice = defaultInitialAccountFeeJuice,
   genesisPublicData: PublicDataTreeLeaf[] = [],
+  genesisTimestamp: bigint = 0n,
 ) {
   // Top up the accounts with fee juice.
   let prefilledPublicData = await Promise.all(
@@ -46,11 +44,12 @@ export async function getGenesisValues(
 
   prefilledPublicData.sort((a, b) => (b.slot.lt(a.slot) ? 1 : -1));
 
-  const { genesisArchiveRoot } = await generateGenesisValues(prefilledPublicData);
+  const genesis: GenesisData = { prefilledPublicData, genesisTimestamp };
+  const { genesisArchiveRoot } = await generateGenesisValues(genesis);
 
   return {
     genesisArchiveRoot,
-    prefilledPublicData,
+    genesis,
     fundingNeeded: BigInt(initialAccounts.length) * initialAccountFeeJuice.toBigInt(),
   };
 }

package/src/world-state-db/merkle_tree_db.ts

@@ -1,14 +1,12 @@
 import { MAX_NULLIFIERS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX } from '@aztec/constants';
 import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { IndexedTreeSnapshot, TreeSnapshot } from '@aztec/merkle-tree';
-import type { L2BlockNew } from '@aztec/stdlib/block';
+import type { L2Block } from '@aztec/stdlib/block';
 import type {
   ForkMerkleTreeOperations,
   MerkleTreeReadOperations,
   ReadonlyWorldStateAccess,
 } from '@aztec/stdlib/interfaces/server';
-import type { MerkleTreeId } from '@aztec/stdlib/trees';
 
 import type { WorldStateStatusFull, WorldStateStatusSummary } from '../native/message.js';
 
@@ -31,21 +29,13 @@ export const INITIAL_NULLIFIER_TREE_SIZE = 2 * MAX_NULLIFIERS_PER_TX;
 
 export const INITIAL_PUBLIC_DATA_TREE_SIZE = 2 * MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX;
 
-export type TreeSnapshots = {
-  [MerkleTreeId.NULLIFIER_TREE]: IndexedTreeSnapshot;
-  [MerkleTreeId.NOTE_HASH_TREE]: TreeSnapshot<Fr>;
-  [MerkleTreeId.PUBLIC_DATA_TREE]: IndexedTreeSnapshot;
-  [MerkleTreeId.L1_TO_L2_MESSAGE_TREE]: TreeSnapshot<Fr>;
-  [MerkleTreeId.ARCHIVE]: TreeSnapshot<Fr>;
-};
-
 export interface MerkleTreeAdminDatabase extends ForkMerkleTreeOperations, ReadonlyWorldStateAccess {
   /**
    * 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.
    */
-  handleL2BlockAndMessages(block: L2BlockNew, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull>;
+  handleL2BlockAndMessages(block: L2Block, l1ToL2Messages: Fr[]): Promise<WorldStateStatusFull>;
 
   /**
    * Gets a handle that allows reading the latest committed state