@aztec/simulator 0.0.1-commit.993d52e → 0.0.1-commit.9a89641

package/src/public/avm_simulator_pool.ts

@@ -0,0 +1,226 @@
+import { AvmService } from '@aztec/bb-avm-sim';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import type { AvmContractsDBContext, AvmSimulator } from './avm_simulator.js';
+import { CdbIpcServer } from './cdb_ipc_server.js';
+
+export interface AvmSimulatorPoolOptions {
+  /** Maximum number of concurrent AVM processes. If not set, defaults to AVM_MAX_CONCURRENT_SIMULATIONS env var or 4. */
+  maxSize?: number;
+  /** Path to the bb-avm-sim binary. If omitted, the generated package resolves it. */
+  avmBinaryPath?: string;
+  /** IPC path for the shared WSDB server. */
+  wsdbIpcPath: string;
+  /** Optional logger function for AVM process output. */
+  logger?: (msg: string) => void;
+}
+
+/**
+ * A raw handle to a single bb-avm-sim process: it runs a serialized simulation and connects back to the
+ * shared CDB/WSDB servers for state, but is unaware of which fork's contract data it is reading — that is
+ * routed by the fork id baked into the input buffer.
+ */
+interface AvmProcessHandle {
+  simulate(inputBuffer: Uint8Array, signal?: AbortSignal): Promise<Uint8Array>;
+  simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array>;
+  destroy(): Promise<void>;
+}
+
+/**
+ * The public-execution AVM backend: a lazily-grown pool of bb-avm-sim processes plus the CDB server that
+ * answers those processes' contract-data callbacks. Callers hold this as an {@link AvmSimulator}; the pool,
+ * the CDB server, its IPC path, and fork-id routing are all hidden behind that interface. Each `simulate`
+ * registers the call's contracts DB on the CDB server for the duration of the simulation (keyed by fork id
+ * so concurrent simulations on different forks don't collide) and unregisters it once the call returns.
+ */
+export class AvmSimulatorPool implements AvmSimulator {
+  private slots: Array<AvmProcessHandle | null> = [];
+  private available: number[] = [];
+  private waiters: Array<{ resolve: (simulator: AvmProcessHandle) => void; reject: (error: Error) => void }> = [];
+  private createdCount = 0;
+  private log: Logger;
+  private maxSize: number;
+  private cdbServer: CdbIpcServer;
+
+  constructor(private options: AvmSimulatorPoolOptions) {
+    this.log = createLogger('simulator:avm-pool');
+    this.maxSize = options.maxSize ?? parseInt(process.env.AVM_MAX_CONCURRENT_SIMULATIONS ?? '4', 10);
+    this.cdbServer = new CdbIpcServer();
+  }
+
+  static async spawn(options: AvmSimulatorPoolOptions): Promise<AvmSimulatorPool> {
+    const pool = new AvmSimulatorPool(options);
+    // Always start one process up front so the first simulate() doesn't pay process spawn/connect cost.
+    await pool.prewarm();
+    return pool;
+  }
+
+  async [Symbol.asyncDispose](): Promise<void> {
+    await this.destroy();
+  }
+
+  async simulate(inputBuffer: Uint8Array, context: AvmContractsDBContext, signal?: AbortSignal): Promise<Uint8Array> {
+    // Register the fork's contracts DB so the C++ AVM's callbacks (which carry this fork id) route to it,
+    // and unregister once the simulation returns — registration is only needed while the call is running.
+    this.cdbServer.registerFork(context.forkId, context.contractsDB, context.timestamp);
+    try {
+      const simulator = await this.checkout();
+      try {
+        return await simulator.simulate(inputBuffer, signal);
+      } finally {
+        this.return(simulator);
+      }
+    } finally {
+      this.cdbServer.unregisterFork(context.forkId);
+    }
+  }
+
+  async simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array> {
+    // The hinted path makes no contract-data callbacks, so no CDB registration is needed.
+    const simulator = await this.checkout();
+    try {
+      return await simulator.simulateWithHints(inputBuffer);
+    } finally {
+      this.return(simulator);
+    }
+  }
+
+  /** Destroy all AVM processes in the pool and close the CDB server. */
+  async destroy(): Promise<void> {
+    for (const waiter of this.waiters) {
+      waiter.reject(new Error('AVM simulator pool destroyed'));
+    }
+    this.waiters = [];
+
+    const destroyPromises: Promise<void>[] = [];
+    for (const slot of this.slots) {
+      if (slot) {
+        destroyPromises.push(slot.destroy());
+      }
+    }
+    await Promise.all(destroyPromises);
+
+    this.slots = [];
+    this.available = [];
+    this.createdCount = 0;
+    await this.cdbServer.close();
+    this.log.info('AVM simulator pool destroyed');
+  }
+
+  /**
+   * Eagerly spawn up to `count` AVM processes (capped at maxSize) and leave them available, so the
+   * first simulate() doesn't pay process spawn/connect cost. Idempotent.
+   */
+  async prewarm(count = 1): Promise<void> {
+    const target = Math.min(count, this.maxSize);
+    const created: AvmProcessHandle[] = [];
+    while (this.createdCount < target) {
+      created.push(await this.createSlot());
+    }
+    // Hand the freshly-spawned processes back to the pool so checkout() reuses them.
+    for (const simulator of created) {
+      this.return(simulator);
+    }
+  }
+
+  /** Check out an AVM process from the pool, blocking until one is free. Caller must return() it when done. */
+  private async checkout(): Promise<AvmProcessHandle> {
+    const idx = this.available.pop();
+    if (idx !== undefined && this.slots[idx]) {
+      return this.slots[idx]!;
+    }
+
+    if (this.createdCount < this.maxSize || (idx !== undefined && !this.slots[idx])) {
+      return await this.createSlot(idx);
+    }
+
+    return new Promise<AvmProcessHandle>((resolve, reject) => {
+      this.waiters.push({ resolve, reject });
+    });
+  }
+
+  /** Return an AVM process to the pool after use. */
+  private return(simulator: AvmProcessHandle): void {
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter.resolve(simulator);
+    } else {
+      const idx = this.slots.indexOf(simulator);
+      if (idx >= 0) {
+        this.available.push(idx);
+      }
+    }
+  }
+
+  private async createSlot(reuseIdx?: number): Promise<AvmProcessHandle> {
+    const reuse = reuseIdx !== undefined && reuseIdx < this.slots.length;
+    // Reserve the slot count synchronously, before the async spawn, so concurrent checkouts can't all
+    // observe `createdCount < maxSize` and overshoot the pool (the count is only bumped once control has
+    // yielded on the await). Roll back the reservation if the spawn itself fails.
+    if (!reuse) {
+      this.createdCount++;
+    }
+    let simulator: AvmProcessHandle;
+    try {
+      simulator = await AvmSimulatorProcess.spawn({
+        binaryPath: this.options.avmBinaryPath,
+        wsdbIpcPath: this.options.wsdbIpcPath,
+        cdbIpcPath: this.cdbServer.ipcPath,
+        logger: this.options.logger,
+      });
+    } catch (err) {
+      if (!reuse) {
+        this.createdCount--;
+      }
+      throw err;
+    }
+    if (reuse) {
+      this.slots[reuseIdx!] = simulator;
+    } else {
+      this.slots.push(simulator);
+    }
+    this.log.debug(`Created AVM pool slot (${this.createdCount}/${this.maxSize})`);
+    return simulator;
+  }
+}
+
+class AvmSimulatorProcess implements AvmProcessHandle {
+  private constructor(private service: AvmService) {}
+
+  static async spawn(options: {
+    binaryPath?: string;
+    wsdbIpcPath: string;
+    cdbIpcPath: string;
+    logger?: (msg: string) => void;
+  }): Promise<AvmSimulatorProcess> {
+    const service = await AvmService.spawn({
+      binaryPath: options.binaryPath,
+      transport: 'uds',
+      logger: options.logger,
+      extraArgs: ['--wsdb', options.wsdbIpcPath, '--cdb', options.cdbIpcPath],
+    });
+    return new AvmSimulatorProcess(service);
+  }
+
+  public async simulate(inputBuffer: Uint8Array, signal?: AbortSignal): Promise<Uint8Array> {
+    // Signal the C++ process to stop at its next cancellation checkpoint when the caller aborts.
+    const onAbort = () => this.service.sendProcessSignal('SIGUSR1');
+    if (signal?.aborted) {
+      onAbort();
+    }
+    signal?.addEventListener('abort', onAbort, { once: true });
+    try {
+      return (await this.service.simulate({ inputs: inputBuffer })).result;
+    } finally {
+      signal?.removeEventListener('abort', onAbort);
+    }
+  }
+
+  public async simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array> {
+    return (await this.service.simulateWithHints({ inputs: inputBuffer })).result;
+  }
+
+  public async destroy(): Promise<void> {
+    await this.service.destroy();
+  }
+}

