@aztec/simulator 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/src/public/cdb/generated/server.ts

@@ -0,0 +1,109 @@
+// AUTOGENERATED FILE - DO NOT EDIT
+// Server-side dispatch for IPC protocol
+
+import { Decoder, Encoder } from 'msgpackr';
+import type { CdbAddContracts, CdbAddContractsResponse, CdbCommitCheckpoint, CdbCommitCheckpointResponse, CdbCreateCheckpoint, CdbCreateCheckpointResponse, CdbGetBytecodeCommitment, CdbGetBytecodeCommitmentResponse, CdbGetContractClass, CdbGetContractClassResponse, CdbGetContractInstance, CdbGetContractInstanceResponse, CdbGetDebugFunctionName, CdbGetDebugFunctionNameResponse, CdbRevertCheckpoint, CdbRevertCheckpointResponse } from './api_types.js';
+import { fromCdbAddContractsResponse, fromCdbCommitCheckpointResponse, fromCdbCreateCheckpointResponse, fromCdbGetBytecodeCommitmentResponse, fromCdbGetContractClassResponse, fromCdbGetContractInstanceResponse, fromCdbGetDebugFunctionNameResponse, fromCdbRevertCheckpointResponse, toCdbAddContracts, toCdbCommitCheckpoint, toCdbCreateCheckpoint, toCdbGetBytecodeCommitment, toCdbGetContractClass, toCdbGetContractInstance, toCdbGetDebugFunctionName, toCdbRevertCheckpoint } from './api_types.js';
+
+/** Handler interface — implement this to serve commands. */
+export interface Handler {
+  getContractInstance(command: CdbGetContractInstance): Promise<CdbGetContractInstanceResponse>;
+  getContractClass(command: CdbGetContractClass): Promise<CdbGetContractClassResponse>;
+  getBytecodeCommitment(command: CdbGetBytecodeCommitment): Promise<CdbGetBytecodeCommitmentResponse>;
+  getDebugFunctionName(command: CdbGetDebugFunctionName): Promise<CdbGetDebugFunctionNameResponse>;
+  addContracts(command: CdbAddContracts): Promise<CdbAddContractsResponse>;
+  createCheckpoint(command: CdbCreateCheckpoint): Promise<CdbCreateCheckpointResponse>;
+  commitCheckpoint(command: CdbCommitCheckpoint): Promise<CdbCommitCheckpointResponse>;
+  revertCheckpoint(command: CdbRevertCheckpoint): Promise<CdbRevertCheckpointResponse>;
+}
+
+/**
+ * Dispatch a [commandName, payload] pair to the handler.
+ * Returns [responseName, responsePayload] for serialization.
+ * Handler failures are wrapped into the schema error variant.
+ */
+export async function dispatch(
+  handler: Handler,
+  commandName: string,
+  payload: any,
+): Promise<[string, any]> {
+  try {
+    switch (commandName) {
+      case 'CdbGetContractInstance': {
+        const cmd = toCdbGetContractInstance(payload);
+        const result = await handler.getContractInstance(cmd);
+        return ['CdbGetContractInstanceResponse', fromCdbGetContractInstanceResponse(result)];
+      }
+      case 'CdbGetContractClass': {
+        const cmd = toCdbGetContractClass(payload);
+        const result = await handler.getContractClass(cmd);
+        return ['CdbGetContractClassResponse', fromCdbGetContractClassResponse(result)];
+      }
+      case 'CdbGetBytecodeCommitment': {
+        const cmd = toCdbGetBytecodeCommitment(payload);
+        const result = await handler.getBytecodeCommitment(cmd);
+        return ['CdbGetBytecodeCommitmentResponse', fromCdbGetBytecodeCommitmentResponse(result)];
+      }
+      case 'CdbGetDebugFunctionName': {
+        const cmd = toCdbGetDebugFunctionName(payload);
+        const result = await handler.getDebugFunctionName(cmd);
+        return ['CdbGetDebugFunctionNameResponse', fromCdbGetDebugFunctionNameResponse(result)];
+      }
+      case 'CdbAddContracts': {
+        const cmd = toCdbAddContracts(payload);
+        const result = await handler.addContracts(cmd);
+        return ['CdbAddContractsResponse', fromCdbAddContractsResponse(result)];
+      }
+      case 'CdbCreateCheckpoint': {
+        const cmd = toCdbCreateCheckpoint(payload);
+        const result = await handler.createCheckpoint(cmd);
+        return ['CdbCreateCheckpointResponse', fromCdbCreateCheckpointResponse(result)];
+      }
+      case 'CdbCommitCheckpoint': {
+        const cmd = toCdbCommitCheckpoint(payload);
+        const result = await handler.commitCheckpoint(cmd);
+        return ['CdbCommitCheckpointResponse', fromCdbCommitCheckpointResponse(result)];
+      }
+      case 'CdbRevertCheckpoint': {
+        const cmd = toCdbRevertCheckpoint(payload);
+        const result = await handler.revertCheckpoint(cmd);
+        return ['CdbRevertCheckpointResponse', fromCdbRevertCheckpointResponse(result)];
+      }
+      default:
+        return ['CdbErrorResponse', { message: `Unknown command: ${commandName}` }];
+    }
+  } catch (err: any) {
+    return ['CdbErrorResponse', { message: err?.message ?? String(err) }];
+  }
+}
+
+const requestDecoder = new Decoder({ useRecords: false });
+const responseEncoder = new Encoder({ useRecords: false, variableMapSize: true });
+
+/**
+ * Decode a framed request, dispatch it, and encode the framed response.
+ * All failures (malformed framing included) produce a decodable error
+ * variant rather than a throw, so transports can use this directly as
+ * their request handler.
+ */
+export async function handleRequest(
+  handler: Handler,
+  requestBytes: Uint8Array,
+): Promise<Uint8Array> {
+  let commandName: string;
+  let payload: any;
+  try {
+    const request = requestDecoder.unpack(requestBytes) as [[string, any]];
+    [[commandName, payload]] = request;
+    if (typeof commandName !== 'string') {
+      throw new Error('expected [name, payload] request framing');
+    }
+  } catch (err: any) {
+    return responseEncoder.pack([
+      'CdbErrorResponse',
+      { message: `Malformed request: ${err?.message ?? String(err)}` },
+    ]);
+  }
+  const [respName, respPayload] = await dispatch(handler, commandName, payload ?? {});
+  return responseEncoder.pack([respName, respPayload]);
+}

