@aztec/simulator 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/src/public/avm/testing/account_proof_fetcher.ts

@@ -0,0 +1,166 @@
+/**
+ * Fetches an account proof from the Ethereum mainnet and saves it as account_proof.json.
+ * This script is not using any Aztec library code, so it's easily portable.
+ */
+import fs from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { createPublicClient, fromRlp, hexToBytes, http } from 'viem';
+import { mainnet } from 'viem/chains';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const RPC_URL = process.env.RPC_URL;
+const ADDRESS = (process.env.ADDRESS || '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045') as `0x${string}`;
+const BLOCK_TAG = process.env.BLOCK_NUMBER ? BigInt(process.env.BLOCK_NUMBER) : 'latest';
+const MAX_ACCOUNT_PATH = 15;
+
+function padTo(arr: number[], len: number) {
+  return [...arr, ...Array(len - arr.length).fill(0)].slice(0, len);
+}
+
+function toBytes(hex: `0x${string}`) {
+  return Array.from(hexToBytes(hex));
+}
+
+function bytesToU64s(bytes: number[]) {
+  const paddedBytes = padTo(bytes, 32);
+  return Array.from({ length: 4 }, (_, i) => {
+    let val = 0n;
+    for (let j = 0; j < 8; j++) {
+      val += BigInt(paddedBytes[i * 8 + j]) << BigInt(j * 8);
+    }
+    return val.toString();
+  });
+}
+
+function toBytesAndLen(val: bigint | number) {
+  if (val === 0n || val === 0) {
+    return { bytes: [0], length: 0 };
+  }
+  let hex = val.toString(16);
+  if (hex.length % 2) {
+    hex = '0' + hex;
+  }
+  const bytes = toBytes(`0x${hex}`);
+  return { bytes, length: bytes.length };
+}
+
+function parseNode(rlp: `0x${string}`) {
+  // Should be safe when working with branches and extensions without embedded children.
+  const decoded = fromRlp(rlp) as `0x${string}`[];
+  const node = {
+    rows: Array(16)
+      .fill(0)
+      .map(() => Array(32).fill(0)),
+    row_exist: Array(16).fill(false),
+    node_type: 0,
+  };
+
+  if (decoded.length === 17) {
+    for (let i = 0; i < 16; i++) {
+      if (decoded[i] !== '0x') {
+        node.row_exist[i] = true;
+        node.rows[i] = padTo(toBytes(decoded[i]), 32);
+      }
+    }
+  } else if (decoded.length === 2) {
+    const keyBytes = toBytes(decoded[0]);
+    const prefix = keyBytes[0];
+    if (prefix >> 4 >= 2) {
+      throw new Error('Unsupported: leaf node in proof path');
+    }
+    node.node_type = 1;
+    // Extension header format expected by the noir code: check out storage_proof types.nr.
+    node.rows[0][0] = prefix >> 4;
+    node.rows[0][8] = prefix & 0x0f;
+    node.rows[0][16] = keyBytes.length - 1;
+
+    for (let i = 1; i < keyBytes.length && i < 32; i++) {
+      node.rows[1][i - 1] = keyBytes[i];
+    }
+    node.rows[2] = padTo(toBytes(decoded[1]), 32);
+    node.row_exist[0] = node.row_exist[1] = node.row_exist[2] = true;
+  }
+  return node;
+}
+
+function parseProof(proof: `0x${string}`[], maxLen: number) {
+  const nodes = proof.slice(0, -1).slice(0, maxLen).map(parseNode);
+  while (nodes.length < maxLen) {
+    nodes.push({
+      rows: Array(16)
+        .fill(0)
+        .map(() => Array(32).fill(0)),
+      row_exist: Array(16).fill(false),
+      node_type: 0,
+    });
+  }
+  return nodes;
+}
+
+function nodeToLibFormat(node: { rows: number[][]; row_exist: boolean[]; node_type: number }) {
+  return {
+    rows: node.rows.map(bytesToU64s),
+    row_exist: node.row_exist,
+    node_type: String(node.node_type),
+  };
+}
+
+async function main() {
+  if (!RPC_URL) {
+    throw new Error('RPC_URL is not set');
+  }
+  console.log(`Fetching account proof for ${ADDRESS}`);
+
+  const client = createPublicClient({
+    chain: mainnet,
+    transport: http(RPC_URL),
+  });
+
+  const [blockNumber, proof, block] = await Promise.all([
+    client.getBlockNumber(),
+    client.getProof({
+      address: ADDRESS,
+      storageKeys: [],
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+    client.getBlock({
+      blockNumber: BLOCK_TAG === 'latest' ? undefined : BLOCK_TAG,
+    }),
+  ]);
+
+  console.log(`Block: ${blockNumber}, Account nodes: ${proof.accountProof.length}`);
+
+  // The -1 is because the last node in the proof is the leaf, which is excluded from path verification.
+  const accountPathLen = proof.accountProof.length - 1;
+  if (accountPathLen > MAX_ACCOUNT_PATH) {
+    throw new Error(
+      `Account proof path length ${accountPathLen} exceeds MAX_ACCOUNT_PATH ${MAX_ACCOUNT_PATH}. Increase the limit.`,
+    );
+  }
+
+  const nonce = toBytesAndLen(proof.nonce);
+  const balance = toBytesAndLen(proof.balance);
+
+  const data = {
+    block_number: String(blockNumber),
+    node_length: String(accountPathLen),
+    root: bytesToU64s(toBytes(block.stateRoot)),
+    nodes: parseProof(proof.accountProof, MAX_ACCOUNT_PATH).map(nodeToLibFormat),
+    account: {
+      address: toBytes(ADDRESS).map(String),
+      balance: padTo(balance.bytes, 32).map(String),
+      balance_length: String(balance.length),
+      code_hash: bytesToU64s(toBytes(proof.codeHash)),
+      nonce: padTo(nonce.bytes, 8).map(String),
+      nonce_length: String(nonce.length),
+      storage_hash: bytesToU64s(toBytes(proof.storageHash)),
+    },
+  };
+
+  fs.writeFileSync(join(__dirname, 'account_proof.json'), JSON.stringify(data, null, 2));
+  console.log('account_proof.json generated');
+}
+
+main().catch(console.error);

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