package/src/public/cdb_ipc_server.ts

@@ -0,0 +1,198 @@
+/**
+ * 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 {
+  type CdbAddContracts,
+  type CdbAddContractsResponse,
+  type CdbCommitCheckpoint,
+  type CdbCommitCheckpointResponse,
+  type CdbCreateCheckpoint,
+  type CdbCreateCheckpointResponse,
+  type CdbGetBytecodeCommitment,
+  type CdbGetBytecodeCommitmentResponse,
+  type CdbGetContractClass,
+  type CdbGetContractClassResponse,
+  type CdbGetContractInstance,
+  type CdbGetContractInstanceResponse,
+  type CdbGetDebugFunctionName,
+  type CdbGetDebugFunctionNameResponse,
+  type Handler as CdbHandler,
+  type CdbRevertCheckpoint,
+  type CdbRevertCheckpointResponse,
+  handleRequest,
+} from '@aztec/cdb';
+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 { 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/contracts_db_checkpoint.ts

@@ -31,7 +31,7 @@ export class ContractsDbCheckpoint {
     return this.bytecodeCommitments.get(classId.toString());
   }
 
-  public deepCopy(): ContractsDbCheckpoint {
+  public fork(): ContractsDbCheckpoint {
     const copy = new ContractsDbCheckpoint();
     this.instances.forEach((value, key) => copy.instances.set(key, value));
     this.classes.forEach((value, key) => copy.classes.set(key, value));

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,
@@ -25,14 +25,26 @@ export async function bulkTest(
   // Register multiple different protocol contracts (to ensure we don't dedup bytecode hashing events):
   await tester.registerAuthContract();
   await tester.registerInstanceRegistryContract();
+  await tester.registerClassRegistryContract();
 
   // Get a deployed contract instance to pass to the contract
   // for it to use as "expected" values when testing contract instance retrieval.
   const expectContractInstance = avmTestContract;
   const argsField = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8].map(x => new Fr(x));
-  argsU8.push(new Fr(2n ** 128n + 9n)); // Trigger truncation from large (> 128 bits) value (canonical decomposition event)
-  argsU8.push(new Fr(2n ** 125n + 10n)); // Trigger truncation from small (< 128 bits) value (no canonical decomposition event)
+  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  // Pinned grumpkin-Poseidon2 Schnorr signature (mirrors the C++ `pinned_test_vector_large`
+  // and noir-lang/schnorr v0.4.0's `pinned_vector_large`). Passing these in as calldata
+  // (rather than baking them into Noir as constants) keeps MSM + Poseidon2 from being folded
+  // by the Noir compiler.
+  const schnorrInputs = [
+    Fr.fromHexString('0x065812e335a97c2108ea8cf4ccfe2f9dd6b117a0714f5e18461575be93f61da6'), // pubkey.x
+    Fr.fromHexString('0x1a915003e8ec534f9a15d926a7ded478e178468ccc4f28e236e67450a55ac622'), // pubkey.y
+    Fr.fromHexString('0xf3bc3b7147acb9c621fd9f72dbf15ffa'), // sig_s.lo
+    Fr.fromHexString('0x08599f379f0301dfefdbd0272554454d'), // sig_s.hi
+    Fr.fromHexString('0x97065383ebbbd76620398792bd259bc2'), // sig_e.lo
+    Fr.fromHexString('0x2ceaee87f45b7a417f0ffb05451a8c92'), // sig_e.hi
+    Fr.fromHexString('0x0123456789abcdef0fedcba9876543210123456789abcdef0fedcba987654321'), // message
+  ];
   const args = [
     argsField,
     argsU8,
@@ -40,6 +52,8 @@ export async function bulkTest(
     /*expectedDeployer=*/ expectContractInstance.deployer,
     /*expectedClassId=*/ expectContractInstance.currentContractClassId,
     /*expectedInitializationHash=*/ expectContractInstance.initializationHash,
+    /*expectedImmutablesHash=*/ expectContractInstance.immutablesHash,
+    /*schnorrInputs=*/ schnorrInputs,
     /*skip_strictly_limited_side_effects=*/ false,
   ];
 
@@ -62,7 +76,7 @@ export async function bulkTest(
       {
         address: avmTestContract.address,
         fnName: 'assert_calldata_copy',
-        args: [argsField.slice(3), /* with_selector: */ true],
+        args: [argsField.slice(0, 3), /* with_selector: */ true],
       },
       {
         address: avmTestContract.address,
@@ -100,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,
@@ -123,6 +137,15 @@ export async function megaBulkTest(
   //const argsField7 = [15, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   //const argsField8 = [17, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const schnorrInputs = [
+    Fr.fromHexString('0x065812e335a97c2108ea8cf4ccfe2f9dd6b117a0714f5e18461575be93f61da6'), // pubkey.x
+    Fr.fromHexString('0x1a915003e8ec534f9a15d926a7ded478e178468ccc4f28e236e67450a55ac622'), // pubkey.y
+    Fr.fromHexString('0xf3bc3b7147acb9c621fd9f72dbf15ffa'), // sig_s.lo
+    Fr.fromHexString('0x08599f379f0301dfefdbd0272554454d'), // sig_s.hi
+    Fr.fromHexString('0x97065383ebbbd76620398792bd259bc2'), // sig_e.lo
+    Fr.fromHexString('0x2ceaee87f45b7a417f0ffb05451a8c92'), // sig_e.hi
+    Fr.fromHexString('0x0123456789abcdef0fedcba9876543210123456789abcdef0fedcba987654321'), // message
+  ];
   const genArgs = (argsField: Fr[]) => [
     argsField,
     argsU8,
@@ -130,6 +153,8 @@ export async function megaBulkTest(
     /*expectedDeployer=*/ expectContractInstance.deployer.toField(),
     /*expectedClassId=*/ expectContractInstance.currentContractClassId.toField(),
     /*expectedInitializationHash=*/ expectContractInstance.initializationHash.toField(),
+    /*expectedImmutablesHash=*/ expectContractInstance.immutablesHash.toField(),
+    /*schnorrInputs=*/ schnorrInputs,
     // Must skip strictly limited side effects (logs, messages) so we can spam the bulk test several times.
     /*skip_strictly_limited_side_effects=*/ true,
   ];

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,15 +1,13 @@
 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 { executeAvmMinimalPublicTx } from './minimal_public_tx.js';
 export { TestExecutorMetrics } from '../test_executor_metrics.js';
 export { ammTest } from './amm_test.js';
 export { bulkTest, megaBulkTest } from './bulk_test.js';
 export { tokenTest } from './token_test.js';
-export * from './custom_bytecode_tests.js';
 export {
   deployCustomBytecode,
   executeCustomBytecode,
   deployAndExecuteCustomBytecode,
 } from './custom_bytecode_tester.js';
-export { getSpamConfigsPerOpcode, testOpcodeSpamCase } from './opcode_spammer.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();
+  }
+}