package/src/public/cdb_ipc_server.ts

@@ -0,0 +1,197 @@
+/**
+ * UDS server for AVM CDB requests.
+ *
+ * Transport (socket, framing, per-connection response ordering) is handled by the shared
+ * `UdsIpcServer` from `@aztec/ipc-runtime`; message dispatch comes from the generated CDB
+ * server. This class only implements the generated handler interface and routes requests to
+ * PublicContractsDB instances by fork ID.
+ */
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { UdsIpcServer } from '@aztec/ipc-runtime';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { ContractDeploymentData, type ContractInstanceWithAddress } from '@aztec/stdlib/contract';
+
+import { Decoder, Encoder } from 'msgpackr';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { threadId } from 'node:worker_threads';
+
+import type {
+  CdbAddContracts,
+  CdbAddContractsResponse,
+  CdbCommitCheckpoint,
+  CdbCommitCheckpointResponse,
+  CdbCreateCheckpoint,
+  CdbCreateCheckpointResponse,
+  CdbGetBytecodeCommitment,
+  CdbGetBytecodeCommitmentResponse,
+  CdbGetContractClass,
+  CdbGetContractClassResponse,
+  CdbGetContractInstance,
+  CdbGetContractInstanceResponse,
+  CdbGetDebugFunctionName,
+  CdbGetDebugFunctionNameResponse,
+  CdbRevertCheckpoint,
+  CdbRevertCheckpointResponse,
+} from './cdb/generated/api_types.js';
+import { type Handler as CdbHandler, handleRequest } from './cdb/generated/server.js';
+import type { PublicContractsDB } from './public_db_sources.js';
+
+const encoder = new Encoder({ useRecords: false });
+const decoder = new Decoder({ useRecords: false });
+
+let instanceCounter = 0;
+
+function toFieldBuffer(field: Fr | AztecAddress): Buffer {
+  return field.toBuffer();
+}
+
+/** Serializes contract instances to the AVM CDB wire shape. */
+export function serializeContractInstance(instance: ContractInstanceWithAddress): Record<string, unknown> {
+  return {
+    salt: toFieldBuffer(instance.salt),
+    deployer: toFieldBuffer(instance.deployer),
+    currentContractClassId: toFieldBuffer(instance.currentContractClassId),
+    originalContractClassId: toFieldBuffer(instance.originalContractClassId),
+    initializationHash: toFieldBuffer(instance.initializationHash),
+    immutablesHash: toFieldBuffer(instance.immutablesHash),
+    publicKeys: {
+      npkMHash: toFieldBuffer(instance.publicKeys.npkMHash),
+      ivpkM: {
+        x: toFieldBuffer(instance.publicKeys.ivpkM.x),
+        y: toFieldBuffer(instance.publicKeys.ivpkM.y),
+      },
+      ovpkMHash: toFieldBuffer(instance.publicKeys.ovpkMHash),
+      tpkMHash: toFieldBuffer(instance.publicKeys.tpkMHash),
+      mspkMHash: toFieldBuffer(instance.publicKeys.mspkMHash),
+      fbpkMHash: toFieldBuffer(instance.publicKeys.fbpkMHash),
+    },
+  };
+}
+
+/** Serializes contract classes to the AVM CDB wire shape. */
+function serializeContractClass(contractClass: {
+  id: Fr;
+  artifactHash: Fr;
+  privateFunctionsRoot: Fr;
+  packedBytecode: Buffer;
+}): Record<string, unknown> {
+  return {
+    id: toFieldBuffer(contractClass.id),
+    artifactHash: toFieldBuffer(contractClass.artifactHash),
+    privateFunctionsRoot: toFieldBuffer(contractClass.privateFunctionsRoot),
+    packedBytecode: contractClass.packedBytecode,
+  };
+}
+
+/** Routes AVM CDB IPC requests to registered PublicContractsDB forks. */
+export class CdbIpcServer implements CdbHandler {
+  public readonly ipcPath: string;
+  private server: Promise<UdsIpcServer>;
+  private log: Logger;
+  /** Maps WSDB fork IDs to contracts DB/timestamp pairs for concurrent simulations. */
+  private forks = new Map<number, { db: PublicContractsDB; timestamp: bigint }>();
+
+  constructor() {
+    this.log = createLogger('cdb-ipc-server');
+    this.ipcPath = path.join(os.tmpdir(), `cdb-ts-${process.pid}-${threadId}-${instanceCounter++}.sock`);
+
+    // Listen asynchronously; the C++ AVM retries connecting until the socket is up.
+    this.server = UdsIpcServer.listen(this.ipcPath, (_clientId, request) => handleRequest(this, request));
+    this.server.then(
+      () => this.log.debug(`CDB IPC server listening on ${this.ipcPath}`),
+      err => this.log.error(`CDB IPC server failed to listen on ${this.ipcPath}`, { err }),
+    );
+  }
+
+  /** Register a PublicContractsDB for a given WSDB fork ID. */
+  registerFork(forkId: number, contractsDB: PublicContractsDB, timestamp: bigint): void {
+    this.forks.set(forkId, { db: contractsDB, timestamp });
+  }
+
+  /** Unregister a fork's contracts DB (call after simulation completes). */
+  unregisterFork(forkId: number): void {
+    this.forks.delete(forkId);
+  }
+
+  /** Close the server and all active connections. */
+  async close(): Promise<void> {
+    const server = await this.server.catch(() => undefined);
+    await server?.close();
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.close();
+  }
+
+  /** Look up the contracts DB for a given fork ID, throwing if not registered. */
+  private getFork(forkId: number): { db: PublicContractsDB; timestamp: bigint } {
+    const fork = this.forks.get(forkId);
+    if (!fork) {
+      const registered = Array.from(this.forks.keys()).sort((a, b) => a - b);
+      throw new Error(
+        `CDB server: no contracts DB registered for forkId ${forkId} (registered=[${registered.join(',')}])`,
+      );
+    }
+    return fork;
+  }
+
+  async getContractInstance(command: CdbGetContractInstance): Promise<CdbGetContractInstanceResponse> {
+    const { db, timestamp } = this.getFork(command.forkId);
+    const address = AztecAddress.fromBuffer(Buffer.from(command.address));
+    const instance = await db.getContractInstance(address, timestamp);
+    return { instance: instance ? encoder.encode(serializeContractInstance(instance)) : null };
+  }
+
+  async getContractClass(command: CdbGetContractClass): Promise<CdbGetContractClassResponse> {
+    const { db } = this.getFork(command.forkId);
+    const classId = Fr.fromBuffer(Buffer.from(command.classId));
+    const contractClass = await db.getContractClass(classId);
+    return { contractClass: contractClass ? encoder.encode(serializeContractClass(contractClass)) : null };
+  }
+
+  async getBytecodeCommitment(command: CdbGetBytecodeCommitment): Promise<CdbGetBytecodeCommitmentResponse> {
+    const { db } = this.getFork(command.forkId);
+    const classId = Fr.fromBuffer(Buffer.from(command.classId));
+    const commitment = await db.getBytecodeCommitment(classId);
+    return { commitment: commitment ? toFieldBuffer(commitment) : null };
+  }
+
+  async getDebugFunctionName(command: CdbGetDebugFunctionName): Promise<CdbGetDebugFunctionNameResponse> {
+    const { db } = this.getFork(command.forkId);
+    const address = AztecAddress.fromBuffer(Buffer.from(command.address));
+    const selectorField = Fr.fromBuffer(Buffer.from(command.selector));
+    const selector = FunctionSelector.fromFieldOrUndefined(selectorField);
+    const name = selector ? await db.getDebugFunctionName(address, selector) : undefined;
+    return { name: name ?? null };
+  }
+
+  addContracts(command: CdbAddContracts): Promise<CdbAddContractsResponse> {
+    const { db } = this.getFork(command.forkId);
+    const contractDeploymentData = ContractDeploymentData.fromPlainObject(
+      decoder.decode(command.contractDeploymentData),
+    );
+    db.addContractsFromLogs(contractDeploymentData);
+    return Promise.resolve({});
+  }
+
+  createCheckpoint(command: CdbCreateCheckpoint): Promise<CdbCreateCheckpointResponse> {
+    const { db } = this.getFork(command.forkId);
+    db.createCheckpoint();
+    return Promise.resolve({});
+  }
+
+  commitCheckpoint(command: CdbCommitCheckpoint): Promise<CdbCommitCheckpointResponse> {
+    const { db } = this.getFork(command.forkId);
+    db.commitCheckpoint();
+    return Promise.resolve({});
+  }
+
+  revertCheckpoint(command: CdbRevertCheckpoint): Promise<CdbRevertCheckpointResponse> {
+    const { db } = this.getFork(command.forkId);
+    db.revertCheckpoint();
+    return Promise.resolve({});
+  }
+}

