@aztec/world-state 0.0.1-commit.2ed92850 → 0.0.1-commit.3100065

package/src/native/merkle_trees_facade.ts

@@ -4,6 +4,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { serializeToBuffer } from '@aztec/foundation/serialize';
 import { sleep } from '@aztec/foundation/sleep';
 import { type IndexedTreeLeafPreimage, SiblingPath } from '@aztec/foundation/trees';
+import { BlockHash } from '@aztec/stdlib/block';
 import type {
   BatchInsertionResult,
   IndexedTreeId,
@@ -118,7 +119,7 @@ export class MerkleTreesFacade implements MerkleTreeReadOperations {
 
     const leaf = deserializeLeafValue(resp);
     if (leaf instanceof Fr) {
-      return leaf as any;
+      return treeId === MerkleTreeId.ARCHIVE ? (new BlockHash(leaf) as any) : (leaf as any);
     } else {
       return leaf.toBuffer() as any;
     }
@@ -207,6 +208,7 @@ export class MerkleTreesFacade implements MerkleTreeReadOperations {
 
 export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTreeWriteOperations {
   private log = createLogger('world-state:merkle-trees-fork-facade');
+  private closePromise: Promise<void> | undefined;
 
   constructor(
     instance: NativeWorldStateInstance,
@@ -228,7 +230,7 @@ export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTr
 
   async appendLeaves<ID extends MerkleTreeId>(treeId: ID, leaves: MerkleTreeLeafType<ID>[]): Promise<void> {
     await this.instance.call(WorldStateMessageType.APPEND_LEAVES, {
-      leaves: leaves.map(leaf => leaf as any),
+      leaves: leaves.map(leaf => serializeLeaf(hydrateLeaf(treeId, leaf as any))),
       forkId: this.revision.forkId,
       treeId,
     });
@@ -290,8 +292,17 @@ export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTr
     };
   }
 
-  public async close(): Promise<void> {
+  public close(): Promise<void> {
     assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
+    // Share the in-flight close promise across duplicate dispose calls so DELETE_FORK is sent at most once.
+    if (this.closePromise) {
+      return this.closePromise;
+    }
+    this.closePromise = this.doClose();
+    return this.closePromise;
+  }
+
+  private async doClose(): Promise<void> {
     try {
       await this.instance.call(WorldStateMessageType.DELETE_FORK, { forkId: this.revision.forkId });
     } catch (err: any) {
@@ -300,18 +311,21 @@ export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTr
       if (err?.message === 'Native instance is closed') {
         return;
       }
+      // Ignore "Fork not found": the native fork was already destroyed by a pending-chain unwind or a
+      // historical prune (both call C++ remove_forks_for_block). Fork IDs are monotonic and never reused,
+      // so swallowing this on close cannot mask a deletion of a different fork.
+      if (err?.message === 'Fork not found') {
+        return;
+      }
       throw err;
     }
   }
 
-  async [Symbol.dispose](): Promise<void> {
+  async [Symbol.asyncDispose](): Promise<void> {
     if (this.opts.closeDelayMs) {
       void sleep(this.opts.closeDelayMs)
         .then(() => this.close())
         .catch(err => {
-          if (err && 'message' in err && err.message === 'Native instance is closed') {
-            return; // Ignore errors due to native instance being closed
-          }
           this.log.warn('Error closing MerkleTreesForkFacade after delay', { err });
         });
     } else {
@@ -319,9 +333,10 @@ export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTr
     }
   }
 
-  public async createCheckpoint(): Promise<void> {
+  public async createCheckpoint(): Promise<number> {
     assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
-    await this.instance.call(WorldStateMessageType.CREATE_CHECKPOINT, { forkId: this.revision.forkId });
+    const resp = await this.instance.call(WorldStateMessageType.CREATE_CHECKPOINT, { forkId: this.revision.forkId });
+    return resp.depth;
   }
 
   public async commitCheckpoint(): Promise<void> {
@@ -334,20 +349,28 @@ export class MerkleTreesForkFacade extends MerkleTreesFacade implements MerkleTr
     await this.instance.call(WorldStateMessageType.REVERT_CHECKPOINT, { forkId: this.revision.forkId });
   }
 
-  public async commitAllCheckpoints(): Promise<void> {
+  public async commitAllCheckpointsTo(depth: number): Promise<void> {
     assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
-    await this.instance.call(WorldStateMessageType.COMMIT_ALL_CHECKPOINTS, { forkId: this.revision.forkId });
+    await this.instance.call(WorldStateMessageType.COMMIT_ALL_CHECKPOINTS, {
+      forkId: this.revision.forkId,
+      depth,
+    });
   }
 
-  public async revertAllCheckpoints(): Promise<void> {
+  public async revertAllCheckpointsTo(depth: number): Promise<void> {
     assert.notEqual(this.revision.forkId, 0, 'Fork ID must be set');
-    await this.instance.call(WorldStateMessageType.REVERT_ALL_CHECKPOINTS, { forkId: this.revision.forkId });
+    await this.instance.call(WorldStateMessageType.REVERT_ALL_CHECKPOINTS, {
+      forkId: this.revision.forkId,
+      depth,
+    });
   }
 }
 
-function hydrateLeaf<ID extends MerkleTreeId>(treeId: ID, leaf: Fr | Buffer) {
+function hydrateLeaf(treeId: MerkleTreeId, leaf: Fr | BlockHash | Buffer) {
   if (leaf instanceof Fr) {
     return leaf;
+  } else if (leaf instanceof BlockHash) {
+    return leaf.toFr();
   } else if (treeId === MerkleTreeId.NULLIFIER_TREE) {
     return NullifierLeaf.fromBuffer(leaf);
   } else if (treeId === MerkleTreeId.PUBLIC_DATA_TREE) {
@@ -357,8 +380,10 @@ function hydrateLeaf<ID extends MerkleTreeId>(treeId: ID, leaf: Fr | Buffer) {
   }
 }
 
-export function serializeLeaf(leaf: Fr | NullifierLeaf | PublicDataTreeLeaf): SerializedLeafValue {
-  if (leaf instanceof Fr) {
+export function serializeLeaf(leaf: Fr | BlockHash | NullifierLeaf | PublicDataTreeLeaf): SerializedLeafValue {
+  if (leaf instanceof BlockHash) {
+    return leaf.toBuffer();
+  } else if (leaf instanceof Fr) {
     return leaf.toBuffer();
   } else if (leaf instanceof NullifierLeaf) {
     return { nullifier: leaf.nullifier.toBuffer() };

package/src/native/message.ts

@@ -283,6 +283,16 @@ interface WithForkId {
   forkId: number;
 }
 
+interface CreateCheckpointResponse {
+  depth: number;
+}
+
+/** Request to commit/revert all checkpoints down to a target depth. The resulting depth after the operation equals the given depth. */
+interface CheckpointDepthRequest extends WithForkId {
+  /** The target depth after the operation. All checkpoints above this depth are committed/reverted. */
+  depth: number;
+}
+
 interface WithWorldStateRevision {
   revision: WorldStateRevision;
 }
@@ -412,7 +422,11 @@ interface UpdateArchiveRequest extends WithForkId {
 interface SyncBlockRequest extends WithCanonicalForkId {
   blockNumber: BlockNumber;
   blockStateRef: BlockStateReference;
-  blockHeaderHash: Fr;
+  blockHeaderHash: Buffer;
+  /** Canonical archive root after this block; world state rejects the sync if its computed root differs. */
+  expectedArchiveRoot: Buffer;
+  /** Canonical archive root before this block (the block's lastArchive); verified against the local root. */
+  expectedPreviousArchiveRoot: Buffer;
   paddedNoteHashes: readonly SerializedLeafValue[];
   paddedL1ToL2Messages: readonly SerializedLeafValue[];
   paddedNullifiers: readonly SerializedLeafValue[];
@@ -486,8 +500,8 @@ export type WorldStateRequest = {
   [WorldStateMessageType.CREATE_CHECKPOINT]: WithForkId;
   [WorldStateMessageType.COMMIT_CHECKPOINT]: WithForkId;
   [WorldStateMessageType.REVERT_CHECKPOINT]: WithForkId;
-  [WorldStateMessageType.COMMIT_ALL_CHECKPOINTS]: WithForkId;
-  [WorldStateMessageType.REVERT_ALL_CHECKPOINTS]: WithForkId;
+  [WorldStateMessageType.COMMIT_ALL_CHECKPOINTS]: CheckpointDepthRequest;
+  [WorldStateMessageType.REVERT_ALL_CHECKPOINTS]: CheckpointDepthRequest;
 
   [WorldStateMessageType.COPY_STORES]: CopyStoresRequest;
 
@@ -528,7 +542,7 @@ export type WorldStateResponse = {
 
   [WorldStateMessageType.GET_STATUS]: WorldStateStatusSummary;
 
-  [WorldStateMessageType.CREATE_CHECKPOINT]: void;
+  [WorldStateMessageType.CREATE_CHECKPOINT]: CreateCheckpointResponse;
   [WorldStateMessageType.COMMIT_CHECKPOINT]: void;
   [WorldStateMessageType.REVERT_CHECKPOINT]: void;
   [WorldStateMessageType.COMMIT_ALL_CHECKPOINTS]: void;

package/src/native/native_world_state.ts

@@ -4,9 +4,9 @@ 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, createLogger } from '@aztec/foundation/log';
+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,8 +14,8 @@ 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';
@@ -44,6 +44,29 @@ export const WORLD_STATE_DB_VERSION = 2; // The initial version
 
 export const WORLD_STATE_DIR = 'world_state';
 
+const DEFAULT_TMP_TREE_MAP_SIZE_KB = 10 * 1024 * 1024;
+
+/**
+ * Sets up a fresh `mkdtemp` directory + default `WorldStateTreeMapSizes` shared by both
+ * the `.tmp` (fsync-on) and `.ephemeral` (fsync-off) factories. Returns the raw tmpdir,
+ * the tree map sizes, and the package logger.
+ */
+async function createTmpWorldStateDir(
+  bindings?: LoggerBindings,
+): Promise<{ dataDir: string; wsTreeMapSizes: WorldStateTreeMapSizes; log: Logger }> {
+  const log = createLogger('world-state:database', bindings);
+  const dataDir = await mkdtemp(join(tmpdir(), 'aztec-world-state-'));
+  const wsTreeMapSizes: WorldStateTreeMapSizes = {
+    archiveTreeMapSizeKb: DEFAULT_TMP_TREE_MAP_SIZE_KB,
+    nullifierTreeMapSizeKb: DEFAULT_TMP_TREE_MAP_SIZE_KB,
+    noteHashTreeMapSizeKb: DEFAULT_TMP_TREE_MAP_SIZE_KB,
+    messageTreeMapSizeKb: DEFAULT_TMP_TREE_MAP_SIZE_KB,
+    publicDataTreeMapSizeKb: DEFAULT_TMP_TREE_MAP_SIZE_KB,
+  };
+  log.debug(`Created temporary world state database at: ${dataDir} (map size ${DEFAULT_TMP_TREE_MAP_SIZE_KB} KB)`);
+  return { dataDir, wsTreeMapSizes, log };
+}
+
 export class NativeWorldStateService implements MerkleTreeDatabase {
   protected initialHeader: BlockHeader | undefined;
   // This is read heavily and only changes when data is persisted, so we cache it
@@ -52,32 +75,47 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
   protected constructor(
     protected instance: NativeWorldState,
     protected readonly worldStateInstrumentation: WorldStateInstrumentation,
-    protected readonly log: Logger = createLogger('world-state:database'),
+    protected readonly log: Logger,
+    private readonly genesis: GenesisData = EMPTY_GENESIS_DATA,
     private readonly cleanup = () => Promise.resolve(),
   ) {}
 
+  /**
+   * Opens a persistent world state at `dataDir`. Goes through `DatabaseVersionManager` so the
+   * caller's rollup address is bound to the on-disk schema and incompatible versions surface
+   * loudly. The LMDB envs commit with full fsync.
+   */
   static async new(
     rollupAddress: EthAddress,
     dataDir: string,
     wsTreeMapSizes: WorldStateTreeMapSizes,
-    prefilledPublicData: PublicDataTreeLeaf[] = [],
+    genesis: GenesisData = EMPTY_GENESIS_DATA,
     instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
-    log = createLogger('world-state:database'),
+    bindings?: LoggerBindings,
     cleanup = () => Promise.resolve(),
   ): Promise<NativeWorldStateService> {
+    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));
-      },
+      onOpen: (dir: string) =>
+        Promise.resolve(
+          new NativeWorldState(
+            dir,
+            wsTreeMapSizes,
+            genesis,
+            instrumentation,
+            bindings,
+            undefined,
+            /*ephemeral=*/ false,
+          ),
+        ),
     });
 
     const [instance] = await versionManager.open();
-    const worldState = new this(instance, instrumentation, log, cleanup);
+    const worldState = new this(instance, instrumentation, log, genesis, cleanup);
     try {
       await worldState.init();
     } catch (e) {
@@ -88,25 +126,23 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
     return worldState;
   }
 
+  /**
+   * Opens a world state in a fresh tmpdir with full fsync semantics. Use when you need the
+   * on-disk file to remain crash-recoverable (e.g. for snapshot/backup tests) but don't
+   * want a persistent dataDir. Pass `cleanupTmpDir=false` to keep the directory after
+   * close for inspection.
+   *
+   * If you don't care about crash-recoverability — i.e. you just want a fast scratch
+   * database for tests — use {@link ephemeral} instead.
+   */
   static async tmp(
     rollupAddress = EthAddress.ZERO,
     cleanupTmpDir = true,
-    prefilledPublicData: PublicDataTreeLeaf[] = [],
+    genesis: GenesisData = EMPTY_GENESIS_DATA,
     instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
+    bindings?: LoggerBindings,
   ): Promise<NativeWorldStateService> {
-    const log = createLogger('world-state:database');
-    const dataDir = await mkdtemp(join(tmpdir(), 'aztec-world-state-'));
-    const dbMapSizeKb = 10 * 1024 * 1024;
-    const worldStateTreeMapSizes: WorldStateTreeMapSizes = {
-      archiveTreeMapSizeKb: dbMapSizeKb,
-      nullifierTreeMapSizeKb: dbMapSizeKb,
-      noteHashTreeMapSizeKb: dbMapSizeKb,
-      messageTreeMapSizeKb: dbMapSizeKb,
-      publicDataTreeMapSizeKb: dbMapSizeKb,
-    };
-    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 { dataDir, wsTreeMapSizes, log } = await createTmpWorldStateDir(bindings);
     const cleanup = async () => {
       if (cleanupTmpDir) {
         await rm(dataDir, { recursive: true, force: true, maxRetries: 3 });
@@ -115,8 +151,45 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
         log.debug(`Leaving temporary world state database: ${dataDir}`);
       }
     };
+    return this.new(rollupAddress, dataDir, wsTreeMapSizes, genesis, instrumentation, bindings, cleanup);
+  }
 
-    return this.new(rollupAddress, dataDir, worldStateTreeMapSizes, prefilledPublicData, instrumentation, log, cleanup);
+  /**
+   * Opens a fully-ephemeral world state. The directory is created in `os.tmpdir()`, the LMDB
+   * envs open with `MDB_NOSYNC | MDB_NOMETASYNC` so commits never block on fsync, and the
+   * directory is removed on dispose. A crash mid-write leaves the env unrecoverable.
+   *
+   * For unit tests and other isolated runs. Use {@link tmp} when you need fsync semantics in a
+   * tmp dir, and {@link new} for a persistent store. Skips {@link DatabaseVersionManager} —
+   * there is no on-disk schema to bind to and no rollup address is taken.
+   */
+  static async ephemeral(
+    genesis: GenesisData = EMPTY_GENESIS_DATA,
+    instrumentation = new WorldStateInstrumentation(getTelemetryClient()),
+    bindings?: LoggerBindings,
+  ): Promise<NativeWorldStateService> {
+    const { dataDir, wsTreeMapSizes, log } = await createTmpWorldStateDir(bindings);
+    const cleanup = async () => {
+      await rm(dataDir, { recursive: true, force: true, maxRetries: 3 });
+      log.debug(`Deleted ephemeral world state database: ${dataDir}`);
+    };
+    const instance = new NativeWorldState(
+      join(dataDir, WORLD_STATE_DIR),
+      wsTreeMapSizes,
+      genesis,
+      instrumentation,
+      bindings,
+      undefined,
+      /*ephemeral=*/ true,
+    );
+    const worldState = new this(instance, instrumentation, log, genesis, cleanup);
+    try {
+      await worldState.init();
+    } catch (e) {
+      log.error(`Error initializing ephemeral world state: ${e}`);
+      throw e;
+    }
+    return worldState;
   }
 
   protected async init() {
@@ -135,9 +208,7 @@ 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');
   }
@@ -175,7 +246,7 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
       this.initialHeader!,
       new WorldStateRevision(
         /*forkId=*/ resp.forkId,
-        /* blockNumber=*/ BlockNumber.ZERO,
+        /* blockNumber=*/ WorldStateRevision.LATEST,
         /* includeUncommitted=*/ true,
       ),
       opts,
@@ -222,7 +293,10 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
         WorldStateMessageType.SYNC_BLOCK,
         {
           blockNumber: l2Block.number,
-          blockHeaderHash: await l2Block.hash(),
+          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),
@@ -246,7 +320,10 @@ export class NativeWorldStateService implements MerkleTreeDatabase {
 
   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) {

package/src/native/native_world_state_instance.ts

@@ -1,6 +1,6 @@
 import {
   ARCHIVE_HEIGHT,
-  GeneratorIndex,
+  DomainSeparator,
   L1_TO_L2_MSG_TREE_HEIGHT,
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
@@ -8,10 +8,10 @@ import {
   NULLIFIER_TREE_HEIGHT,
   PUBLIC_DATA_TREE_HEIGHT,
 } from '@aztec/constants';
-import { type Logger, createLogger } from '@aztec/foundation/log';
+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 { EMPTY_GENESIS_DATA, type GenesisData } from '@aztec/stdlib/world-state';
 
 import assert from 'assert';
 import { cpus } from 'os';
@@ -55,17 +55,34 @@ export class NativeWorldState implements NativeWorldStateInstance {
   constructor(
     private readonly dataDir: string,
     private readonly wsTreeMapSizes: WorldStateTreeMapSizes,
-    private readonly prefilledPublicData: PublicDataTreeLeaf[] = [],
+    private readonly genesis: GenesisData = EMPTY_GENESIS_DATA,
     private readonly instrumentation: WorldStateInstrumentation,
-    private readonly log: Logger = createLogger('world-state:database'),
+    bindings?: LoggerBindings,
+    private readonly log: Logger = createLogger('world-state:database', bindings),
+    private readonly ephemeral: boolean = false,
   ) {
     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.`,
+      )} and ${threads} threads (ephemeral=${ephemeral}).`,
     );
-    const prefilledPublicDataBufferArray = prefilledPublicData.map(d => [d.slot.toBuffer(), d.value.toBuffer()]);
+    const prefilledPublicDataBufferArray = genesis.prefilledPublicData.map(d => [
+      d.slot.toBuffer(),
+      d.value.toBuffer(),
+    ]);
+    // Nullifiers to pre-insert into the genesis nullifier tree (empty by default, so production genesis roots are
+    // unchanged). The native indexed nullifier tree requires its prefilled leaves to be unique and strictly
+    // increasing, so we enforce that here before handing them over rather than failing deep inside the C++ tree
+    // construction.
+    const prefilledNullifiers = genesis.prefilledNullifiers ?? [];
+    for (let i = 1; i < prefilledNullifiers.length; i++) {
+      assert(
+        prefilledNullifiers[i].toBigInt() > prefilledNullifiers[i - 1].toBigInt(),
+        'Prefilled genesis nullifiers must be unique and strictly increasing',
+      );
+    }
+    const prefilledNullifiersBufferArray = prefilledNullifiers.map(n => n.toBuffer());
     const ws = new BaseNativeWorldState(
       dataDir,
       {
@@ -80,7 +97,9 @@ export class NativeWorldState implements NativeWorldStateInstance {
         [MerkleTreeId.PUBLIC_DATA_TREE]: 2 * MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
       },
       prefilledPublicDataBufferArray,
-      GeneratorIndex.BLOCK_HASH,
+      prefilledNullifiersBufferArray,
+      DomainSeparator.BLOCK_HEADER_HASH,
+      Number(genesis.genesisTimestamp),
       {
         [MerkleTreeId.NULLIFIER_TREE]: wsTreeMapSizes.nullifierTreeMapSizeKb,
         [MerkleTreeId.NOTE_HASH_TREE]: wsTreeMapSizes.noteHashTreeMapSizeKb,
@@ -89,6 +108,7 @@ export class NativeWorldState implements NativeWorldStateInstance {
         [MerkleTreeId.ARCHIVE]: wsTreeMapSizes.archiveTreeMapSizeKb,
       },
       threads,
+      ephemeral,
     );
     this.instance = new MsgpackChannel(ws);
     // Manually create the queue for the canonical fork
@@ -103,9 +123,11 @@ export class NativeWorldState implements NativeWorldStateInstance {
     return new NativeWorldState(
       this.dataDir,
       this.wsTreeMapSizes,
-      this.prefilledPublicData,
+      this.genesis,
       this.instrumentation,
+      this.log.getBindings(),
       this.log,
+      this.ephemeral,
     );
   }
 
@@ -178,30 +200,37 @@ export class NativeWorldState implements NativeWorldStateInstance {
       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);
+    // Enqueue the request and wait for the response. The per-fork queue is cleaned up in `finally` even on
+    // error, so the JS-side queues map cannot outlive the native fork (e.g. when the native fork was already
+    // destroyed by an unwind/historical-prune and DELETE_FORK rejects with "Fork not found").
+    let shouldDeleteForkQueue = false;
+    try {
+      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,
+      );
+      return response;
+    } catch (err: any) {
+      shouldDeleteForkQueue = forkId !== 0 && err?.message === 'Fork not found';
+      throw err;
+    } finally {
+      if (messageType === WorldStateMessageType.DELETE_FORK || shouldDeleteForkQueue) {
+        await requestQueue.stop();
+        this.queues.delete(forkId);
+      }
     }
-    return response;
   }
 
   /**

package/src/native/world_state_ops_queue.ts

@@ -96,7 +96,7 @@ export class WorldStateOpsQueue {
     // then send the request immediately
     // If a mutating request is in flight then we must wait
     // If a mutating request is not in flight but something is queued then it must be a mutating request
-    if (this.inFlightMutatingCount == 0 && this.requests.length == 0) {
+    if (this.inFlightMutatingCount === 0 && this.requests.length === 0) {
       this.sendEnqueuedRequest(op);
     } else {
       this.requests.push(op);
@@ -122,7 +122,7 @@ export class WorldStateOpsQueue {
     --this.inFlightCount;
 
     // If there are still requests in flight then do nothing further
-    if (this.inFlightCount != 0) {
+    if (this.inFlightCount !== 0) {
       return;
     }
 
@@ -134,7 +134,7 @@ export class WorldStateOpsQueue {
     while (this.requests.length > 0) {
       const next = this.requests[0];
       if (next.mutating) {
-        if (this.inFlightCount == 0) {
+        if (this.inFlightCount === 0) {
           // send the mutating request
           this.requests.shift();
           this.sendEnqueuedRequest(next);
@@ -149,7 +149,7 @@ export class WorldStateOpsQueue {
     }
 
     // If the queue is empty, there is nothing in flight and we have been told to stop, then resolve the stop promise
-    if (this.inFlightCount == 0 && this.stopResolve !== undefined) {
+    if (this.inFlightCount === 0 && this.stopResolve !== undefined) {
       this.stopResolve();
     }
   }
@@ -182,7 +182,7 @@ export class WorldStateOpsQueue {
     });
 
     // If no outstanding requests then immediately resolve the promise
-    if (this.requests.length == 0 && this.inFlightCount == 0 && this.stopResolve !== undefined) {
+    if (this.requests.length === 0 && this.inFlightCount === 0 && this.stopResolve !== undefined) {
       this.stopResolve();
     }
     return this.stopPromise;