@aztec/world-state 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/src/native/native_world_state.ts

@@ -3,10 +3,9 @@ import { BlockNumber } from '@aztec/foundation/branded-types';
 import { fromEntries, padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { tryRmDir } from '@aztec/foundation/fs';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { L2Block } from '@aztec/stdlib/block';
-import { DatabaseVersionManager } from '@aztec/stdlib/database-version';
+import { DatabaseVersionManager } from '@aztec/stdlib/database-version/manager';
 import type {
   IndexedTreeId,
   MerkleTreeReadOperations,
@@ -14,21 +13,21 @@ import type {
 } from '@aztec/stdlib/interfaces/server';
 import type { SnapshotDataKeys } from '@aztec/stdlib/snapshots';
 import { MerkleTreeId, NullifierLeaf, type NullifierLeafPreimage, PublicDataTreeLeaf } from '@aztec/stdlib/trees';
-import { BlockHeader, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
-import { WorldStateRevision } from '@aztec/stdlib/world-state';
+import { BlockHeader, GlobalVariables, PartialStateReference, StateReference } from '@aztec/stdlib/tx';
+import { EMPTY_GENESIS_DATA, type GenesisData, WorldStateRevision } from '@aztec/stdlib/world-state';
 import { getTelemetryClient } from '@aztec/telemetry-client';
 
 import assert from 'assert/strict';
-import { mkdtemp, rm } from 'fs/promises';
+import { mkdir, mkdtemp, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { join } from 'path';
 
 import { WorldStateInstrumentation } from '../instrumentation/instrumentation.js';
 import type { WorldStateTreeMapSizes } from '../synchronizer/factory.js';
 import type { MerkleTreeAdminDatabase as MerkleTreeDatabase } from '../world-state-db/merkle_tree_db.js';
+import { IpcWorldState } from './ipc_world_state_instance.js';
 import { MerkleTreesFacade, MerkleTreesForkFacade, serializeLeaf } from './merkle_trees_facade.js';
 import {
-  WorldStateMessageType,
   type WorldStateStatusFull,
   type WorldStateStatusSummary,
   blockStateReference,
@@ -36,7 +35,7 @@ import {
   sanitizeSummary,
   treeStateReferenceToSnapshot,
 } from './message.js';
-import { NativeWorldState } from './native_world_state_instance.js';
+import type { NativeWorldStateInstance } from './native_world_state_instance.js';
 
 // The current version of the world state database schema
 // Increment this when making incompatible changes to the database schema
@@ -50,37 +49,49 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   private cachedStatusSummary: WorldStateStatusSummary | undefined;
 
   protected constructor(
-    protected instance: NativeWorldState,
+    protected instance: NativeWorldStateInstance,
     protected readonly worldStateInstrumentation: WorldStateInstrumentation,
     protected readonly log: Logger,
+    private readonly genesis: GenesisData = EMPTY_GENESIS_DATA,
     private readonly cleanup = () => Promise.resolve(),
+    /** Factory to recreate a fresh IpcWorldState after clear(). */
+    private readonly recreateInstance?: () => Promise<NativeWorldStateInstance>,
   ) {}
 
   static async new(
     rollupAddress: EthAddress,
     dataDir: string,
     wsTreeMapSizes: WorldStateTreeMapSizes,
-    prefilledPublicData: PublicDataTreeLeaf[] = [],
+    genesis: GenesisData = EMPTY_GENESIS_DATA,
     instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
     bindings?: LoggerBindings,
     cleanup = () => Promise.resolve(),
   ): Promise<NativeWorldStateService> {
+    for (const [key, value] of Object.entries(wsTreeMapSizes)) {
+      if (value <= 0) {
+        throw new Error(`Map size must be a positive number, got ${value} for ${key}`);
+      }
+    }
+
     const log = createLogger('world-state:database', bindings);
     const worldStateDirectory = join(dataDir, WORLD_STATE_DIR);
-    // Create a version manager to handle versioning
+
     const versionManager = new DatabaseVersionManager({
       schemaVersion: WORLD_STATE_DB_VERSION,
       rollupAddress,
       dataDirectory: worldStateDirectory,
-      onOpen: (dir: string) => {
-        return Promise.resolve(
-          new NativeWorldState(dir, wsTreeMapSizes, prefilledPublicData, instrumentation, bindings),
-        );
-      },
+      onOpen: dir => IpcWorldState.spawn(dir, wsTreeMapSizes, genesis, instrumentation, bindings),
     });
 
     const [instance] = await versionManager.open();
-    const worldState = new this(instance, instrumentation, log, cleanup);
+
+    const recreateInstance = async () => {
+      await rm(worldStateDirectory, { recursive: true, force: true, maxRetries: 3 });
+      await mkdir(worldStateDirectory, { recursive: true });
+      return IpcWorldState.spawn(worldStateDirectory, wsTreeMapSizes, genesis, instrumentation, bindings);
+    };
+
+    const worldState = new this(instance, instrumentation, log, genesis, cleanup, recreateInstance);
     try {
       await worldState.init();
     } catch (e) {
@@ -92,15 +103,19 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   }
 
   static async tmp(
-    rollupAddress = EthAddress.ZERO,
     cleanupTmpDir = true,
-    prefilledPublicData: PublicDataTreeLeaf[] = [],
+    genesis: GenesisData = EMPTY_GENESIS_DATA,
     instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
     bindings?: LoggerBindings,
+    threads?: number,
   ): Promise<NativeWorldStateService> {
     const log = createLogger('world-state:database', bindings);
     const dataDir = await mkdtemp(join(tmpdir(), 'aztec-world-state-'));
-    const dbMapSizeKb = 10 * 1024 * 1024;
+    // Temporary (test/dev) world states are small and short-lived. Keep the LMDB
+    // map sizes in the MB range: with the IPC backend each tmp() spawns a separate
+    // aztec-wsdb that maps these per tree, and oversized maps add real cold-start
+    // I/O under parallel CI load. 256 MB/tree is ample for tests.
+    const dbMapSizeKb = 256 * 1024;
     const worldStateTreeMapSizes: WorldStateTreeMapSizes = {
       archiveTreeMapSizeKb: dbMapSizeKb,
       nullifierTreeMapSizeKb: dbMapSizeKb,
@@ -110,7 +125,15 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     };
     log.debug(`Created temporary world state database at: ${dataDir} with tree map size: ${dbMapSizeKb}`);
 
-    // pass a cleanup callback because process.on('beforeExit', cleanup) does not work under Jest
+    const instance = await IpcWorldState.spawn(
+      dataDir,
+      worldStateTreeMapSizes,
+      genesis,
+      instrumentation,
+      bindings,
+      threads,
+    );
+
     const cleanup = async () => {
       if (cleanupTmpDir) {
         await rm(dataDir, { recursive: true, force: true, maxRetries: 3 });
@@ -120,15 +143,47 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
       }
     };
 
-    return this.new(
-      rollupAddress,
-      dataDir,
-      worldStateTreeMapSizes,
-      prefilledPublicData,
-      instrumentation,
-      bindings,
-      cleanup,
-    );
+    const recreateInstance = async () => {
+      await rm(dataDir, { recursive: true, force: true, maxRetries: 3 });
+      await mkdir(dataDir, { recursive: true });
+      return IpcWorldState.spawn(dataDir, worldStateTreeMapSizes, genesis, instrumentation, bindings, threads);
+    };
+
+    const worldState = new this(instance, instrumentation, log, genesis, cleanup, recreateInstance);
+    try {
+      await worldState.init();
+    } catch (e) {
+      log.error(`Error initializing tmp world state: ${e}`);
+      throw e;
+    }
+    return worldState;
+  }
+
+  static ephemeral(
+    genesis: GenesisData = EMPTY_GENESIS_DATA,
+    instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
+    bindings?: LoggerBindings,
+  ): Promise<NativeWorldStateService> {
+    // The TXE spins up one tiny, short-lived world state per test, many concurrently. Cap the wsdb thread
+    // usage to the minimum: a single tree-op thread instead of one per core (the C++ IPC dispatcher pool
+    // still floors at 2). This avoids ~32 threads per wsdb multiplied across dozens of concurrent test
+    // world states — the trees are cache-sized (see tmp's map-size note), so extra threads buy nothing.
+    return this.tmp(/*cleanupTmpDir=*/ true, genesis, instrumentation, bindings, /*threads=*/ 1);
+  }
+
+  static async fromIpc(
+    wsdbBackend: ConstructorParameters<typeof IpcWorldState>[0],
+    instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
+    bindings?: LoggerBindings,
+    genesis: GenesisData = EMPTY_GENESIS_DATA,
+    cleanup = () => Promise.resolve(),
+    recreateInstance?: () => Promise<NativeWorldStateInstance>,
+  ): Promise<NativeWorldStateService> {
+    const log = createLogger('world-state:database', bindings);
+    const instance = new IpcWorldState(wsdbBackend, instrumentation, bindings);
+    const worldState = new this(instance, instrumentation, log, genesis, cleanup, recreateInstance);
+    await worldState.init();
+    return worldState;
   }
 
   protected async init() {
@@ -147,18 +202,29 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
 
     // the initial header _must_ be the first element in the archive tree
     // if this assertion fails, check that the hashing done in Header in yarn-project matches the initial header hash done in world_state.cpp
-    const indices = await committed.findLeafIndices(MerkleTreeId.ARCHIVE, [
-      (await this.initialHeader.hash()).toField(),
-    ]);
+    const indices = await committed.findLeafIndices(MerkleTreeId.ARCHIVE, [await this.initialHeader.hash()]);
     const initialHeaderIndex = indices[0];
     assert.strictEqual(initialHeaderIndex, 0n, 'Invalid initial archive state');
   }
 
-  public async clear() {
+  public async clear(): Promise<void> {
+    if (!this.recreateInstance) {
+      throw new Error('clear() is not available for externally-managed IPC backends');
+    }
+    this.log.warn('Clearing world state: shutting down WSDB, deleting data, and recreating');
     await this.instance.close();
     this.cachedStatusSummary = undefined;
-    await tryRmDir(this.instance.getDataDir(), this.log);
-    this.instance = this.instance.clone();
+    this.instance = await this.recreateInstance();
+    await this.init();
+    this.log.info('World state cleared and reinitialized from genesis');
+  }
+
+  /** Returns the IPC path of the underlying IPC backend, if available. */
+  public getIpcPath(): string {
+    if (this.instance instanceof IpcWorldState) {
+      return this.instance.getIpcPath();
+    }
+    throw new Error('getIpcPath() is only available with IPC world state');
   }
 
   public getCommitted(): MerkleTreeReadOperations {
@@ -177,17 +243,16 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     blockNumber?: BlockNumber,
     opts: { closeDelayMs?: number } = {},
   ): Promise<MerkleTreeWriteOperations> {
-    const resp = await this.instance.call(WorldStateMessageType.CREATE_FORK, {
+    const forkId = await this.instance.createFork({
       latest: blockNumber === undefined,
       blockNumber: blockNumber ?? BlockNumber.ZERO,
-      canonical: true,
     });
     return new MerkleTreesForkFacade(
       this.instance,
       this.initialHeader!,
       new WorldStateRevision(
-        /*forkId=*/ resp.forkId,
-        /* blockNumber=*/ BlockNumber.ZERO,
+        /*forkId=*/ forkId,
+        /* blockNumber=*/ WorldStateRevision.LATEST,
         /* includeUncommitted=*/ true,
       ),
       opts,
@@ -230,35 +295,44 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     });
 
     try {
-      return await this.instance.call(
-        WorldStateMessageType.SYNC_BLOCK,
-        {
-          blockNumber: l2Block.number,
-          blockHeaderHash: await l2Block.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.sanitizeAndCacheSummaryFromFull.bind(this),
-        this.deleteCachedSummary.bind(this),
-      );
+      const status = await this.instance.syncBlock({
+        blockNumber: l2Block.number,
+        blockHeaderHash: (await l2Block.hash()).toBuffer(),
+        // Forwarded so the native sync verifies the archive root against canonical and rejects a divergent tree.
+        expectedArchiveRoot: l2Block.archive.root.toBuffer(),
+        expectedPreviousArchiveRoot: l2Block.header.lastArchive.root.toBuffer(),
+        paddedL1ToL2Messages: paddedL1ToL2Messages.map(serializeLeaf),
+        paddedNoteHashes: paddedNoteHashes.map(serializeLeaf),
+        paddedNullifiers: paddedNullifiers.map(serializeLeaf),
+        publicDataWrites: publicDataWrites.map(serializeLeaf),
+        blockStateRef: blockStateReference(l2Block.header.state),
+      });
+      return this.sanitizeAndCacheSummaryFromFull(status);
     } catch (err) {
+      this.deleteCachedSummary();
       this.worldStateInstrumentation.incCriticalErrors('synch_pending_block');
       throw err;
     }
   }
 
   public async close(): Promise<void> {
-    await this.instance.close();
-    await this.cleanup();
+    try {
+      await this.instance.close();
+    } finally {
+      await this.cleanup();
+    }
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.close();
   }
 
   private async buildInitialHeader(): Promise<BlockHeader> {
     const state = await this.getInitialStateReference();
-    return BlockHeader.empty({ state });
+    return BlockHeader.empty({
+      state,
+      globalVariables: GlobalVariables.empty({ timestamp: this.genesis.genesisTimestamp }),
+    });
   }
 
   private sanitizeAndCacheSummaryFromFull(response: WorldStateStatusFull) {
@@ -273,7 +347,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     return sanitized;
   }
 
-  private deleteCachedSummary(_: string) {
+  private deleteCachedSummary() {
     this.cachedStatusSummary = undefined;
   }
 
@@ -284,16 +358,9 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    */
   public async setFinalized(toBlockNumber: BlockNumber) {
     try {
-      await this.instance.call(
-        WorldStateMessageType.FINALIZE_BLOCKS,
-        {
-          toBlockNumber,
-          canonical: true,
-        },
-        this.sanitizeAndCacheSummary.bind(this),
-        this.deleteCachedSummary.bind(this),
-      );
+      this.sanitizeAndCacheSummary(await this.instance.finalizeBlocks(toBlockNumber));
     } catch (err) {
+      this.deleteCachedSummary();
       this.worldStateInstrumentation.incCriticalErrors('finalize_block');
       throw err;
     }
@@ -307,16 +374,9 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    */
   public async removeHistoricalBlocks(toBlockNumber: BlockNumber) {
     try {
-      return await this.instance.call(
-        WorldStateMessageType.REMOVE_HISTORICAL_BLOCKS,
-        {
-          toBlockNumber,
-          canonical: true,
-        },
-        this.sanitizeAndCacheSummaryFromFull.bind(this),
-        this.deleteCachedSummary.bind(this),
-      );
+      return this.sanitizeAndCacheSummaryFromFull(await this.instance.removeHistoricalBlocks(toBlockNumber));
     } catch (err) {
+      this.deleteCachedSummary();
       this.worldStateInstrumentation.incCriticalErrors('prune_historical_block');
       throw err;
     }
@@ -329,16 +389,9 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
    */
   public async unwindBlocks(toBlockNumber: BlockNumber) {
     try {
-      return await this.instance.call(
-        WorldStateMessageType.UNWIND_BLOCKS,
-        {
-          toBlockNumber,
-          canonical: true,
-        },
-        this.sanitizeAndCacheSummaryFromFull.bind(this),
-        this.deleteCachedSummary.bind(this),
-      );
+      return this.sanitizeAndCacheSummaryFromFull(await this.instance.unwindBlocks(toBlockNumber));
     } catch (err) {
+      this.deleteCachedSummary();
       this.worldStateInstrumentation.incCriticalErrors('prune_pending_block');
       throw err;
     }
@@ -348,11 +401,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     if (this.cachedStatusSummary !== undefined) {
       return { ...this.cachedStatusSummary };
     }
-    return await this.instance.call(
-      WorldStateMessageType.GET_STATUS,
-      { canonical: true },
-      this.sanitizeAndCacheSummary.bind(this),
-    );
+    return this.sanitizeAndCacheSummary(await this.instance.getStatus());
   }
 
   updateLeaf<ID extends IndexedTreeId>(
@@ -364,14 +413,14 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   }
 
   private async getInitialStateReference(): Promise<StateReference> {
-    const resp = await this.instance.call(WorldStateMessageType.GET_INITIAL_STATE_REFERENCE, { canonical: true });
+    const state = await this.instance.getInitialStateReference();
 
     return new StateReference(
-      treeStateReferenceToSnapshot(resp.state[MerkleTreeId.L1_TO_L2_MESSAGE_TREE]),
+      treeStateReferenceToSnapshot(state[MerkleTreeId.L1_TO_L2_MESSAGE_TREE]),
       new PartialStateReference(
-        treeStateReferenceToSnapshot(resp.state[MerkleTreeId.NOTE_HASH_TREE]),
-        treeStateReferenceToSnapshot(resp.state[MerkleTreeId.NULLIFIER_TREE]),
-        treeStateReferenceToSnapshot(resp.state[MerkleTreeId.PUBLIC_DATA_TREE]),
+        treeStateReferenceToSnapshot(state[MerkleTreeId.NOTE_HASH_TREE]),
+        treeStateReferenceToSnapshot(state[MerkleTreeId.NULLIFIER_TREE]),
+        treeStateReferenceToSnapshot(state[MerkleTreeId.PUBLIC_DATA_TREE]),
       ),
     );
   }
@@ -380,11 +429,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     dstPath: string,
     compact: boolean = true,
   ): Promise<Record<Exclude<SnapshotDataKeys, 'archiver'>, string>> {
-    await this.instance.call(WorldStateMessageType.COPY_STORES, {
-      dstPath,
-      compact,
-      canonical: true,
-    });
+    await this.instance.copyStores(dstPath, compact);
     return fromEntries(NATIVE_WORLD_STATE_DBS.map(([name, dir]) => [name, join(dstPath, dir, 'data.mdb')] as const));
   }
 }