package/src/public/fixtures/amm_test.ts

@@ -25,8 +25,8 @@ export async function ammTest(
 ) {
   const timer = new Timer();
 
-  const admin = AztecAddress.fromNumber(42);
-  const sender = AztecAddress.fromNumber(111);
+  const admin = AztecAddress.fromNumberUnsafe(42);
+  const sender = AztecAddress.fromNumberUnsafe(111);
 
   logger.debug(`Deploying tokens`);
   const token0 = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 0);

package/src/public/fixtures/bulk_test.ts

@@ -13,7 +13,7 @@ export async function bulkTest(
 ) {
   const timer = new Timer();
 
-  const deployer = AztecAddress.fromNumber(42);
+  const deployer = AztecAddress.fromNumberUnsafe(42);
   const avmTestContract = await tester.registerAndDeployContract(
     /*constructorArgs=*/ [],
     deployer,
@@ -114,7 +114,7 @@ export async function megaBulkTest(
 ) {
   const timer = new Timer();
 
-  const deployer = AztecAddress.fromNumber(42);
+  const deployer = AztecAddress.fromNumberUnsafe(42);
   const avmTestContract = await tester.registerAndDeployContract(
     /*constructorArgs=*/ [],
     deployer,

package/src/public/fixtures/custom_bytecode_tester.ts

@@ -17,7 +17,7 @@ export async function deployCustomBytecode(
   bytecode: Buffer,
   tester: PublicTxSimulationTester,
   contractName: string = 'CustomBytecodeContract',
-  deployer: AztecAddress = AztecAddress.fromNumber(42),
+  deployer: AztecAddress = AztecAddress.fromNumberUnsafe(42),
 ): Promise<ContractInstanceWithAddress> {
   const contractArtifact = emptyContractArtifact();
   contractArtifact.name = contractName;
@@ -75,7 +75,7 @@ export async function deployAndExecuteCustomBytecode(
   tester: PublicTxSimulationTester,
   txLabel: string = 'CustomBytecodeTest',
   contractName: string = 'CustomBytecodeContract',
-  deployer: AztecAddress = AztecAddress.fromNumber(42),
+  deployer: AztecAddress = AztecAddress.fromNumberUnsafe(42),
   calldata: any[] = [],
 ): Promise<PublicTxResult> {
   const testContract = await deployCustomBytecode(bytecode, tester, contractName, deployer);

package/src/public/fixtures/index.ts

@@ -1,4 +1,5 @@
 export * from './public_tx_simulation_tester.js';
+export * from './public_processor_test_env.js';
 export * from './utils.js';
 export * from './simple_contract_data_source.js';
 export { TestExecutorMetrics } from '../test_executor_metrics.js';

package/src/public/fixtures/public_processor_test_env.ts

@@ -0,0 +1,88 @@
+import { createLogger } from '@aztec/foundation/log';
+import { TestDateProvider } from '@aztec/foundation/timer';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
+import { GasFees } from '@aztec/stdlib/gas';
+import { GlobalVariables } from '@aztec/stdlib/tx';
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { NativeWorldStateService } from '@aztec/world-state';
+
+import { AvmSimulatorPool } from '../avm_simulator_pool.js';
+import { PublicContractsDB } from '../public_db_sources.js';
+import { GuardedMerkleTreeOperations } from '../public_processor/guarded_merkle_tree.js';
+import { PublicProcessor } from '../public_processor/public_processor.js';
+import { PublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
+import { PublicTxSimulationTester } from './public_tx_simulation_tester.js';
+import { SimpleContractDataSource } from './simple_contract_data_source.js';
+
+/** Options for {@link PublicProcessorTestEnv.create}. */
+export interface PublicProcessorTestEnvOptions {
+  /** Global variables shared by the processor and the tester. Defaults to empty with nonzero gas fees. */
+  globals?: GlobalVariables;
+  /** Simulator config for the processor's PublicTxSimulator. */
+  config?: Partial<PublicSimulatorConfig>;
+}
+
+function defaultGlobals(): GlobalVariables {
+  const globals = GlobalVariables.empty();
+  globals.gasFees = new GasFees(2, 3);
+  return globals;
+}
+
+const defaultConfig = PublicSimulatorConfig.from({
+  skipFeeEnforcement: false,
+  collectDebugLogs: true,
+  collectHints: false,
+  collectStatistics: false,
+  collectCallMetadata: true,
+});
+
+/**
+ * Bundles the real-AVM wiring shared by public-processor app tests: a live WSDB world state, a CDB IPC
+ * server, a spawned AVM simulator, a {@link PublicProcessor} backed by all three, and a setup-only
+ * {@link PublicTxSimulationTester} sharing the same fork and contract data source for building txs and
+ * seeding balances. Own it with `await using`, or call {@link Symbol.asyncDispose} from `afterEach`.
+ */
+export class PublicProcessorTestEnv implements AsyncDisposable {
+  private constructor(
+    public readonly processor: PublicProcessor,
+    public readonly tester: PublicTxSimulationTester,
+    public readonly contractsDB: PublicContractsDB,
+    public readonly globals: GlobalVariables,
+    private readonly worldStateService: NativeWorldStateService,
+    private readonly avmSimulator: AvmSimulatorPool,
+  ) {}
+
+  static async create(opts: PublicProcessorTestEnvOptions = {}): Promise<PublicProcessorTestEnv> {
+    const globals = opts.globals ?? defaultGlobals();
+    const config = opts.config ? PublicSimulatorConfig.from({ ...defaultConfig, ...opts.config }) : defaultConfig;
+
+    const contractDataSource = new SimpleContractDataSource();
+    const worldStateService = await NativeWorldStateService.tmp();
+    const merkleTrees = await worldStateService.fork();
+    const contractsDB = new PublicContractsDB(contractDataSource);
+
+    const forkId = merkleTrees.getRevision().forkId;
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
+
+    const simulator = new PublicTxSimulator(avmSimulator, globals, contractsDB, forkId, config, undefined);
+    const processor = new PublicProcessor(
+      globals,
+      new GuardedMerkleTreeOperations(merkleTrees),
+      contractsDB,
+      simulator,
+      new TestDateProvider(),
+      getTelemetryClient(),
+      createLogger('simulator:public-processor'),
+    );
+
+    const tester = new PublicTxSimulationTester(merkleTrees, contractDataSource, globals);
+
+    return new PublicProcessorTestEnv(processor, tester, contractsDB, globals, worldStateService, avmSimulator);
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.avmSimulator[Symbol.asyncDispose]();
+    await this.tester.close();
+    await this.worldStateService.close();
+  }
+}

package/src/public/fixtures/public_tx_simulation_tester.ts

@@ -5,7 +5,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 import { type ContractArtifact, encodeArguments } from '@aztec/stdlib/abi';
 import { PublicSimulatorConfig, type PublicTxResult } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { FALLBACK_TEARDOWN_DA_GAS_LIMIT, FALLBACK_TEARDOWN_L2_GAS_LIMIT, Gas, GasFees } from '@aztec/stdlib/gas';
+import { Gas, GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
 import { PublicCallRequest } from '@aztec/stdlib/kernel';
 import { GlobalVariables, PublicCallRequestWithCalldata, type Tx } from '@aztec/stdlib/tx';
@@ -18,6 +18,7 @@ import {
   getContractFunctionAbi,
   getFunctionSelector,
 } from '../avm/testing/utils.js';
+import { AvmSimulatorPool } from '../avm_simulator_pool.js';
 import { PublicContractsDB } from '../public_db_sources.js';
 import { MeasuredPublicTxSimulator } from '../public_tx_simulator/public_tx_simulator.js';
 import type { MeasuredPublicTxSimulatorInterface } from '../public_tx_simulator/public_tx_simulator_interface.js';
@@ -26,6 +27,8 @@ import { SimpleContractDataSource } from './simple_contract_data_source.js';
 import { type TestPrivateInsertions, createTxForPublicCalls } from './utils.js';
 
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
+const TEARDOWN_DA_GAS_LIMIT = 98_304;
+const TEARDOWN_L2_GAS_LIMIT = 817_500;
 
 export type TestEnqueuedCall = {
   sender?: AztecAddress;
@@ -63,8 +66,9 @@ export type MeasuredSimulatorFactory = (
  */
 export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   protected txCount: number = 0;
-  private simulator: MeasuredPublicTxSimulatorInterface;
+  private simulator: MeasuredPublicTxSimulatorInterface | undefined;
   private metricsPrefix?: string;
+  protected avmSimulator?: AvmSimulatorPool;
 
   constructor(
     merkleTree: MerkleTreeWriteOperations,
@@ -80,7 +84,9 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     if (simulatorFactory) {
       this.simulator = simulatorFactory(merkleTree, contractsDB, globals, this.metrics, config);
     } else {
-      this.simulator = new MeasuredPublicTxSimulator(merkleTree, contractsDB, globals, this.metrics, config);
+      // No simulator — this tester can only be used for setup (setFeePayerBalance, createTx, etc.)
+      // To simulate, use PublicTxSimulationTester.create() or pass a simulatorFactory.
+      this.simulator = undefined;
     }
   }
 
@@ -92,9 +98,21 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
   ): Promise<PublicTxSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTree = await worldStateService.fork();
+
+    const avmSimulator = await AvmSimulatorPool.spawn({ wsdbIpcPath: worldStateService.getIpcPath() });
     const simulatorFactory: MeasuredSimulatorFactory = (mt, cdb, g, m, c) =>
-      new MeasuredPublicTxSimulator(mt, cdb, g, m, c);
-    return new PublicTxSimulationTester(merkleTree, contractDataSource, globals, metrics, simulatorFactory, config);
+      new MeasuredPublicTxSimulator(avmSimulator, g, cdb, mt.getRevision().forkId, m, c, undefined);
+
+    const tester = new PublicTxSimulationTester(
+      merkleTree,
+      contractDataSource,
+      globals,
+      metrics,
+      simulatorFactory,
+      config,
+    );
+    tester.avmSimulator = avmSimulator;
+    return tester;
   }
 
   public setMetricsPrefix(prefix: string) {
@@ -129,10 +147,7 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCallRequest,
       feePayer,
       /*gasUsedByPrivate*/ teardownCall
-        ? new Gas(
-            FALLBACK_TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD,
-            FALLBACK_TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD,
-          )
+        ? new Gas(TEARDOWN_DA_GAS_LIMIT + TX_DA_GAS_OVERHEAD, TEARDOWN_L2_GAS_LIMIT + PUBLIC_TX_L2_GAS_OVERHEAD)
         : new Gas(TX_DA_GAS_OVERHEAD, PUBLIC_TX_L2_GAS_OVERHEAD),
       defaultGlobals(),
       gasLimits,
@@ -164,8 +179,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     }
     const avmResult = await this.simulator.simulate(tx, fullTxLabel);
 
-    await this.#recordBytecodeSizes(fullTxLabel, [...setupCalls, ...appCalls, ...(teardownCall ? [teardownCall] : [])]);
-
     // Something like this is often useful for debugging:
     //if (avmResult.revertReason) {
     //  // resolve / enrich revert reason
@@ -195,18 +208,8 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     teardownCall?: TestEnqueuedCall,
     feePayer?: AztecAddress,
     privateInsertions?: TestPrivateInsertions,
-    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
-    return await this.simulateTx(
-      sender,
-      setupCalls,
-      appCalls,
-      teardownCall,
-      feePayer,
-      privateInsertions,
-      txLabel,
-      gasLimits,
-    );
+    return await this.simulateTx(sender, setupCalls, appCalls, teardownCall, feePayer, privateInsertions, txLabel);
   }
 
   /**
@@ -224,7 +227,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     teardownCall?: TestEnqueuedCall,
     feePayer?: AztecAddress,
     privateInsertions?: TestPrivateInsertions,
-    gasLimits?: Gas,
   ): Promise<PublicTxResult> {
     return await this.simulateTxWithLabel(
       txLabel,
@@ -234,7 +236,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
       teardownCall,
       feePayer,
       privateInsertions,
-      gasLimits,
     );
   }
 
@@ -242,22 +243,31 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
     this.metrics.prettyPrint();
   }
 
+  /** Clean up IPC resources (AVM simulator pool and merkle tree fork) created by create(). */
+  public async close(): Promise<void> {
+    await this.avmSimulator?.[Symbol.asyncDispose]();
+    // Close the merkle tree fork to release IPC resources before the wsdb process is killed.
+    if (this.merkleTrees?.close) {
+      await this.merkleTrees.close().catch(() => {});
+    }
+  }
+
   /**
    * Cancel the current simulation if one is in progress.
-   * This signals the underlying simulator (e.g., C++) to stop at the next safe point.
+   * This signals the underlying simulator to stop at the next safe point.
    * Safe to call even if no simulation is in progress.
    *
    * @param waitTimeoutMs - If provided, wait up to this many ms for the simulation to actually stop.
    */
   public async cancel(waitTimeoutMs?: number): Promise<void> {
-    await this.simulator.cancel?.(waitTimeoutMs);
+    await this.simulator?.cancel?.(waitTimeoutMs);
   }
 
   /**
    * Get the underlying simulator for advanced test scenarios.
    * Use this when you need direct control over simulation (e.g., for testing cancellation).
    */
-  public getSimulator(): MeasuredPublicTxSimulatorInterface {
+  public getSimulator(): MeasuredPublicTxSimulatorInterface | undefined {
     return this.simulator;
   }
 
@@ -294,27 +304,6 @@ export class PublicTxSimulationTester extends BaseAvmSimulationTester {
 
     return new PublicCallRequestWithCalldata(request, calldata);
   }
-
-  // WARNING: Deduplicates by artifact name, so two different artifacts with the same name
-  // in a single tx would only record the first one's bytecode size.
-  async #recordBytecodeSizes(txLabel: string, calls: TestEnqueuedCall[]) {
-    const seenArtifactNames = new Set<string>();
-    for (const call of calls) {
-      const artifact = await this.contractDataSource.getContractArtifact(call.address);
-      if (!artifact || seenArtifactNames.has(artifact.name)) {
-        continue;
-      }
-      seenArtifactNames.add(artifact.name);
-      const instance = await this.contractDataSource.getContract(call.address);
-      if (!instance) {
-        continue;
-      }
-      const contractClass = await this.contractDataSource.getContractClass(instance.currentContractClassId);
-      if (contractClass) {
-        this.metrics.recordBytecodeSize(txLabel, artifact.name, contractClass.packedBytecode.length);
-      }
-    }
-  }
 }
 
 export function defaultGlobals() {

package/src/public/fixtures/token_test.ts

@@ -21,9 +21,9 @@ export async function tokenTest(
 ) {
   const timer = new Timer();
 
-  const admin = AztecAddress.fromNumber(42);
-  const sender = AztecAddress.fromNumber(111);
-  const receiver = AztecAddress.fromNumber(222);
+  const admin = AztecAddress.fromNumberUnsafe(42);
+  const sender = AztecAddress.fromNumberUnsafe(111);
+  const receiver = AztecAddress.fromNumberUnsafe(222);
 
   const token = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue);