@aztec/simulator 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/public/avm/{fixtures → testing}/base_avm_simulation_tester.ts

@@ -2,9 +2,10 @@ import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
+import { getCanonicalClassRegistry } from '@aztec/protocol-contracts/class-registry';
 import { computeFeePayerBalanceStorageSlot, getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { getCanonicalInstanceRegistry } from '@aztec/protocol-contracts/instance-registry';
+import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -91,7 +92,7 @@ export abstract class BaseAvmSimulationTester {
   }
 
   async registerAuthContract(): Promise<ContractInstanceWithAddress> {
-    const authRegistry = await getCanonicalAuthRegistry();
+    const authRegistry = await getStandardAuthRegistry();
     const authRegistryContractClassPublic = {
       ...authRegistry.contractClass,
       privateFunctions: [],
@@ -102,9 +103,28 @@ export abstract class BaseAvmSimulationTester {
       authRegistryContractClassPublic,
       authRegistry.instance,
     );
+    // AuthRegistry is a standard contract (not a protocol contract), so the AVM enforces a
+    // deployment-nullifier check on every instance retrieval. Insert the nullifier here so
+    // calls to AuthRegistry don't EXCEPTIONAL_HALT during simulation.
+    await this.insertContractAddressNullifier(authRegistry.instance.address);
     return authRegistry.instance;
   }
 
+  async registerClassRegistryContract(): Promise<ContractInstanceWithAddress> {
+    const classRegistry = await getCanonicalClassRegistry();
+    const classRegistryContractClassPublic = {
+      ...classRegistry.contractClass,
+      privateFunctions: [],
+      utilityFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(
+      classRegistry.artifact,
+      classRegistryContractClassPublic,
+      classRegistry.instance,
+    );
+    return classRegistry.instance;
+  }
+
   async registerInstanceRegistryContract(): Promise<ContractInstanceWithAddress> {
     const instanceRegistry = await getCanonicalInstanceRegistry();
     const instanceRegistryContractClassPublic = {
@@ -129,7 +149,7 @@ export abstract class BaseAvmSimulationTester {
 
   private async insertContractAddressNullifier(contractAddress: AztecAddress) {
     const contractAddressNullifier = await siloNullifier(
-      AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+      AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
       contractAddress.toField(),
     );
     await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()]);

package/src/public/avm/{fixtures → testing}/utils.ts

@@ -14,7 +14,6 @@ import {
   type ContractInstanceWithAddress,
   computeInitializationHash,
 } from '@aztec/stdlib/contract';
-import { isNoirCallStackUnresolved } from '@aztec/stdlib/errors';
 import { siloNullifier } from '@aztec/stdlib/hash';
 import { deriveKeys } from '@aztec/stdlib/keys';
 import { makeContractClassPublic, makeContractInstanceFromClassId } from '@aztec/stdlib/testing';
@@ -23,10 +22,6 @@ import type { UInt64 } from '@aztec/stdlib/types';
 import { strict as assert } from 'assert';
 import merge from 'lodash.merge';
 
-import { resolveAssertionMessageFromRevertData, traverseCauseChain } from '../../../common/index.js';
-import { Field, Uint8, Uint32, Uint64 } from '../avm_memory_types.js';
-import type { AvmRevertReason } from '../errors.js';
-
 export const PUBLIC_DISPATCH_FN_NAME = 'public_dispatch';
 export const DEFAULT_TIMESTAMP: UInt64 = 99833n;
 export const DEFAULT_BLOCK_NUMBER = BlockNumber(42);
@@ -38,22 +33,6 @@ export function allSameExcept(original: any, overrides: any): any {
   return merge({}, original, overrides);
 }
 
-export function randomMemoryBytes(length: number): Uint8[] {
-  return [...Array(length)].map(_ => new Uint8(Math.floor(Math.random() * 255)));
-}
-
-export function randomMemoryUint32s(length: number): Uint32[] {
-  return [...Array(length)].map(_ => new Uint32(Math.floor(Math.random() * 255)));
-}
-
-export function randomMemoryUint64s(length: number): Uint64[] {
-  return [...Array(length)].map(_ => new Uint64(Math.floor(Math.random() * 255)));
-}
-
-export function randomMemoryFields(length: number): Field[] {
-  return [...Array(length)].map(_ => new Field(Fr.random()));
-}
-
 export function getFunctionSelector(
   functionName: string,
   contractArtifact: ContractArtifact,
@@ -81,24 +60,6 @@ export function getContractFunctionAbi(
   );
 }
 
-export function resolveContractAssertionMessage(
-  functionName: string,
-  revertReason: AvmRevertReason,
-  output: Fr[],
-  contractArtifact: ContractArtifact,
-): string | undefined {
-  traverseCauseChain(revertReason, cause => {
-    revertReason = cause as AvmRevertReason;
-  });
-
-  const functionArtifact = getAllFunctionAbis(contractArtifact).find(f => f.name === functionName);
-  if (!functionArtifact || !revertReason.noirCallStack || !isNoirCallStackUnresolved(revertReason.noirCallStack)) {
-    return undefined;
-  }
-
-  return resolveAssertionMessageFromRevertData(output, functionArtifact);
-}
-
 /**
  * Create a contract class and instance given constructor args, artifact, etc.
  * NOTE: This is useful for testing real-ish contract class registration and instance deployment TXs (via logs)
@@ -128,22 +89,25 @@ export async function createContractClassAndInstance(
   const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
   const { publicKeys } = await deriveKeys(new Fr(seed));
   const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
+  const immutablesHash = new Fr(seed + 1);
   const contractInstance =
     originalContractClassId === undefined
       ? await makeContractInstanceFromClassId(contractClass.id, seed, {
           deployer,
           initializationHash,
+          immutablesHash,
           publicKeys,
         })
       : await makeContractInstanceFromClassId(originalContractClassId, seed, {
           deployer,
           initializationHash,
           currentClassId: contractClass.id,
+          immutablesHash,
           publicKeys,
         });
 
   const contractAddressNullifier = await siloNullifier(
-    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
     contractInstance.address.toField(),
   );
 

package/src/public/avm_simulator.ts

@@ -0,0 +1,29 @@
+import type { PublicContractsDB } from './public_db_sources.js';
+
+/**
+ * Identifies the contract data a single simulation reads. The AVM's contract-data lookups during a
+ * `simulate` call are answered from `contractsDB`; `forkId` and `timestamp` scope those lookups to the
+ * world-state fork being simulated against. How this reaches the AVM (in-process call, IPC callback
+ * server, ...) is the implementation's concern — callers only supply the context.
+ */
+export interface AvmContractsDBContext {
+  contractsDB: PublicContractsDB;
+  forkId: number;
+  timestamp: bigint;
+}
+
+/**
+ * Something that can run AVM simulations, independent of how the work is dispatched (a single external
+ * process, a pool of them, or an in-process stub). Callers hold this and never see the underlying transport.
+ */
+export interface AvmSimulator {
+  /**
+   * Run a fast simulation and return the msgpack-encoded result. `context` supplies the contracts DB whose
+   * data the simulation reads. If `signal` aborts, the simulation stops at the next cancellation checkpoint.
+   */
+  simulate(inputBuffer: Uint8Array, context: AvmContractsDBContext, signal?: AbortSignal): Promise<Uint8Array>;
+  /** Run a simulation collecting proving hints and return the msgpack-encoded result. */
+  simulateWithHints(inputBuffer: Uint8Array): Promise<Uint8Array>;
+  /** Release any resources held by the underlying implementation. */
+  destroy?(): Promise<void>;
+}

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();
+  }
+}