@aztec/world-state 0.76.4 → 0.77.0-testnet-ignition.17

package/src/instrumentation/instrumentation.ts

@@ -1,11 +1,12 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
 import { createLogger } from '@aztec/foundation/log';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
 import {
   Attributes,
   type Gauge,
   type Histogram,
   Metrics,
   type TelemetryClient,
+  type UpDownCounter,
   ValueType,
 } from '@aztec/telemetry-client';
 
@@ -19,6 +20,15 @@ import {
 
 type DBTypeString = 'leaf_preimage' | 'leaf_indices' | 'nodes' | 'blocks' | 'block_indices';
 
+const durationTrackDenylist = new Set<WorldStateMessageType>([
+  WorldStateMessageType.GET_INITIAL_STATE_REFERENCE,
+  WorldStateMessageType.CLOSE,
+
+  // these aren't used anymore, should be removed from the API
+  WorldStateMessageType.COMMIT,
+  WorldStateMessageType.ROLLBACK,
+]);
+
 export class WorldStateInstrumentation {
   private dbMapSize: Gauge;
   private treeSize: Gauge;
@@ -28,6 +38,7 @@ export class WorldStateInstrumentation {
   private dbNumItems: Gauge;
   private dbUsedSize: Gauge;
   private requestHistogram: Histogram;
+  private criticalErrors: UpDownCounter;
 
   constructor(public readonly telemetry: TelemetryClient, private log = createLogger('world-state:instrumentation')) {
     const meter = telemetry.getMeter('World State');
@@ -71,6 +82,11 @@ export class WorldStateInstrumentation {
       unit: 'us',
       valueType: ValueType.INT,
     });
+
+    this.criticalErrors = meter.createUpDownCounter(Metrics.WORLD_STATE_CRITICAL_ERROR_COUNT, {
+      description: 'The number of critical errors in the world state',
+      valueType: ValueType.INT,
+    });
   }
 
   private updateTreeStats(treeDbStats: TreeDBStats, treeMeta: TreeMeta, tree: MerkleTreeId) {
@@ -141,8 +157,18 @@ export class WorldStateInstrumentation {
   }
 
   public recordRoundTrip(timeUs: number, request: WorldStateMessageType) {
-    this.requestHistogram.record(Math.ceil(timeUs), {
-      [Attributes.WORLD_STATE_REQUEST_TYPE]: WorldStateMessageType[request],
+    if (!durationTrackDenylist.has(request)) {
+      this.requestHistogram.record(Math.ceil(timeUs), {
+        [Attributes.WORLD_STATE_REQUEST_TYPE]: WorldStateMessageType[request],
+      });
+    }
+  }
+
+  public incCriticalErrors(
+    errorType: 'synch_pending_block' | 'finalize_block' | 'prune_pending_block' | 'prune_historical_block',
+  ) {
+    this.criticalErrors.add(1, {
+      [Attributes.ERROR_TYPE]: errorType,
     });
   }
 }

package/src/native/fork_checkpoint.ts

@@ -0,0 +1,30 @@
+import type { MerkleTreeCheckpointOperations } from '@aztec/stdlib/interfaces/server';
+
+export class ForkCheckpoint {
+  private completed = false;
+
+  private constructor(private readonly fork: MerkleTreeCheckpointOperations) {}
+
+  static async new(fork: MerkleTreeCheckpointOperations): Promise<ForkCheckpoint> {
+    await fork.createCheckpoint();
+    return new ForkCheckpoint(fork);
+  }
+
+  async commit(): Promise<void> {
+    if (this.completed) {
+      return;
+    }
+
+    await this.fork.commitCheckpoint();
+    this.completed = true;
+  }
+
+  async revert(): Promise<void> {
+    if (this.completed) {
+      return;
+    }
+
+    await this.fork.revertCheckpoint();
+    this.completed = true;
+  }
+}

package/src/native/index.ts

@@ -1 +1,2 @@
 export * from './native_world_state.js';
+export * from './fork_checkpoint.js';

package/src/native/merkle_trees_facade.ts

@@ -1,26 +1,23 @@
+import { Fr } from '@aztec/foundation/fields';
+import { serializeToBuffer } from '@aztec/foundation/serialize';
+import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
+import type {
+  BatchInsertionResult,
+  IndexedTreeId,
+  MerkleTreeLeafType,
+  MerkleTreeReadOperations,
+  MerkleTreeWriteOperations,
+  SequentialInsertionResult,
+  TreeInfo,
+} from '@aztec/stdlib/interfaces/server';
 import {
-  type BatchInsertionResult,
-  type IndexedTreeId,
   MerkleTreeId,
-  type MerkleTreeLeafType,
-  type MerkleTreeReadOperations,
-  type MerkleTreeWriteOperations,
-  type SequentialInsertionResult,
-  SiblingPath,
-  type TreeInfo,
-} from '@aztec/circuit-types';
-import {
-  type BlockHeader,
-  Fr,
   NullifierLeaf,
   NullifierLeafPreimage,
-  PartialStateReference,
   PublicDataTreeLeaf,
   PublicDataTreeLeafPreimage,
-  StateReference,
-} from '@aztec/circuits.js';
-import { serializeToBuffer } from '@aztec/foundation/serialize';
-import { type IndexedTreeLeafPreimage } from '@aztec/foundation/trees';
+} from '@aztec/stdlib/trees';
+import { type BlockHeader, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
 
 import assert from 'assert';
 
@@ -32,7 +29,7 @@ import {
   blockStateReference,
   treeStateReferenceToSnapshot,
 } from './message.js';
-import { type NativeWorldStateInstance } from './native_world_state_instance.js';
+import type { NativeWorldStateInstance } from './native_world_state_instance.js';
 
 export class MerkleTreesFacade implements MerkleTreeReadOperations {
   constructor(

package/src/native/message.ts

@@ -1,6 +1,8 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
-import { AppendOnlyTreeSnapshot, Fr, type StateReference, type UInt32 } from '@aztec/circuits.js';
-import { type Tuple } from '@aztec/foundation/serialize';
+import { Fr } from '@aztec/foundation/fields';
+import type { Tuple } from '@aztec/foundation/serialize';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
+import type { StateReference } from '@aztec/stdlib/tx';
+import type { UInt32 } from '@aztec/stdlib/types';
 
 export enum WorldStateMessageType {
   GET_TREE_INFO = 100,

package/src/native/native_world_state.ts

@@ -1,25 +1,16 @@
-import {
-  type IndexedTreeId,
-  type L2Block,
-  MerkleTreeId,
-  type MerkleTreeReadOperations,
-  type MerkleTreeWriteOperations,
-} from '@aztec/circuit-types';
-import {
-  BlockHeader,
-  EthAddress,
-  Fr,
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-  NullifierLeaf,
-  type NullifierLeafPreimage,
-  PartialStateReference,
-  PublicDataTreeLeaf,
-  StateReference,
-} from '@aztec/circuits.js';
+import { MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
+import type { L2Block } from '@aztec/stdlib/block';
+import type {
+  IndexedTreeId,
+  MerkleTreeReadOperations,
+  MerkleTreeWriteOperations,
+} from '@aztec/stdlib/interfaces/server';
+import { MerkleTreeId, NullifierLeaf, type NullifierLeafPreimage, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
+import { BlockHeader, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import assert from 'assert/strict';
@@ -28,7 +19,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
-import { type MerkleTreeAdminDatabase as MerkleTreeDatabase } from '../world-state-db/merkle_tree_db.js';
+import type { MerkleTreeAdminDatabase as MerkleTreeDatabase } from '../world-state-db/merkle_tree_db.js';
 import { MerkleTreesFacade, MerkleTreesForkFacade, serializeLeaf } from './merkle_trees_facade.js';
 import {
   WorldStateMessageType,
@@ -68,6 +59,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     rollupAddress: EthAddress,
     dataDir: string,
     dbMapSizeKb: number,
+    prefilledPublicData: PublicDataTreeLeaf[] = [],
     instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
     log = createLogger('world-state:database'),
     cleanup = () => Promise.resolve(),
@@ -78,13 +70,13 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
 
     if (!storedWorldStateVersion) {
       log.warn('No world state version found, deleting world state directory');
-      await rm(worldStateDirectory, { recursive: true, force: true });
+      await rm(worldStateDirectory, { recursive: true, force: true, maxRetries: 3 });
     } else if (!rollupAddress.equals(storedWorldStateVersion.rollupAddress)) {
       log.warn('Rollup address changed, deleting world state directory');
-      await rm(worldStateDirectory, { recursive: true, force: true });
+      await rm(worldStateDirectory, { recursive: true, force: true, maxRetries: 3 });
     } else if (storedWorldStateVersion.version != WORLD_STATE_DB_VERSION) {
       log.warn('World state version change detected, deleting world state directory');
-      await rm(worldStateDirectory, { recursive: true, force: true });
+      await rm(worldStateDirectory, { recursive: true, force: true, maxRetries: 3 });
     }
 
     const newWorldStateVersion = new WorldStateVersion(WORLD_STATE_DB_VERSION, rollupAddress);
@@ -92,7 +84,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     await mkdir(worldStateDirectory, { recursive: true });
     await newWorldStateVersion.writeVersionFile(versionFile);
 
-    const instance = new NativeWorldState(worldStateDirectory, dbMapSizeKb, instrumentation);
+    const instance = new NativeWorldState(worldStateDirectory, dbMapSizeKb, prefilledPublicData, instrumentation);
     const worldState = new this(instance, instrumentation, log, cleanup);
     try {
       await worldState.init();
@@ -107,6 +99,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   static async tmp(
     rollupAddress = EthAddress.ZERO,
     cleanupTmpDir = true,
+    prefilledPublicData: PublicDataTreeLeaf[] = [],
     instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
   ): Promise<NativeWorldStateService> {
     const log = createLogger('world-state:database');
@@ -117,14 +110,14 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     // pass a cleanup callback because process.on('beforeExit', cleanup) does not work under Jest
     const cleanup = async () => {
       if (cleanupTmpDir) {
-        await rm(dataDir, { recursive: true, force: true });
+        await rm(dataDir, { recursive: true, force: true, maxRetries: 3 });
         log.debug(`Deleted temporary world state database: ${dataDir}`);
       } else {
         log.debug(`Leaving temporary world state database: ${dataDir}`);
       }
     };
 
-    return this.new(rollupAddress, dataDir, dbMapSizeKb, instrumentation, log, cleanup);
+    return this.new(rollupAddress, dataDir, dbMapSizeKb, prefilledPublicData, instrumentation, log, cleanup);
   }
 
   protected async init() {
@@ -189,21 +182,26 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
       });
     });
 
-    return await this.instance.call(
-      WorldStateMessageType.SYNC_BLOCK,
-      {
-        blockNumber: l2Block.number,
-        blockHeaderHash: await l2Block.header.hash(),
-        paddedL1ToL2Messages: paddedL1ToL2Messages.map(serializeLeaf),
-        paddedNoteHashes: paddedNoteHashes.map(serializeLeaf),
-        paddedNullifiers: paddedNullifiers.map(serializeLeaf),
-        publicDataWrites: publicDataWrites.map(serializeLeaf),
-        blockStateRef: blockStateReference(l2Block.header.state),
-        canonical: true,
-      },
-      this.sanitiseAndCacheSummaryFromFull.bind(this),
-      this.deleteCachedSummary.bind(this),
-    );
+    try {
+      return await this.instance.call(
+        WorldStateMessageType.SYNC_BLOCK,
+        {
+          blockNumber: l2Block.number,
+          blockHeaderHash: await l2Block.header.hash(),
+          paddedL1ToL2Messages: paddedL1ToL2Messages.map(serializeLeaf),
+          paddedNoteHashes: paddedNoteHashes.map(serializeLeaf),
+          paddedNullifiers: paddedNullifiers.map(serializeLeaf),
+          publicDataWrites: publicDataWrites.map(serializeLeaf),
+          blockStateRef: blockStateReference(l2Block.header.state),
+          canonical: true,
+        },
+        this.sanitiseAndCacheSummaryFromFull.bind(this),
+        this.deleteCachedSummary.bind(this),
+      );
+    } catch (err) {
+      this.worldStateInstrumentation.incCriticalErrors('synch_pending_block');
+      throw err;
+    }
   }
 
   public async close(): Promise<void> {
@@ -238,15 +236,20 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    * @returns The new WorldStateStatus
    */
   public async setFinalised(toBlockNumber: bigint) {
-    await this.instance.call(
-      WorldStateMessageType.FINALISE_BLOCKS,
-      {
-        toBlockNumber,
-        canonical: true,
-      },
-      this.sanitiseAndCacheSummary.bind(this),
-      this.deleteCachedSummary.bind(this),
-    );
+    try {
+      await this.instance.call(
+        WorldStateMessageType.FINALISE_BLOCKS,
+        {
+          toBlockNumber,
+          canonical: true,
+        },
+        this.sanitiseAndCacheSummary.bind(this),
+        this.deleteCachedSummary.bind(this),
+      );
+    } catch (err) {
+      this.worldStateInstrumentation.incCriticalErrors('finalize_block');
+      throw err;
+    }
     return this.getStatusSummary();
   }
 
@@ -256,15 +259,20 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    * @returns The new WorldStateStatus
    */
   public async removeHistoricalBlocks(toBlockNumber: bigint) {
-    return await this.instance.call(
-      WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS,
-      {
-        toBlockNumber,
-        canonical: true,
-      },
-      this.sanitiseAndCacheSummaryFromFull.bind(this),
-      this.deleteCachedSummary.bind(this),
-    );
+    try {
+      return await this.instance.call(
+        WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS,
+        {
+          toBlockNumber,
+          canonical: true,
+        },
+        this.sanitiseAndCacheSummaryFromFull.bind(this),
+        this.deleteCachedSummary.bind(this),
+      );
+    } catch (err) {
+      this.worldStateInstrumentation.incCriticalErrors('prune_historical_block');
+      throw err;
+    }
   }
 
   /**
@@ -273,15 +281,20 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    * @returns The new WorldStateStatus
    */
   public async unwindBlocks(toBlockNumber: bigint) {
-    return await this.instance.call(
-      WorldStateMessageType.UNWIND_BLOCKS,
-      {
-        toBlockNumber,
-        canonical: true,
-      },
-      this.sanitiseAndCacheSummaryFromFull.bind(this),
-      this.deleteCachedSummary.bind(this),
-    );
+    try {
+      return await this.instance.call(
+        WorldStateMessageType.UNWIND_BLOCKS,
+        {
+          toBlockNumber,
+          canonical: true,
+        },
+        this.sanitiseAndCacheSummaryFromFull.bind(this),
+        this.deleteCachedSummary.bind(this),
+      );
+    } catch (err) {
+      this.worldStateInstrumentation.incCriticalErrors('prune_pending_block');
+      throw err;
+    }
   }
 
   public async getStatusSummary() {

package/src/native/native_world_state_instance.ts

@@ -1,4 +1,3 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
 import {
   ARCHIVE_HEIGHT,
   GeneratorIndex,
@@ -8,14 +7,16 @@ import {
   NOTE_HASH_TREE_HEIGHT,
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
-} from '@aztec/circuits.js';
+} from '@aztec/constants';
 import { 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 { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
 import {
   WorldStateMessageType,
   type WorldStateRequest,
@@ -51,6 +52,7 @@ export class NativeWorldState implements NativeWorldStateInstance {
   constructor(
     dataDir: string,
     dbMapSizeKb: number,
+    prefilledPublicData: PublicDataTreeLeaf[] = [],
     private instrumentation: WorldStateInstrumentation,
     private log = createLogger('world-state:database'),
   ) {
@@ -58,6 +60,7 @@ export class NativeWorldState implements NativeWorldStateInstance {
     log.info(
       `Creating world state data store at directory ${dataDir} with map size ${dbMapSizeKb} KB and ${threads} threads.`,
     );
+    const prefilledPublicDataBufferArray = prefilledPublicData.map(d => [d.slot.toBuffer(), d.value.toBuffer()]);
     const ws = new BaseNativeWorldState(
       dataDir,
       {
@@ -71,6 +74,7 @@ export class NativeWorldState implements NativeWorldStateInstance {
         [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,
       dbMapSizeKb,
       threads,

package/src/native/world_state_version.ts

@@ -1,4 +1,4 @@
-import { EthAddress } from '@aztec/circuits.js';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
 
 import { readFile, writeFile } from 'fs/promises';

package/src/synchronizer/factory.ts

@@ -1,25 +1,29 @@
-import { type L1ToL2MessageSource, type L2BlockSource } from '@aztec/circuit-types';
-import { type DataStoreConfig } from '@aztec/kv-store/config';
+import type { DataStoreConfig } from '@aztec/kv-store/config';
+import type { L2BlockSource } from '@aztec/stdlib/block';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { PublicDataTreeLeaf } from '@aztec/stdlib/trees';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
 import { NativeWorldStateService } from '../native/native_world_state.js';
-import { type WorldStateConfig } from './config.js';
+import type { WorldStateConfig } from './config.js';
 import { ServerWorldStateSynchronizer } from './server_world_state_synchronizer.js';
 
 export async function createWorldStateSynchronizer(
   config: WorldStateConfig & DataStoreConfig,
   l2BlockSource: L2BlockSource & L1ToL2MessageSource,
+  prefilledPublicData: PublicDataTreeLeaf[] = [],
   client: TelemetryClient = getTelemetryClient(),
 ) {
   const instrumentation = new WorldStateInstrumentation(client);
-  const merkleTrees = await createWorldState(config, instrumentation);
+  const merkleTrees = await createWorldState(config, prefilledPublicData, instrumentation);
   return new ServerWorldStateSynchronizer(merkleTrees, l2BlockSource, config, instrumentation);
 }
 
 export async function createWorldState(
   config: WorldStateConfig & DataStoreConfig,
-  instrumentation: WorldStateInstrumentation,
+  prefilledPublicData: PublicDataTreeLeaf[] = [],
+  instrumentation: WorldStateInstrumentation = new WorldStateInstrumentation(getTelemetryClient()),
 ) {
   const newConfig = {
     dataDirectory: config.worldStateDataDirectory ?? config.dataDirectory,
@@ -36,11 +40,13 @@ export async function createWorldState(
         config.l1Contracts.rollupAddress,
         newConfig.dataDirectory,
         newConfig.dataStoreMapSizeKB,
+        prefilledPublicData,
         instrumentation,
       )
     : await NativeWorldStateService.tmp(
         config.l1Contracts.rollupAddress,
         !['true', '1'].includes(process.env.DEBUG_WORLD_STATE!),
+        prefilledPublicData,
       );
 
   return merkleTrees;

package/src/synchronizer/server_world_state_synchronizer.ts

@@ -1,34 +1,35 @@
-import {
-  type L1ToL2MessageSource,
-  type L2Block,
-  type L2BlockId,
-  type L2BlockSource,
-  type L2BlockStream,
-  type L2BlockStreamEvent,
-  type L2BlockStreamEventHandler,
-  type L2BlockStreamLocalDataProvider,
-  type L2Tips,
-  MerkleTreeId,
-  type MerkleTreeReadOperations,
-  type MerkleTreeWriteOperations,
-  WorldStateRunningState,
-  type WorldStateSynchronizer,
-  type WorldStateSynchronizerStatus,
-} from '@aztec/circuit-types';
-import { type L2BlockHandledStats } from '@aztec/circuit-types/stats';
-import { MerkleTreeCalculator } from '@aztec/circuits.js';
-import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js/constants';
-import { type Fr } from '@aztec/foundation/fields';
+import { L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/constants';
+import type { Fr } from '@aztec/foundation/fields';
 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 type {
+  L2Block,
+  L2BlockId,
+  L2BlockSource,
+  L2BlockStream,
+  L2BlockStreamEvent,
+  L2BlockStreamEventHandler,
+  L2BlockStreamLocalDataProvider,
+  L2Tips,
+} from '@aztec/stdlib/block';
+import {
+  WorldStateRunningState,
+  type WorldStateSyncStatus,
+  type WorldStateSynchronizer,
+  type WorldStateSynchronizerStatus,
+} from '@aztec/stdlib/interfaces/server';
+import type { L1ToL2MessageSource } from '@aztec/stdlib/messaging';
+import type { L2BlockHandledStats } from '@aztec/stdlib/stats';
+import { MerkleTreeId, type MerkleTreeReadOperations, type MerkleTreeWriteOperations } from '@aztec/stdlib/trees';
 import { TraceableL2BlockStream, getTelemetryClient } from '@aztec/telemetry-client';
 
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
-import { type WorldStateStatusFull } from '../native/message.js';
-import { type MerkleTreeAdminDatabase } from '../world-state-db/merkle_tree_db.js';
-import { type WorldStateConfig } from './config.js';
+import type { WorldStateStatusFull } from '../native/message.js';
+import type { MerkleTreeAdminDatabase } from '../world-state-db/merkle_tree_db.js';
+import type { WorldStateConfig } from './config.js';
 
 /**
  * Synchronizes the world state with the L2 blocks from a L2BlockSource via a block stream.
@@ -128,8 +129,16 @@ export class ServerWorldStateSynchronizer
   }
 
   public async status(): Promise<WorldStateSynchronizerStatus> {
+    const summary = await this.merkleTreeDb.getStatusSummary();
+    const status: WorldStateSyncStatus = {
+      latestBlockNumber: Number(summary.unfinalisedBlockNumber),
+      latestBlockHash: (await this.getL2BlockHash(Number(summary.unfinalisedBlockNumber))) ?? '',
+      finalisedBlockNumber: Number(summary.finalisedBlockNumber),
+      oldestHistoricBlockNumber: Number(summary.oldestHistoricalBlock),
+      treesAreSynched: summary.treesAreSynched,
+    };
     return {
-      syncedToL2Block: (await this.getL2Tips()).latest,
+      syncSummary: status,
       state: this.currentState,
     };
   }
@@ -224,6 +233,8 @@ export class ServerWorldStateSynchronizer
    * @returns Whether the block handled was produced by this same node.
    */
   private async handleL2Blocks(l2Blocks: L2Block[]) {
+    this.log.trace(`Handling L2 blocks ${l2Blocks[0].number} to ${l2Blocks.at(-1)!.number}`);
+
     const messagePromises = l2Blocks.map(block => this.l2BlockSource.getL1ToL2Messages(BigInt(block.number)));
     const l1ToL2Messages: Fr[][] = await Promise.all(messagePromises);
     let updateStatus: WorldStateStatusFull | undefined = undefined;
@@ -260,6 +271,11 @@ export class ServerWorldStateSynchronizer
     await this.verifyMessagesHashToInHash(l1ToL2Messages, l2Block.header.contentCommitment.inHash);
 
     // If the above check succeeds, we can proceed to handle the block.
+    this.log.trace(`Pushing L2 block ${l2Block.number} to merkle tree db `, {
+      blockNumber: l2Block.number,
+      blockHash: await l2Block.hash().then(h => h.toString()),
+      l1ToL2Messages: l1ToL2Messages.map(msg => msg.toString()),
+    });
     const result = await this.merkleTreeDb.handleL2BlockAndMessages(l2Block, l1ToL2Messages);
 
     if (this.currentState === WorldStateRunningState.SYNCHING && l2Block.number >= this.latestBlockNumberAtStart) {
@@ -281,7 +297,8 @@ export class ServerWorldStateSynchronizer
       return;
     }
     this.log.verbose(`Pruning historic blocks to ${newHistoricBlock}`);
-    await this.merkleTreeDb.removeHistoricalBlocks(newHistoricBlock);
+    const status = await this.merkleTreeDb.removeHistoricalBlocks(newHistoricBlock);
+    this.log.debug(`World state summary `, status.summary);
   }
 
   private handleChainProven(blockNumber: number) {

package/src/test/utils.ts

@@ -1,20 +1,16 @@
 import {
-  L2Block,
-  MerkleTreeId,
-  type MerkleTreeReadOperations,
-  type MerkleTreeWriteOperations,
-} from '@aztec/circuit-types';
-import {
-  AppendOnlyTreeSnapshot,
-  Fr,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   NULLIFIER_SUBTREE_HEIGHT,
   NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-} from '@aztec/circuits.js';
+} from '@aztec/constants';
 import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/fields';
+import { L2Block } from '@aztec/stdlib/block';
+import type { MerkleTreeReadOperations, MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { AppendOnlyTreeSnapshot, MerkleTreeId } from '@aztec/stdlib/trees';
 
-import { type NativeWorldStateService } from '../native/native_world_state.js';
+import type { NativeWorldStateService } from '../native/native_world_state.js';
 
 export async function mockBlock(blockNum: number, size: number, fork: MerkleTreeWriteOperations) {
   const l2Block = await L2Block.random(blockNum, size);